allow dynamic access to parsed arguments by name

Author: yonaskolb

Sources/Utility/ArgumentParser.swift

@@ -52,7 +52,7 @@ extension ArgumentParserError: CustomStringConvertible {
 /// initializer.
 public enum ArgumentConversionError: Swift.Error {
 
-    /// The value is unkown.
+    /// The value is unknown.
     case unknown(value: String)
 
     /// The value could not be converted to the target type.
@@ -502,7 +502,7 @@ public final class ArgumentParser {
     /// A class representing result of the parsed arguments.
     public class Result: CustomStringConvertible {
         /// Internal representation of arguments mapped to their values.
-        private var results = [AnyArgument: Any]()
+        private var results = [String: Any]()
 
         /// Result of the parent parent parser, if any.
         private var parentResult: Result?
@@ -530,39 +530,56 @@ public final class ArgumentParser {
         ///     simplifications in the parsing code.
         fileprivate func add(_ values: [ArgumentKind], for argument: AnyArgument) throws {
             if argument.isArray {
-                var array = results[argument] as? [ArgumentKind] ?? []
+                var array = results[argument.name] as? [ArgumentKind] ?? []
                 array.append(contentsOf: values)
-                results[argument] = array
+                results[argument.name] = array
             } else {
                 // We expect only one value for non-array arguments.
                 guard let value = values.only else {
                     assertionFailure()
                     return
                 }
-                results[argument] = value
+                results[argument.name] = value
             }
         }
 
         /// Get an option argument's value from the results.
         ///
         /// Since the options are optional, their result may or may not be present.
         public func get<T>(_ argument: OptionArgument<T>) -> T? {
-            return (results[AnyArgument(argument)] as? T) ?? parentResult?.get(argument)
+            return (results[argument.name] as? T) ?? parentResult?.get(argument)
         }
 
         /// Array variant for option argument's get(_:).
         public func get<T>(_ argument: OptionArgument<[T]>) -> [T]? {
-            return (results[AnyArgument(argument)] as? [T]) ?? parentResult?.get(argument)
+            return (results[argument.name] as? [T]) ?? parentResult?.get(argument)
         }
 
         /// Get a positional argument's value.
         public func get<T>(_ argument: PositionalArgument<T>) -> T? {
-            return results[AnyArgument(argument)] as? T
+            return results[argument.name] as? T
         }
 
         /// Array variant for positional argument's get(_:).
         public func get<T>(_ argument: PositionalArgument<[T]>) -> [T]? {
-            return results[AnyArgument(argument)] as? [T]
+            return results[argument.name] as? [T]
+        }
+
+        /// Get an argument's value using its name.
+        /// - throws: An ArgumentParserError.invalidValue error if the parsed argument does not match the expected type.
+        public func get<T>(_ name: String) throws -> T? {
+            guard let value = results[name] else {
+                // if we have a parent and this is an option argument, look in the parent result
+                if let parentResult = parentResult, name.hasPrefix("-") {
+                    return try parentResult.get(name)
+                } else {
+                    return nil
+                }
+            }
+            guard let typedValue = value as? T else {
+                throw ArgumentParserError.invalidValue(argument: name, error: .typeMismatch(value: String(describing: value), expectedType: T.self))
+            }
+            return typedValue
         }
 
         /// Get the subparser which was chosen for the given parser.

Tests/UtilityTests/ArgumentParserTests.swift

@@ -82,6 +82,9 @@ class ArgumentParserTests: XCTestCase {
         XCTAssertEqual(args.get(inputFiles) ?? [], ["input1", "input2"])
         XCTAssertEqual(args.get(outputFiles) ?? [], ["output1", "output2"])
         XCTAssertEqual(args.get(remaining) ?? [], ["--foo", "-Xld", "bar"])
+        XCTAssertEqual(try args.get("--verbose") as Int?, 2)
+        XCTAssertEqual(try args.get("input files") as [String]? ?? [], ["input1", "input2"])
+        XCTAssertEqual(try args.get("invalid") as Int?, nil)
 
         let stream = BufferedOutputByteStream()
         parser.printUsage(on: stream)
@@ -136,6 +139,15 @@ class ArgumentParserTests: XCTestCase {
             XCTAssertEqual(error, ArgumentConversionError.typeMismatch(value: "yes", expectedType: Int.self))
         }
 
+        do {
+            let results = try parser.parse(["foo", "--verbosity", "2"])
+            _ = try results.get("--verbosity") as String?
+            XCTFail("unexpected success")
+        } catch ArgumentParserError.invalidValue(let value, let error) {
+            XCTAssertEqual(value, "--verbosity")
+            XCTAssertEqual(error, ArgumentConversionError.typeMismatch(value: "2", expectedType: String.self))
+        }
+
         do {
             _ = try parser.parse(["foo", "--foo=hello"])
             XCTFail("unexpected success")
@@ -198,6 +210,8 @@ class ArgumentParserTests: XCTestCase {
         let foo = parser.add(option: "--foo", kind: String.self, usage: "The foo option")
         let bar = parser.add(option: "--bar", shortName: "-b", kind: String.self, usage: "The bar option")
 
+        let parentArg = parser.add(option: "--parent", kind: String.self, usage: "The parent option")
+
         let parserA = parser.add(subparser: "a", overview: "A!")
         let branchOption = parserA.add(option: "--branch", kind: String.self, usage: "The branch to use")
 
@@ -211,13 +225,15 @@ class ArgumentParserTests: XCTestCase {
         XCTAssertEqual(args.get(noFlyOption), nil)
         XCTAssertEqual(args.subparser(parser), "a")
 
-        args = try parser.parse(["--bar", "bar", "--foo", "foo", "b", "--no-fly"])
+        args = try parser.parse(["--parent", "p", "--bar", "bar", "--foo", "foo", "b", "--no-fly"])
 
         XCTAssertEqual(args.get(foo), "foo")
         XCTAssertEqual(args.get(bar), "bar")
         XCTAssertEqual(args.get(branchOption), nil)
         XCTAssertEqual(args.get(noFlyOption), true)
         XCTAssertEqual(args.subparser(parser), "b")
+        XCTAssertEqual(args.get(parentArg), "p")
+        XCTAssertEqual(try args.get("--parent") as String?, "p")
 
         do {
             args = try parser.parse(["c"])
@@ -251,6 +267,7 @@ class ArgumentParserTests: XCTestCase {
         XCTAssert(usage.contains("USAGE: SomeBinary sample parser"))
         XCTAssert(usage.contains("  --bar, -b   The bar option"))
         XCTAssert(usage.contains("  --foo       The foo option"))
+        XCTAssert(usage.contains("  --parent    The parent option"))
         XCTAssert(usage.contains("SUBCOMMANDS:"))
         XCTAssert(usage.contains("  b           B!"))
         XCTAssert(usage.contains("--help"))