Add argument option parsing

Author: kylef

Commander/ArgumentParser.swift

@@ -1,4 +1,4 @@
-private enum Arg {
+private enum Arg : CustomStringConvertible {
   /// A positional argument
   case Argument(String)
 
@@ -7,6 +7,37 @@ private enum Arg {
 
   /// A flag
   case Flag(Set<Character>)
+
+  var description:String {
+    switch self {
+    case .Argument(let value):
+      return value
+    case .Option(let key):
+      return "--\(key)"
+    case .Flag(let flags):
+      return "-\(String(flags))"
+    }
+  }
+
+  var type:String {
+    switch self {
+    case .Argument:
+      return "argument"
+    case .Option:
+      return "option"
+    case .Flag:
+      return "flag"
+    }
+  }
+}
+
+
+public struct ArgumentParserError : ErrorType, CustomStringConvertible {
+  public let description:String
+
+  init(description:String) {
+    self.description = description
+  }
 }
 
 
@@ -51,6 +82,53 @@ public final class ArgumentParser : ArgumentConvertible {
     return nil
   }
 
+  /// Returns the value for an option (--name Kyle, --name=Kyle)
+  public func shiftValueForOption(name:String) throws -> String? {
+    return try shiftValuesForOption(name)?.first
+  }
+
+  /// Returns the value for an option (--name Kyle, --name=Kyle)
+  public func shiftValuesForOption(name:String, count:Int = 1) throws -> [String]? {
+    var index = 0
+    var hasOption = false
+
+    for argument in arguments {
+      switch argument {
+      case .Option(let option):
+        if option == name {
+          hasOption = true
+          break
+        }
+        fallthrough
+      default:
+        ++index
+      }
+
+      if hasOption {
+        break
+      }
+    }
+
+    if hasOption {
+      arguments.removeAtIndex(index)  // Pop option
+      return try (0..<count).map { i in
+        if arguments.count > index {
+          let argument = arguments.removeAtIndex(index)
+          switch argument {
+          case .Argument(let value):
+            return value
+          default:
+            throw ArgumentParserError(description: "Unexpected \(argument.type) `\(argument)` as a value for `--\(name)`")
+          }
+        }
+
+        throw ArgumentParserError(description: "Missing value for `--\(name)`")
+      }
+    }
+
+    return nil
+  }
+
   /// Returns whether an option was specified in the arguments
   public func hasOption(name:String) -> Bool {
     for argument in arguments {

CommanderTests/ArgumentParserTests.swift

@@ -3,7 +3,7 @@ import Commander
 
 
 class ArgumentParserTests : XCTestCase {
-  let parser = ArgumentParser(arguments: ["first", "-f", "--verbose", "last"])
+  let parser = ArgumentParser(arguments: ["first", "-f", "--verbose", "middle", "end"])
 
   func testShiftingReturnsFirstPositionalArgument() {
     XCTAssertEqual(parser.shift(), "first")
@@ -12,7 +12,7 @@ class ArgumentParserTests : XCTestCase {
   func testShiftingRemovesPositionalArgument() {
     parser.shift()
 
-    XCTAssertEqual(parser.shift(), "last")
+    XCTAssertEqual(parser.shift(), "middle")
   }
 
   func testHasOption() {
@@ -30,4 +30,45 @@ class ArgumentParserTests : XCTestCase {
   func testDoesNotHaveFlag() {
     XCTAssertFalse(parser.hasFlag("v"))
   }
+
+  func testValueForOptionMissing() {
+    let value = try! parser.shiftValueForOption("unknown")
+    XCTAssertNil(value)
+  }
+
+  func testValueForOption() {
+    let value = try! parser.shiftValueForOption("verbose")
+    XCTAssertEqual(value, "middle")
+  }
+
+  func testValueForOptionThrowsWhenValueIsNotPositionalArgument() {
+    let parser = ArgumentParser(arguments: ["--verbose", "-t"])
+
+    do {
+      try parser.shiftValueForOption("verbose")
+      XCTFail("Unexpected Success")
+    } catch let error as CustomStringConvertible {
+      XCTAssertEqual(error.description, "Unexpected flag `-t` as a value for `--verbose`")
+    } catch {
+      XCTFail("Unexpected error")
+    }
+  }
+
+  func testValueForOptionThrowsWhenValueIsMissing() {
+    let parser = ArgumentParser(arguments: ["--verbose"])
+
+    do {
+      try parser.shiftValueForOption("verbose")
+      XCTFail("Unexpected Success")
+    } catch let error as CustomStringConvertible {
+      XCTAssertEqual(error.description, "Missing value for `--verbose`")
+    } catch {
+      XCTFail("Unexpected error")
+    }
+  }
+
+  func testValuesForOption() {
+    let value = try! parser.shiftValuesForOption("verbose", count: 2)!
+    XCTAssertEqual(value, ["middle", "end"])
+  }
 }