Merge pull request #12 from MFB-Technologies-Inc/feature/option-value-formatting

r-jarvis · web-flow · commit 98f9fd9b2def · 2024-02-15T09:33:56.000-06:00
Improve Option formatting
diff --git a/Sources/ArgumentEncoding/Formatters.swift b/Sources/ArgumentEncoding/Formatters.swift
@@ -13,11 +13,11 @@ import XCTestDynamicOverlay
 public struct FlagFormatter: Sendable {
     /// Formats a key string
     public let prefix: @Sendable () -> String
-    public let body: @Sendable (_ key: String) -> String
+    public let key: @Sendable (_ key: String) -> String
 
     @Sendable
     public func format(key: String) -> String {
-        prefix() + body(key)
+        prefix() + self.key(key)
     }
 
     @Sendable
@@ -29,73 +29,80 @@ public struct FlagFormatter: Sendable {
     ///
     /// - Parameters
     ///   - prefix: Closure that returns the prefix string
-    ///   - body: Closure that transforms the key string for formatting
+    ///   - key: Closure that transforms the key string for formatting
     public init(
         prefix: @escaping @Sendable () -> String,
-        body: @escaping @Sendable (_ key: String) -> String
+        key: @escaping @Sendable (_ key: String) -> String
     ) {
         self.prefix = prefix
-        self.body = body
+        self.key = key
     }
 
     /// Initialize a new formatter
     ///
     /// - Parameters
     ///   - prefix: Name spaced closure that returns the prefix string for a Flag
-    ///   - body: Name spaced closure that transforms the key string for formatting
-    public init(prefix: PrefixFormatter = .empty, body: BodyFormatter = .empty) {
+    ///   - key: Name spaced closure that transforms the key string for formatting
+    public init(prefix: PrefixFormatter = .empty, key: KeyFormatter = .empty) {
         self.init(
             prefix: prefix.transform,
-            body: body.transform
+            key: key.transform
         )
     }
 }
 
 /// Formats `Option`s to match how different executables format arguments
 public struct OptionFormatter: Sendable {
     public let prefix: @Sendable () -> String
-    public let body: @Sendable (_ key: String) -> String
-    public let separator: @Sendable () -> String
+    public let key: @Sendable (_ key: String) -> String
+    public let separator: @Sendable (_ key: String, _ value: String) -> [String]
+    public let value: @Sendable (_ value: String) -> String
 
-    public func format(key: String, value: String) -> String {
-        prefix() + body(key) + separator() + value
+    public func format(key: String, value: String) -> [String] {
+        separator(prefix() + self.key(key), self.value(value))
     }
 
-    func format(encoding: OptionEncoding) -> String {
+    func format(encoding: OptionEncoding) -> [String] {
         format(key: encoding.key, value: encoding.value)
     }
 
     /// Initialize a new formatter
     ///
     /// - Parameters
     ///   - prefix: Closure that returns the prefix string
-    ///   - body: Closure that transforms the key string for formatting
+    ///   - key: Closure that transforms the key string for formatting
     ///   - separator: Closure that returns the string that separates the key and value
+    ///   - value: Closure that transforms the value string for formatting
     public init(
         prefix: @escaping @Sendable () -> String,
-        body: @escaping @Sendable (_ key: String) -> String,
-        separator: @escaping @Sendable () -> String
+        key: @escaping @Sendable (_ key: String) -> String,
+        separator: @escaping @Sendable (_ key: String, _ value: String) -> [String],
+        value: @escaping @Sendable (_ value: String) -> String
     ) {
         self.prefix = prefix
-        self.body = body
+        self.key = key
         self.separator = separator
+        self.value = value
     }
 
     /// Initialize a new formatter
     ///
     /// - Parameters
     ///   - prefix: Name spaced closure that returns the prefix string for a Flag
-    ///   - body: Name spaced closure that transforms the key string for formatting
+    ///   - key: Name spaced closure that transforms the key string for formatting
     ///   - separator: Name spaced closure that returns the string that separates the key and value
+    ///   - value: Name spaced closure that transforms the value string for formatting
     public init(
         prefix: PrefixFormatter = .empty,
-        body: BodyFormatter = .empty,
-        separator: SeparatorFormatter = .space
+        key: KeyFormatter = .empty,
+        separator: SeparatorFormatter = .separate,
+        value: KeyFormatter = .empty
     ) {
         self.init(
             prefix: prefix.transform,
-            body: body.transform,
-            separator: separator.transform
+            key: key.transform,
+            separator: separator.transform,
+            value: value.transform
         )
     }
 }
@@ -116,7 +123,7 @@ public struct PrefixFormatter: Sendable {
 }
 
 /// Name space for a closure that transforms a Flag or Option's key
-public struct BodyFormatter: Sendable {
+public struct KeyFormatter: Sendable {
     public let transform: @Sendable (_ key: String) -> String
 
     public init(_ transform: @escaping @Sendable (_ key: String) -> String) {
@@ -126,18 +133,20 @@ public struct BodyFormatter: Sendable {
     public static let empty = Self { $0 }
     public static let kebabCase = Self(CaseConverter.kebabCase)
     public static let snakeCase = Self(CaseConverter.snakeCase)
+    public static let singleQuote = Self { "'\($0)'" }
 }
 
-/// Name space for a closure that returns the separator string between an Option's key and value
+/// Name space for a closure that returns the Option's key and value separated by a string or as separate elements in an
+/// array
 public struct SeparatorFormatter: Sendable {
-    public let transform: @Sendable () -> String
+    public let transform: @Sendable (_ key: String, _ value: String) -> [String]
 
-    public init(_ transform: @escaping @Sendable () -> String) {
+    public init(_ transform: @escaping @Sendable (_ key: String, _ value: String) -> [String]) {
         self.transform = transform
     }
 
-    public static let space = Self { StaticString.space.description }
-    public static let equal = Self { StaticString.equal.description }
+    public static let separate = Self { [$0, $1] }
+    public static let equal = Self { ["\($0)\(StaticString.equal.description)\($1)"] }
 }
 
 // MARK: Dependency
diff --git a/Sources/ArgumentEncoding/Option.swift b/Sources/ArgumentEncoding/Option.swift
@@ -338,7 +338,7 @@ struct OptionEncoding {
     let value: String
 
     func arguments() -> [String] {
-        [formatter.format(encoding: self)]
+        formatter.format(encoding: self)
     }
 }
 
diff --git a/Sources/ArgumentEncoding/OptionSet.swift b/Sources/ArgumentEncoding/OptionSet.swift
@@ -263,7 +263,7 @@ struct OptionSetEncoding {
     let values: [OptionEncoding]
 
     func arguments() -> [String] {
-        values.map { formatter.format(encoding: $0) }
+        values.flatMap { formatter.format(encoding: $0) }
     }
 }
 
diff --git a/Tests/ArgumentEncodingTests/ArgumentGroupTests.swift b/Tests/ArgumentEncodingTests/ArgumentGroupTests.swift
@@ -42,7 +42,7 @@ final class ArgumentGroupTests: XCTestCase {
                 numThreads: 2,
                 target: "target"
             ).arguments(),
-            ["--numThreads 2", "target"]
+            ["--numThreads", "2", "target"]
         )
 
         XCTAssertEqual(
@@ -51,7 +51,7 @@ final class ArgumentGroupTests: XCTestCase {
                 numThreads: 0,
                 target: "target"
             ).arguments(),
-            ["--asyncMain", "--numThreads 0", "target"]
+            ["--asyncMain", "--numThreads", "0", "target"]
         )
     }
 
@@ -106,7 +106,7 @@ final class ArgumentGroupTests: XCTestCase {
                     target: "target"
                 )
             ).arguments(),
-            ["--numThreads 2", "target", "-configuration arm64", "target"]
+            ["--numThreads", "2", "target", "-configuration", "arm64", "target"]
         )
 
         XCTAssertEqual(
@@ -120,7 +120,7 @@ final class ArgumentGroupTests: XCTestCase {
                     target: "target"
                 )
             ).arguments(),
-            ["--asyncMain", "--numThreads 1", "target", "-configuration x86_64", "-buildTests", "target"]
+            ["--asyncMain", "--numThreads", "1", "target", "-configuration", "x86_64", "-buildTests", "target"]
         )
     }
 
@@ -206,7 +206,7 @@ final class ArgumentGroupTests: XCTestCase {
     func testEnumGroupTest() throws {
         XCTAssertEqual(
             ParentEnumGroup.test(numWorkers: 2, testProduct: "PackageTarget").arguments(),
-            ["-numWorkers 2", "-testProduct PackageTarget"]
+            ["-numWorkers", "2", "-testProduct", "PackageTarget"]
         )
     }
 
diff --git a/Tests/ArgumentEncodingTests/CommandRepresentableTests.swift b/Tests/ArgumentEncodingTests/CommandRepresentableTests.swift
@@ -53,7 +53,8 @@ final class CommandRepresentableTests: XCTestCase {
             )).arguments(),
             [
                 "command",
-                "--product Target",
+                "--product",
+                "Target",
             ]
         )
 
@@ -116,7 +117,7 @@ final class CommandRepresentableTests: XCTestCase {
                     buildTests: true
                 )
             )).arguments(),
