fastlane 2.150.3 → 2.151.0

data/fastlane/swift/Plugins.swift

@@ -12,4 +12,4 @@ import Foundation
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.56]
+// FastlaneRunnerAPIVersion [0.9.56]

data/fastlane/swift/Precheckfile.swift

@@ -9,13 +9,9 @@
 //
 
 class Precheckfile: PrecheckfileProtocol {
-// If you want to enable `precheck`, run `fastlane precheck init`
-// After, this file will be replaced with a custom implementation that contains values you supplied
-// during the `init` process, and you won't see this message
+    // If you want to enable `precheck`, run `fastlane precheck init`
+    // After, this file will be replaced with a custom implementation that contains values you supplied
+    // during the `init` process, and you won't see this message
 }
 
-
-
-
-
-// Generated with fastlane 2.150.3
+// Generated with fastlane 2.151.0

data/fastlane/swift/PrecheckfileProtocol.swift

@@ -1,37 +1,36 @@
 protocol PrecheckfileProtocol: class {
+    /// The bundle identifier of your app
+    var appIdentifier: String { get }
 
-  /// The bundle identifier of your app
-  var appIdentifier: String { get }
+    /// Your Apple ID Username
+    var username: String { get }
 
-  /// Your Apple ID Username
-  var username: String { get }
+    /// The ID of your App Store Connect team if you're in multiple teams
+    var teamId: String? { get }
 
-  /// The ID of your App Store Connect team if you're in multiple teams
-  var teamId: String? { get }
+    /// The name of your App Store Connect team if you're in multiple teams
+    var teamName: String? { get }
 
-  /// The name of your App Store Connect team if you're in multiple teams
-  var teamName: String? { get }
+    /// The default rule level unless otherwise configured
+    var defaultRuleLevel: String { get }
 
-  /// The default rule level unless otherwise configured
-  var defaultRuleLevel: String { get }
+    /// Should check in-app purchases?
+    var includeInAppPurchases: Bool { get }
 
-  /// Should check in-app purchases?
-  var includeInAppPurchases: Bool { get }
-
-  /// using text indicating that your IAP is free
-  var freeStuffInIap: String? { get }
+    /// using text indicating that your IAP is free
+    var freeStuffInIap: String? { get }
 }
 
 extension PrecheckfileProtocol {
-  var appIdentifier: String { return "" }
-  var username: String { return "" }
-  var teamId: String? { return nil }
-  var teamName: String? { return nil }
-  var defaultRuleLevel: String { return "error" }
-  var includeInAppPurchases: Bool { return true }
-  var freeStuffInIap: String? { return nil }
+    var appIdentifier: String { return "" }
+    var username: String { return "" }
+    var teamId: String? { return nil }
+    var teamName: String? { return nil }
+    var defaultRuleLevel: String { return "error" }
+    var includeInAppPurchases: Bool { return true }
+    var freeStuffInIap: String? { return nil }
 }
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.11]
+// FastlaneRunnerAPIVersion [0.9.18]

data/fastlane/swift/RubyCommand.swift

