convoy 1.0.0

data/lib/convoy/option_dependency_validator.rb

@@ -0,0 +1,82 @@
+module Convoy
+    class OptionDependencyValidator
+        class << self
+            def for(parser)
+                self.new(parser)
+            end
+        end
+
+        attr_reader :parser
+
+        def initialize(parser)
+            @parser = parser
+        end
+
+        def validate(options, dependencies)
+            dependencies.each_pair do |option_name, dependency_rules|
+                ensure_dependencies_satisfied_for(option_name, dependency_rules, options)
+            end
+            options
+        end
+
+        private
+
+        def option_exists?(option)
+            parser.specs.keys.include?(option)
+        end
+
+        def ensure_dependencies_satisfied_for(option_name, dependency_rules, options)
+            ensure_dependency_for_valid_option(option_name)
+            dependency_rules.each do |rule|
+                case rule
+                    when Hash
+                        handle_all_option_value_dependency_rules(option_name, rule, options)
+                    else
+                        ensure_option_depends_on_valid_option(option_name, rule)
+                        handle_possible_presence_dependency_issue(option_name, rule, options)
+                end
+            end
+        end
+
+        def handle_all_option_value_dependency_rules(option_name, rule, options)
+            if option_was_specified?(option_name, options)
+                rule.each_pair do |rule_option, rule_option_value|
+                    ensure_option_depends_on_valid_option(option_name, rule_option)
+                    handle_possible_option_value_dependency_issue(option_name, rule_option, rule_option_value, options)
+                end
+            end
+        end
+
+        def handle_possible_option_value_dependency_issue(option_name, rule_option, rule_option_value, options)
+            unless options[rule_option] == rule_option_value
+                raise Convoy::UserError.new("Option dependency unsatisfied, '#{option_name}' depends on '#{rule_option}' having value '#{rule_option_value}', '#{option_name}' specified with value '#{options[option_name]}', but '#{rule_option}' is '#{options[rule_option]}'")
+            end
+        end
+
+        def handle_possible_presence_dependency_issue(option_name, rule, options)
+            if option_was_specified?(option_name, options) && option_was_unspecified?(rule, options)
+                raise Convoy::UserError.new("Option dependency unsatisfied, '#{option_name}' depends on '#{rule}', '#{option_name}' specified with value '#{options[option_name]}', but '#{rule}' is unspecified")
+            end
+        end
+
+        def option_was_unspecified?(option_name, options)
+            !option_was_specified?(option_name, options)
+        end
+
+        def option_was_specified?(option_name, options)
+            !options[option_name].nil? && !(options[option_name] == []) && !(options[option_name] == false)
+        end
+
+        def ensure_dependency_for_valid_option(option_name)
+            unless option_exists?(option_name)
+                raise Convoy::ClientError.new("Dependency specified for option '#{option_name}', but no such option was defined, perhaps you misspelled it")
+            end
+        end
+
+        def ensure_option_depends_on_valid_option(option_name, rule)
+            unless option_exists?(rule)
+                raise Convoy::ClientError.new("'#{option_name}' is set up to depend on '#{rule}', but '#{rule}' does not appear to be a valid option, perhaps it is a spelling error")
+            end
+        end
+    end
+end

data/lib/convoy/option_parser.rb