-            ["command", "--product OtherTarget", "child", "-configuration arm64", "-buildTests"]
+            ["command", "--product", "OtherTarget", "child", "-configuration", "arm64", "-buildTests"]
         )
 
         XCTAssertEqual(
@@ -128,7 +129,7 @@ final class CommandRepresentableTests: XCTestCase {
                     buildTests: false
                 )
             )).arguments(),
-            ["command", "--verbose", "child", "-configuration x86_64"]
+            ["command", "--verbose", "child", "-configuration", "x86_64"]
         )
     }
 
@@ -165,14 +166,14 @@ final class CommandRepresentableTests: XCTestCase {
     func testEnumTest() throws {
         XCTAssertEqual(
             ParentEnumCommand.test(numWorkers: 2, testProduct: "PackageTarget").arguments(),
-            ["test", "-numWorkers 2", "-testProduct PackageTarget"]
+            ["test", "-numWorkers", "2", "-testProduct", "PackageTarget"]
         )
     }
 
     func testEnumChild() throws {
         XCTAssertEqual(
             ParentEnumCommand.child(ChildCommand(configuration: .arm64, buildTests: true)).arguments(),
-            ["child", "-configuration arm64", "-buildTests"]
+            ["child", "-configuration", "arm64", "-buildTests"]
         )
     }
 }
