fastlane-mercafacil 2.214.0

data/fastlane/swift/OptionalConfigValue.swift

@@ -0,0 +1,101 @@
+// OptionalConfigValue.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 enum OptionalConfigValue<T> {
+    case fastlaneDefault(T)
+    case userDefined(T)
+    case `nil`
+
+    func asRubyArgument(name: String, type: RubyCommand.Argument.ArgType? = nil) -> RubyCommand.Argument? {
+        if case let .userDefined(value) = self {
+            return RubyCommand.Argument(name: name, value: value, type: type)
+        }
+        return nil
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByUnicodeScalarLiteral where T == String? {
+    public typealias UnicodeScalarLiteralType = String
+
+    public init(unicodeScalarLiteral value: UnicodeScalarLiteralType) {
+        self = .userDefined(value)
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByExtendedGraphemeClusterLiteral where T == String? {
+    public typealias ExtendedGraphemeClusterLiteralType = String
+
+    public init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType) {
+        self = .userDefined(value)
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByStringLiteral where T == String? {
+    public typealias StringLiteralType = String
+
+    public init(stringLiteral value: StringLiteralType) {
+        self = .userDefined(value)
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByStringInterpolation where T == String? {}
+
+extension OptionalConfigValue: ExpressibleByNilLiteral {
+    public init(nilLiteral _: ()) {
+        self = .nil
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByIntegerLiteral where T == Int? {
+    public typealias IntegerLiteralType = Int
+
+    public init(integerLiteral value: IntegerLiteralType) {
+        self = .userDefined(value)
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByArrayLiteral where T == [String] {
+    public typealias ArrayLiteralElement = String
+
+    public init(arrayLiteral elements: ArrayLiteralElement...) {
+        self = .userDefined(elements)
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByFloatLiteral where T == Float {
+    public typealias FloatLiteralType = Float
+
+    public init(floatLiteral value: FloatLiteralType) {
+        self = .userDefined(value)
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByBooleanLiteral where T == Bool {
+    public typealias BooleanLiteralType = Bool
+
+    public init(booleanLiteral value: BooleanLiteralType) {
+        self = .userDefined(value)
+    }
+}
+
+extension OptionalConfigValue: ExpressibleByDictionaryLiteral where T == [String: Any] {
+    public typealias Key = String
+    public typealias Value = Any
+
+    public init(dictionaryLiteral elements: (Key, Value)...) {
+        var dict: [Key: Value] = [:]
+        elements.forEach {
+            dict[$0.0] = $0.1
+        }
+        self = .userDefined(dict)
+    }
+}

data/fastlane/swift/Plugins.swift

@@ -0,0 +1,16 @@
+// Plugins.swift
+// Copyright (c) 2023 FastlaneTools
+
+// This autogenerated file will be overwritten or replaced when installing/updating plugins or running "fastlane generate_swift"
+//
+//  ** 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
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.56]

data/fastlane/swift/Precheckfile.swift

@@ -0,0 +1,20 @@
+// Precheckfile.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 `precheck`
+//
+//  ** 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 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.214.0

data/fastlane/swift/PrecheckfileProtocol.swift

@@ -0,0 +1,55 @@
+// PrecheckfileProtocol.swift
+// Copyright (c) 2023 FastlaneTools
+
+public protocol PrecheckfileProtocol: AnyObject {
+    /// Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)
+    var apiKeyPath: String? { get }
+
+    /// Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)
+    var apiKey: [String: Any]? { get }
+
+    /// The bundle identifier of your app
+    var appIdentifier: String { get }
+
+    /// Your Apple ID Username
+    var username: String? { get }
+
+    /// The ID of your App Store Connect team if you're in multiple teams
+    var teamId: String? { get }
+
+    /// The name of your App Store Connect team if you're in multiple teams
+    var teamName: String? { get }
+
+    /// The platform to use (optional)
+    var platform: String { get }
+
+    /// The default rule level unless otherwise configured
+    var defaultRuleLevel: String { get }
+
+    /// Should check in-app purchases?
+    var includeInAppPurchases: Bool { get }
+
+    /// Should force check live app?
+    var useLive: Bool { get }
+
+    /// using text indicating that your IAP is free
+    var freeStuffInIap: String? { get }
+}
+
+public extension PrecheckfileProtocol {
+    var apiKeyPath: String? { return nil }
+    var apiKey: [String: Any]? { return nil }
+    var appIdentifier: String { return "" }
+    var username: String? { return nil }
+    var teamId: String? { return nil }
+    var teamName: String? { return nil }
+    var platform: String { return "ios" }
+    var defaultRuleLevel: String { return "error" }
+    var includeInAppPurchases: Bool { return true }
+    var useLive: Bool { return false }
+    var freeStuffInIap: String? { return nil }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.113]

data/fastlane/swift/RubyCommand.swift

@@ -0,0 +1,157 @@
+// RubyCommand.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
+
+struct RubyCommand: RubyCommandable {
+    var type: CommandType { return .action }
+
+    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 value != nil
+        }
+
+        var json: String {
+            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)\(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]
+    let id: String = UUID().uuidString
+
+    var closure: ((String) -> Void)? {
+        let callbacks = args.filter { ($0.type != nil) && $0.type == .stringClosure }
+        guard let callback = callbacks.first else {
+            return nil
+        }
+
+        guard let callbackArgValue = callback.value else {
+            return nil
+        }
+
+        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 = 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 nil
+        }
+
+        guard let callbackArgValue = callback.value else {
+            verbose(message: "received call to performCallback with \(callbackArg), but callback is nil")
+            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 nil
+        }
+        return callbackClosure
+    }
+
+    func performCallback(callbackArg: String, socket: SocketClient, completion: @escaping () -> Void) {
+        verbose(message: "Performing callback with: \(callbackArg)")
+        socket.leave()
+        callbackClosure(callbackArg)?(callbackArg)
+        completion()
+    }
+
+    var commandJson: String {
+        let argsArrayJson = args
+            .map { $0.json }
+            .filter { $0 != "" }
+
+        let argsJson: String?
+        if !argsArrayJson.isEmpty {
+            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.2]

data/fastlane/swift/RubyCommandable.swift

@@ -0,0 +1,43 @@
+// RubyCommandable.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
+
+enum CommandType {
+    case action
+    case control
+
+    var token: String {
+        switch self {
+        case .action:
+            return "action"
+        case .control:
+            return "control"
+        }
+    }
+}
+
+protocol RubyCommandable {
+    var type: CommandType { get }
+    var commandJson: String { get }
+    var id: String { get }
+}
+
+extension RubyCommandable {
+    var json: String {
+        return """
+        { "commandType": "\(type.token)", "command": \(commandJson) }
+        """
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/Runner.swift

@@ -0,0 +1,279 @@
+// Runner.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
+
+let logger: Logger = .init()
+
+let runner: Runner = .init()
+
+func desc(_: String) {
+    // no-op, this is handled in fastlane/lane_list.rb
+}
+
+class Runner {
+    private var thread: Thread!
+    private var socketClient: SocketClient!
+    private let dispatchGroup = DispatchGroup()
+    private var returnValue: String? // lol, so safe
+    private var currentlyExecutingCommand: RubyCommandable?
+    private var shouldLeaveDispatchGroupDuringDisconnect = false
+    private var executeNext: AtomicDictionary<String, Bool> = {
+        if #available(macOS 10.12, *) {
+            return UnfairAtomicDictionary<String, Bool>()
+        } else {
+            return OSSPinAtomicDictionary<String, Bool>()
+        }
+    }()
+
+    func executeCommand(_ command: RubyCommandable) -> String {
+        dispatchGroup.enter()
+        currentlyExecutingCommand = command
+        socketClient.send(rubyCommand: command)
+
+        let secondsToWait = DispatchTimeInterval.seconds(SocketClient.defaultCommandTimeoutSeconds)
+        // swiftformat:disable:next redundantSelf
+        let timeoutResult = Self.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)
+        guard success else {
+            log(message: "command timeout")
+            preconditionFailure()
+        }
+
+        if let _returnValue = returnValue {
+            return _returnValue
+        } else {
+            return ""
+        }
+    }
+
+    static 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 = 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
+extension Runner {
+    func startSocketThread(port: UInt32) {
+        let secondsToWait = DispatchTimeInterval.seconds(SocketClient.connectTimeoutSeconds)
+
+        dispatchGroup.enter()
+
+        socketClient = SocketClient(port: port, commandTimeoutSeconds: timeout, socketDelegate: self)
+        thread = Thread(target: self, selector: #selector(startSocketComs), object: nil)
+        guard let thread = thread else {
+            preconditionFailure("Thread did not instantiate correctly")
+        }
+
+        thread.name = "socket thread"
+        thread.start()
+
+        let connectTimeout = DispatchTime.now() + secondsToWait
+        let timeoutResult = 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")
+            preconditionFailure()
+        }
+    }
+
+    func disconnectFromFastlaneProcess() {
+        shouldLeaveDispatchGroupDuringDisconnect = true
+        dispatchGroup.enter()
+        socketClient.sendComplete()
+
+        let connectTimeout = DispatchTime.now() + 2
+        _ = dispatchGroup.wait(timeout: connectTimeout)
+    }
+
+    @objc func startSocketComs() {
+        guard let socketClient = socketClient else {
+            return
+        }
+
+        socketClient.connectAndOpenStreams()
+        dispatchGroup.leave()
+    }
+
+    private 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, completion: (SocketClient) -> Void) {
+        switch serverResponse {
+        case let .success(returnedObject, closureArgumentValue):
+            verbose(message: "command executed")
+            returnValue = returnedObject
+            if let command = currentlyExecutingCommand as? RubyCommand {
+                if let closureArgumentValue = closureArgumentValue, !closureArgumentValue.isEmpty {
+                    command.performCallback(callbackArg: closureArgumentValue, socket: socketClient) {
+                        self.executeNext[command.id] = true
+                    }
+                } else {
+                    executeNext[command.id] = true
+                }
+            }
+            dispatchGroup.leave()
+            completion(socketClient)
+        case .clientInitiatedCancelAcknowledged:
+            verbose(message: "server acknowledged a cancel request")
+            dispatchGroup.leave()
+            if let command = currentlyExecutingCommand as? RubyCommand {
+                executeNext[command.id] = true
+            }
+            completion(socketClient)
+        case .alreadyClosedSockets, .connectionFailure, .malformedRequest, .malformedResponse, .serverError:
+            log(message: "error encountered while executing command:\n\(serverResponse)")
+            dispatchGroup.leave()
+            if let command = currentlyExecutingCommand as? RubyCommand {
+                executeNext[command.id] = true
+            }
+            completion(socketClient)
+        case let .commandTimeout(timeout):
+            log(message: "Runner timed out after \(timeout) second(s)")
+        }
+    }
+
+    func connectionsOpened() {
+        DispatchQueue.main.async {
+            verbose(message: "connected!")
+        }
+    }
+
+    func connectionsClosed() {
+        DispatchQueue.main.async {
+            if let thread = self.thread {
+                thread.cancel()
+            }
+            self.thread = nil
+            self.socketClient.closeSession()
+            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)
+}
+
+private extension DispatchTimeInterval {
+    var timeInterval: TimeInterval {
+        var result: TimeInterval = 0
+        switch self {
+        case let .seconds(value):
+            result = TimeInterval(value)
+        case let .milliseconds(value):
+            result = TimeInterval(value) * 0.001
+        case let .microseconds(value):
+            result = TimeInterval(value) * 0.000_001
+        case let .nanoseconds(value):
+            result = TimeInterval(value) * 0.000_000_001
+        case .never:
+            fatalError()
+        @unknown default:
+            fatalError()
+        }
+        return result
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/RunnerArgument.swift

@@ -0,0 +1,20 @@
+// RunnerArgument.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
+
+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.2]