Merge pull request #7 from MFB-Technologies-Inc/feature/add-positional-and-option-set

Feature/add positional and option set

Author: roanutil

Package.resolved

@@ -18,8 +18,8 @@ Typically, modeling a CLI tool will begin with a `TopLevelCommandRepresentable`.
 ```swift
 struct MyCommand: TopLevelCommandRepresentable {
     func commandValue() -> Command { "my-command" }
-    var flagFormatter: FlagFormatter { .doubleDashPrefix }
-    var optionFormatter: OptionFormatter { .doubleDashPrefix }
+    let flagFormatter = FlagFormatter(prefix: .doubleDash) }
+    let optionFormatter = OptionFormatter(prefix: .doubleDash) }
 }
 ```
 
@@ -30,23 +30,39 @@ Within `MyCommand` we need the ability to model a boolean value to enable/disabl
 ```swift
 struct MyCommand: TopLevelCommandRepresentable {
     func commandValue() -> Command { "my-command" }
-    var flagFormatter: FlagFormatter { .doubleDashPrefix }
-    var optionFormatter: OptionFormatter { .doubleDashPrefix }
+    let flagFormatter = FlagFormatter(prefix: .doubleDash) }
+    let optionFormatter = OptionFormatter(prefix: .doubleDash) }
 
     @Flag var myFlag: Bool = false
 }
 ```
 
-In addition to modeling the ability to enable/disable a feature, we need to set a value against some variable. For this, we can use `Option`.
+In addition to modeling the ability to enable/disable a feature, we need to set a value against some variable. For this, we can use `Option`. For options that can have multiple values, there is `OptionSet`.
 
 ```swift
 struct MyCommand: TopLevelCommandRepresentable {
     func commandValue() -> Command { "my-command" }
-    var flagFormatter: FlagFormatter { .doubleDashPrefix }
-    var optionFormatter: OptionFormatter { .doubleDashPrefix }
+    let flagFormatter = FlagFormatter(prefix: .doubleDash) }
+    let optionFormatter = OptionFormatter(prefix: .doubleDash) }
 
     @Flag var myFlag: Bool = false
     @Option var myOption: Int = 0
+    @OptionSet var myOptions: [String] = ["value1", "value2"]
+}
+```
+
+Positional arguments that are just a value, with no key are supported through the `Positional` type.
+
+```swift
+struct MyCommand: TopLevelCommandRepresentable {
+    func commandValue() -> Command { "my-command" }
+    let flagFormatter = FlagFormatter(prefix: .doubleDash) }
+    let optionFormatter = OptionFormatter(prefix: .doubleDash) }
+
+    @Flag var myFlag: Bool = false
+    @Option var myOption: Int = 0
+    @OptionSet var myOptions: [String] = ["value1", "value2"]
+    @Positional var myPositional: String = "positional"
 }
 ```
 
@@ -114,35 +130,27 @@ import ArgumentEncoding
 enum SwiftCommand: TopLevelCommandRepresentable {
     func commandValue() -> Command { "swift" }
 
-    var flagFormatter: FlagFormatter { .doubleDashPrefixKebabCase }
-    var optionFormatter: OptionFormatter { .doubleDashPrefixKebabCase }
+    var flagFormatter: FlagFormatter { FlagFormatter(prefix: .doubleDash, body: .kebabCase) }
+    var optionFormatter: OptionFormatter { OptionFormatter(prefix: .doubleDash, body: .kebabCase) }
 
     case run(RunCommand)
     case test(TestCommand)
 }
 
 struct RunCommand: CommandRepresentable {
-    let flagFormatter: FlagFormatter = .doubleDashPrefixKebabCase
-    let optionFormatter: OptionFormatter = .doubleDashPrefixKebabCase
-
-    let executable: Command
+    @Positional var executable: String
 }
 
 extension RunCommand: ExpressibleByStringLiteral {
     init(stringLiteral value: StringLiteralType) {
-        self.init(executable: Command(rawValue: value))
+        self.init(executable: Positional(wrapped: value))
     }
 }
 
 struct TestCommand: CommandRepresentable {
-    let flagFormatter: FlagFormatter = .doubleDashPrefixKebabCase
-    let optionFormatter: OptionFormatter = .doubleDashPrefixKebabCase
-
     @Flag var parallel: Bool = true
     @Option var numWorkers: Int = 1
     @Flag var showCodecovPath: Bool = false
-    var testProducts: [Command]
+    @OptionSet var testProducts: [String] = []
 }
