fastlane-security-patched 2.216.0

data/fastlane/swift/GymfileProtocol.swift

@@ -0,0 +1,211 @@
+// GymfileProtocol.swift
+// Copyright (c) 2023 FastlaneTools
+
+public protocol GymfileProtocol: AnyObject {
+    /// Path to the workspace file
+    var workspace: String? { get }
+
+    /// Path to the project file
+    var project: String? { get }
+
+    /// The project's scheme. Make sure it's marked as `Shared`
+    var scheme: String? { get }
+
+    /// Should the project be cleaned before building it?
+    var clean: Bool { get }
+
+    /// The directory in which the ipa file should be stored in
+    var outputDirectory: String { get }
+
+    /// The name of the resulting ipa file
+    var outputName: String? { get }
+
+    /// The configuration to use when building the app. Defaults to 'Release'
+    var configuration: String? { get }
+
+    /// Hide all information that's not necessary while building
+    var silent: Bool { get }
+
+    /// The name of the code signing identity to use. It has to match the name exactly. e.g. 'iPhone Distribution: SunApps GmbH'
+    var codesigningIdentity: String? { get }
+
+    /// Should we skip packaging the ipa?
+    var skipPackageIpa: Bool { get }
+
+    /// Should we skip packaging the pkg?
+    var skipPackagePkg: Bool { get }
+
+    /// Should the ipa file include symbols?
+    var includeSymbols: Bool? { get }
+
+    /// Should the ipa file include bitcode?
+    var includeBitcode: Bool? { get }
+
+    /// Method used to export the archive. Valid values are: app-store, validation, ad-hoc, package, enterprise, development, developer-id and mac-application
+    var exportMethod: String? { get }
+
+    /// Path to an export options plist or a hash with export options. Use 'xcodebuild -help' to print the full set of available options
+    var exportOptions: [String: Any]? { get }
+
+    /// Pass additional arguments to xcodebuild for the package phase. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS="-ObjC -lstdc++"
+    var exportXcargs: String? { get }
+
+    /// Export ipa from previously built xcarchive. Uses archive_path as source
+    var skipBuildArchive: Bool? { get }
+
+    /// After building, don't archive, effectively not including -archivePath param
+    var skipArchive: Bool? { get }
+
+    /// Build without codesigning
+    var skipCodesigning: Bool? { get }
+
+    /// Platform to build when using a Catalyst enabled app. Valid values are: ios, macos
+    var catalystPlatform: String? { get }
+
+    /// Full name of 3rd Party Mac Developer Installer or Developer ID Installer certificate. Example: `3rd Party Mac Developer Installer: Your Company (ABC1234XWYZ)`
+    var installerCertName: String? { get }
+
+    /// The directory in which the archive should be stored in
+    var buildPath: String? { get }
+
+    /// The path to the created archive
+    var archivePath: String? { get }
+
+    /// The directory where built products and other derived data will go
+    var derivedDataPath: String? { get }
+
+    /// Should an Xcode result bundle be generated in the output directory
+    var resultBundle: Bool { get }
+
+    /// Path to the result bundle directory to create. Ignored if `result_bundle` if false
+    var resultBundlePath: String? { get }
+
+    /// The directory where to store the build log
+    var buildlogPath: String { get }
+
+    /// The SDK that should be used for building the application
+    var sdk: String? { get }
+
+    /// The toolchain that should be used for building the application (e.g. com.apple.dt.toolchain.Swift_2_3, org.swift.30p620160816a)
+    var toolchain: String? { get }
+
+    /// Use a custom destination for building the app
+    var destination: String? { get }
+
+    /// Optional: Sometimes you need to specify a team id when exporting the ipa file
+    var exportTeamId: String? { get }
+
+    /// Pass additional arguments to xcodebuild for the build phase. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS="-ObjC -lstdc++"
+    var xcargs: String? { get }
+
+    /// Use an extra XCCONFIG file to build your app
+    var xcconfig: String? { get }
+
+    /// Suppress the output of xcodebuild to stdout. Output is still saved in buildlog_path
+    var suppressXcodeOutput: Bool? { get }
+
+    /// xcodebuild formatter to use (ex: 'xcbeautify', 'xcbeautify --quieter', 'xcpretty', 'xcpretty -test'). Use empty string (ex: '') to disable any formatter (More information: https://docs.fastlane.tools/best-practices/xcodebuild-formatters/)
+    var xcodebuildFormatter: String { get }
+
+    /// Create a build timing summary
+    var buildTimingSummary: Bool { get }
+
+    /// **DEPRECATED!** Use `xcodebuild_formatter: ''` instead - Disable xcpretty formatting of build output
+    var disableXcpretty: Bool? { get }
+
+    /// Use the test (RSpec style) format for build output
+    var xcprettyTestFormat: Bool? { get }
+
+    /// A custom xcpretty formatter to use
+    var xcprettyFormatter: String? { get }
+
+    /// Have xcpretty create a JUnit-style XML report at the provided path
+    var xcprettyReportJunit: String? { get }
+
+    /// Have xcpretty create a simple HTML report at the provided path
+    var xcprettyReportHtml: String? { get }
+
+    /// Have xcpretty create a JSON compilation database at the provided path
+    var xcprettyReportJson: String? { get }
+
+    /// Have xcpretty use unicode encoding when reporting builds
+    var xcprettyUtf: Bool? { get }
+
+    /// Analyze the project build time and store the output in 'culprits.txt' file
+    var analyzeBuildTime: Bool? { get }
+
+    /// Do not try to build a profile mapping from the xcodeproj. Match or a manually provided mapping should be used
+    var skipProfileDetection: Bool { get }
+
+    /// Allows for override of the default `xcodebuild` command
+    var xcodebuildCommand: String { get }
+
+    /// Sets a custom path for Swift Package Manager dependencies
+    var clonedSourcePackagesPath: String? { get }
+
+    /// Skips resolution of Swift Package Manager dependencies
+    var skipPackageDependenciesResolution: Bool { get }
+
+    /// Prevents packages from automatically being resolved to versions other than those recorded in the `Package.resolved` file
+    var disablePackageAutomaticUpdates: Bool { get }
+
+    /// Lets xcodebuild use system's scm configuration
+    var useSystemScm: Bool { get }
+}
+
+public extension GymfileProtocol {
+    var workspace: String? { return nil }
+    var project: String? { return nil }
+    var scheme: String? { return nil }
+    var clean: Bool { return false }
+    var outputDirectory: String { return "." }
+    var outputName: String? { return nil }
+    var configuration: String? { return nil }
+    var silent: Bool { return false }
+    var codesigningIdentity: String? { return nil }
+    var skipPackageIpa: Bool { return false }
+    var skipPackagePkg: Bool { return false }
+    var includeSymbols: Bool? { return nil }
+    var includeBitcode: Bool? { return nil }
+    var exportMethod: String? { return nil }
+    var exportOptions: [String: Any]? { return nil }
+    var exportXcargs: String? { return nil }
+    var skipBuildArchive: Bool? { return nil }
+    var skipArchive: Bool? { return nil }
+    var skipCodesigning: Bool? { return nil }
+    var catalystPlatform: String? { return nil }
+    var installerCertName: String? { return nil }
+    var buildPath: String? { return nil }
+    var archivePath: String? { return nil }
+    var derivedDataPath: String? { return nil }
+    var resultBundle: Bool { return false }
+    var resultBundlePath: String? { return nil }
+    var buildlogPath: String { return "~/Library/Logs/gym" }
+    var sdk: String? { return nil }
+    var toolchain: String? { return nil }
+    var destination: String? { return nil }
+    var exportTeamId: String? { return nil }
+    var xcargs: String? { return nil }
+    var xcconfig: String? { return nil }
+    var suppressXcodeOutput: Bool? { return nil }
+    var xcodebuildFormatter: String { return "xcbeautify" }
+    var buildTimingSummary: Bool { return false }
+    var disableXcpretty: Bool? { return nil }
+    var xcprettyTestFormat: Bool? { return nil }
+    var xcprettyFormatter: String? { return nil }
+    var xcprettyReportJunit: String? { return nil }
+    var xcprettyReportHtml: String? { return nil }
+    var xcprettyReportJson: String? { return nil }
+    var xcprettyUtf: Bool? { return nil }
+    var analyzeBuildTime: Bool? { return nil }
+    var skipProfileDetection: Bool { return false }
+    var xcodebuildCommand: String { return "xcodebuild" }
+    var clonedSourcePackagesPath: String? { return nil }
+    var skipPackageDependenciesResolution: Bool { return false }
+    var disablePackageAutomaticUpdates: Bool { return false }
+    var useSystemScm: Bool { return false }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.124]