diff --git a/Tests/ArgumentEncodingTests/FormatterTests.swift b/Tests/ArgumentEncodingTests/FormatterTests.swift
@@ -34,57 +34,64 @@ final class FormatterTests: XCTestCase {
 
     func testFlagFormatterKebabCaseBody() throws {
         XCTAssertEqual(
-            FlagFormatter(body: .kebabCase).format(key: "flagKey"),
+            FlagFormatter(key: .kebabCase).format(key: "flagKey"),
             "flag-key"
         )
     }
 
     func testFlagFormatterSnakeCaseBody() throws {
         XCTAssertEqual(
-            FlagFormatter(body: .snakeCase).format(key: "flagKey"),
+            FlagFormatter(key: .snakeCase).format(key: "flagKey"),
             "flag_key"
         )
     }
 
     func testOptionFormatterSingleDashPrefix() throws {
         XCTAssertEqual(
             OptionFormatter(prefix: .singleDash).format(key: "optionKey", value: "optionValue"),
-            "-optionKey optionValue"
+            ["-optionKey", "optionValue"]
         )
     }
 
     func testOptionFormatterDoubleDashPrefix() throws {
         XCTAssertEqual(
             OptionFormatter(prefix: .doubleDash).format(key: "optionKey", value: "optionValue"),
-            "--optionKey optionValue"
+            ["--optionKey", "optionValue"]
         )
     }
 
     func testOptionFormatterEmptyPrefix() throws {
         XCTAssertEqual(
             OptionFormatter(prefix: .empty).format(key: "optionKey", value: "optionValue"),
-            "optionKey optionValue"
+            ["optionKey", "optionValue"]
         )
     }
 
     func testOptionFormatterKebabCaseBody() throws {
         XCTAssertEqual(
-            OptionFormatter(body: .kebabCase).format(key: "optionKey", value: "optionValue"),
-            "option-key optionValue"
+            OptionFormatter(key: .kebabCase).format(key: "optionKey", value: "optionValue"),
+            ["option-key", "optionValue"]
         )
     }
 
     func testOptionFormatterSnakeCaseBody() throws {
         XCTAssertEqual(
-            OptionFormatter(body: .snakeCase).format(key: "optionKey", value: "optionValue"),
-            "option_key optionValue"
+            OptionFormatter(key: .snakeCase).format(key: "optionKey", value: "optionValue"),
+            ["option_key", "optionValue"]
         )
     }
 
     func testOptionFormatterEqualSeparator() throws {
         XCTAssertEqual(
             OptionFormatter(separator: .equal).format(key: "optionKey", value: "optionValue"),
-            "optionKey=optionValue"
+            ["optionKey=optionValue"]
+        )
+    }
+
+    func testOptionFormatterSingleQuoteValue() throws {
+        XCTAssertEqual(
+            OptionFormatter(value: .singleQuote).format(key: "optionKey", value: "optionValue"),
+            ["optionKey", "'optionValue'"]
         )
     }
 }