@@ -0,0 +1,155 @@
+module Convoy
+    class OptionParser
+        attr_reader :setup, :configuration
+
+        def initialize(configuration, setup)
+            @configuration = configuration
+            @setup = setup
+        end
+
+        def parse(cli_options)
+            options = init_invoked_options_hash
+            parse_global_options(cli_options, options[:global][:options])
+            parse_command_options(cli_options, [], options[:global][:commands])
+
+            [options, arguments_from(cli_options)]
+        end
+
+        private
+
+        def init_invoked_options_hash
+            {
+                :global => {
+                    :options => {},
+                    :commands => {}
+                }
+            }
+        end
+
+        def parse_global_options(cli_options, options)
+            context = []
+            options.merge!(parse_options(cli_options, context))
+        end
+
+        def parse_command_options(cli_options, context, options)
+            unless cli_option_is_a_command?(cli_options, context)
+                options
+            else
+                command = command_name_from(cli_options)
+                context << command
+                current_options = parse_options(cli_options, context)
+                options[command] = {}
+                options[command][:options] = current_options
+                options[command][:commands] = {}
+                parse_command_options(cli_options, context, options[command][:commands])
+            end
+        end
+
+        def parse_options(cli_options, context = [])
+            stop_words = setup.command_names_for(context).map(&:to_s)
+            parser = init_parser(stop_words)
+            parser = add_setup_options_to(parser, context)
+            parser = add_option_conflicts_to(parser, context)
+            parser = default_option_values_from_config_for(parser, context)
+            parser.version(setup.version) #set the version if it was provided
+            parser.help_formatter(Convoy::Formatter::DefaultHelpFormatter.new(setup, context))
+            parsed_options = parse_options_string(parser, cli_options)
+            Convoy::OptionDependencyValidator.for(parser).validate(parsed_options, setup.dependencies_for(context))
+            Convoy::Validator.for(parser).validate(parsed_options, setup.validations_for(context))
+        end
+
+        def add_setup_options_to(parser, context = [])
+            setup.options_for(context).each do |name, opts|
+                parser.opt name, opts[:desc] || "", opts.dup #have to make sure to dup here, otherwise opts might get stuff added to it and it
+                #may cause problems later, e.g. adds default value and when parsed again trollop barfs
+            end
+            parser
+        end
+
+        def add_option_conflicts_to(parser, context = [])
+            conflicting_options_for_context = setup.conflicting_options_for(context)
+            conflicting_options_for_context.keys.each do |option_name|
+                conflict_list = [option_name] + conflicting_options_for_context[option_name]
+                conflict_list.each do |option|
+                    raise Convoy::ClientError.new("Conflict defined with option '#{option}', but this option does not exist, perhaps it is a spelling error.") unless option_exists?(parser, option)
+                end
+                parser.conflicts *conflict_list
+            end
+            parser
+        end
+
+        def option_exists?(parser, option)
+            parser.specs.keys.include?(option)
+        end
+
+        def default_option_values_from_config_for(parser, context)
+            unless configuration.empty?
+                parser.specs.each do |sym, opts|
+                    if config_has_value_for_context?(sym, context)
+                        default = config_value_for_context(sym, context)
+                        opts[:default] = default
+                        if opts[:multi] && default.nil?
+                            opts[:default] = [] # multi arguments default to [], not nil
+                        elsif opts[:multi] && !default.kind_of?(Array)
+                            opts[:default] = [default]
+                        else
+                            opts[:default] = default
+                        end
+                    end
+                end
+            end
+            parser
+        end
+
+        def config_has_value_for_context?(option, context)
+            relevant_config_hash = config_hash_for_context(context)
+            relevant_config_hash[:options].include?(option)
+        end
+
+        def config_value_for_context(option, context)
+            relevant_config_hash = config_hash_for_context(context)
+            relevant_config_hash[:options][option]
+        end
+
+        def config_hash_for_context(context)
+            relevant_config_hash = configuration.global
+            context.each do |command_name|
+                command_name = command_name.to_sym
+                relevant_config_hash = relevant_config_hash[:commands][command_name]
+                relevant_config_hash = ensure_config_hash_has_options_and_commands(relevant_config_hash)
+            end
+            relevant_config_hash
+        end
+
+        def ensure_config_hash_has_options_and_commands(relevant_config_hash)
+            relevant_config_hash ||= {}
+            relevant_config_hash[:commands] ||= {}
+            relevant_config_hash[:options] ||= {}
+            relevant_config_hash
+        end
+
+        def cli_option_is_a_command?(cli_options, context)
+            cli_options.size > 0 && setup.command_names_for(context).include?(cli_options[0].to_sym)
+        end
+
+        def init_parser(stop_words)
+            Trollop::Parser.new.tap do |parser|
+                parser.stop_on(stop_words) # make sure we halt parsing if we see a command
+            end
+        end
+
+        def parse_options_string(parser, cli_options)
+            Trollop::with_standard_exception_handling(parser) do
+                parser.parse(cli_options)
+            end
+        end
+
+        def command_name_from(cli_options)
+            cli_options.shift.to_sym
+        end
+
+        def arguments_from(cli_options)
+            cli_options
+        end
+    end
+end

data/lib/convoy/setup/configuration/generator.rb

