fastlane 2.149.1 → 2.150.0.rc1

data/fastlane/lib/fastlane/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
-  VERSION = '2.149.1'.freeze
+  VERSION = '2.150.0.rc1'.freeze
   DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
   MINIMUM_XCODE_RELEASE = "7.0".freeze
   RUBOCOP_REQUIREMENT = '0.49.1'.freeze

data/fastlane/swift/ControlCommand.swift

@@ -49,6 +49,7 @@ struct ControlCommand: RubyCommandable {
     }
 
     let message: String?
+    let id: String = UUID().uuidString
     let shutdownCommandType: ShutdownCommandType
     var commandJson: String {
         var jsonDictionary: [String: Any] = [ControlCommand.commandKey : self.shutdownCommandType.token]

data/fastlane/swift/Fastlane.swift

@@ -1491,7 +1491,7 @@ func captureIosScreenshots(workspace: String? = nil,
                            appIdentifier: String? = nil,
                            addPhotos: [String]? = nil,
                            addVideos: [String]? = nil,
-                           htmlTemplate: String = "/Users/josh/Projects/fastlane/fastlane/snapshot/lib/snapshot/page.html.erb",
+                           htmlTemplate: String? = nil,
                            buildlogPath: String = "~/Library/Logs/snapshot",
                            clean: Bool = false,
                            testWithoutBuilding: Bool? = nil,
@@ -1625,7 +1625,7 @@ func captureScreenshots(workspace: String? = nil,
                         appIdentifier: String? = nil,
                         addPhotos: [String]? = nil,
                         addVideos: [String]? = nil,
-                        htmlTemplate: String = "/Users/josh/Projects/fastlane/fastlane/snapshot/lib/snapshot/page.html.erb",
+                        htmlTemplate: String? = nil,
                         buildlogPath: String = "~/Library/Logs/snapshot",
                         clean: Bool = false,
                         testWithoutBuilding: Bool? = nil,
@@ -2039,7 +2039,7 @@ func cocoapods(repoUpdate: Bool = false,
                ansi: Bool = true,
                useBundleExec: Bool = true,
                podfile: String? = nil,
-               errorCallback: Any? = nil,
+               errorCallback: ((String) -> Void)? = nil,
                tryRepoUpdateOnError: Bool = false,
                deployment: Bool = false,
                clean: Bool = true,
@@ -2051,7 +2051,7 @@ func cocoapods(repoUpdate: Bool = false,
                                                                                            RubyCommand.Argument(name: "ansi", value: ansi),
                                                                                            RubyCommand.Argument(name: "use_bundle_exec", value: useBundleExec),
                                                                                            RubyCommand.Argument(name: "podfile", value: podfile),
-                                                                                           RubyCommand.Argument(name: "error_callback", value: errorCallback),
+                                                                                           RubyCommand.Argument(name: "error_callback", value: errorCallback, type: .stringClosure),
                                                                                            RubyCommand.Argument(name: "try_repo_update_on_error", value: tryRepoUpdateOnError),
                                                                                            RubyCommand.Argument(name: "deployment", value: deployment),
                                                                                            RubyCommand.Argument(name: "clean", value: clean),
@@ -3054,7 +3054,7 @@ func frameScreenshots(white: Bool? = nil,
                       useLegacyIphonexr: Bool = false,
                       useLegacyIphonexs: Bool = false,
                       useLegacyIphonexsmax: Bool = false,
-                      forceOrientationBlock: String? = nil,
+                      forceOrientationBlock: ((String) -> Void)? = nil,
                       debugMode: Bool = false,
                       resume: Bool = false,
                       usePlatform: String = "IOS",
@@ -3071,7 +3071,7 @@ func frameScreenshots(white: Bool? = nil,
                                                                                                    RubyCommand.Argument(name: "use_legacy_iphonexr", value: useLegacyIphonexr),
                                                                                                    RubyCommand.Argument(name: "use_legacy_iphonexs", value: useLegacyIphonexs),
                                                                                                    RubyCommand.Argument(name: "use_legacy_iphonexsmax", value: useLegacyIphonexsmax),
-                                                                                                   RubyCommand.Argument(name: "force_orientation_block", value: forceOrientationBlock),
+                                                                                                   RubyCommand.Argument(name: "force_orientation_block", value: forceOrientationBlock, type: .stringClosure),
                                                                                                    RubyCommand.Argument(name: "debug_mode", value: debugMode),
                                                                                                    RubyCommand.Argument(name: "resume", value: resume),
                                                                                                    RubyCommand.Argument(name: "use_platform", value: usePlatform),
@@ -3116,7 +3116,7 @@ func frameit(white: Bool? = nil,
              useLegacyIphonexr: Bool = false,
              useLegacyIphonexs: Bool = false,
              useLegacyIphonexsmax: Bool = false,
-             forceOrientationBlock: String? = nil,
+             forceOrientationBlock: ((String) -> Void)? = nil,
              debugMode: Bool = false,
              resume: Bool = false,
              usePlatform: String = "IOS",
@@ -3133,7 +3133,7 @@ func frameit(white: Bool? = nil,
                                                                                          RubyCommand.Argument(name: "use_legacy_iphonexr", value: useLegacyIphonexr),
                                                                                          RubyCommand.Argument(name: "use_legacy_iphonexs", value: useLegacyIphonexs),
                                                                                          RubyCommand.Argument(name: "use_legacy_iphonexsmax", value: useLegacyIphonexsmax),
-                                                                                         RubyCommand.Argument(name: "force_orientation_block", value: forceOrientationBlock),
+                                                                                         RubyCommand.Argument(name: "force_orientation_block", value: forceOrientationBlock, type: .stringClosure),
                                                                                          RubyCommand.Argument(name: "debug_mode", value: debugMode),
                                                                                          RubyCommand.Argument(name: "resume", value: resume),
                                                                                          RubyCommand.Argument(name: "use_platform", value: usePlatform),
@@ -3639,6 +3639,42 @@ func githubApi(serverUrl: String = "https://api.github.com",
   _ = runner.executeCommand(command)
 }
 
+/**
+ Retrieves release names for a Google Play track
+
+ - parameters:
+   - packageName: The package name of the application to use
+   - track: The track of the application to use. The default available tracks are: production, beta, alpha, internal
+   - key: **DEPRECATED!** Use `--json_key` instead - The p12 File used to authenticate with Google
+   - issuer: **DEPRECATED!** Use `--json_key` instead - The issuer of the p12 file (email address of the service account)
+   - jsonKey: The path to a file containing service account JSON, used to authenticate with Google
+   - jsonKeyData: The raw service account JSON data used to authenticate with Google
+   - rootUrl: Root URL for the Google Play API. The provided URL will be used for API calls in place of https://www.googleapis.com/
+   - timeout: Timeout for read, open, and send (in seconds)
+
+ - returns: Array of strings representing the release names for the given Google Play track
+
+ More information: [https://docs.fastlane.tools/actions/supply/](https://docs.fastlane.tools/actions/supply/)
+*/
+func googlePlayTrackReleaseNames(packageName: String,
+                                 track: String = "production",
+                                 key: String? = nil,
+                                 issuer: String? = nil,
+                                 jsonKey: String? = nil,
+                                 jsonKeyData: String? = nil,
+                                 rootUrl: String? = nil,
+                                 timeout: Int = 300) {
+  let command = RubyCommand(commandID: "", methodName: "google_play_track_release_names", className: nil, args: [RubyCommand.Argument(name: "package_name", value: packageName),
+                                                                                                                 RubyCommand.Argument(name: "track", value: track),
+                                                                                                                 RubyCommand.Argument(name: "key", value: key),
+                                                                                                                 RubyCommand.Argument(name: "issuer", value: issuer),
+                                                                                                                 RubyCommand.Argument(name: "json_key", value: jsonKey),
+                                                                                                                 RubyCommand.Argument(name: "json_key_data", value: jsonKeyData),
+                                                                                                                 RubyCommand.Argument(name: "root_url", value: rootUrl),
+                                                                                                                 RubyCommand.Argument(name: "timeout", value: timeout)])
+  _ = runner.executeCommand(command)
+}
+
 /**
  Retrieves version codes for a Google Play track
 
@@ -6520,10 +6556,10 @@ func setupTravis(force: Bool = false) {
 */
 @discardableResult func sh(command: String,
                            log: Bool = true,
-                           errorCallback: Any? = nil) -> String {
+                           errorCallback: ((String) -> Void)? = nil) -> String {
   let command = RubyCommand(commandID: "", methodName: "sh", className: nil, args: [RubyCommand.Argument(name: "command", value: command),
                                                                                     RubyCommand.Argument(name: "log", value: log),
-                                                                                    RubyCommand.Argument(name: "error_callback", value: errorCallback)])
+                                                                                    RubyCommand.Argument(name: "error_callback", value: errorCallback, type: .stringClosure)])
   return runner.executeCommand(command)
 }
 
@@ -6868,7 +6904,7 @@ func snapshot(workspace: Any? = snapshotfile.workspace,
               appIdentifier: Any? = snapshotfile.appIdentifier,
               addPhotos: [String]? = snapshotfile.addPhotos,
               addVideos: [String]? = snapshotfile.addVideos,
-              htmlTemplate: Any = snapshotfile.htmlTemplate,
+              htmlTemplate: Any? = snapshotfile.htmlTemplate,
               buildlogPath: Any = snapshotfile.buildlogPath,
               clean: Bool = snapshotfile.clean,
               testWithoutBuilding: Bool? = snapshotfile.testWithoutBuilding,
@@ -8924,4 +8960,4 @@ let snapshotfile: Snapshotfile = Snapshotfile()
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.77]
+// FastlaneRunnerAPIVersion [0.9.71]

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]