diff --git a/Tests/ArgumentEncodingTests/OptionSetTests.swift b/Tests/ArgumentEncodingTests/OptionSetTests.swift
@@ -18,7 +18,7 @@ final class OptionSetTests: XCTestCase {
         } operation: {
             optionSet.arguments()
         }
-        XCTAssertEqual(args, ["--configuration release", "--configuration debug"])
+        XCTAssertEqual(args, ["--configuration", "release", "--configuration", "debug"])
     }
 
     func testBothRawValueAndStringConvertible() throws {
@@ -34,7 +34,7 @@ final class OptionSetTests: XCTestCase {
         } operation: {
             optionSet.arguments()
         }
-        XCTAssertEqual(args, ["--configuration release", "--configuration debug"])
+        XCTAssertEqual(args, ["--configuration", "release", "--configuration", "debug"])
     }
 
     func testBothRawValueAndStringConvertibleContainer() throws {
@@ -47,7 +47,7 @@ final class OptionSetTests: XCTestCase {
         } operation: {
             container.arguments()
         }
-        XCTAssertEqual(args, ["--configuration release", "--configuration debug"])
+        XCTAssertEqual(args, ["--configuration", "release", "--configuration", "debug"])
     }
 }
 
diff --git a/Tests/ArgumentEncodingTests/OptionTests.swift b/Tests/ArgumentEncodingTests/OptionTests.swift
@@ -18,7 +18,7 @@ final class OptionTests: XCTestCase {
         } operation: {
             option.arguments()
         }
-        XCTAssertEqual(args, ["--configuration release"])
+        XCTAssertEqual(args, ["--configuration", "release"])
     }
 
     func testBothRawValueAndStringConvertible() throws {
@@ -28,7 +28,7 @@ final class OptionTests: XCTestCase {
         } operation: {
             option.arguments()
         }
-        XCTAssertEqual(args, ["--configuration release"])
+        XCTAssertEqual(args, ["--configuration", "release"])
     }
 
     func testBothRawValueAndStringConvertibleContainer() throws {
@@ -38,7 +38,7 @@ final class OptionTests: XCTestCase {
         } operation: {
             container.arguments()
         }
-        XCTAssertEqual(args, ["--configuration release"])
+        XCTAssertEqual(args, ["--configuration", "release"])
     }
 }
 
diff --git a/Tests/ArgumentEncodingTests/TopLevelCommandRepresentableTests.swift b/Tests/ArgumentEncodingTests/TopLevelCommandRepresentableTests.swift