@@ -0,0 +1,75 @@
+module Convoy
+    module Setup
+        module Configuration
+            class Generator
+                attr_reader :setup
+
+                def initialize(setup)
+                    @setup = setup
+                end
+
+                def default_data
+                    config_hash = init_config_hash
+                    options([], config_hash[:global][:options]) #global options
+                    options_for_commands(setup.canonical_command_names_for([]), [], config_hash[:global][:commands])
+                    config_hash
+                end
+
+                private
+
+                def options_for_commands(commands, context, options = {})
+                    commands.each do |command_name|
+                        command_name = command_name.to_sym
+                        #next if command_name == :convoy
+                        options[command_name] = {}
+                        options[command_name][:options] = {}
+                        options[command_name][:commands] = {}
+                        current_context = context.dup
+                        current_context << command_name
+                        options(current_context, options[command_name][:options]) #command_options
+                        options_for_commands(setup.canonical_command_names_for(current_context), current_context, options[command_name][:commands])
+                    end
+                end
+
+                def init_config_hash
+                    {
+                        :global => {
+                            :options => {},
+                            :commands => {}
+                        },
+                        :user => {}
+                    }
+                end
+
+                def options(context = [], options = {})
+                    command_names = setup.command_names_for(context)
+                    parser = init_parser(command_names)
+                    parser = add_setup_options_to(parser, context)
+                    options.merge!(default_option_values(parser))
+                end
+
+                def init_parser(stop_words)
+                    Trollop::Parser.new.tap do |parser|
+                        parser.stop_on(stop_words) # make sure we halt parsing if we see a command
+                    end
+                end
+
+                def add_setup_options_to(parser, context = [])
+                    setup.options_for(context).each do |name, opts|
+                        parser.opt name, opts[:desc] || "", opts.dup #have to make sure to dup here, otherwise opts might get stuff added to it and it
+                        #may cause problems later, e.g. adds default value and when parsed again trollop barfs
+                    end
+                    parser
+                end
+
+                def default_option_values(parser)
+                    hash = {}
+                    parser.specs.each_pair do |key, data|
+                        hash[key] = data[:default] || nil
+                    end
+                    hash
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/configuration/instance.rb

@@ -0,0 +1,34 @@
+module Convoy
+    module Setup
+        module Configuration
+            class Instance
+                class << self
+                    def blank
+                        self.new(nil, {})
+                    end
+                end
+
+                attr_reader :data, :path
+
+                def initialize(path, hash)
+                    @data = hash
+                    @path = path
+                end
+
+                def blank?
+                    data.empty?
+                end
+
+                alias empty? blank?
+
+                def global
+                    data[:global] || {}
+                end
+
+                def user
+                    data[:user] || {}
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/configuration/loader.rb

@@ -0,0 +1,43 @@
+module Convoy
+    module Setup
+        module Configuration
+            class Loader
+                attr_reader :setup, :auto_options
+
+                def initialize(setup, auto_options)
+                    @setup = setup
+                    @auto_options = auto_options
+                end
+
+                def configuration
+                    if setup.has_config_file?
+                        Writer.new(config_path, Generator.new(setup).default_data).write if setup.config_file_autocreatable?
+                        Reader.new(config_path).read
+                    else
+                        Instance.blank
+                    end
+                end
+
+                def default_config_path
+                    @default_config_path ||= (config_filename ? File.join(File.expand_path(ENV["HOME"]), config_filename) : nil)
+                end
+
+                private
+
+                def config_filename
+                    @config_filename ||= setup.config_file
+                end
+
+                def config_path
+                    @config_path ||= (auto_options.non_default_config_path || locator.locate || default_config_path)
+                end
+
+                def locator
+                    Locator::Chaining.new(config_filename).
+                        add_locator(Locator::ExecutingScriptDirectory.new(config_filename)).
+                        add_locator(Locator::DescendingToHome.new(config_filename))
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/configuration/locator/base.rb

@@ -0,0 +1,19 @@
+module Convoy
+    module Setup
+        module Configuration
+            module Locator
+                class Base
+                    attr_reader :filename
+
+                    def initialize(filename)
+                        @filename = filename
+                    end
+
+                    def locate
+                        raise "Must be defined in child class"
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/configuration/locator/chaining.rb

@@ -0,0 +1,29 @@
+module Convoy
+    module Setup
+        module Configuration
+            module Locator
+                class Chaining < Base
+                    attr_reader :locators
+
+                    def initialize(filename, locators = [])
+                        super(filename)
+                        @locators = locators || []
+                    end
+
+                    def locate
+                        locators.each do |locator|
+                            filepath = locator.locate
+                            return filepath if filepath
+                        end
+                        nil
+                    end
+
+                    def add_locator(locator)
+                        @locators << locator
+                        self
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/configuration/locator/descending_to_home.rb

@@ -0,0 +1,23 @@
+require 'pathname'
+
+module Convoy
+    module Setup
+        module Configuration
+            module Locator
+                class DescendingToHome < Base
+                    def locate
+                        return nil unless filename
+                        possible_configs = []
+                        Pathname.new(Dir.pwd).descend do |path|
+                            filepath = File.join(path, filename)
+                            if File.exists?(filepath)
+                                possible_configs << filepath
+                            end
+                        end
+                        possible_configs.empty? ? nil : possible_configs.last
+                    end
+                end
+            end
+        end
+    end
+end