@@ -40,40 +40,38 @@ struct RubyCommand: RubyCommandable {
         }
 
         var hasValue: Bool {
-            return nil != self.value
+            return value != nil
         }
 
         var json: String {
-            get {
-                if let someValue = value {
-                    let typeJson: String
-                    if let type = type {
-                        typeJson = ", \"value_type\" : \"\(type.typeString)\""
-                    } else {
-                        typeJson = ""
-                    }
-
-                    if type == .stringClosure  {
-                        return "{\"name\" : \"\(name)\", \"value\" : \"ignored_for_closure\"\(typeJson)}"
-                    } else if let array = someValue as? [String] {
-                        return "{\"name\" : \"\(name)\", \"value\" : \"\(array.joined(separator: ","))\"\(typeJson)}"
-                    } else if let hash = someValue as? [String : Any] {
-                        let jsonData = try! JSONSerialization.data(withJSONObject: hash, options: [])
-                        let jsonString = String(data: jsonData, encoding: .utf8)!
-                        return "{\"name\" : \"\(name)\", \"value\" : \(jsonString)\(typeJson)}"
-                    } else {
-                        let dictionary = [
-                            "name": name,
-                            "value": someValue
-                        ]
-                        let jsonData = try! JSONSerialization.data(withJSONObject: dictionary, options: [])
-                        let jsonString = String(data: jsonData, encoding: .utf8)!
-                        return jsonString
-                    }
+            if let someValue = value {
+                let typeJson: String
+                if let type = type {
+                    typeJson = ", \"value_type\" : \"\(type.typeString)\""
                 } else {
-                    // Just exclude this arg if it doesn't have a value
-                    return ""
+                    typeJson = ""
                 }
+
+                if type == .stringClosure {
+                    return "{\"name\" : \"\(name)\", \"value\" : \"ignored_for_closure\"\(typeJson)}"
+                } else if let array = someValue as? [String] {
+                    return "{\"name\" : \"\(name)\", \"value\" : \"\(array.joined(separator: ","))\"\(typeJson)}"
+                } else if let hash = someValue as? [String: Any] {
+                    let jsonData = try! JSONSerialization.data(withJSONObject: hash, options: [])
+                    let jsonString = String(data: jsonData, encoding: .utf8)!
+                    return "{\"name\" : \"\(name)\", \"value\" : \(jsonString)\(typeJson)}"
+                } else {
+                    let dictionary = [
+                        "name": name,
+                        "value": someValue,
+                    ]
+                    let jsonData = try! JSONSerialization.data(withJSONObject: dictionary, options: [])
+                    let jsonString = String(data: jsonData, encoding: .utf8)!
+                    return jsonString
+                }
+            } else {
+                // Just exclude this arg if it doesn't have a value
+                return ""
             }
         }
     }
@@ -83,9 +81,9 @@ struct RubyCommand: RubyCommandable {
     let className: String?
     let args: [Argument]
     let id: String = UUID().uuidString
-    
+
     var closure: ((String) -> Void)? {
-        let callbacks = self.args.filter { ($0.type != nil) && $0.type == .stringClosure }
+        let callbacks = args.filter { ($0.type != nil) && $0.type == .stringClosure }
         guard let callback = callbacks.first else {
             return nil
         }
@@ -99,11 +97,10 @@ struct RubyCommand: RubyCommandable {
         }
         return callbackClosure
     }
-    
-    
+
     func callbackClosure(_ callbackArg: String) -> ((String) -> Void)? {
         // WARNING: This will perform the first callback it receives
-        let callbacks = self.args.filter { ($0.type != nil) && $0.type == .stringClosure }
+        let callbacks = args.filter { ($0.type != nil) && $0.type == .stringClosure }
         guard let callback = callbacks.first else {
             verbose(message: "received call to performCallback with \(callbackArg), but no callback available to perform")
             return nil
@@ -124,17 +121,17 @@ struct RubyCommand: RubyCommandable {
     func performCallback(callbackArg: String, socket: SocketClient, completion: @escaping () -> Void) {
         verbose(message: "Performing callback with: \(callbackArg)")
         socket.leave()
-        self.callbackClosure(callbackArg)?(callbackArg)
+        callbackClosure(callbackArg)?(callbackArg)
         completion()
     }
 
     var commandJson: String {
-        let argsArrayJson = self.args
+        let argsArrayJson = args
             .map { $0.json }
             .filter { $0 != "" }
 
         let argsJson: String?
-        if argsArrayJson.count > 0 {
+        if !argsArrayJson.isEmpty {
             argsJson = "\"args\" : [\(argsArrayJson.joined(separator: ","))]"
         } else {
             argsJson = nil

data/fastlane/swift/RubyCommandable.swift

@@ -36,7 +36,9 @@ protocol RubyCommandable {
 
 extension RubyCommandable {
     var json: String {
-        return "{\"commandType\" : \"\(self.type.token)\", \"command\" : \(self.commandJson)}"
+        return """
+        { "commandType": "\(type.token)", "command": \(commandJson) }
+        """
     }
 }
 

data/fastlane/swift/Runner.swift

@@ -15,48 +15,49 @@
 import Foundation
 
 let logger: Logger = {
-    return Logger()
+    Logger()
 }()
 
 let runner: Runner = {
-    return Runner()
+    Runner()
 }()
 
-func desc(_ laneDescription: String) {
+func desc(_: String) {
     // no-op, this is handled in fastlane/lane_list.rb
 }
 
 class Runner {
-    fileprivate var thread: Thread!
-    fileprivate var socketClient: SocketClient!
-    fileprivate let dispatchGroup: DispatchGroup = DispatchGroup()
-    fileprivate var returnValue: String? // lol, so safe
-    fileprivate var currentlyExecutingCommand: RubyCommandable? = nil
-    fileprivate var shouldLeaveDispatchGroupDuringDisconnect = false
-    fileprivate var executeNext: [String: Bool] = [:]
-    
+    private var thread: Thread!
+    private var socketClient: SocketClient!
+    private let dispatchGroup: DispatchGroup = DispatchGroup()
+    private var returnValue: String? // lol, so safe
+    private var currentlyExecutingCommand: RubyCommandable?
+    private var shouldLeaveDispatchGroupDuringDisconnect = false
+    private var executeNext: [String: Bool] = [:]
+
     func executeCommand(_ command: RubyCommandable) -> String {
-        self.dispatchGroup.enter()
-        self.currentlyExecutingCommand = command
-        self.socketClient.send(rubyCommand: command)
-        
+        dispatchGroup.enter()
+        currentlyExecutingCommand = command
+        socketClient.send(rubyCommand: command)
+
         let secondsToWait = DispatchTimeInterval.seconds(SocketClient.defaultCommandTimeoutSeconds)
+        // swiftlint:disable next
         let timeoutResult = waitWithPolling(self.executeNext[command.id], toEventually: { $0 == true }, timeout: SocketClient.defaultCommandTimeoutSeconds)
         executeNext.removeValue(forKey: command.id)
         let failureMessage = "command didn't execute in: \(SocketClient.defaultCommandTimeoutSeconds) seconds"
-        let success = self.testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
+        let success = testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
         guard success else {
             log(message: "command timeout")
-            fatalError()
+            preconditionFailure()
         }
-        
-        if let _returnValue = self.returnValue {
+
+        if let _returnValue = returnValue {
             return _returnValue
         } else {
             return ""
         }
     }
-    
+
     private func waitWithPolling<T>(_ expression: @autoclosure @escaping () throws -> T, toEventually predicate: @escaping (T) -> Bool, timeout: Int, pollingInterval: DispatchTimeInterval = .milliseconds(4)) -> DispatchTimeoutResult {
         func memoizedClosure<T>(_ closure: @escaping () throws -> T) -> (Bool) throws -> T {
             var cache: T?
@@ -67,11 +68,11 @@ class Runner {
                 guard let cache = cache else {
                     preconditionFailure()
                 }
-                
+
                 return cache
             }
         }
-        
+
         let runLoop = RunLoop.current
         let timeoutDate = Date(timeInterval: TimeInterval(timeout), since: Date())
         var fulfilled: Bool = false
@@ -102,44 +103,48 @@ class Runner {
 extension Runner {
     func startSocketThread(port: UInt32) {
         let secondsToWait = DispatchTimeInterval.seconds(SocketClient.connectTimeoutSeconds)
-        
-        self.dispatchGroup.enter()
-        
-        self.socketClient = SocketClient(port: port, commandTimeoutSeconds:timeout, socketDelegate: self)
-        self.thread = Thread(target: self, selector: #selector(startSocketComs), object: nil)
-        self.thread!.name = "socket thread"
-        self.thread!.start()
-        
+
+        dispatchGroup.enter()
+
+        socketClient = SocketClient(port: port, commandTimeoutSeconds: timeout, socketDelegate: self)
+        thread = Thread(target: self, selector: #selector(startSocketComs), object: nil)
+        guard let thread = thread else {
+            preconditionFailure("Thread did not instantiate correctly")
+        }
+
+        thread.name = "socket thread"
+        thread.start()
+
         let connectTimeout = DispatchTime.now() + secondsToWait
-        let timeoutResult = self.dispatchGroup.wait(timeout: connectTimeout)
-        
+        let timeoutResult = dispatchGroup.wait(timeout: connectTimeout)
+
         let failureMessage = "couldn't start socket thread in: \(SocketClient.connectTimeoutSeconds) seconds"
         let success = testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
         guard success else {
             log(message: "socket thread timeout")
-            fatalError()
+            preconditionFailure()
         }
     }
-    
+
     func disconnectFromFastlaneProcess() {
-        self.shouldLeaveDispatchGroupDuringDisconnect = true
-        self.dispatchGroup.enter()
+        shouldLeaveDispatchGroupDuringDisconnect = true
+        dispatchGroup.enter()
         socketClient.sendComplete()
-        
+
         let connectTimeout = DispatchTime.now() + 2
-        _ = self.dispatchGroup.wait(timeout: connectTimeout)
+        _ = dispatchGroup.wait(timeout: connectTimeout)
     }
-    
+
     @objc func startSocketComs() {
         guard let socketClient = self.socketClient else {
             return
         }
-        
+
         socketClient.connectAndOpenStreams()
-        self.dispatchGroup.leave()
+        dispatchGroup.leave()
     }
-    
-    fileprivate func testDispatchTimeoutResult(_ timeoutResult: DispatchTimeoutResult, failureMessage: String, timeToWait: DispatchTimeInterval) -> Bool {
+
+    fileprivate func testDispatchTimeoutResult(_ timeoutResult: DispatchTimeoutResult, failureMessage: String, timeToWait _: DispatchTimeInterval) -> Bool {
         switch timeoutResult {
         case .success:
             return true
@@ -150,51 +155,53 @@ extension Runner {
     }
 }
 
-extension Runner : SocketClientDelegateProtocol {
+extension Runner: SocketClientDelegateProtocol {
     func commandExecuted(serverResponse: SocketClientResponse, completion: (SocketClient) -> Void) {
         switch serverResponse {
-        case .success(let returnedObject, let closureArgumentValue):
+        case let .success(returnedObject, closureArgumentValue):
             verbose(message: "command executed")
-            self.returnValue = returnedObject
-            if let command = self.currentlyExecutingCommand as? RubyCommand {
+            returnValue = returnedObject
+            if let command = currentlyExecutingCommand as? RubyCommand {
                 if let closureArgumentValue = closureArgumentValue, !closureArgumentValue.isEmpty {
                     command.performCallback(callbackArg: closureArgumentValue, socket: socketClient) {
                         self.executeNext[command.id] = true
                     }
                 } else {
-                    self.executeNext[command.id] = true
+                    executeNext[command.id] = true
                 }
             }
             dispatchGroup.leave()
             completion(socketClient)
         case .clientInitiatedCancelAcknowledged:
             verbose(message: "server acknowledged a cancel request")
-            self.dispatchGroup.leave()
-            if let command = self.currentlyExecutingCommand as? RubyCommand {
-                self.executeNext[command.id] = true
+            dispatchGroup.leave()
+            if let command = currentlyExecutingCommand as? RubyCommand {
+                executeNext[command.id] = true
             }
             completion(socketClient)
         case .alreadyClosedSockets, .connectionFailure, .malformedRequest, .malformedResponse, .serverError:
             log(message: "error encountered while executing command:\n\(serverResponse)")
-            self.dispatchGroup.leave()
-            if let command = self.currentlyExecutingCommand as? RubyCommand {
-                self.executeNext[command.id] = true
+            dispatchGroup.leave()
+            if let command = currentlyExecutingCommand as? RubyCommand {
+                executeNext[command.id] = true
             }
             completion(socketClient)
-        case .commandTimeout(let timeout):
+        case let .commandTimeout(timeout):
             log(message: "Runner timed out after \(timeout) second(s)")
         }
     }
-    
+
     func connectionsOpened() {
         DispatchQueue.main.async {
             verbose(message: "connected!")
         }
     }
-    
+
     func connectionsClosed() {
         DispatchQueue.main.async {
-            self.thread?.cancel()
+            if let thread = self.thread {
+                thread.cancel()
+            }
             self.thread = nil
             self.socketClient.closeSession()
             self.socketClient = nil
@@ -220,17 +227,18 @@ class Logger {
                 self = .normal
             }
         }
+
         case normal
         case verbose
     }
-    
+
     public static var logMode: LogMode = .normal
-    
+
     func log(message: String) {
         let timestamp = NSDate().timeIntervalSince1970
         print("[\(timestamp)]: \(message)")
     }
-    
+
     func verbose(message: String) {
         if Logger.logMode == .verbose {
             let timestamp = NSDate().timeIntervalSince1970
@@ -251,14 +259,14 @@ private extension DispatchTimeInterval {
     var timeInterval: TimeInterval {
         var result: TimeInterval = 0
         switch self {
-        case .seconds(let value):
+        case let .seconds(value):
             result = TimeInterval(value)
-        case .milliseconds(let value):
-            result = TimeInterval(value)*0.001
-        case .microseconds(let value):
-            result = TimeInterval(value)*0.000001
-        case .nanoseconds(let value):
-            result = TimeInterval(value)*0.000000001
+        case let .milliseconds(value):
+            result = TimeInterval(value) * 0.001
+        case let .microseconds(value):
+            result = TimeInterval(value) * 0.000_001
+        case let .nanoseconds(value):
+            result = TimeInterval(value) * 0.000_000_001
         case .never:
             fatalError()
         }
@@ -269,4 +277,3 @@ private extension DispatchTimeInterval {
 // Please don't remove the lines below
 // They are used to detect outdated files
 // FastlaneRunnerAPIVersion [0.9.2]
-