fastlane 2.149.1 → 2.150.0.rc5

data/fastlane/swift/FastlaneSwiftRunner/FastlaneSwiftRunner.xcodeproj/xcshareddata/xcschemes/FastlaneRunner.xcscheme

@@ -26,10 +26,7 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       shouldUseLaunchSchemeArgsEnv = "YES">
-      <Testables>
-      </Testables>
       <MacroExpansion>
          <BuildableReference
             BuildableIdentifier = "primary"
@@ -39,14 +36,13 @@
             ReferencedContainer = "container:FastlaneSwiftRunner.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
+      <Testables>
+      </Testables>
    </TestAction>
    <LaunchAction
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"
@@ -65,7 +61,7 @@
       </BuildableProductRunnable>
       <CommandLineArguments>
          <CommandLineArgument
-            argument = "lane test"
+            argument = "lane testLane"
             isEnabled = "YES">
          </CommandLineArgument>
          <CommandLineArgument
@@ -73,8 +69,6 @@
             isEnabled = "YES">
          </CommandLineArgument>
       </CommandLineArguments>
-      <AdditionalOptions>
-      </AdditionalOptions>
    </LaunchAction>
    <ProfileAction
       buildConfiguration = "Release"

data/fastlane/swift/LaneFileProtocol.swift

