Support up-to three command arguments

Author: kylef

Commander/Command.swift

@@ -1,16 +1,20 @@
 /// A simple CommandType using a closure
 struct AnonymousCommand : CommandType {
-  var closure:ArgumentParser -> ()
+  var closure:ArgumentParser throws -> ()
 
-  init(_ closure:(ArgumentParser -> ())) {
+  init(_ closure:(ArgumentParser throws -> ())) {
     self.closure = closure
   }
 
-  func run(parser:ArgumentParser) {
-    closure(parser)
+  func run(parser:ArgumentParser) throws {
+    try closure(parser)
   }
 }
 
+enum CommandError : ErrorType {
+  case InvalidArgument
+}
+
 /// Create a command using a closure
 public func command(closure:() -> ()) -> CommandType {
   return AnonymousCommand { parser in
@@ -23,6 +27,36 @@ public func command<A : ArgumentConvertible>(closure:A -> ()) -> CommandType {
   return AnonymousCommand { parser in
     if let argument = A(parser: parser) {
       closure(argument)
+    } else {
+      throw CommandError.InvalidArgument
+    }
+  }
+}
+
+/// Create a command which takes two arguments using a closure
+public func command<A : ArgumentConvertible, B : ArgumentConvertible>(closure:(A, B) -> ()) -> CommandType {
+  return AnonymousCommand { parser in
+    if let argumentA = A(parser: parser),
+      argumentB = B(parser: parser)
+    {
+      closure(argumentA, argumentB)
+    } else {
+      throw CommandError.InvalidArgument
+    }
+  }
+}
+
+
+/// Create a command which takes three arguments using a closure
+public func command<A : ArgumentConvertible, B : ArgumentConvertible, C : ArgumentConvertible>(closure:(A, B, C) -> ()) -> CommandType {
+  return AnonymousCommand { parser in
+    if let argumentA = A(parser: parser),
+           argumentB = B(parser: parser),
+           argumentC = C(parser: parser)
+    {
+      closure(argumentA, argumentB, argumentC)
+    } else {
+      throw CommandError.InvalidArgument
     }
   }
 }

Commander/Group.swift

@@ -75,7 +75,17 @@ extension Group {
   }
 
   /// Add a command which takes one argument using a closure
-  public func command<A : ArgumentConvertible>(name:String, closure:A -> ()) {
+  public func command<A:ArgumentConvertible>(name:String, closure:A -> ()) {
+    addCommand(name, Commander.command(closure))
+  }
+
+  /// Add a command which takes two argument using a closure
+  public func command<A:ArgumentConvertible, B:ArgumentConvertible>(name:String, closure:(A,B) -> ()) {
+    addCommand(name, Commander.command(closure))
+  }
+
+  /// Add a command which takes three argument using a closure
+  public func command<A:ArgumentConvertible, B:ArgumentConvertible, C:ArgumentConvertible>(name:String, closure:(A,B,C) -> ()) {
     addCommand(name, Commander.command(closure))
   }
 }