Original file line number	Diff line number	Diff line change
`@@ -338,7 +338,7 @@ struct OptionEncoding {`
`338`	`338`	`let value: String`
`339`	`339`
`340`	`340`	`func arguments() -> [String] {`
`341`		`- [formatter.format(encoding: self)]`
	`341`	`+ formatter.format(encoding: self)`
`342`	`342`	`}`
`343`	`343`	`}`
`344`	`344`
Original file line number	Diff line number	Diff line change
`@@ -263,7 +263,7 @@ struct OptionSetEncoding {`
`263`	`263`	`let values: [OptionEncoding]`
`264`	`264`
`265`	`265`	`func arguments() -> [String] {`
`266`		`- values.map { formatter.format(encoding: $0) }`
	`266`	`+ values.flatMap { formatter.format(encoding: $0) }`
`267`	`267`	`}`
`268`	`268`	`}`
`269`	`269`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ final class ArgumentGroupTests: XCTestCase {`
`42`	`42`	`numThreads: 2,`
`43`	`43`	`target: "target"`
`44`	`44`	`).arguments(),`
`45`		`- ["--numThreads 2", "target"]`
	`45`	`+ ["--numThreads", "2", "target"]`
`46`	`46`	`)`
`47`	`47`
`48`	`48`	`XCTAssertEqual(`
`@@ -51,7 +51,7 @@ final class ArgumentGroupTests: XCTestCase {`
`51`	`51`	`numThreads: 0,`
`52`	`52`	`target: "target"`
`53`	`53`	`).arguments(),`
`54`		`- ["--asyncMain", "--numThreads 0", "target"]`
	`54`	`+ ["--asyncMain", "--numThreads", "0", "target"]`
`55`	`55`	`)`
`56`	`56`	`}`
`57`	`57`
`@@ -106,7 +106,7 @@ final class ArgumentGroupTests: XCTestCase {`
`106`	`106`	`target: "target"`
`107`	`107`	`)`
`108`	`108`	`).arguments(),`
`109`		`- ["--numThreads 2", "target", "-configuration arm64", "target"]`
	`109`	`+ ["--numThreads", "2", "target", "-configuration", "arm64", "target"]`
`110`	`110`	`)`
`111`	`111`
`112`	`112`	`XCTAssertEqual(`
`@@ -120,7 +120,7 @@ final class ArgumentGroupTests: XCTestCase {`
`120`	`120`	`target: "target"`
`121`	`121`	`)`
`122`	`122`	`).arguments(),`
`123`		`- ["--asyncMain", "--numThreads 1", "target", "-configuration x86_64", "-buildTests", "target"]`
	`123`	`+ ["--asyncMain", "--numThreads", "1", "target", "-configuration", "x86_64", "-buildTests", "target"]`
`124`	`124`	`)`
`125`	`125`	`}`
`126`	`126`
`@@ -206,7 +206,7 @@ final class ArgumentGroupTests: XCTestCase {`
`206`	`206`	`func testEnumGroupTest() throws {`
`207`	`207`	`XCTAssertEqual(`
`208`	`208`	`ParentEnumGroup.test(numWorkers: 2, testProduct: "PackageTarget").arguments(),`
`209`		`- ["-numWorkers 2", "-testProduct PackageTarget"]`
	`209`	`+ ["-numWorkers", "2", "-testProduct", "PackageTarget"]`
`210`	`210`	`)`
`211`	`211`	`}`
`212`	`212`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,8 @@ final class CommandRepresentableTests: XCTestCase {`
`53`	`53`	`)).arguments(),`
`54`	`54`	`[`
`55`	`55`	`"command",`
`56`		`- "--product Target",`
	`56`	`+ "--product",`
	`57`	`+ "Target",`
`57`	`58`	`]`
`58`	`59`	`)`
`59`	`60`
`@@ -116,7 +117,7 @@ final class CommandRepresentableTests: XCTestCase {`
`116`	`117`	`buildTests: true`
`117`	`118`	`)`
`118`	`119`	`)).arguments(),`
`119`		`- ["command", "--product OtherTarget", "child", "-configuration arm64", "-buildTests"]`
	`120`	`+ ["command", "--product", "OtherTarget", "child", "-configuration", "arm64", "-buildTests"]`
`120`	`121`	`)`
`121`	`122`
`122`	`123`	`XCTAssertEqual(`
`@@ -128,7 +129,7 @@ final class CommandRepresentableTests: XCTestCase {`
`128`	`129`	`buildTests: false`
`129`	`130`	`)`
`130`	`131`	`)).arguments(),`
`131`		`- ["command", "--verbose", "child", "-configuration x86_64"]`
	`132`	`+ ["command", "--verbose", "child", "-configuration", "x86_64"]`
`132`	`133`	`)`
`133`	`134`	`}`
`134`	`135`
`@@ -165,14 +166,14 @@ final class CommandRepresentableTests: XCTestCase {`
`165`	`166`	`func testEnumTest() throws {`
`166`	`167`	`XCTAssertEqual(`
`167`	`168`	`ParentEnumCommand.test(numWorkers: 2, testProduct: "PackageTarget").arguments(),`
`168`		`- ["test", "-numWorkers 2", "-testProduct PackageTarget"]`
	`169`	`+ ["test", "-numWorkers", "2", "-testProduct", "PackageTarget"]`
`169`	`170`	`)`
`170`	`171`	`}`
`171`	`172`
`172`	`173`	`func testEnumChild() throws {`
`173`	`174`	`XCTAssertEqual(`
`174`	`175`	`ParentEnumCommand.child(ChildCommand(configuration: .arm64, buildTests: true)).arguments(),`
`175`		`- ["child", "-configuration arm64", "-buildTests"]`
	`176`	`+ ["child", "-configuration", "arm64", "-buildTests"]`
`176`	`177`	`)`
`177`	`178`	`}`
`178`	`179`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,57 +34,64 @@ final class FormatterTests: XCTestCase {`
`34`	`34`
`35`	`35`	`func testFlagFormatterKebabCaseBody() throws {`
`36`	`36`	`XCTAssertEqual(`
`37`		`- FlagFormatter(body: .kebabCase).format(key: "flagKey"),`
	`37`	`+ FlagFormatter(key: .kebabCase).format(key: "flagKey"),`
`38`	`38`	`"flag-key"`
`39`	`39`	`)`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`func testFlagFormatterSnakeCaseBody() throws {`
`43`	`43`	`XCTAssertEqual(`
`44`		`- FlagFormatter(body: .snakeCase).format(key: "flagKey"),`
	`44`	`+ FlagFormatter(key: .snakeCase).format(key: "flagKey"),`
`45`	`45`	`"flag_key"`
`46`	`46`	`)`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`func testOptionFormatterSingleDashPrefix() throws {`
`50`	`50`	`XCTAssertEqual(`
`51`	`51`	`OptionFormatter(prefix: .singleDash).format(key: "optionKey", value: "optionValue"),`
`52`		`- "-optionKey optionValue"`
	`52`	`+ ["-optionKey", "optionValue"]`
`53`	`53`	`)`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`func testOptionFormatterDoubleDashPrefix() throws {`
`57`	`57`	`XCTAssertEqual(`
`58`	`58`	`OptionFormatter(prefix: .doubleDash).format(key: "optionKey", value: "optionValue"),`
`59`		`- "--optionKey optionValue"`
	`59`	`+ ["--optionKey", "optionValue"]`
`60`	`60`	`)`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`func testOptionFormatterEmptyPrefix() throws {`
`64`	`64`	`XCTAssertEqual(`
`65`	`65`	`OptionFormatter(prefix: .empty).format(key: "optionKey", value: "optionValue"),`
`66`		`- "optionKey optionValue"`
	`66`	`+ ["optionKey", "optionValue"]`
`67`	`67`	`)`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`func testOptionFormatterKebabCaseBody() throws {`
`71`	`71`	`XCTAssertEqual(`
`72`		`- OptionFormatter(body: .kebabCase).format(key: "optionKey", value: "optionValue"),`
`73`		`- "option-key optionValue"`
	`72`	`+ OptionFormatter(key: .kebabCase).format(key: "optionKey", value: "optionValue"),`
	`73`	`+ ["option-key", "optionValue"]`
`74`	`74`	`)`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`func testOptionFormatterSnakeCaseBody() throws {`
`78`	`78`	`XCTAssertEqual(`
`79`		`- OptionFormatter(body: .snakeCase).format(key: "optionKey", value: "optionValue"),`
`80`		`- "option_key optionValue"`
	`79`	`+ OptionFormatter(key: .snakeCase).format(key: "optionKey", value: "optionValue"),`
	`80`	`+ ["option_key", "optionValue"]`
`81`	`81`	`)`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`func testOptionFormatterEqualSeparator() throws {`
`85`	`85`	`XCTAssertEqual(`
`86`	`86`	`OptionFormatter(separator: .equal).format(key: "optionKey", value: "optionValue"),`
`87`		`- "optionKey=optionValue"`
	`87`	`+ ["optionKey=optionValue"]`
	`88`	`+ )`
	`89`	`+ }`
	`90`	`+`
	`91`	`+ func testOptionFormatterSingleQuoteValue() throws {`
	`92`	`+ XCTAssertEqual(`
	`93`	`+ OptionFormatter(value: .singleQuote).format(key: "optionKey", value: "optionValue"),`
	`94`	`+ ["optionKey", "'optionValue'"]`
`88`	`95`	`)`
`89`	`96`	`}`
`90`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ final class OptionSetTests: XCTestCase {`
`18`	`18`	`} operation: {`
`19`	`19`	`optionSet.arguments()`
`20`	`20`	`}`
`21`		`- XCTAssertEqual(args, ["--configuration release", "--configuration debug"])`
	`21`	`+ XCTAssertEqual(args, ["--configuration", "release", "--configuration", "debug"])`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`func testBothRawValueAndStringConvertible() throws {`
`@@ -34,7 +34,7 @@ final class OptionSetTests: XCTestCase {`
`34`	`34`	`} operation: {`
`35`	`35`	`optionSet.arguments()`
`36`	`36`	`}`
`37`		`- XCTAssertEqual(args, ["--configuration release", "--configuration debug"])`
	`37`	`+ XCTAssertEqual(args, ["--configuration", "release", "--configuration", "debug"])`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`func testBothRawValueAndStringConvertibleContainer() throws {`
`@@ -47,7 +47,7 @@ final class OptionSetTests: XCTestCase {`
`47`	`47`	`} operation: {`
`48`	`48`	`container.arguments()`
`49`	`49`	`}`
`50`		`- XCTAssertEqual(args, ["--configuration release", "--configuration debug"])`
	`50`	`+ XCTAssertEqual(args, ["--configuration", "release", "--configuration", "debug"])`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ final class OptionTests: XCTestCase {`
`18`	`18`	`} operation: {`
`19`	`19`	`option.arguments()`
`20`	`20`	`}`
`21`		`- XCTAssertEqual(args, ["--configuration release"])`
	`21`	`+ XCTAssertEqual(args, ["--configuration", "release"])`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`func testBothRawValueAndStringConvertible() throws {`
`@@ -28,7 +28,7 @@ final class OptionTests: XCTestCase {`
`28`	`28`	`} operation: {`
`29`	`29`	`option.arguments()`
`30`	`30`	`}`
`31`		`- XCTAssertEqual(args, ["--configuration release"])`
	`31`	`+ XCTAssertEqual(args, ["--configuration", "release"])`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`func testBothRawValueAndStringConvertibleContainer() throws {`
`@@ -38,7 +38,7 @@ final class OptionTests: XCTestCase {`
`38`	`38`	`} operation: {`
`39`	`39`	`container.arguments()`
`40`	`40`	`}`
`41`		`- XCTAssertEqual(args, ["--configuration release"])`
	`41`	`+ XCTAssertEqual(args, ["--configuration", "release"])`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`