@@ -19,7 +19,6 @@ public protocol LaneFileProtocol: class {
     static func runLane(named: String, parameters: [String : String]) -> Bool
 
     func recordLaneDescriptions()
-    func beforeAll(currentLane: String, parameters: [String : String])
     func beforeAll()
     func afterAll(currentLane: String)
     func onError(currentLane: String, errorInfo: String)
@@ -27,7 +26,6 @@ public protocol LaneFileProtocol: class {
 
 public extension LaneFileProtocol {
     var fastlaneVersion: String { return "" } // default "" because that means any is fine
-    func beforeAll(currentLane: String, parameters: [String : String]) { } // no op by default
     func beforeAll() { } // no op by default
     func afterAll(currentLane: String) { } // no op by default
     func onError(currentLane: String, errorInfo: String) {} // no op by default
@@ -39,8 +37,7 @@ public class LaneFile: NSObject, LaneFileProtocol {
     private(set) static var fastfileInstance: Fastfile?
 
     // Called before any lane is executed.
-    private func setupAllTheThings(lane: String, parameters: [String : String]) {
-        LaneFile.fastfileInstance!.beforeAll(currentLane: lane, parameters: parameters)
+    private func setupAllTheThings() {
         LaneFile.fastfileInstance!.beforeAll()
     }
 
@@ -126,7 +123,7 @@ public class LaneFile: NSObject, LaneFileProtocol {
         }
 
         // call all methods that need to be called before we start calling lanes
-        fastfileInstance.setupAllTheThings(lane: named, parameters: parameters)
+        fastfileInstance.setupAllTheThings()
 
         // We need to catch all possible errors here and display a nice message
         _ = fastfileInstance.perform(NSSelectorFromString(laneMethod), with: parameters)

data/fastlane/swift/MatchfileProtocol.swift

@@ -154,4 +154,4 @@ extension MatchfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.17]
+// FastlaneRunnerAPIVersion [0.9.12]

data/fastlane/swift/RubyCommand.swift

@@ -82,27 +82,50 @@ struct RubyCommand: RubyCommandable {
     let methodName: String
     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 }
+        guard let callback = callbacks.first else {
+            return nil
+        }
+
+        guard let callbackArgValue = callback.value else {
+            return nil
+        }
 
-    func performCallback(callbackArg: String) {
+        guard let callbackClosure = callbackArgValue as? ((String) -> Void) else {
+            return nil
+        }
+        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 }
         guard let callback = callbacks.first else {
             verbose(message: "received call to performCallback with \(callbackArg), but no callback available to perform")
-            return
+            return nil
         }
 
         guard let callbackArgValue = callback.value else {
             verbose(message: "received call to performCallback with \(callbackArg), but callback is nil")
-            return
+            return nil
         }
 
         guard let callbackClosure = callbackArgValue as? ((String) -> Void) else {
             verbose(message: "received call to performCallback with \(callbackArg), but callback type is unknown \(callbackArgValue.self)")
-            return
+            return nil
         }
+        return callbackClosure
+    }
 
-        print("Performing callback with: \(callbackArg)")
-        callbackClosure(callbackArg)
+    func performCallback(callbackArg: String, socket: SocketClient, completion: @escaping () -> Void) {
+        verbose(message: "Performing callback with: \(callbackArg)")
+        socket.leave()
+        self.callbackClosure(callbackArg)?(callbackArg)
+        completion()
     }
 
     var commandJson: String {

data/fastlane/swift/RubyCommandable.swift

@@ -31,6 +31,7 @@ enum CommandType {
 protocol RubyCommandable {
     var type: CommandType { get }
     var commandJson: String { get }
+    var id: String { get }
 }
 
 extension RubyCommandable {

data/fastlane/swift/Runner.swift

@@ -33,28 +33,69 @@ class Runner {
     fileprivate var returnValue: String? // lol, so safe
     fileprivate var currentlyExecutingCommand: RubyCommandable? = nil
     fileprivate var shouldLeaveDispatchGroupDuringDisconnect = false
+    fileprivate var executeNext: [String: Bool] = [:]
     
     func executeCommand(_ command: RubyCommandable) -> String {
         self.dispatchGroup.enter()
-        currentlyExecutingCommand = command
-        socketClient.send(rubyCommand: command)
+        self.currentlyExecutingCommand = command
+        self.socketClient.send(rubyCommand: command)
         
         let secondsToWait = DispatchTimeInterval.seconds(SocketClient.defaultCommandTimeoutSeconds)
-        let connectTimeout = DispatchTime.now() + secondsToWait
-        let timeoutResult = self.dispatchGroup.wait(timeout: connectTimeout)
+        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 = testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
+        let success = self.testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
         guard success else {
             log(message: "command timeout")
             fatalError()
         }
         
-        if let returnValue = self.returnValue {
-            return returnValue
+        if let _returnValue = self.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?
+            return { withoutCaching in
+                if withoutCaching || cache == nil {
+                    cache = try closure()
+                }
+                guard let cache = cache else {
+                    preconditionFailure()
+                }
+                
+                return cache
+            }
+        }
+        
+        let runLoop = RunLoop.current
+        let timeoutDate = Date(timeInterval: TimeInterval(timeout), since: Date())
+        var fulfilled: Bool = false
+        let _expression = memoizedClosure(expression)
+        repeat {
+            do {
+                let exp = try _expression(true)
+                fulfilled = predicate(exp)
+            } catch {
+                fatalError("Error raised \(error.localizedDescription)")
+            }
+            if !fulfilled {
+                runLoop.run(until: Date(timeIntervalSinceNow: pollingInterval.timeInterval))
+            } else {
+                break
+            }
+        } while Date().compare(timeoutDate) == .orderedAscending
+
+        if fulfilled {
+            return .success
+        } else {
+            return .timedOut
+        }
+    }
 }
 
 // Handle threading stuff
@@ -110,25 +151,36 @@ extension Runner {
 }
 
 extension Runner : SocketClientDelegateProtocol {
-    func commandExecuted(serverResponse: SocketClientResponse) {
+    func commandExecuted(serverResponse: SocketClientResponse, completion: (SocketClient) -> Void) {
         switch serverResponse {
         case .success(let returnedObject, let closureArgumentValue):
             verbose(message: "command executed")
             self.returnValue = returnedObject
             if let command = self.currentlyExecutingCommand as? RubyCommand {
-                if let closureArgumentValue = closureArgumentValue {
-                    command.performCallback(callbackArg: closureArgumentValue)
+                if let closureArgumentValue = closureArgumentValue, !closureArgumentValue.isEmpty {
+                    command.performCallback(callbackArg: closureArgumentValue, socket: socketClient) {
+                        self.executeNext[command.id] = true
+                    }
+                } else {
+                    self.executeNext[command.id] = true
                 }
             }
-            self.dispatchGroup.leave()
+            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
+            }
+            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
+            }
+            completion(socketClient)
         case .commandTimeout(let timeout):
             log(message: "Runner timed out after \(timeout) second(s)")
         }
@@ -144,6 +196,7 @@ extension Runner : SocketClientDelegateProtocol {
         DispatchQueue.main.async {
             self.thread?.cancel()
             self.thread = nil
+            self.socketClient.closeSession()
             self.socketClient = nil
             verbose(message: "connection closed!")
             if self.shouldLeaveDispatchGroupDuringDisconnect {
@@ -194,6 +247,25 @@ func verbose(message: String) {
     logger.verbose(message: message)
 }
 
+private extension DispatchTimeInterval {
+    var timeInterval: TimeInterval {
+        var result: TimeInterval = 0
+        switch self {
+        case .seconds(let 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 .never:
+            fatalError()
+        }
+        return result
+    }
+}
+
 // Please don't remove the lines below
 // They are used to detect outdated files
 // FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/ScanfileProtocol.swift

@@ -258,4 +258,4 @@ extension ScanfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.30]
+// FastlaneRunnerAPIVersion [0.9.23]

data/fastlane/swift/SnapshotfileProtocol.swift

@@ -64,7 +64,7 @@ protocol SnapshotfileProtocol: class {
   var addVideos: [String]? { get }
 
   /// A path to screenshots.html template
-  var htmlTemplate: String { get }
+  var htmlTemplate: String? { get }
 
   /// The directory where to store the build log
   var buildlogPath: String { get }
@@ -149,7 +149,7 @@ extension SnapshotfileProtocol {
   var appIdentifier: String? { return nil }
   var addPhotos: [String]? { return nil }
   var addVideos: [String]? { return nil }
-  var htmlTemplate: String { return "/Users/josh/Projects/fastlane/fastlane/snapshot/lib/snapshot/page.html.erb" }
+  var htmlTemplate: String? { return nil }
   var buildlogPath: String { return "~/Library/Logs/snapshot" }
   var clean: Bool { return false }
   var testWithoutBuilding: Bool? { return nil }
@@ -174,4 +174,4 @@ extension SnapshotfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.10]
+// FastlaneRunnerAPIVersion [0.9.7]

data/fastlane/swift/SocketClient.swift

@@ -13,6 +13,7 @@
 //
 
 import Foundation
+import Dispatch
 
 public enum SocketClientResponse: Error {
     case alreadyClosedSockets
@@ -41,8 +42,12 @@ class SocketClient: NSObject {
     fileprivate var outputStream: OutputStream!
     fileprivate var cleaningUpAfterDone = false
     fileprivate let dispatchGroup: DispatchGroup = DispatchGroup()
+    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
@@ -58,7 +63,9 @@ class SocketClient: NSObject {
         self.host = host
         self.port = port
         self.commandTimeoutSeconds = commandTimeoutSeconds
-        self.streamQueue = DispatchQueue(label: "streamQueue")
+        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
         self.socketDelegate = socketDelegate
         super.init()
@@ -68,7 +75,7 @@ class SocketClient: NSObject {
         var readStream: Unmanaged<CFReadStream>?
         var writeStream: Unmanaged<CFWriteStream>?
         
-        self.streamQueue.async {
+        self.streamQueue.sync {
             CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, self.host as CFString, self.port, &readStream, &writeStream)
             
             self.inputStream = readStream!.takeRetainedValue()
@@ -82,12 +89,12 @@ class SocketClient: NSObject {
         }
         
         self.dispatchGroup.enter()
-        self.streamQueue.async {
+        self.readQueue.sync {
             self.inputStream.open()
         }
         
         self.dispatchGroup.enter()
-        self.streamQueue.async {
+        self.writeQueue.sync {
             self.outputStream.open()
         }
         
@@ -100,7 +107,7 @@ class SocketClient: NSObject {
         let success = testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
         
         guard success else {
-            self.socketDelegate?.commandExecuted(serverResponse: .connectionFailure)
+            self.socketDelegate?.commandExecuted(serverResponse: .connectionFailure) { _ in }
             return
         }
         
@@ -125,7 +132,7 @@ class SocketClient: NSObject {
             log(message: "Timeout: \(failureMessage)")
             
             if case .seconds(let seconds) = timeToWait {
-                socketDelegate?.commandExecuted(serverResponse: .commandTimeout(seconds: seconds))
+                socketDelegate?.commandExecuted(serverResponse: .commandTimeout(seconds: seconds)) { _ in }
             }
             return false
         }
@@ -140,29 +147,30 @@ class SocketClient: NSObject {
     }
 
     private func sendThroughQueue(string: String) {
-        streamQueue.async {
-            let data = string.data(using: .utf8)!
-            _ = data.withUnsafeBytes { self.outputStream.write($0, maxLength: data.count) }
-        }
+        let data = string.data(using: .utf8)!
+        _ = data.withUnsafeBytes { self.outputStream.write($0, maxLength: data.count) }
     }
 
     private func privateSend(string: String) {
-        self.dispatchGroup.enter()
-        sendThroughQueue(string: string)
-
-        let timeoutSeconds = self.cleaningUpAfterDone ? 1 : self.commandTimeoutSeconds
-        let timeToWait = DispatchTimeInterval.seconds(timeoutSeconds)
-        let commandTimeout = DispatchTime.now() + timeToWait
-        let timeoutResult =  self.dispatchGroup.wait(timeout: commandTimeout)
-
-        _ = testDispatchTimeoutResult(timeoutResult, failureMessage: "Ruby process didn't return after: \(SocketClient.connectTimeoutSeconds) seconds", timeToWait: timeToWait)
+        writeQueue.sync {
+            writeSemaphore.wait()
+            self.sendThroughQueue(string: string)
+            writeSemaphore.signal()
+            let timeoutSeconds = self.cleaningUpAfterDone ? 1 : self.commandTimeoutSeconds
+            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 {
             // 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)
+            socketDelegate?.commandExecuted(serverResponse: .alreadyClosedSockets) { _ in }
             return
         }
 
@@ -185,6 +193,15 @@ class SocketClient: NSObject {
         stopOutputSession()
         self.socketDelegate?.connectionsClosed()
     }
+    
+    public func enter() {
+        dispatchGroup.enter()
+    }
+    
+    public func leave() {
+        readSemaphore.signal()
+        writeSemaphore.signal()
+    }
 }
 
 extension SocketClient: StreamDelegate {
@@ -246,18 +263,24 @@ extension SocketClient: StreamDelegate {
     }
     
     func read() {
-        var buffer = [UInt8](repeating: 0, count: maxReadLength)
-        var output = ""
-        while self.inputStream!.hasBytesAvailable {
-            let bytesRead: Int = inputStream!.read(&buffer, maxLength: buffer.count)
-            if bytesRead >= 0 {
-                output += NSString(bytes: UnsafePointer(buffer), length: bytesRead, encoding: String.Encoding.utf8.rawValue)! as String
-            } else {
-                verbose(message: "Stream read() error")
+        readQueue.sync {
+            self.readSemaphore.wait()
+            var buffer = [UInt8](repeating: 0, count: maxReadLength)
+            var output = ""
+            while self.inputStream!.hasBytesAvailable {
+                let bytesRead: Int = inputStream!.read(&buffer, maxLength: buffer.count)
+                if bytesRead >= 0 {
+                    guard let read = String(bytes: buffer[..<bytesRead], encoding: .utf8) else {
+                        fatalError("Unable to decode bytes from buffer \(buffer[..<bytesRead])")
+                    }
+                    output.append(contentsOf: read)
+                } else {
+                    verbose(message: "Stream read() error")
+                }
             }
+            self.processResponse(string: output, socket: self)
+            readSemaphore.signal()
         }
-
-        processResponse(string: output)
     }
     
     func handleFailure(message: [String]) {
@@ -266,11 +289,12 @@ extension SocketClient: StreamDelegate {
         self.send(rubyCommand: shutdownCommand)
     }
     
-    func processResponse(string: String) {
+    func processResponse(string: String, socket: SocketClient) {
         guard string.count > 0 else {
-            self.socketDelegate?.commandExecuted(serverResponse: .malformedResponse)
-            self.handleFailure(message: ["empty response from ruby process"])
-
+            self.socketDelegate?.commandExecuted(serverResponse: .malformedResponse) {
+                self.handleFailure(message: ["empty response from ruby process"])
+                $0.writeSemaphore.signal()
+            }
             return
         }
         
@@ -279,24 +303,31 @@ extension SocketClient: StreamDelegate {
         verbose(message: "response is: \(responseString)")
         switch socketResponse.responseType {
         case .clientInitiatedCancel:
-            self.socketDelegate?.commandExecuted(serverResponse: .clientInitiatedCancelAcknowledged)
-            self.closeSession(sendAbort: false)
+            self.socketDelegate?.commandExecuted(serverResponse: .clientInitiatedCancelAcknowledged) {
+                self.closeSession(sendAbort: false)
+                $0.writeSemaphore.signal()
+            }
+            
 
         case .failure(let failureInformation):
-            self.socketDelegate?.commandExecuted(serverResponse: .serverError)
-            self.handleFailure(message: failureInformation)
+            self.socketDelegate?.commandExecuted(serverResponse: .serverError) {
+                self.handleFailure(message: failureInformation)
+                $0.writeSemaphore.signal()
+            }
+            
 
         case .parseFailure(let failureInformation):
-            self.socketDelegate?.commandExecuted(serverResponse: .malformedResponse)
-            self.handleFailure(message: failureInformation)
+            self.socketDelegate?.commandExecuted(serverResponse: .malformedResponse) {
+                self.handleFailure(message: failureInformation)
+                $0.writeSemaphore.signal()
+            }
+            
 
         case .readyForNext(let returnedObject, let closureArgumentValue):
-            self.socketDelegate?.commandExecuted(serverResponse: .success(returnedObject: returnedObject, closureArgumentValue: closureArgumentValue))
-            // cool, ready for next command
-            break
+            self.socketDelegate?.commandExecuted(serverResponse: .success(returnedObject: returnedObject, closureArgumentValue: closureArgumentValue)) {
+                $0.writeSemaphore.signal()
+            }
         }
-
-        self.dispatchGroup.leave() // should now pull the next piece of work
     }
 }