0001    //
0002    //  Argument.swift
0003    //  Commandant
0004    //
0005    //  Created by Syo Ikeda on 12/14/15.
0006    //  Copyright (c) 2015 Carthage. All rights reserved.
0007    //
0008    
0009    import Result
0010    
0011    /// Describes an argument that can be provided on the command line.
0012    public struct Argument
Argument.swift:38
public func <| <T: ArgumentType, ClientError>(mode: CommandMode, argument: Argument<T>) -> Result<T, CommandantError<ClientError>> {
Argument.swift:64
public func <| <T: ArgumentType, ClientError>(mode: CommandMode, argument: Argument<[T]>) -> Result<[T], CommandantError<ClientError>> {
Errors.swift:78
internal func informativeUsageError<T, ClientError>(valueExample: String, argument: Argument<T>) -> CommandantError<ClientError> {
Errors.swift:87
internal func informativeUsageError<T: ArgumentType, ClientError>(argument: Argument<T>) -> CommandantError<ClientError> {
Errors.swift:105
internal func informativeUsageError<T: ArgumentType, ClientError>(argument: Argument<[T]>) -> CommandantError<ClientError> {<T
Argument.swift:17
	public let defaultValue: T?
Argument.swift:23
	public init(defaultValue: T? = nil, usage: String) {> {
0013    	/// The default value for this argument. This is the value that will be used
0014    	/// if the argument is never explicitly specified on the command line.
0015    	///
0016    	/// If this is nil, this argument is always required.
0017    	public let defaultValue
Argument.swift:24
		self.defaultValue = defaultValue
Errors.swift:79
	if argument.defaultValue != nil {
Errors.swift:91
	if let defaultValue = argument.defaultValue {
Errors.swift:109
	if let defaultValue = argument.defaultValue {: T?
0018    
0019    	/// A human-readable string describing the purpose of this argument. This will
0020    	/// be shown in help messages.
0021    	public let usage
Argument.swift:25
		self.usage = usage
Errors.swift:80
		return informativeUsageError("[\(valueExample)]", usage: argument.usage)
Errors.swift:82
		return informativeUsageError(valueExample, usage: argument.usage): String
0022    
0023    	public init(defaultValue: T? = nil, usage: String) {
0024    		self.defaultValue = defaultValue
0025    		self.usage = usage
0026    	}
0027    
0028    	private func invalidUsageError<ClientError>(value: String) -> CommandantError<ClientError> {
0029    		let description = "Invalid value for '\(self)': \(value)"
0030    		return .UsageError(description: description)
0031    	}
0032    }
0033    
0034    /// Evaluates the given argument in the given mode.
0035    ///
0036    /// If parsing command line arguments, and no value was specified on the command
0037    /// line, the argument's `defaultValue` is used.
0038    public func <| <T: ArgumentType, ClientError>(mode: CommandMode, argument: Argument<T>) -> Result<T, CommandantError<ClientError>> {
0039    	switch mode {
0040    	case let .Arguments(arguments):
0041    		guard let stringValue = arguments.consumePositionalArgument() else {
0042    			if let defaultValue = argument.defaultValue {
0043    				return .Success(defaultValue)
0044    			} else {
0045    				return .Failure(missingArgumentError(argument.usage))
0046    			}
0047    		}
0048    
0049    		if let value = T.fromString(stringValue) {
0050    			return .Success(value)
0051    		} else {
0052    			return .Failure(argument.invalidUsageError(stringValue))
0053    		}
0054    
0055    	case .Usage:
0056    		return .Failure(informativeUsageError(argument))
0057    	}
0058    }
0059    
0060    /// Evaluates the given argument list in the given mode.
0061    ///
0062    /// If parsing command line arguments, and no value was specified on the command
0063    /// line, the argument's `defaultValue` is used.
0064    public func <| <T: ArgumentType, ClientError>(mode: CommandMode, argument: Argument<[T]>) -> Result<[T], CommandantError<ClientError>> {
0065    	switch mode {
0066    	case let .Arguments(arguments):
0067    		guard let firstValue = arguments.consumePositionalArgument() else {
0068    			if let defaultValue = argument.defaultValue {
0069    				return .Success(defaultValue)
0070    			} else {
0071    				return .Failure(missingArgumentError(argument.usage))
0072    			}
0073    		}
0074    
0075    		var values = [T]()
0076    
0077    		guard let value = T.fromString(firstValue) else {
0078    			return .Failure(argument.invalidUsageError(firstValue))
0079    		}
0080    
0081    		values.append(value)
0082    
0083    		while let nextValue = arguments.consumePositionalArgument() {
0084    			guard let value = T.fromString(nextValue) else {
0085    				return .Failure(argument.invalidUsageError(nextValue))
0086    			}
0087    
0088    			values.append(value)
0089    		}
0090    
0091    		return .Success(values)
0092    
0093    	case .Usage:
0094    		return .Failure(informativeUsageError(argument))
0095    	}
0096    }
0097