data/fastlane/swift/LaneFileProtocol.swift

@@ -0,0 +1,155 @@
+// LaneFileProtocol.swift
+// Copyright (c) 2023 FastlaneTools
+
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+import Foundation
+
+public protocol LaneFileProtocol: AnyObject {
+    var fastlaneVersion: String { get }
+    static func runLane(from fastfile: LaneFile?, named lane: String, with parameters: [String: String]) -> Bool
+
+    func recordLaneDescriptions()
+    func beforeAll(with lane: String)
+    func afterAll(with lane: String)
+    func onError(currentLane: String, errorInfo: String, errorClass: String?, errorMessage: String?)
+}
+
+public extension LaneFileProtocol {
+    var fastlaneVersion: String { return "" } // Defaults to "" because that means any is fine
+    func beforeAll(with _: String) {} // No-op by default
+    func afterAll(with _: String) {} // No-op by default
+    func recordLaneDescriptions() {} // No-op by default
+}
+
+@objcMembers
+open class LaneFile: NSObject, LaneFileProtocol {
+    private(set) static var fastfileInstance: LaneFile?
+    private static var onErrorCalled = Set<String>()
+
+    private static func trimLaneFromName(laneName: String) -> String {
+        return String(laneName.prefix(laneName.count - 4))
+    }
+
+    private static func trimLaneWithOptionsFromName(laneName: String) -> String {
+        return String(laneName.prefix(laneName.count - 12))
+    }
+
+    public func onError(currentLane: String, errorInfo _: String, errorClass _: String?, errorMessage _: String?) {
+        LaneFile.onErrorCalled.insert(currentLane)
+    }
+
+    private static var laneFunctionNames: [String] {
+        var lanes: [String] = []
+        var methodCount: UInt32 = 0
+        #if !SWIFT_PACKAGE
+            let methodList = class_copyMethodList(self, &methodCount)
+        #else
+            // In SPM we're calling this functions out of the scope of the normal binary that it's
+            // being built, so *self* in this scope would be the SPM executable instead of the Fastfile
+            // that we'd normally expect.
+            let methodList = class_copyMethodList(type(of: fastfileInstance!), &methodCount)
+        #endif
+        for i in 0 ..< Int(methodCount) {
+            let selName = sel_getName(method_getName(methodList![i]))
+            let name = String(cString: selName)
+            let lowercasedName = name.lowercased()
+            if lowercasedName.hasSuffix("lane") || lowercasedName.hasSuffix("lanewithoptions:") {
+                lanes.append(name)
+            }
+        }
+        return lanes
+    }
+
+    public static var lanes: [String: String] {
+        var laneToMethodName: [String: String] = [:]
+        laneFunctionNames.forEach { name in
+            let lowercasedName = name.lowercased()
+            if lowercasedName.hasSuffix("lane") {
+                laneToMethodName[lowercasedName] = name
+                let lowercasedNameNoLane = trimLaneFromName(laneName: lowercasedName)
+                laneToMethodName[lowercasedNameNoLane] = name
+            } else if lowercasedName.hasSuffix("lanewithoptions:") {
+                let lowercasedNameNoOptions = trimLaneWithOptionsFromName(laneName: lowercasedName)
+                laneToMethodName[lowercasedNameNoOptions] = name
+                let lowercasedNameNoLane = trimLaneFromName(laneName: lowercasedNameNoOptions)
+                laneToMethodName[lowercasedNameNoLane] = name
+            }
+        }
+
+        return laneToMethodName
+    }
+
+    public static func loadFastfile() {
+        if fastfileInstance == nil {
+            let fastfileType: AnyObject.Type = NSClassFromString(className())!
+            let fastfileAsNSObjectType: NSObject.Type = fastfileType as! NSObject.Type
+            let currentFastfileInstance: Fastfile? = fastfileAsNSObjectType.init() as? Fastfile
+            fastfileInstance = currentFastfileInstance
+        }
+    }
+
+    public static func runLane(from fastfile: LaneFile?, named lane: String, with parameters: [String: String]) -> Bool {
+        log(message: "Running lane: \(lane)")
+        #if !SWIFT_PACKAGE
+            // When not in SPM environment, we load the Fastfile from its `className()`.
+            loadFastfile()
+            guard let fastfileInstance = fastfileInstance as? Fastfile else {
+                let message = "Unable to instantiate class named: \(className())"
+                log(message: message)
+                fatalError(message)
+            }
+        #else
+            // When in SPM environment, we can't load the Fastfile from its `className()` because the executable is in
+            // another scope, so `className()` won't be the expected Fastfile. Instead, we load the Fastfile as a Lanefile
+            // in a static way, by parameter.
+            guard let fastfileInstance = fastfile else {
+                log(message: "Found nil instance of fastfile")
+                preconditionFailure()
+            }
+            self.fastfileInstance = fastfileInstance
+        #endif
+        let currentLanes = lanes
+        let lowerCasedLaneRequested = lane.lowercased()
+
+        guard let laneMethod = currentLanes[lowerCasedLaneRequested] else {
+            let laneNames = laneFunctionNames.map { laneFuctionName in
+                if laneFuctionName.hasSuffix("lanewithoptions:") {
+                    return trimLaneWithOptionsFromName(laneName: laneFuctionName)
+                } else {
+                    return trimLaneFromName(laneName: laneFuctionName)
+                }
+            }.joined(separator: ", ")
+
+            let message = "[!] Could not find lane '\(lane)'. Available lanes: \(laneNames)"
+            log(message: message)
+
+            let shutdownCommand = ControlCommand(commandType: .cancel(cancelReason: .clientError), message: message)
+            _ = runner.executeCommand(shutdownCommand)
+            return false
+        }
+
+        // Call all methods that need to be called before we start calling lanes.
+        fastfileInstance.beforeAll(with: lane)
+
+        // We need to catch all possible errors here and display a nice message.
+        _ = fastfileInstance.perform(NSSelectorFromString(laneMethod), with: parameters)
+
+        // Call only on success.
+        if !LaneFile.onErrorCalled.contains(lane) {
+            fastfileInstance.afterAll(with: lane)
+        }
+
+        log(message: "Done running lane: \(lane) 🚀")
+        return true
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/MainProcess.swift

@@ -0,0 +1,79 @@
+// MainProcess.swift
+// Copyright (c) 2023 FastlaneTools
+
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+import Foundation
+#if canImport(SwiftShell)
+    import SwiftShell
+#endif
+
+let argumentProcessor = ArgumentProcessor(args: CommandLine.arguments)
+let timeout = argumentProcessor.commandTimeout
+
+class MainProcess {
+    var doneRunningLane = false
+    var thread: Thread!
+    #if SWIFT_PACKAGE
+        var lastPrintDate = Date.distantFuture
+        var timeBetweenPrints = Int.min
+        var rubySocketCommand: AsyncCommand!
+    #endif
+
+    @objc func connectToFastlaneAndRunLane(_ fastfile: LaneFile?) {
+        runner.startSocketThread(port: argumentProcessor.port)
+
+        let completedRun = Fastfile.runLane(from: fastfile, named: argumentProcessor.currentLane, with: argumentProcessor.laneParameters())
+        if completedRun {
+            runner.disconnectFromFastlaneProcess()
+        }
+
+        doneRunningLane = true
+    }
+
+    func startFastlaneThread(with fastFile: LaneFile?) {
+        #if !SWIFT_PACKAGE
+            thread = Thread(target: self, selector: #selector(connectToFastlaneAndRunLane), object: nil)
+        #else
+            thread = Thread(target: self, selector: #selector(connectToFastlaneAndRunLane), object: fastFile)
+        #endif
+        thread.name = "worker thread"
+        #if SWIFT_PACKAGE
+            let PATH = run("/bin/bash", "-c", "-l", "eval $(/usr/libexec/path_helper -s) ; echo $PATH").stdout
+            main.env["PATH"] = PATH
+            let path = main.run(bash: "which fastlane").stdout
+            let pids = main.run("lsof", "-t", "-i", ":\(argumentProcessor.port)").stdout.split(separator: "\n")
+            pids.forEach { main.run("kill", "-9", $0) }
+            rubySocketCommand = main.runAsync(path, "socket_server", "-c", argumentProcessor.commandTimeout, "-p", argumentProcessor.port)
+            lastPrintDate = Date()
+            rubySocketCommand.stderror.onStringOutput { print($0) }
+            rubySocketCommand.stdout.onStringOutput { stdout in
+                print(stdout)
+                self.timeBetweenPrints = Int(self.lastPrintDate.timeIntervalSinceNow)
+            }
+
+            // swiftformat:disable:next redundantSelf
+            _ = Runner.waitWithPolling(self.timeBetweenPrints, toEventually: { $0 > 5 }, timeout: 10)
+            thread.start()
+        #endif
+    }
+}
+
+public class Main {
+    let process = MainProcess()
+
+    public init() {}
+
+    public func run(with fastFile: LaneFile?) {
+        process.startFastlaneThread(with: fastFile)
+
+        while !process.doneRunningLane, RunLoop.current.run(mode: RunLoopMode.defaultRunLoopMode, before: Date(timeIntervalSinceNow: 2)) {
+            // no op
+        }
+    }
+}

data/fastlane/swift/Matchfile.swift

@@ -0,0 +1,20 @@
+// Matchfile.swift
+// Copyright (c) 2023 FastlaneTools
+
+// 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`
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+public 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.217.0