Skip to content
Type-safe command line argument handling
Branch: master
Clone or download
Latest commit ab68611 Apr 12, 2019
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
Carthage/Checkouts Remove Swift 4.2 compatibility. This release will only support Swift 5. Apr 8, 2019
Commandant.xcodeproj Remove Swift 4.2 compatibility. This release will only support Swift 5. Apr 8, 2019
Commandant.xcworkspace Remove Swift 4.2 compatibility. This release will only support Swift 5. Apr 8, 2019
Sources/Commandant Bump up version to 0.17.0 Apr 12, 2019
Tests Bump up version to 0.17.0 Apr 12, 2019
.gitignore Update gitignore; Dec 12, 2016
.gitmodules Remove Swift 4.2 compatibility. This release will only support Swift 5. Apr 8, 2019
.hound.yml [lint] Add .swiftlint.yml, .hound.yml and address some violations Apr 6, 2019
.swift-version Update .swift-version Apr 8, 2019
.swiftlint.yml [lint] Add .swiftlint.yml, .hound.yml and address some violations Apr 6, 2019
.travis.yml
CONTRIBUTING.md Add better CONTRIBUTING and LICENSE files Nov 22, 2014
Cartfile.private Update Cartfiles and submodules Mar 7, 2019
Cartfile.resolved Remove Result from Cartfile.resolved Apr 12, 2019
Commandant.podspec Bump up version to 0.17.0 Apr 12, 2019
LICENSE.md Add better CONTRIBUTING and LICENSE files Nov 22, 2014
Package.resolved Remove Swift 4.2 compatibility. This release will only support Swift 5. Apr 8, 2019
Package.swift Remove Swift 4.2 compatibility. This release will only support Swift 5. Apr 8, 2019
README.md Add a "Reviewed by Hound" badge Jan 9, 2019

README.md

Commandant

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

Reviewed by Hound

Example

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

struct LogCommand: CommandProtocol {
	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: OptionsProtocol {
	let lines: Int
	let verbose: Bool
	let logName: String

	static func create(_ lines: Int) -> (Bool) -> (String) -> LogOptions {
		return { verbose in { logName in 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 <| Argument(usage: "the log to read")
	}
}

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

let commands = CommandRegistry<YourErrorType>()
commands.register(LogCommand())
commands.register(VersionCommand())

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

var arguments = CommandLine.arguments

// Remove the executable name.
assert(!arguments.isEmpty)
arguments.remove(at: 0)

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

	if let result = commands.run(command: 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.

You can’t perform that action at this time.