fastlane 2.150.3 → 2.151.0

data/fastlane/swift/SocketClient.swift

@@ -12,8 +12,8 @@
 //  new group so that it won't be marked for upgrade
 //
 
-import Foundation
 import Dispatch
+import Foundation
 
 public enum SocketClientResponse: Error {
     case alreadyClosedSockets
@@ -27,17 +27,16 @@ public enum SocketClientResponse: Error {
 }
 
 class SocketClient: NSObject {
-    
     enum SocketStatus {
         case ready
         case closed
     }
-    
+
     static let connectTimeoutSeconds = 2
     static let defaultCommandTimeoutSeconds = 10_800 // 3 hours
     static let doneToken = "done" // TODO: remove these
     static let cancelToken = "cancelFastlaneRun"
-    
+
     fileprivate var inputStream: InputStream!
     fileprivate var outputStream: OutputStream!
     fileprivate var cleaningUpAfterDone = false
@@ -45,104 +44,104 @@ class SocketClient: NSObject {
     fileprivate let readSemaphore = DispatchSemaphore(value: 1)
     fileprivate let writeSemaphore = DispatchSemaphore(value: 1)
     fileprivate let commandTimeoutSeconds: Int
-    
+
     private let writeQueue: DispatchQueue
     private let readQueue: DispatchQueue
     private let streamQueue: DispatchQueue
     private let host: String
     private let port: UInt32
 
-    let maxReadLength = 65_536 // max for ipc on 10.12 is kern.ipc.maxsockbuf: 8388608 ($sysctl kern.ipc.maxsockbuf)
-    
-    weak private(set) var socketDelegate: SocketClientDelegateProtocol?
-    
+    let maxReadLength = 65536 // max for ipc on 10.12 is kern.ipc.maxsockbuf: 8388608 ($sysctl kern.ipc.maxsockbuf)
+
+    private(set) weak var socketDelegate: SocketClientDelegateProtocol?
+
     public private(set) var socketStatus: SocketStatus
-    
+
     // localhost only, this prevents other computers from connecting
     init(host: String = "localhost", port: UInt32 = 2000, commandTimeoutSeconds: Int = defaultCommandTimeoutSeconds, socketDelegate: SocketClientDelegateProtocol) {
         self.host = host
         self.port = port
         self.commandTimeoutSeconds = commandTimeoutSeconds
-        self.readQueue = DispatchQueue(label: "readQueue", qos: .background, attributes: .concurrent)
-        self.writeQueue = DispatchQueue(label: "writeQueue", qos: .background, attributes: .concurrent)
-        self.streamQueue = DispatchQueue.global(qos: .background)
-        self.socketStatus = .closed
+        readQueue = DispatchQueue(label: "readQueue", qos: .background, attributes: .concurrent)
+        writeQueue = DispatchQueue(label: "writeQueue", qos: .background, attributes: .concurrent)
+        streamQueue = DispatchQueue.global(qos: .background)
+        socketStatus = .closed
         self.socketDelegate = socketDelegate
         super.init()
     }
-    
+
     func connectAndOpenStreams() {
         var readStream: Unmanaged<CFReadStream>?
         var writeStream: Unmanaged<CFWriteStream>?
-        
-        self.streamQueue.sync {
+
+        streamQueue.sync {
             CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, self.host as CFString, self.port, &readStream, &writeStream)
-            
+
             self.inputStream = readStream!.takeRetainedValue()
             self.outputStream = writeStream!.takeRetainedValue()
-            
+
             self.inputStream.delegate = self
             self.outputStream.delegate = self
-            
+
             self.inputStream.schedule(in: .main, forMode: .defaultRunLoopMode)
             self.outputStream.schedule(in: .main, forMode: .defaultRunLoopMode)
         }
-        
-        self.dispatchGroup.enter()
-        self.readQueue.sync {
+
+        dispatchGroup.enter()
+        readQueue.sync {
             self.inputStream.open()
         }
-        
-        self.dispatchGroup.enter()
-        self.writeQueue.sync {
+
+        dispatchGroup.enter()
+        writeQueue.sync {
             self.outputStream.open()
         }
-        
+
         let secondsToWait = DispatchTimeInterval.seconds(SocketClient.connectTimeoutSeconds)
         let connectTimeout = DispatchTime.now() + secondsToWait
-        
-        let timeoutResult = self.dispatchGroup.wait(timeout: connectTimeout)
+
+        let timeoutResult = dispatchGroup.wait(timeout: connectTimeout)
         let failureMessage = "Couldn't connect to ruby process within: \(SocketClient.connectTimeoutSeconds) seconds"
-        
+
         let success = testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
-        
+
         guard success else {
-            self.socketDelegate?.commandExecuted(serverResponse: .connectionFailure) { _ in }
+            socketDelegate?.commandExecuted(serverResponse: .connectionFailure) { _ in }
             return
         }
-        
-        self.socketStatus = .ready
-        self.socketDelegate?.connectionsOpened()
+
+        socketStatus = .ready
+        socketDelegate?.connectionsOpened()
     }
-    
+
     public func send(rubyCommand: RubyCommandable) {
         verbose(message: "sending: \(rubyCommand.json)")
         send(string: rubyCommand.json)
         writeSemaphore.signal()
     }
-    
+
     public func sendComplete() {
         closeSession(sendAbort: true)
     }
-    
+
     private func testDispatchTimeoutResult(_ timeoutResult: DispatchTimeoutResult, failureMessage: String, timeToWait: DispatchTimeInterval) -> Bool {
         switch timeoutResult {
         case .success:
             return true
         case .timedOut:
             log(message: "Timeout: \(failureMessage)")
-            
-            if case .seconds(let seconds) = timeToWait {
+
+            if case let .seconds(seconds) = timeToWait {
                 socketDelegate?.commandExecuted(serverResponse: .commandTimeout(seconds: seconds)) { _ in }
             }
             return false
         }
     }
-    
+
     private func stopInputSession() {
         inputStream.close()
     }
-    
+
     private func stopOutputSession() {
         outputStream.close()
     }
@@ -161,14 +160,13 @@ class SocketClient: NSObject {
             let timeToWait = DispatchTimeInterval.seconds(timeoutSeconds)
             let commandTimeout = DispatchTime.now() + timeToWait
             let timeoutResult = writeSemaphore.wait(timeout: commandTimeout)
-            
+
             _ = self.testDispatchTimeoutResult(timeoutResult, failureMessage: "Ruby process didn't return after: \(SocketClient.connectTimeoutSeconds) seconds", timeToWait: timeToWait)
-            
         }
     }
 
     private func send(string: String) {
-        guard !self.cleaningUpAfterDone else {
+        guard !cleaningUpAfterDone else {
             // This will happen after we abort if there are commands waiting to be executed
             // Need to check state of SocketClient in command runner to make sure we can accept `send`
             socketDelegate?.commandExecuted(serverResponse: .alreadyClosedSockets) { _ in }
@@ -176,14 +174,14 @@ class SocketClient: NSObject {
         }
 
         if string == SocketClient.doneToken {
-            self.cleaningUpAfterDone = true
+            cleaningUpAfterDone = true
         }
 
         privateSend(string: string)
     }
 
     func closeSession(sendAbort: Bool = true) {
-        self.socketStatus = .closed
+        socketStatus = .closed
 
         stopInputSession()
 
@@ -192,13 +190,13 @@ class SocketClient: NSObject {
         }
 
         stopOutputSession()
-        self.socketDelegate?.connectionsClosed()
+        socketDelegate?.connectionsClosed()
     }
-    
+
     public func enter() {
         dispatchGroup.enter()
     }
-    
+
     public func leave() {
         readSemaphore.signal()
         writeSemaphore.signal()
@@ -207,52 +205,51 @@ class SocketClient: NSObject {
 
 extension SocketClient: StreamDelegate {
     func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
-        guard !self.cleaningUpAfterDone else {
+        guard !cleaningUpAfterDone else {
             // Still getting response from server eventhough we are done.
             // No big deal, we're closing the streams anyway.
             // That being said, we need to balance out the dispatchGroups
-            self.dispatchGroup.leave()
+            dispatchGroup.leave()
             return
         }
-        
-        if aStream === self.inputStream {
+
+        if aStream === inputStream {
             switch eventCode {
             case Stream.Event.openCompleted:
-                self.dispatchGroup.leave()
-                
+                dispatchGroup.leave()
+
             case Stream.Event.errorOccurred:
                 verbose(message: "input stream error occurred")
                 closeSession(sendAbort: true)
-                
+
             case Stream.Event.hasBytesAvailable:
                 read()
-                
+
             case Stream.Event.endEncountered:
                 // nothing special here
                 break
-                
+
             case Stream.Event.hasSpaceAvailable:
                 // we don't care about this
                 break
-                
+
             default:
                 verbose(message: "input stream caused unrecognized event: \(eventCode)")
             }
-            
-        } else if aStream === self.outputStream {
+
+        } else if aStream === outputStream {
             switch eventCode {
             case Stream.Event.openCompleted:
-                self.dispatchGroup.leave()
-                
+                dispatchGroup.leave()
+
             case Stream.Event.errorOccurred:
                 // probably safe to close all the things because Ruby already disconnected
                 verbose(message: "output stream recevied error")
-                break
-                
+
             case Stream.Event.endEncountered:
                 // nothing special here
                 break
-                
+
             case Stream.Event.hasSpaceAvailable:
                 // we don't care about this
                 break
@@ -262,7 +259,7 @@ extension SocketClient: StreamDelegate {
             }
         }
     }
-    
+
     func read() {
         readQueue.sync {
             self.readSemaphore.wait()
@@ -279,53 +276,50 @@ extension SocketClient: StreamDelegate {
                     verbose(message: "Stream read() error")
                 }
             }
-            self.processResponse(string: output, socket: self)
+            self.processResponse(string: output)
             readSemaphore.signal()
         }
     }
-    
+
     func handleFailure(message: [String]) {
-        log(message: "Encountered a problem: \(message.joined(separator:"\n"))")
+        log(message: "Encountered a problem: \(message.joined(separator: "\n"))")
         let shutdownCommand = ControlCommand(commandType: .cancel(cancelReason: .serverError))
-        self.send(rubyCommand: shutdownCommand)
+        send(rubyCommand: shutdownCommand)
     }
-    
-    func processResponse(string: String, socket: SocketClient) {
-        guard string.count > 0 else {
-            self.socketDelegate?.commandExecuted(serverResponse: .malformedResponse) {
+
+    func processResponse(string: String) {
+        guard !string.isEmpty else {
+            socketDelegate?.commandExecuted(serverResponse: .malformedResponse) {
                 self.handleFailure(message: ["empty response from ruby process"])
                 $0.writeSemaphore.signal()
             }
             return
         }
-        
+
         let responseString = string.trimmingCharacters(in: .whitespacesAndNewlines)
         let socketResponse = SocketResponse(payload: responseString)
         verbose(message: "response is: \(responseString)")
         switch socketResponse.responseType {
         case .clientInitiatedCancel:
-            self.socketDelegate?.commandExecuted(serverResponse: .clientInitiatedCancelAcknowledged) {
-                self.closeSession(sendAbort: false)
+            socketDelegate?.commandExecuted(serverResponse: .clientInitiatedCancelAcknowledged) {
                 $0.writeSemaphore.signal()
+                self.closeSession(sendAbort: false)
             }
-            
 
-        case .failure(let failureInformation):
-            self.socketDelegate?.commandExecuted(serverResponse: .serverError) {
-                self.handleFailure(message: failureInformation)
+        case let .failure(failureInformation):
+            socketDelegate?.commandExecuted(serverResponse: .serverError) {
                 $0.writeSemaphore.signal()
+                self.handleFailure(message: failureInformation)
             }
-            
 
-        case .parseFailure(let failureInformation):
-            self.socketDelegate?.commandExecuted(serverResponse: .malformedResponse) {
-                self.handleFailure(message: failureInformation)
+        case let .parseFailure(failureInformation):
+            socketDelegate?.commandExecuted(serverResponse: .malformedResponse) {
                 $0.writeSemaphore.signal()
+                self.handleFailure(message: failureInformation)
             }
-            
 
-        case .readyForNext(let returnedObject, let closureArgumentValue):
-            self.socketDelegate?.commandExecuted(serverResponse: .success(returnedObject: returnedObject, closureArgumentValue: closureArgumentValue)) {
+        case let .readyForNext(returnedObject, closureArgumentValue):
+            socketDelegate?.commandExecuted(serverResponse: .success(returnedObject: returnedObject, closureArgumentValue: closureArgumentValue)) {
                 $0.writeSemaphore.signal()
             }
         }

data/fastlane/swift/SocketResponse.swift

@@ -20,13 +20,13 @@ struct SocketResponse {
         case failure(failureInformation: [String])
         case readyForNext(returnedObject: String?, closureArgumentValue: String?)
         case clientInitiatedCancel
-        
-        init(statusDictionary: [String : Any]) {
+
+        init(statusDictionary: [String: Any]) {
             guard let status = statusDictionary["status"] as? String else {
                 self = .parseFailure(failureInformation: ["Message failed to parse from Ruby server"])
                 return
             }
-            
+
             if status == "ready_for_next" {
                 verbose(message: "ready for next")
                 let returnedObject = statusDictionary["return_object"] as? String
@@ -43,36 +43,36 @@ struct SocketResponse {
                     self = .parseFailure(failureInformation: ["Ruby server indicated failure but Swift couldn't receive it"])
                     return
                 }
-                
+
                 self = .failure(failureInformation: failureInformation)
                 return
             }
             self = .parseFailure(failureInformation: ["Message status: \(status) not a supported status"])
         }
     }
-    
+
     let responseType: ResponseType
-    
+
     init(payload: String) {
         guard let data = SocketResponse.convertToDictionary(text: payload) else {
-            self.responseType = .parseFailure(failureInformation: ["Unable to parse message from Ruby server"])
+            responseType = .parseFailure(failureInformation: ["Unable to parse message from Ruby server"])
             return
         }
-        
-        guard case let statusDictionary? = data["payload"] as? [String : Any] else {
-            self.responseType = .parseFailure(failureInformation: ["Payload missing from Ruby server response"])
+
+        guard case let statusDictionary? = data["payload"] as? [String: Any] else {
+            responseType = .parseFailure(failureInformation: ["Payload missing from Ruby server response"])
             return
         }
-        
-        self.responseType = ResponseType(statusDictionary: statusDictionary)
+
+        responseType = ResponseType(statusDictionary: statusDictionary)
     }
 }
 
 extension SocketResponse {
-    static func convertToDictionary(text: String) -> [String : Any]? {
+    static func convertToDictionary(text: String) -> [String: Any]? {
         if let data = text.data(using: .utf8) {
             do {
-                return try JSONSerialization.jsonObject(with: data, options: []) as? [String : Any]
+                return try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
             } catch {
                 log(message: error.localizedDescription)
             }

data/fastlane/swift/formatting/Brewfile

@@ -0,0 +1 @@
+brew("swiftformat")

data/fastlane/swift/formatting/Brewfile.lock.json

@@ -0,0 +1,39 @@
+{
+  "entries": {
+    "brew": {
+      "swiftformat": {
+        "version": "0.44.8",
+        "bottle": {
+          "cellar": ":any_skip_relocation",
+          "prefix": "/usr/local",
+          "files": {
+            "catalina": {
+              "url": "https://homebrew.bintray.com/bottles/swiftformat-0.44.8.catalina.bottle.tar.gz",
+              "sha256": "9cbd2c21d4579c8c4ffc9df7b44593f7622d13f8517a3fed047c5e5f3f2560c6"
+            },
+            "mojave": {
+              "url": "https://homebrew.bintray.com/bottles/swiftformat-0.44.8.mojave.bottle.tar.gz",
+              "sha256": "a8f8b6fa977804c2d13f0cbc9ed223ddaa88e3c0684e91519e005784c8418b36"
+            },
+            "high_sierra": {
+              "url": "https://homebrew.bintray.com/bottles/swiftformat-0.44.8.high_sierra.bottle.tar.gz",
+              "sha256": "fd43d192d194a8bb02308714b691e6a7101f839889f749dff4a1facf8172b951"
+            }
+          }
+        }
+      }
+    }
+  },
+  "system": {
+    "macos": {
+      "catalina": {
+        "HOMEBREW_VERSION": "2.2.14-62-g9befd55",
+        "HOMEBREW_PREFIX": "/usr/local",
+        "Homebrew/homebrew-core": "0b738b77a5a13a66a52d76d34c4f608b719e0485",
+        "CLT": "11.0.28.3",
+        "Xcode": "11.4.1",
+        "macOS": "10.15.4"
+      }
+    }
+  }
+}