-
-extension [Command]: ArgumentGroup {}
-```
+```

README.md

@@ -100,6 +100,8 @@ extension ArgumentGroup {
             return container
         } else if let option = value as? OptionProtocol {
             return .option(option)
+        } else if let optionSet = value as? OptionSetProtocol {
+            return .optionSet(optionSet)
         } else if let flag = value as? Flag {
             return .flag(flag)
         } else if let command = value as? Command {
@@ -110,6 +112,8 @@ extension ArgumentGroup {
             return .commandRep(commandRep)
         } else if let group = value as? (any ArgumentGroup) {
             return .group(group)
+        } else if let positional = value as? PositionalProtocol {
+            return .positional(positional)
         } else {
             return nil
         }
@@ -122,6 +126,8 @@ extension ArgumentGroup {
             switch value {
             case let .option(option):
                 return option.arguments(key: label)
+            case let .optionSet(optionSet):
+                return optionSet.arguments(key: label)
             case let .flag(flag):
                 return flag.arguments(key: label)
             case let .command(command):
@@ -136,6 +142,8 @@ extension ArgumentGroup {
                 }
             case let .group(group):
                 return group.arguments()
+            case let .positional(positional):
+                return positional.arguments()
             }
         })
     }
@@ -250,9 +258,11 @@ extension ArgumentGroup {
 // Represents the possible underlying argument types
 private enum Container {
     case option(any OptionProtocol)
+    case optionSet(any OptionSetProtocol)
     case flag(Flag)
     case command(Command)
     case topLevelCommandRep(any TopLevelCommandRepresentable)
     case commandRep(any CommandRepresentable)
     case group(any ArgumentGroup)
+    case positional(any PositionalProtocol)
 }

Sources/ArgumentEncoding/ArgumentGroup.swift

@@ -7,11 +7,12 @@ import Foundation
 
 /// Convert from Swift's typical camelCase to kebab-case and snake_case as some argument formats require them.
 public enum CaseConverter {
-    public static let kebabCase: (String) -> String = fromCamelCase(template: "$1-$2")
+    public static let kebabCase: @Sendable (String) -> String = fromCamelCase(template: "$1-$2")
 
-    public static let snakeCase: (String) -> String = fromCamelCase(template: "$1_$2")
+    public static let snakeCase: @Sendable (String) -> String = fromCamelCase(template: "$1_$2")
 
-    private static func fromCamelCase(template: String) -> (String) -> String {
+    @Sendable
+    private static func fromCamelCase(template: String) -> @Sendable (String) -> String {
         guard let regex = try? NSRegularExpression(pattern: "([a-z0-9])([A-Z])", options: []) else {
             return { $0 }
         }

Sources/ArgumentEncoding/CaseConverter.swift

@@ -13,7 +13,7 @@ import Dependencies
 /// struct ParentGroup: CommandRepresentable {
 ///     // Formatters to satisfy `FormatterNode` requirements
 ///     let flagFormatter: FlagFormatter = .doubleDashPrefix
-///     let optionFormatter: OptionFormatter = .doubleDashPrefix
+///     let optionFormatter: OptionFormatter = OptionFormatter(prefix: .doubleDash)
 ///
 ///     // Properties that represent the child arguments
 ///     @Flag var asyncMain: Bool

Sources/ArgumentEncoding/CommandRepresentable.swift

@@ -22,7 +22,7 @@ import Dependencies
 /// ```swift
 /// struct FlagContainer: ArgumentGroup, FormatterNode {
 ///     let flagFormatter: FlagFormatter = .doubleDashPrefix
-///     let optionFormatter: OptionFormatter = .doubleDashPrefix
+///     let optionFormatter: OptionFormatter = OptionFormatter(prefix: .doubleDash)
 ///
 ///     @Flag var name: Bool = true
 /// }