Add up to 5 argument support

Author: kylef

Commander/ArgumentDescription.swift

@@ -240,3 +240,34 @@ public func command<A:ArgumentDescriptor, B:ArgumentDescriptor, C:ArgumentDescri
     closure(try descriptorA.parse(parser), try descriptorB.parse(parser), try descriptorC.parse(parser))
   }
 }
+
+public func command<A:ArgumentDescriptor, B:ArgumentDescriptor, C:ArgumentDescriptor, D:ArgumentDescriptor>(a:A, _ b:B, _ c:C, _ d:D, closure:((A.ValueType, B.ValueType, C.ValueType, D.ValueType) -> ())) -> CommandType {
+  return AnonymousCommand { parser in
+    if parser.hasOption("help") {
+      throw Help([
+        BoxedArgumentDescriptor(value: a),
+        BoxedArgumentDescriptor(value: b),
+        BoxedArgumentDescriptor(value: c),
+        BoxedArgumentDescriptor(value: d),
+      ])
+    }
+
+    closure(try a.parse(parser), try b.parse(parser), try c.parse(parser), try d.parse(parser))
+  }
+}
+
+public func command<A:ArgumentDescriptor, B:ArgumentDescriptor, C:ArgumentDescriptor, D:ArgumentDescriptor, E:ArgumentDescriptor>(a:A, _ b:B, _ c:C, _ d:D, _ e:E, closure:((A.ValueType, B.ValueType, C.ValueType, D.ValueType, E.ValueType) -> ())) -> CommandType {
+  return AnonymousCommand { parser in
+    if parser.hasOption("help") {
+      throw Help([
+        BoxedArgumentDescriptor(value: a),
+        BoxedArgumentDescriptor(value: b),
+        BoxedArgumentDescriptor(value: c),
+        BoxedArgumentDescriptor(value: d),
+        BoxedArgumentDescriptor(value: e),
+      ])
+    }
+
+    closure(try a.parse(parser), try b.parse(parser), try c.parse(parser), try d.parse(parser), try e.parse(parser))
+  }
+}

Commander/Command.swift

@@ -23,23 +23,36 @@ public func command(closure:() -> ()) -> CommandType {
 }
 
 /// Create a command which takes one argument using a closure
-public func command<A : ArgumentConvertible>(closure:A -> ()) -> CommandType {
+public func command<A:ArgumentConvertible>(closure:A -> ()) -> CommandType {
   return AnonymousCommand { parser in
     closure(try A(parser: parser))
   }
 }
 
 /// Create a command which takes two arguments using a closure
-public func command<A : ArgumentConvertible, B : ArgumentConvertible>(closure:(A, B) -> ()) -> CommandType {
+public func command<A:ArgumentConvertible, B:ArgumentConvertible>(closure:(A, B) -> ()) -> CommandType {
   return AnonymousCommand { parser in
     closure(try A(parser: parser), try B(parser: parser))
   }
 }
 
-
 /// Create a command which takes three arguments using a closure
-public func command<A : ArgumentConvertible, B : ArgumentConvertible, C : ArgumentConvertible>(closure:(A, B, C) -> ()) -> CommandType {
+public func command<A:ArgumentConvertible, B:ArgumentConvertible, C:ArgumentConvertible>(closure:(A, B, C) -> ()) -> CommandType {
   return AnonymousCommand { parser in
     closure(try A(parser: parser), try B(parser: parser), try C(parser: parser))
   }
 }
+
+/// Create a command which takes four arguments using a closure
+public func command<A:ArgumentConvertible, B:ArgumentConvertible, C:ArgumentConvertible, D:ArgumentConvertible>(closure:(A, B, C, D) -> ()) -> CommandType {
+  return AnonymousCommand { parser in
+    closure(try A(parser: parser), try B(parser: parser), try C(parser: parser), try D(parser: parser))
+  }
+}
+
+/// Create a command which takes five arguments using a closure
+public func command<A:ArgumentConvertible, B:ArgumentConvertible, C:ArgumentConvertible, D:ArgumentConvertible, E:ArgumentConvertible>(closure:(A, B, C, D, E) -> ()) -> CommandType {
+  return AnonymousCommand { parser in
+    closure(try A(parser: parser), try B(parser: parser), try C(parser: parser), try D(parser: parser), try E(parser: parser))
+  }
+}

Commander/Group.swift

@@ -76,6 +76,8 @@ extension Group {
     addCommand(name, AnonymousCommand { parser in closure() })
   }
 
+  // MARK: Argument Commands
+
   /// Add a command which takes one argument using a closure
   public func command<A:ArgumentConvertible>(name:String, closure:A -> ()) {
     addCommand(name, Commander.command(closure))
@@ -90,4 +92,41 @@ extension Group {
   public func command<A:ArgumentConvertible, B:ArgumentConvertible, C:ArgumentConvertible>(name:String, closure:(A,B,C) -> ()) {
     addCommand(name, Commander.command(closure))
   }
+
+  /// Add a command which takes four argument using a closure
+  public func command<A:ArgumentConvertible, B:ArgumentConvertible, C:ArgumentConvertible, D:ArgumentConvertible>(name:String, closure:(A,B,C,D) -> ()) {
+    addCommand(name, Commander.command(closure))
+  }
+
+  /// Add a command which takes five argument using a closure
+  public func command<A:ArgumentConvertible, B:ArgumentConvertible, C:ArgumentConvertible, D:ArgumentConvertible, E:ArgumentConvertible>(name:String, closure:(A,B,C,D,E) -> ()) {
+    addCommand(name, Commander.command(closure))
+  }
+
+  // MARK: Argument Description Commands
+
+  /// Add a command which takes one argument using a closure
+  public func command<A:ArgumentDescriptor>(name:String, a:A, closure:(A.ValueType) -> ()) {
+    addCommand(name, Commander.command(a, closure: closure))
+  }
+
+  /// Add a command which takes two argument using a closure
+  public func command<A:ArgumentDescriptor, B:ArgumentDescriptor>(name:String, a:A, b:B, closure:(A.ValueType,B.ValueType) -> ()) {
+    addCommand(name, Commander.command(a, b, closure: closure))
+  }
+
+  /// Add a command which takes three argument using a closure
+  public func command<A:ArgumentDescriptor, B:ArgumentDescriptor, C:ArgumentDescriptor>(name:String, a:A, b:B, c:C, closure:(A.ValueType,B.ValueType,C.ValueType) -> ()) {
+    addCommand(name, Commander.command(a, b, c, closure: closure))
+  }
+
+  /// Add a command which takes four argument using a closure
+  public func command<A:ArgumentDescriptor, B:ArgumentDescriptor, C:ArgumentDescriptor, D:ArgumentDescriptor>(name:String, a:A, b:B, c:C, d:D, closure:(A.ValueType,B.ValueType,C.ValueType,D.ValueType) -> ()) {
+    addCommand(name, Commander.command(a, b, c, d, closure: closure))
+  }
+
+  /// Add a command which takes five argument using a closure
+  public func command<A:ArgumentDescriptor, B:ArgumentDescriptor, C:ArgumentDescriptor, D:ArgumentDescriptor, E:ArgumentDescriptor>(name:String, a:A, b:B, c:C, d:D, e:E, closure:(A.ValueType,B.ValueType,C.ValueType,D.ValueType,E.ValueType) -> ()) {
+    addCommand(name, Commander.command(a, b, c, d, e, closure: closure))
+  }
 }