fastlane 2.70.0.beta.20171214010003 → 2.70.0.beta.20171215010003

data/fastlane/swift/LaneFileProtocol.swift

@@ -0,0 +1,103 @@
+//
+//  LaneFileProtocol.swift
+//  FastlaneSwiftRunner
+//
+//  Created by Joshua Liebowitz on 8/4/17.
+//  Copyright © 2017 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+public protocol LaneFileProtocol: class {
+    var fastlaneVersion: String { get }
+    static func runLane(named: String)
+    
+    func recordLaneDescriptions()
+    func beforeAll()
+    func afterAll(currentLane: String)
+    func onError(currentLane: String, errorInfo: String)
+}
+
+public extension LaneFileProtocol {
+    var fastlaneVersion: String { return "" } // default "" because that means any is fine
+    func beforeAll() { } // no op by default
+    func afterAll(currentLane: String) { } // no op by default
+    func onError(currentLane: String, errorInfo: String) {} // no op by default
+    func recordLaneDescriptions() { } // no op by default
+}
+
+@objcMembers
+public class LaneFile: NSObject, LaneFileProtocol {
+    private(set) static var fastfileInstance: Fastfile?
+    
+    // Called before any lane is executed.
+    private func setupAllTheThings() {
+        // Step 1, add lange descriptions
+        (self as! Fastfile).recordLaneDescriptions()
+        
+        // Step 2, run beforeAll() function
+        LaneFile.fastfileInstance!.beforeAll()
+    }
+    
+    public static var lanes: [String : String] {
+        var laneToMethodName: [String : String] = [:]
+        var methodCount: UInt32 = 0
+        let methodList = class_copyMethodList(self, &methodCount)
+        for i in 0..<Int(methodCount) {
+            let selName = sel_getName(method_getName(methodList![i]))
+            let name = String(cString: selName)
+            let lowercasedName = name.lowercased()
+            guard lowercasedName.hasSuffix("lane") else {
+                continue
+            }
+            
+            laneToMethodName[lowercasedName] = name
+            let lowercasedNameNoLane = String(lowercasedName.prefix(lowercasedName.count - 4))
+            laneToMethodName[lowercasedNameNoLane] = name
+        }
+        return laneToMethodName
+    }
+    
+    public static func loadFastfile() {
+        if self.fastfileInstance == nil {
+            let fastfileType: AnyObject.Type = NSClassFromString(self.className())!
+            let fastfileAsNSObjectType: NSObject.Type = fastfileType as! NSObject.Type
+            let currentFastfileInstance: Fastfile? = fastfileAsNSObjectType.init() as? Fastfile
+            self.fastfileInstance = currentFastfileInstance
+        }
+    }
+    
+    public static func runLane(named: String) {
+        log(message: "Running lane: \(named)")
+        self.loadFastfile()
+        
+        guard let fastfileInstance: Fastfile = self.fastfileInstance else {
+            let message = "Unable to instantiate class named: \(self.className())"
+            log(message: message)
+            fatalError(message)
+        }
+        
+        // call all methods that need to be called before we start calling lanes
+        fastfileInstance.setupAllTheThings()
+        
+        let currentLanes = self.lanes
+        let lowerCasedLaneRequested = named.lowercased()
+        
+        guard let laneMethod = currentLanes[lowerCasedLaneRequested] else {
+            let message = "unable to find lane named: \(named)"
+            log(message: message)
+            fatalError(message)
+        }
+        
+        // We need to catch all possible errors here and display a nice message
+        _ = fastfileInstance.perform(NSSelectorFromString(laneMethod))
+        
+        // only call on success
+        fastfileInstance.afterAll(currentLane: named)
+        log(message: "Done running lane: \(named) 🚀")
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/Matchfile.swift

@@ -0,0 +1,14 @@
+// This class is automatically included in FastlaneRunner during build
+
+// This autogenerated file will be overwritten or replaced during build time, or when you initialize `match`
+class Matchfile: MatchfileProtocol {
+// If you want to enable `match`, run `fastlane match 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.69.2

data/fastlane/swift/MatchfileProtocol.swift

@@ -0,0 +1,54 @@
+protocol MatchfileProtocol: class {
+  var gitUrl: String { get }
+  var gitBranch: String { get }
+  var type: String { get }
+  var appIdentifier: [String] { get }
+  var username: String { get }
+  var keychainName: String { get }
+  var keychainPassword: String? { get }
+  var readonly: Bool { get }
+  var teamId: String? { get }
+  var gitFullName: String? { get }
+  var gitUserEmail: String? { get }
+  var teamName: String? { get }
+  var verbose: Bool { get }
+  var force: Bool { get }
+  var skipConfirmation: Bool { get }
+  var shallowClone: Bool { get }
+  var cloneBranchDirectly: Bool { get }
+  var workspace: String? { get }
+  var forceForNewDevices: Bool { get }
+  var skipDocs: Bool { get }
+  var platform: String { get }
+  var templateName: String? { get }
+}
+
+extension MatchfileProtocol {
+  var gitUrl: String { return "" }
+  var gitBranch: String { return "master" }
+  var type: String { return "development" }
+  var appIdentifier: [String] { return [] }
+  var username: String { return "" }
+  var keychainName: String { return "login.keychain" }
+  var keychainPassword: String? { return nil }
+  var readonly: Bool { return false }
+  var teamId: String? { return nil }
+  var gitFullName: String? { return nil }
+  var gitUserEmail: String? { return nil }
+  var teamName: String? { return nil }
+  var verbose: Bool { return false }
+  var force: Bool { return false }
+  var skipConfirmation: Bool { return false }
+  var shallowClone: Bool { return false }
+  var cloneBranchDirectly: Bool { return false }
+  var workspace: String? { return nil }
+  var forceForNewDevices: Bool { return false }
+  var skipDocs: Bool { return false }
+  var platform: String { return "ios" }
+  var templateName: String? { return nil }
+}
+
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/Precheckfile.swift

@@ -0,0 +1,14 @@
+// This class is automatically included in FastlaneRunner during build
+
+// This autogenerated file will be overwritten or replaced during build time, or when you initialize `precheck`
+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
+}
+
+
+
+
+
+// Generated with fastlane 2.69.2

data/fastlane/swift/PrecheckfileProtocol.swift

@@ -0,0 +1,24 @@
+protocol PrecheckfileProtocol: class {
+  var appIdentifier: String { get }
+  var username: String { get }
+  var teamId: String? { get }
+  var teamName: String? { get }
+  var defaultRuleLevel: String { get }
+  var includeInAppPurchases: Bool { get }
+  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 }
+}
+
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/RubyCommand.swift

@@ -0,0 +1,138 @@
+//
+//  RubyCommand.swift
+//  FastlaneSwiftRunner
+//
+//  Created by Joshua Liebowitz on 8/4/17.
+//  Copyright © 2017 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+protocol RubyCommandable {
+    var json: String { get }
+}
+
+struct RubyCommand: RubyCommandable {
+    struct Argument {
+        enum ArgType {
+            case stringClosure
+
+            var typeString: String {
+                switch self {
+                case .stringClosure:
+                    return "string_closure" // this should match when is in ruby's SocketServerActionCommandExecutor
+                }
+            }
+        }
+
+        let name: String
+        let value: Any?
+        let type: ArgType?
+
+        init(name: String, value: Any?, type: ArgType? = nil) {
+            self.name = name
+            self.value = value
+            self.type = type
+        }
+
+        var hasValue: Bool {
+            return nil != self.value
+        }
+
+        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
+                    }
+                } else {
+                    // Just exclude this arg if it doesn't have a value
+                    return ""
+                }
+            }
+        }
+    }
+
+    let commandID: String
+    let methodName: String
+    let className: String?
+    let args: [Argument]
+
+    func performCallback(callbackArg: String) {
+        // 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
+        }
+
+        guard let callbackArgValue = callback.value else {
+            verbose(message: "received call to performCallback with \(callbackArg), but callback is nil")
+            return
+        }
+
+        guard let callbackClosure = callbackArgValue as? ((String) -> Void) else {
+            verbose(message: "received call to performCallback with \(callbackArg), but callback type is unknown \(callbackArgValue.self)")
+            return
+        }
+
+        print("Performing callback with: \(callbackArg)")
+        callbackClosure(callbackArg)
+    }
+
+    var json: String {
+        let argsArrayJson = self.args
+            .map { $0.json }
+            .filter { $0 != "" }
+
+        let argsJson: String?
+        if argsArrayJson.count > 0 {
+            argsJson = "\"args\" : [\(argsArrayJson.joined(separator: ","))]"
+        } else {
+            argsJson = nil
+        }
+
+        let commandIDJson = "\"commandID\" : \"\(commandID)\""
+        let methodNameJson = "\"methodName\" : \"\(methodName)\""
+
+        var jsonParts = [commandIDJson, methodNameJson]
+        if let argsJson = argsJson {
+            jsonParts.append(argsJson)
+        }
+
+        if let className = className {
+            let classNameJson = "\"className\" : \"\(className)\""
+            jsonParts.append(classNameJson)
+        }
+
+        let commandJsonString = "{\(jsonParts.joined(separator: ","))}"
+
+        return commandJsonString
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/Runner.swift

@@ -0,0 +1,190 @@
+//
+//  Runner.swift
+//  FastlaneSwiftRunner
+//
+//  Created by Joshua Liebowitz on 8/26/17.
+//  Copyright © 2017 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+let logger: Logger = {
+    return Logger()
+}()
+
+let runner: Runner = {
+    return Runner()
+}()
+
+func desc(_ laneDescription: 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
+    
+    func executeCommand(_ command: RubyCommandable) -> String {
+        self.dispatchGroup.enter()
+        currentlyExecutingCommand = command
+        socketClient.send(rubyCommand: command)
+        
+        let secondsToWait = DispatchTimeInterval.seconds(SocketClient.defaultCommandTimeoutSeconds)
+        let connectTimeout = DispatchTime.now() + secondsToWait
+        let timeoutResult = self.dispatchGroup.wait(timeout: connectTimeout)
+        let failureMessage = "command didn't execute in: \(SocketClient.defaultCommandTimeoutSeconds) seconds"
+        let success = testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
+        guard success else {
+            log(message: "command timeout")
+            fatalError()
+        }
+        
+        if let returnValue = self.returnValue {
+            return returnValue
+        } else {
+            return ""
+        }
+    }
+}
+
+// Handle threading stuff
+extension Runner {
+    func startSocketThread() {
+        let secondsToWait = DispatchTimeInterval.seconds(SocketClient.connectTimeoutSeconds)
+        
+        self.dispatchGroup.enter()
+        
+        self.socketClient = SocketClient(commandTimeoutSeconds:timeout, socketDelegate: self)
+        self.thread = Thread(target: self, selector: #selector(startSocketComs), object: nil)
+        self.thread!.name = "socket thread"
+        self.thread!.start()
+        
+        let connectTimeout = DispatchTime.now() + secondsToWait
+        let timeoutResult = self.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()
+        }
+    }
+    
+    func disconnectFromFastlaneProcess() {
+        self.shouldLeaveDispatchGroupDuringDisconnect = true
+        self.dispatchGroup.enter()
+        socketClient.sendComplete()
+        
+        let connectTimeout = DispatchTime.now() + 2
+        _ = self.dispatchGroup.wait(timeout: connectTimeout)
+    }
+    
+    @objc func startSocketComs() {
+        guard let socketClient = self.socketClient else {
+            return
+        }
+
+        socketClient.connectAndOpenStreams()
+        self.dispatchGroup.leave()
+    }
+    
+    fileprivate func testDispatchTimeoutResult(_ timeoutResult: DispatchTimeoutResult, failureMessage: String, timeToWait: DispatchTimeInterval) -> Bool {
+        switch timeoutResult {
+        case .success:
+            return true
+        case .timedOut:
+            log(message: "timeout: \(failureMessage)")
+            return false
+        }
+    }
+}
+
+extension Runner : SocketClientDelegateProtocol {
+    func commandExecuted(serverResponse: SocketClientResponse) {
+        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)
+                }
+            }
+            self.dispatchGroup.leave()
+            
+        case .alreadyClosedSockets, .connectionFailure, .malformedRequest, .malformedResponse, .serverError:
+            log(message: "error encountered while executing command:\n\(serverResponse)")
+            self.dispatchGroup.leave()
+
+        case .commandTimeout(let 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()
+            self.thread = nil
+            self.socketClient = nil
+            verbose(message: "connection closed!")
+            if self.shouldLeaveDispatchGroupDuringDisconnect {
+                self.dispatchGroup.leave()
+            }
+            exit(0)
+        }
+    }
+}
+
+class Logger {
+    enum LogMode {
+        init(logMode: String) {
+            switch logMode {
+            case "normal", "default":
+                self = .normal
+            case "verbose":
+                self = .verbose
+            default:
+                logger.log(message: "unrecognized log mode: \(logMode), defaulting to 'normal'")
+                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
+            print("[\(timestamp)]: \(message)")
+        }
+    }
+}
+
+func log(message: String) {
+    logger.log(message: message)
+}
+
+func verbose(message: String) {
+    logger.verbose(message: message)
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/RunnerArgument.swift

@@ -0,0 +1,18 @@
+//
+//  RunnerArgument.swift
+//  FastlaneSwiftRunner
+//
+//  Created by Joshua Liebowitz on 9/1/17.
+//  Copyright © 2017 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+struct RunnerArgument {
+    let name: String
+    let value: String
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/Scanfile.swift

@@ -0,0 +1,14 @@
+// This class is automatically included in FastlaneRunner during build
+
+// This autogenerated file will be overwritten or replaced during build time, or when you initialize `scan`
+class Scanfile: ScanfileProtocol {
+// If you want to enable `scan`, run `fastlane scan 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.69.2

data/fastlane/swift/ScanfileProtocol.swift

@@ -0,0 +1,88 @@
+protocol ScanfileProtocol: class {
+  var workspace: String? { get }
+  var project: String? { get }
+  var device: String? { get }
+  var toolchain: String? { get }
+  var devices: [String]? { get }
+  var scheme: String? { get }
+  var clean: Bool { get }
+  var codeCoverage: Bool? { get }
+  var addressSanitizer: Bool? { get }
+  var threadSanitizer: Bool? { get }
+  var skipBuild: Bool { get }
+  var outputDirectory: String { get }
+  var outputStyle: String? { get }
+  var outputTypes: String { get }
+  var outputFiles: String? { get }
+  var buildlogPath: String { get }
+  var includeSimulatorLogs: Bool { get }
+  var formatter: String? { get }
+  var testWithoutBuilding: Bool? { get }
+  var buildForTesting: Bool? { get }
+  var xctestrun: String? { get }
+  var derivedDataPath: String? { get }
+  var resultBundle: String? { get }
+  var sdk: String? { get }
+  var openReport: Bool { get }
+  var configuration: String? { get }
+  var destination: String? { get }
+  var xcargs: String? { get }
+  var xcconfig: String? { get }
+  var onlyTesting: String? { get }
+  var skipTesting: String? { get }
+  var slackUrl: String? { get }
+  var slackChannel: String? { get }
+  var slackMessage: String? { get }
+  var skipSlack: Bool { get }
+  var slackOnlyOnFailure: Bool { get }
+  var useClangReportName: Bool { get }
+  var customReportFileName: String? { get }
+  var failBuild: Bool { get }
+}
+
+extension ScanfileProtocol {
+  var workspace: String? { return nil }
+  var project: String? { return nil }
+  var device: String? { return nil }
+  var toolchain: String? { return nil }
+  var devices: [String]? { return nil }
+  var scheme: String? { return nil }
+  var clean: Bool { return false }
+  var codeCoverage: Bool? { return nil }
+  var addressSanitizer: Bool? { return nil }
+  var threadSanitizer: Bool? { return nil }
+  var skipBuild: Bool { return false }
+  var outputDirectory: String { return "./test_output" }
+  var outputStyle: String? { return nil }
+  var outputTypes: String { return "html,junit" }
+  var outputFiles: String? { return nil }
+  var buildlogPath: String { return "~/Library/Logs/scan" }
+  var includeSimulatorLogs: Bool { return false }
+  var formatter: String? { return nil }
+  var testWithoutBuilding: Bool? { return nil }
+  var buildForTesting: Bool? { return nil }
+  var xctestrun: String? { return nil }
+  var derivedDataPath: String? { return nil }
+  var resultBundle: String? { return nil }
+  var sdk: String? { return nil }
+  var openReport: Bool { return false }
+  var configuration: String? { return nil }
+  var destination: String? { return nil }
+  var xcargs: String? { return nil }
+  var xcconfig: String? { return nil }
+  var onlyTesting: String? { return nil }
+  var skipTesting: String? { return nil }
+  var slackUrl: String? { return nil }
+  var slackChannel: String? { return nil }
+  var slackMessage: String? { return nil }
+  var skipSlack: Bool { return false }
+  var slackOnlyOnFailure: Bool { return false }
+  var useClangReportName: Bool { return false }
+  var customReportFileName: String? { return nil }
+  var failBuild: Bool { return true }
+}
+
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/Screengrabfile.swift

@@ -0,0 +1,14 @@
+// This class is automatically included in FastlaneRunner during build
+
+// This autogenerated file will be overwritten or replaced during build time, or when you initialize `screengrab`
+class Screengrabfile: ScreengrabfileProtocol {
+// If you want to enable `screengrab`, run `fastlane screengrab 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.69.2