scottrhoyt/Commandant

Type-safe command line argument handling

Commandant

Commandant is a Swift framework for parsing command-line arguments, inspired by Argo (which is, in turn, inspired by the Haskell library Aeson).

Example

With Commandant, a command and its associated options could be defined as follows:

struct LogCommand: CommandType {
	typealias Options = LogOptions

	let verb = "log"
	let function = "Reads the log"

	func run(options: Options) -> Result<(), YourErrorType> {
		// Use the parsed options to do something interesting here.
		return ()
	}
}

struct LogOptions: OptionsType {
	let lines: Int
	let verbose: Bool
	let logName: String

	static func create(lines: Int)(verbose: Bool)(logName: String) -> LogOptions {
		return LogOptions(lines: lines, verbose: verbose, logName: logName)
	}

	static func evaluate(m: CommandMode) -> Result<LogOptions, CommandantError<YourErrorType>> {
		return create
			<*> m <| Option(key: "lines", defaultValue: 0, usage: "the number of lines to read from the logs")
			<*> m <| Option(key: "verbose", defaultValue: false, usage: "show verbose output")
			<*> m <| Option(usage: "the log to read")
	}
}

Then, each available command should be added to a registry:

let commands = CommandRegistry()
commands.register(LogCommand())
commands.register(VersionCommand())

After which, arguments can be parsed by simply invoking the registry:

var arguments = Process.arguments

// Remove the executable name.
assert(arguments.count >= 1)
arguments.removeAtIndex(0)

if let verb = arguments.first {
	// Remove the command name.
	arguments.removeAtIndex(0)

	if let result = commands.runCommand(verb, arguments: arguments) {
		// Handle success or failure.
	} else {
		// Unrecognized command.
	}
} else {
	// No command given.
}

For real-world examples, see the implementation of the Carthage command-line tool.

License

Commandant is released under the MIT license.