How to use EncodedArguments class

1import Foundation2struct FlagArgumentEncoding: Encoder {3  final class EncodedArguments {4    private(set) var arguments: [String] = []5    func append(_ name: CodingKey?) {6      if let name = name?.longArgumentName {7        arguments.append(name)8      }9    }10  }11  12  var codingPath: [CodingKey] = []13  var userInfo: [CodingUserInfoKey: Any] = [:]14  let data: EncodedArguments15  16  init(arguments: EncodedArguments = EncodedArguments()) {17    self.data = arguments18  }19  20  func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {21    var container = FlagArgumentKeyedEncoding<Key>(arguments: data)22    container.codingPath = codingPath23    return KeyedEncodingContainer<Key>(container)24  }25  26  func unkeyedContainer() -> UnkeyedEncodingContainer {27    fatalError("Unsupported encoding container type")28  }29  30  func singleValueContainer() -> SingleValueEncodingContainer {31    var container = FlagArgumentSingleValueEncoding(arguments: data)32    container.codingPath = codingPath33    return container34  }35}36struct FlagArgumentKeyedEncoding<Key: CodingKey>: KeyedEncodingContainerProtocol {37  38  var codingPath: [CodingKey] = []39  private let data: FlagArgumentEncoding.EncodedArguments40  41  init(arguments: FlagArgumentEncoding.EncodedArguments) {42    self.data = arguments43  }44  45  mutating func encodeNil(forKey key: Key) throws {46    // No-op47  }48  49  mutating func encode(_ value: Bool, forKey key: Key) throws {50    if value {51      data.append(key)52    }53  }54  55  mutating func encode(_ value: String, forKey key: Key) throws {56    fatalError("Flag arguments must be a 'Bool' type")57  }58  59  mutating func encode(_ value: Double, forKey key: Key) throws {60    fatalError("Flag arguments must be a 'Bool' type")61  }62  63  mutating func encode(_ value: Float, forKey key: Key) throws {64    fatalError("Flag arguments must be a 'Bool' type")65  }66  67  mutating func encode(_ value: Int, forKey key: Key) throws {68    fatalError("Flag arguments must be a 'Bool' type")69  }70  71  mutating func encode(_ value: Int8, forKey key: Key) throws {72    fatalError("Flag arguments must be a 'Bool' type")73  }74  75  mutating func encode(_ value: Int16, forKey key: Key) throws {76    fatalError("Flag arguments must be a 'Bool' type")77  }78  79  mutating func encode(_ value: Int32, forKey key: Key) throws {80    fatalError("Flag arguments must be a 'Bool' type")81  }82  83  mutating func encode(_ value: Int64, forKey key: Key) throws {84    fatalError("Flag arguments must be a 'Bool' type")85  }86  87  mutating func encode(_ value: UInt, forKey key: Key) throws {88    fatalError("Flag arguments must be a 'Bool' type")89  }90  91  mutating func encode(_ value: UInt8, forKey key: Key) throws {92    fatalError("Flag arguments must be a 'Bool' type")93  }94  95  mutating func encode(_ value: UInt16, forKey key: Key) throws {96    fatalError("Flag arguments must be a 'Bool' type")97  }98  99  mutating func encode(_ value: UInt32, forKey key: Key) throws {100    fatalError("Flag arguments must be a 'Bool' type")101  }102  103  mutating func encode(_ value: UInt64, forKey key: Key) throws {104    fatalError("Flag arguments must be a 'Bool' type")105  }106  107  mutating func encode<T: Encodable>(_ value: T, forKey key: Key) throws {108    fatalError("Flag arguments must be a 'Bool' type")109  }110  111  mutating func nestedContainer<NestedKey: CodingKey>(112  keyedBy keyType: NestedKey.Type,113    forKey key: Key114  ) -> KeyedEncodingContainer<NestedKey> {115    fatalError("Flag arguments must be a 'Bool' type")116  }117  118  mutating func nestedUnkeyedContainer(forKey key: Key) -> UnkeyedEncodingContainer {119    fatalError("Flag arguments must be a 'Bool' type")120  }121  122  mutating func superEncoder() -> Encoder {123    fatalError("Flag arguments must be a 'Bool' type")124  }125  126  mutating func superEncoder(forKey key: Key) -> Encoder {127    fatalError("Flag arguments must be a 'Bool' type")128  }129}130struct FlagArgumentSingleValueEncoding: SingleValueEncodingContainer {131  132  var codingPath: [CodingKey] = []133  let data: FlagArgumentEncoding.EncodedArguments134  135  init(arguments: FlagArgumentEncoding.EncodedArguments) {136    self.data = arguments137  }138  139  mutating func encodeNil() throws {140    // No-op141  }142  143  mutating func encode(_ value: Bool) throws {144    if value {145      data.append(codingPath.last)146    }147  }148  149  mutating func encode(_ value: String) throws {...

1import Foundation2import MockingbirdGenerator3import PathKit4struct OptionGroupArgumentEncoding: Encoder {5  final class EncodedArguments {6    private(set) var arguments: [String] = []7    func append(_ values: [String]) {8      arguments.append(contentsOf: values)9    }10  }11  12  var codingPath: [CodingKey] = []13  var userInfo: [CodingUserInfoKey: Any] = [:]14  let data: EncodedArguments15  let pathConfig: OptionArgumentEncoding.PathConfiguration?16  17  init(arguments: EncodedArguments = EncodedArguments(),18       pathConfig: OptionArgumentEncoding.PathConfiguration? = nil) {19    self.data = arguments20    self.pathConfig = pathConfig21  }22  23  func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {24    var container = OptionGroupArgumentKeyedEncoding<Key>(arguments: data, pathConfig: pathConfig)25    container.codingPath = codingPath26    return KeyedEncodingContainer<Key>(container)27  }28  29  func unkeyedContainer() -> UnkeyedEncodingContainer {30    fatalError("Unsupported encoding container type")31  }32  33  func singleValueContainer() -> SingleValueEncodingContainer {34    fatalError("Unsupported encoding container type")35  }36}37struct OptionGroupArgumentKeyedEncoding<Key: CodingKey>: KeyedEncodingContainerProtocol {38  39  var codingPath: [CodingKey] = []40  private let data: OptionGroupArgumentEncoding.EncodedArguments41  private let pathConfig: OptionArgumentEncoding.PathConfiguration?42  43  init(arguments: OptionGroupArgumentEncoding.EncodedArguments,44       pathConfig: OptionArgumentEncoding.PathConfiguration?) {45    self.data = arguments46    self.pathConfig = pathConfig47  }48  49  mutating func encodeNil(forKey key: Key) throws {}50  51  mutating func encode(_ value: Bool, forKey key: Key) throws {}52  53  mutating func encode(_ value: String, forKey key: Key) throws {}54  55  mutating func encode(_ value: Double, forKey key: Key) throws {}56  57  mutating func encode(_ value: Float, forKey key: Key) throws {}...

1import Foundation2struct JavaScriptExpression {3    let function: String4    let arguments: [Any?]5    6    var string: String? {7        guard let encodedArguments = encode(arguments: arguments) else { return nil }8        return "\(function)(\(encodedArguments))"9    }10    11    var wrappedString: String? {12        guard let encodedArguments = encode(arguments: arguments) else { return nil }13        return wrap(function: function, encodedArguments: encodedArguments)14    }15    16    private func wrap(function: String, encodedArguments arguments: String) -> String {17        """18        (function(result) {19          try {20            result.value = \(function)(\(arguments))21          } catch (error) {22            result.error = error.toString()23            result.stack = error.stack24          }25        26          return result27        })({})28        """29    }30    31    private func encode(arguments: [Any?]) -> String? {32        let arguments = arguments.map { $0 == nil ? NSNull() : $0! }33        34        guard let data = try? JSONSerialization.data(withJSONObject: arguments),35            let string = String(data: data, encoding: .utf8) else {36                return nil37        }38        39        // Strip leading/trailing [] so we have a list of arguments suitable for inserting between parens40        return String(string.dropFirst().dropLast())41    }42}...

1import Mockingbird2import Mockingbird3import Mockingbird4import Mockingbird5import Mockingbird6import Mockingbird7import Mockingbird8import Mockingbird9import Mockingbird10import Mockingbird11import Mockingbird12import Mockingbird13import Mockingbird14import Mockingbird15import Mockingbird16import Mockingbird17import Mockingbird18import Mockingbird19import Mockingbird20import Mockingbird

1let encodedArguments = EncodedArguments(args: [1, 2, 3])2let encodedData = try! JSONEncoder().encode(encodedArguments)3let encodedString = String(data: encodedData, encoding: .utf8)4let encodedArguments = EncodedArguments(args: [1, 2, 3])5let encodedData = try! JSONEncoder().encode(encodedArguments)6let encodedString = String(data: encodedData, encoding: .utf8)7let encodedArguments = EncodedArguments(args: [1, 2, 3])8let encodedData = try! JSONEncoder().encode(encodedArguments)9let encodedString = String(data: encodedData, encoding: .utf8)10let encodedArguments = EncodedArguments(args: [1, 2, 3])11let encodedData = try! JSONEncoder().encode(encodedArguments)12let encodedString = String(data: encodedData, encoding: .utf8)13let encodedArguments = EncodedArguments(args: [1, 2, 3])14let encodedData = try! JSONEncoder().encode(encodedArguments)15let encodedString = String(data: encodedData, encoding: .utf8)16let encodedArguments = EncodedArguments(args: [1, 2, 3])17let encodedData = try! JSONEncoder().encode(encodedArguments)18let encodedString = String(data: encodedData, encoding: .utf8)19let encodedArguments = EncodedArguments(args

1import Mockingbird2let arguments = EncodedArguments(arguments: [1, "2", 3.0])3let arguments2 = EncodedArguments(arguments: [1, "2", 3.0], labels: ["a", "b", "c"])4import Mockingbird5let arguments = EncodedArguments(arguments: [1, "2", 3.0])6let arguments2 = EncodedArguments(arguments: [1, "2", 3.0], labels: ["a", "b", "c"])7import Mockingbird8let arguments = EncodedArguments(arguments: [1, "2", 3.0])9let arguments2 = EncodedArguments(arguments: [1, "2", 3.0], labels: ["a", "b", "c"])10import Mockingbird11let arguments = EncodedArguments(arguments: [1, "2", 3.0])12let arguments2 = EncodedArguments(arguments: [1, "2", 3.0], labels: ["a", "b", "c"])13import Mockingbird14let arguments = EncodedArguments(arguments: [1, "2", 3.0])15let arguments2 = EncodedArguments(arguments: [1, "2", 3.0], labels: ["a", "b", "c"])16import Mockingbird17let arguments = EncodedArguments(arguments: [1, "2", 3.0])18let arguments2 = EncodedArguments(arguments: [1, "2", 3.0], labels: ["a", "b", "c"])19import Mockingbird20let arguments = EncodedArguments(arguments:

1import Mockingbird2import MockingbirdFramework3let encodedArguments = EncodedArguments(4        .init(type: "Int", value: "5"),5        .init(type: "String", value: "hello"),6        .init(type: "Bool", value: "true")7let mock = MockingbirdFramework.MockingbirdMock(8print("mock: \(mock)")9print("mock.test(5, \"hello\", true): \(mock.test(5, "hello", true))")10import Mockingbird11import MockingbirdFramework12let mock = Mockingbird(13    encodedArguments: EncodedArguments(14            .init(type: "Int", value: "5"),15            .init(type: "String", value: "hello"),16            .init(type: "Bool", value: "true")17print("mock: \(mock)")18print("mock.test(5, \"hello\", true): \(mock.test(5, "hello", true))")

1import Mockingbird2class EncodedArgumentsMock: EncodedArguments {3    var encodedArgument: String {4        return encodedArguments.joined(separator: " ")5    }6}7let encodedArguments = EncodedArgumentsMock()8encodedArguments.encodedArguments.append("arg1")9encodedArguments.encodedArguments.append("arg2")10mockedFunction(encodedArguments: encodedArguments)11XCTAssertEqual(encodedArguments.encodedArguments, ["arg1", "arg2"])12import Mockingbird13class EncodedArgumentsMock: EncodedArguments {14    var encodedArgument: String {15        return encodedArguments.joined(separator: " ")16    }17}18let encodedArguments = EncodedArgumentsMock()19encodedArguments.encodedArguments.append("arg1")20encodedArguments.encodedArguments.append("arg2")21mockedFunction(encodedArguments: encodedArguments)22XCTAssertEqual(encodedArguments.encodedArguments, ["arg1", "arg2"])

1let encodedArguments = EncodedArguments(arguments: ["arg1": 1, "arg2": "2"])2let encodedArgumentsData = try! JSONEncoder().encode(encodedArguments)3let encodedArgumentsString = String(data: encodedArgumentsData, encoding: .utf8)!4let encodedArgumentsStringBase64 = encodedArgumentsString.data(using: .utf8)!.base64EncodedString()5let encodedArgumentsArray = encodedArgumentsStringBase64.map { String($0) }6let encodedArgumentsArrayString = encodedArgumentsArray.joined(separator: ",")7let encodedArgumentsArrayStringBase64 = encodedArgumentsArrayString.data(using: .utf8)!.base64EncodedString()8let encodedArgumentsArrayStringBase64String = String(data: encodedArgumentsArrayStringBase64, encoding: .utf8)!9let encodedArgumentsArrayStringBase64StringBase64 = encodedArgumentsArrayStringBase64String.data(using: .utf8)!.base64EncodedString()10let encodedArgumentsArrayStringBase64StringBase64String = String(data: encodedArgumentsArrayStringBase64StringBase64, encoding: .utf8)!11let encodedArgumentsArrayStringBase64StringBase64StringBase64 = encodedArgumentsArrayStringBase64StringBase64String.data(using: .utf8)!.base64EncodedString()12let encodedArgumentsArrayStringBase64StringBase64StringBase64String = String(data: encodedArgumentsArrayStringBase64StringBase64StringBase64, encoding: .utf8)!13let encodedArgumentsArrayStringBase64StringBase64StringBase64StringBase64 = encodedArgumentsArrayStringBase64StringBase64StringBase64String.data(using: .utf8)!.base64EncodedString()14let encodedArgumentsArrayStringBase64StringBase64StringBase64StringBase64String = String(data: encodedArgumentsArrayStringBase64StringBase64StringBase64StringBase64, encoding: .utf8)!15let encodedArgumentsArrayStringBase64StringBase64StringBase64StringBase64StringBase64 = encodedArgumentsArrayStringBase64StringBase64StringBase64StringBase64String.data(using: .utf8)!.base64EncodedString()16let encodedArgumentsArrayStringBase64StringBase64StringBase64StringBase64StringBase64String = String(data: encodedArgumentsArrayStringBase64StringBase64StringBase64StringBase64StringBase64, encoding: .utf8)!

1import Foundation2import Mockingbird3let arguments = EncodedArguments(arguments: ["-c", "swiftc", "-o", "test", "test.swift"])4let process = Process()5process.launch()6process.waitUntilExit()7print("exit code: \(process.terminationStatus)")8import Foundation9import Mockingbird10let arguments = EncodedArguments(arguments: ["-c", "swiftc", "-o", "test", "test.swift"])11let process = Process()12process.launch()13process.waitUntilExit()14print("exit code: \(process.terminationStatus)")15import Foundation16import Mockingbird17let arguments = EncodedArguments(arguments: ["-c", "swiftc", "-o", "test", "test.swift"])18let process = Process()19process.launch()20process.waitUntilExit()21print("exit code: \(process.terminationStatus)")22import Foundation23import Mockingbird24let arguments = EncodedArguments(arguments: ["-c", "swiftc", "-o", "test", "test.swift"])25let process = Process()26process.launch()27process.waitUntilExit()28print("exit code: \(process.terminationStatus)")29import Foundation30import Mockingbird31let arguments = EncodedArguments(arguments: ["-c", "swiftc", "-o", "test", "test.swift"])32let process = Process()33process.launch()34process.waitUntilExit()35print("exit code: \(process.terminationStatus)")36import Foundation37import Mockingbird38let arguments = EncodedArguments(arguments: ["-c", "swiftc", "-o", "test", "test.swift

1let encodedArguments = EncodedArguments(arguments: [arg1, arg2])2let encodedArgs = encodedArguments.encodeArguments()3let encodedArguments = EncodedArguments(arguments: [arg1, arg2])4let decodedArgs = encodedArguments.decodeArguments()5let encodedArguments = EncodedArguments(arguments: [arg1, arg2])6let decodedArgs = encodedArguments.decodeArguments()7let encodedArguments = EncodedArguments(arguments: [arg1, arg2])8let decodedArgs = encodedArguments.decodeArguments()9let encodedArguments = EncodedArguments(arguments: [arg1, arg2])10let decodedArgs = encodedArguments.decodeArguments()11let encodedArguments = EncodedArguments(arguments: [arg1, arg2])12let decodedArgs = encodedArguments.decodeArguments()13let encodedArguments = EncodedArguments(arguments: [arg1, arg2])14let decodedArgs = encodedArguments.decodeArguments()15let encodedArguments = EncodedArguments(arguments: [arg1,