0001    //
0002    //  Options.swift
0003    //  SwiftCLI
0004    //
0005    //  Created by Jake Heiser on 7/11/14.
0006    //  Copyright (c) 2014 jakeheis. All rights reserved.
0007    //
0008    
0009    public class FlagOption
Options.swift:65
    var flagOptions: [String: FlagOption] = [:]
Options.swift:69
    var allFlagOptions: [String: FlagOption] = [:]
Options.swift:88
    public func onFlags(flags: [String], usage: String = "", block: FlagOption.FlagBlock?) {
Options.swift:89
        addFlagOption(FlagOption(flags: flags, usage: usage, block: block))
Options.swift:107
    private func addFlagOption(flagOption: FlagOption) {
 {
0010        
0011        public typealias FlagBlock
Options.swift:15
    let block: FlagBlock?
Options.swift:17
    convenience init(flag: String, usage: String, block: FlagBlock?) {
Options.swift:21
    init(flags: [String], usage: String, block: FlagBlock?) {
Options.swift:88
    public func onFlags(flags: [String], usage: String = "", block: FlagOption.FlagBlock?) {
 = (flag: String) -> ()
0012        
0013        let flags
Options.swift:22
        self.flags = flags
Options.swift:108
        flagOptions[flagOption.flags.first!] = flagOption
Options.swift:110
        flagOption.flags.each { self.allFlagOptions[$0] = flagOption }
: [String]
0014        let usage
CommandMessageGenerator.swift:28
                let usage = options.flagOptions[key]?.usage ?? options.keyOptions[key]?.usage ?? ""
Options.swift:27
        self.usage = "\(flagsString)\(paddedUsage)"
: String
0015        let block
Options.swift:23
        self.block = block
Options.swift:132
                flagOption.block?(flag: option)
: FlagBlock?
0016        
0017        convenience init(flag: String, usage: String, block: FlagBlock?) {
0018            self.init(flags: [flag], usage: usage, block: block)
0019        }
0020        
0021        init
Options.swift:18
        self.init(flags: [flag], usage: usage, block: block)
Options.swift:89
        addFlagOption(FlagOption(flags: flags, usage: usage, block: block))
(flags: [String], usage: String, block: FlagBlock?) {
0022            self.flags = flags
0023            self.block = block
0024            
0025            let flagsString = flags.joinWithSeparator(", ")
0026            let paddedUsage = usage.padFront(totalLength: 40 - flagsString.characters.count)
0027            self.usage = "\(flagsString)\(paddedUsage)"
0028        }
0029        
0030    }
0031    
0032    public class KeyOption
Options.swift:58
public func == (lhs: KeyOption, rhs: KeyOption) -> Bool {
Options.swift:58
public func == (lhs: KeyOption, rhs: KeyOption) -> Bool {
Options.swift:66
    var keyOptions: [String: KeyOption] = [:]
Options.swift:70
    var allKeyOptions: [String: KeyOption] = [:]
Options.swift:103
    public func onKeys(keys: [String], usage: String = "", valueSignature: String = "value", block: KeyOption.KeyBlock?) {
Options.swift:104
        addKeyOption(KeyOption(keys: keys, usage: usage, valueSignature: valueSignature, block: block))
Options.swift:113
    private func addKeyOption(keyOption: KeyOption) {
: Equatable {
0033        
0034        public typealias KeyBlock
Options.swift:39
    let block: KeyBlock?
Options.swift:41
    convenience init(key: String, usage: String, valueSignature: String, block: KeyBlock?) {
Options.swift:45
    init(keys: [String], usage: String, valueSignature: String, block: KeyBlock?) {
Options.swift:103
    public func onKeys(keys: [String], usage: String = "", valueSignature: String = "value", block: KeyOption.KeyBlock?) {
 = (key: String, value: String) -> ()
0035        
0036        let keys
Options.swift:46
        self.keys = keys
Options.swift:59
    return lhs.keys == rhs.keys
Options.swift:59
    return lhs.keys == rhs.keys
Options.swift:114
        keyOptions[keyOption.keys.first!] = keyOption
Options.swift:116
        keyOption.keys.each { self.allKeyOptions[$0] = keyOption }
: [String]
0037        let usage
CommandMessageGenerator.swift:28
                let usage = options.flagOptions[key]?.usage ?? options.keyOptions[key]?.usage ?? ""
Options.swift:53
        self.usage = "\(firstPart)\(paddedUsage)"
: String
0038        let valueSignature
Options.swift:47
        self.valueSignature = valueSignature
: String
0039        let block
Options.swift:48
        self.block = block
Options.swift:138
                        keyOption.block?(key: option, value: keyValue)
: KeyBlock?
0040        
0041        convenience init(key: String, usage: String, valueSignature: String, block: KeyBlock?) {
0042            self.init(keys: [key], usage: usage, valueSignature: valueSignature, block: block)
0043        }
0044        
0045        init
Options.swift:42
        self.init(keys: [key], usage: usage, valueSignature: valueSignature, block: block)
Options.swift:104
        addKeyOption(KeyOption(keys: keys, usage: usage, valueSignature: valueSignature, block: block))
(keys: [String], usage: String, valueSignature: String, block: KeyBlock?) {
0046            self.keys = keys
0047            self.valueSignature = valueSignature
0048            self.block = block
0049            
0050            let keysString = keys.joinWithSeparator(", ")
0051            let firstPart = "\(keysString) <\(valueSignature)>"
0052            let paddedUsage = usage.padFront(totalLength: 40 - firstPart.characters.count)
0053            self.usage = "\(firstPart)\(paddedUsage)"
0054        }
0055        
0056    }
0057    
0058    public func == (lhs: KeyOption, rhs: KeyOption) -> Bool {
0059        return lhs.keys == rhs.keys
0060    }
0061    
0062    public class Options
CLI.swift:146
            let options = Options()
Command.swift:53
    func setupOptions(options: Options)
Command.swift:79
    func internalSetupOptions(options: Options) {
CommandMessageGenerator.swift:11
    class func generateUsageStatement(command command: CommandType, options: Options?) -> String {
CommandMessageGenerator.swift:40
    class func generateMisusedOptionsStatement(command command: CommandType, options: Options) -> String? {
LightweightCommand.swift:22
    public typealias OptionsSetupBlock = (options: Options) -> ()
LightweightCommand.swift:31
    public func setupOptions(options: Options) {
 {
0063        
0064        // Keyed by first given flag/key
0065        var flagOptions
CommandMessageGenerator.swift:22
        if let options = options where !options.flagOptions.isEmpty || !options.keyOptions.isEmpty {
CommandMessageGenerator.swift:25
            let allKeys = Array(options.flagOptions.keys) + Array(options.keyOptions.keys)
CommandMessageGenerator.swift:28
                let usage = options.flagOptions[key]?.usage ?? options.keyOptions[key]?.usage ?? ""
Options.swift:108
        flagOptions[flagOption.flags.first!] = flagOption
: [String: FlagOption] = [:]
0066        var keyOptions
CommandMessageGenerator.swift:22
        if let options = options where !options.flagOptions.isEmpty || !options.keyOptions.isEmpty {
CommandMessageGenerator.swift:25
            let allKeys = Array(options.flagOptions.keys) + Array(options.keyOptions.keys)
CommandMessageGenerator.swift:28
                let usage = options.flagOptions[key]?.usage ?? options.keyOptions[key]?.usage ?? ""
Options.swift:114
        keyOptions[keyOption.keys.first!] = keyOption
: [String: KeyOption] = [:]
0067        
0068        // Keyed by each given flag/key
0069        var allFlagOptions
Options.swift:110
        flagOption.flags.each { self.allFlagOptions[$0] = flagOption }
Options.swift:131
            if let flagOption = allFlagOptions[option] {
: [String: FlagOption] = [:]
0070        var allKeyOptions
Options.swift:116
        keyOption.keys.each { self.allKeyOptions[$0] = keyOption }
Options.swift:133
            } else if let keyOption = allKeyOptions[option] {
: [String: KeyOption] = [:]
0071        
0072        var unrecognizedOptions
Options.swift:143
                unrecognizedOptions.append(option)
Options.swift:171
        return unrecognizedOptions.count > 0 || keysNotGivenValue.count > 0
Options.swift:177
        if unrecognizedOptions.count > 0 {
Options.swift:179
            for option in unrecognizedOptions {
: [String] = []
0073        var keysNotGivenValue
Options.swift:140
                    keysNotGivenValue.append(option)
Options.swift:171
        return unrecognizedOptions.count > 0 || keysNotGivenValue.count > 0
Options.swift:186
        if keysNotGivenValue.count > 0 {
Options.swift:188
            for option in keysNotGivenValue {
: [String] = []
0074        
0075        var exitEarlyOptions
Command.swift:89
            options.exitEarlyOptions += helpFlags
Options.swift:146
            if exitEarlyOptions.contains(option) {
: [String] = []
0076        var exitEarly
CLI.swift:151
            if options.exitEarly { // True if -h flag given (show help but exit early before executing command)
Options.swift:147
                exitEarly = true
 = false
0077        
0078        // MARK: - Adding options
0079        
0080        /**
0081            Registers a block to be called on the recognition of certain flags. Usually best
0082            to pair a single letter flag with a more descriptive flag, e.g. [-a, --all]
0083        
0084            - Parameter flags: the flags to be recognized
0085            - Parameter usage: the usage of these flags, printed in the command usage statement
0086            - Parameter block: the block to be called upon recognition of the flags
0087        */
0088        public func onFlags
Command.swift:85
            options.onFlags(helpFlags, usage: "Show help information for this command") {(flag) in
(flags: [String], usage: String = "", block: FlagOption.FlagBlock?) {
0089            addFlagOption(FlagOption(flags: flags, usage: usage, block: block))
0090        }
0091        
0092        /**
0093            Registers a block to be called on the recognition of certain keys. Keys have an associated value
0094            recognized as the argument following the key. Usually best to pair a single letter key with a more 
0095            descriptive key, e.g. [-m, --message]
0096        
0097            - Parameter keys: the keys to be recognized
0098            - Parameter usage: the usage of these keys, printed in the command usage statement
0099            - Parameter valueSignature: a name for the associated value, only used in the command usage statement where it
0100                                        takes the form "-m, --myKey [valueSignature]"
0101            - Parameter block: the block to be called upon recognition of the keys
0102        */
0103        public func onKeys(keys: [String], usage: String = "", valueSignature: String = "value", block: KeyOption.KeyBlock?) {
0104            addKeyOption(KeyOption(keys: keys, usage: usage, valueSignature: valueSignature, block: block))
0105        }
0106        
0107        private func addFlagOption
Options.swift:89
        addFlagOption(FlagOption(flags: flags, usage: usage, block: block))
(flagOption: FlagOption) {
0108            flagOptions[flagOption.flags.first!] = flagOption
0109            
0110            flagOption.flags.each { self.allFlagOptions[$0] = flagOption }
0111        }
0112        
0113        private func addKeyOption
Options.swift:104
        addKeyOption(KeyOption(keys: keys, usage: usage, valueSignature: valueSignature, block: block))
(keyOption: KeyOption) {
0114            keyOptions[keyOption.keys.first!] = keyOption
0115            
0116            keyOption.keys.each { self.allKeyOptions[$0] = keyOption }
0117        }
0118        
0119        // MARK: - Argument parsing
0120        
0121        func recognizeOptionsInArguments
CLI.swift:149
            options.recognizeOptionsInArguments(arguments)
(rawArguments: RawArguments) {
0122            var passedOptions: [String] = []
0123            rawArguments.unclassifiedArguments().each {(argument) in
0124                if argument.hasPrefix("-") {
0125                    passedOptions += self.optionsForRawOption(argument)
0126                    rawArguments.classifyArgument(argument: argument, type: .Option)
0127                }
0128            }
0129            
0130            for option in passedOptions {
0131                if let flagOption = allFlagOptions[option] {
0132                    flagOption.block?(flag: option)
0133                } else if let keyOption = allKeyOptions[option] {
0134                    if let keyValue = rawArguments.argumentFollowingArgument(option)
0135                        where !keyValue.hasPrefix("-") {
0136                            rawArguments.classifyArgument(argument: keyValue, type: .Option)
0137                            
0138                            keyOption.block?(key: option, value: keyValue)
0139                    } else {
0140                        keysNotGivenValue.append(option)
0141                    }
0142                } else {
0143                    unrecognizedOptions.append(option)
0144                }
0145                
0146                if exitEarlyOptions.contains(option) {
0147                    exitEarly = true
0148                }
0149            }
0150        }
0151        
0152        private func optionsForRawOption
Options.swift:125
                passedOptions += self.optionsForRawOption(argument)
(rawOption: String) -> [String] {
0153            if rawOption.hasPrefix("--") {
0154                return [rawOption]
0155            }
0156            
0157            var chars: [String] = []
0158            
0159            for (index, character) in rawOption.characters.enumerate() {
0160                if index > 0 {
0161                    chars.append("-\(character)")
0162                }
0163            }
0164            
0165            return chars
0166        }
0167        
0168        // MARK: - Misused options
0169        
0170        func misusedOptionsPresent
CLI.swift:155
            if options.misusedOptionsPresent() {
() -> Bool {
0171            return unrecognizedOptions.count > 0 || keysNotGivenValue.count > 0
0172        }
0173        
0174        func misusedOptionsMessage
CommandMessageGenerator.swift:51
            return options.misusedOptionsMessage()
CommandMessageGenerator.swift:53
            return generateUsageStatement(command: command, options: options) + "\n" + options.misusedOptionsMessage()
() -> String {
0175            var message = ""
0176            
0177            if unrecognizedOptions.count > 0 {
0178                message += "Unrecognized options:"
0179                for option in unrecognizedOptions {
0180                    message += "\n\t\(option)"
0181                }
0182                
0183                message += "\n"
0184            }
0185            
0186            if keysNotGivenValue.count > 0 {
0187                message += "Required values for options but given none:"
0188                for option in keysNotGivenValue {
0189                    message += "\n\t\(option)"
0190                }
0191                
0192                message += "\n"
0193            }
0194            
0195            return message
0196        }
0197        
0198    }
0199