build: fix swiftlint issues

Package.swift

@@ -95,7 +95,7 @@ let package = Package(
 
     .target(name: "TIMoyaNetworking",
             dependencies: ["TINetworking", "TIFoundationUtils", "Moya"],
-            path: "TIMoyaNetworking",
+            path: "TIMoyaNetworking/Sources",
             plugins: [.plugin(name: "TISwiftLintPlugin")]),
 
     .target(name: "TINetworkingCache", dependencies: ["TIFoundationUtils", "TINetworking", "Cache"], path: "TINetworkingCache/Sources"),

Plugins/TISwiftLintPlugin/plugin.swift

@@ -21,6 +21,7 @@
 //
 
 import PackagePlugin
+import Foundation
 
 @main
 struct SwiftLintPlugin: BuildToolPlugin {
@@ -29,6 +30,12 @@ struct SwiftLintPlugin: BuildToolPlugin {
 
         let swiftlintExecutablePath = try context.tool(named: "swiftlint").path
 
+        let srcRoot = context.package.directory.string
+        let targetDir = target.directory.string
+
+        let relativeTargetDir = targetDir.replacingOccurrences(of: srcRoot, with: "")
+        let clearRelativeTargetDir = relativeTargetDir[relativeTargetDir.index(after: relativeTargetDir.startIndex)...] // trim leading /
+
         return [
             .prebuildCommand(displayName: "SwiftLint linting \(target.name)...",
                              executable: swiftlintScriptPath,
@@ -38,9 +45,9 @@ struct SwiftLintPlugin: BuildToolPlugin {
                              ],
                              environment: [
                                 "SCRIPT_DIR": swiftlintScriptPath.removingLastComponent().string,
-                                "SRCROOT": context.package.directory.string,
+                                "SRCROOT": srcRoot,
                                 "SCRIPT_INPUT_FILE_COUNT": "1",
-                                "SCRIPT_INPUT_FILE_0": target.directory.removingLastComponent().lastComponent,
+                                "SCRIPT_INPUT_FILE_0": clearRelativeTargetDir,
 //                                "FORCE_LINT": "1", // Lint all files in target (not only modified)
 //                                "AUTOCORRECT": "1"
                              ],

TIFoundationUtils/DataStorage/Sources/SingleValueStorage/AppInstallLifetimeSingleValueStorage.swift

@@ -44,17 +44,17 @@ where Storage.ErrorType == StorageError {
     }
 
     open func getValue() -> Result<Storage.ValueType, Storage.ErrorType> {
-        if appReinstallChecker.isAppFirstRun {
-            let result = wrappedStorage.deleteValue()
-
-            if case .success = result {
-                appReinstallChecker.isAppFirstRun = false
-            }
-
-            return result.flatMap { .failure(StorageError.valueNotFound) }
-        } else {
+        guard appReinstallChecker.isAppFirstRun else {
             return wrappedStorage.getValue()
         }
+
+        let result = wrappedStorage.deleteValue()
+
+        if case .success = result {
+            appReinstallChecker.isAppFirstRun = false
+        }
+
+        return result.flatMap { .failure(StorageError.valueNotFound) }
     }
 
     open func store(value: Storage.ValueType) -> Result<Void, Storage.ErrorType> {

TIMoyaNetworking/Sources/RecoverableNetworkService/DefaultRecoverableJsonNetworkService.swift

@@ -36,8 +36,7 @@ open class DefaultRecoverableJsonNetworkService<ApiError: Decodable & Error>: De
     open func process<B: Encodable, S>(recoverableRequest: EndpointRequest<B, S>,
                                        prependRequestRetriers: [RequestRetrier] = [],
                                        appendRequestRetriers: [RequestRetrier] = [],
-                                       completion: @escaping ParameterClosure<EndpointResponse<S>>) -> Cancellable
-     {
+                                       completion: @escaping ParameterClosure<EndpointResponse<S>>) -> Cancellable {
 
         process(recoverableRequest: recoverableRequest,
                 errorHandlers: prependRequestRetriers + defaultRequestRetriers + appendRequestRetriers,
@@ -63,22 +62,12 @@ open class DefaultRecoverableJsonNetworkService<ApiError: Decodable & Error>: De
                                        completion: @escaping ParameterClosure<EndpointResponse<S>>) -> Cancellable {
 
         Cancellables.scoped { cancellableBag in
-            process(request: recoverableRequest) { [weak self] (result: RequestResult<S, ApiError>) in
-                if case let .failure(errorResponse) = result {
-                    guard let self, !cancellableBag.isCancelled else {
-                        completion(result.mapError { .init(failures: [$0]) })
-                        return
-                    }
-
-                    self.recover(request: recoverableRequest,
-                                 errorHandlers: errorHandlers,
-                                 errorResponse: errorResponse,
-                                 originalResult: result,
-                                 cancellableBag: cancellableBag,
-                                 completion: completion)
-                } else {
-                    completion(result.mapError { .init(failures: [$0]) })
-                }
+            process(request: recoverableRequest) { [weak self] in
+                self?.handle(recoverableResponse: $0,
+                             request: recoverableRequest,
+                             errorHandlers: errorHandlers,
+                             cancellableBag: cancellableBag,
+                             completion: completion)
             }
         }
     }
@@ -94,37 +83,45 @@ open class DefaultRecoverableJsonNetworkService<ApiError: Decodable & Error>: De
         }
     }
 
-    open func recover<B: Encodable, S>(request: EndpointRequest<B, S>,
-                                          errorHandlers: [RequestRetrier],
-                                          errorResponse: ErrorType,
-                                          originalResult: RequestResult<S, ApiError>,
-                                          cancellableBag: BaseCancellableBag,
-                                          completion: @escaping ParameterClosure<EndpointResponse<S>>) {
+    open func handle<B: Encodable, S>(recoverableResponse: RequestResult<S, ApiError>,
+                                      request: EndpointRequest<B, S>,
+                                      errorHandlers: [RequestRetrier],
+                                      cancellableBag: BaseCancellableBag,
+                                      completion: @escaping ParameterClosure<EndpointResponse<S>>) {
 
-        Self.validateAndRepair(request: request,
-                               errors: [errorResponse],
-                               retriers: errorHandlers,
-                               cancellableBag: cancellableBag) {
-            switch $0 {
-            case .retry, .retryWithDelay:
-                self.process(request: request) {
-                    completion($0.mapError { .init(failures: [$0]) })
-                }
-                .add(to: cancellableBag)
-            case .doNotRetry, .doNotRetryWithError:
-                completion(originalResult.mapError { .init(failures: [$0]) })
+        if case let .failure(errorResponse) = recoverableResponse {
+            guard !cancellableBag.isCancelled else {
+                return
             }
+
+            Self.validateAndRepair(request: request,
+                                   errors: [errorResponse],
+                                   retriers: errorHandlers,
+                                   cancellableBag: cancellableBag) {
+                switch $0 {
+                case .retry, .retryWithDelay:
+                    self.process(request: request) {
+                        completion($0.mapError { .init(failures: [$0]) })
+                    }
+                    .add(to: cancellableBag)
+
+                case .doNotRetry, .doNotRetryWithError:
+                    completion(recoverableResponse.mapError { .init(failures: [$0]) })
+                }
+            }
+        } else {
+            completion(recoverableResponse.mapError { .init(failures: [$0]) })
         }
     }
 
     public func register<RequestRetrier: EndpointRequestRetrier>(defaultRequestRetrier: RequestRetrier)
-        where RequestRetrier.ErrorResult == ErrorType {
+    where RequestRetrier.ErrorResult == ErrorType {
 
         defaultRequestRetriers.append(defaultRequestRetrier.asAnyEndpointRequestRetrier())
     }
 
     public func set<RequestRetrier: EndpointRequestRetrier>(defaultRequestRetriers: RequestRetrier...)
-        where RequestRetrier.ErrorResult == ErrorType {
+    where RequestRetrier.ErrorResult == ErrorType {
 
         self.defaultRequestRetriers = defaultRequestRetriers.map { $0.asAnyEndpointRequestRetrier() }
     }
@@ -147,6 +144,7 @@ open class DefaultRecoverableJsonNetworkService<ApiError: Decodable & Error>: De
                 switch retryResult {
                 case .retry, .retryWithDelay:
                     completion(.retry)
+
                 case .doNotRetry, .doNotRetryWithError:
                     validateAndRepair(request: request,
                                       errors: errors,
@@ -154,6 +152,7 @@ open class DefaultRecoverableJsonNetworkService<ApiError: Decodable & Error>: De
                                       cancellableBag: cancellableBag,
                                       completion: completion)
                 }
+
             case let .failure(error):
                 validateAndRepair(request: request,
                                   errors: errors + [error],