convoy 1.0.0

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

@@ -0,0 +1,15 @@
+module Convoy
+    module Setup
+        module Configuration
+            module Locator
+                class ExecutingScriptDirectory < Base
+                    def locate
+                        location_directory = File.dirname($0)
+                        filepath = File.expand_path(File.join(location_directory, filename))
+                        File.exists?(filepath) ? filepath : nil
+                    end
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,21 @@
+module Convoy
+    module Setup
+        module Configuration
+            module Locator
+                class SpecifiedDirectory < Base
+                    attr_reader :location_directory
+
+                    def initialize(filename, location_directory)
+                        super(filename)
+                        @location_directory = location_directory
+                    end
+
+                    def locate
+                        filepath = File.expand_path(File.join(location_directory, filename))
+                        File.exists?(filepath) ? filepath : nil
+                    end
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,38 @@
+module Convoy
+    module Setup
+        module Configuration
+            class MergeTool
+                def initialize(new_config_hash, old_config_hash)
+                    @new_config_hash = new_config_hash
+                    @old_config_hash = old_config_hash
+                end
+
+                def config_hash
+                    merge_config(@new_config_hash, @old_config_hash)
+                end
+
+                private
+
+                def merge_config(new_hash, old_hash)
+                    new_hash.keys.each do |key|
+                        new_config_value = new_hash[key]
+                        old_config_value = old_hash[key]
+
+                        if new_config_value.kind_of?(Hash) && old_config_value.kind_of?(Hash)
+                            new_hash[key] = merge_config(new_config_value, old_config_value)
+                        elsif old_config_value.nil?
+                            new_hash[key] = new_config_value
+                        else
+                            new_hash[key] = old_config_value
+                        end
+
+                        if key == :user
+                            new_hash[key] = old_config_value
+                        end
+                    end
+                    new_hash
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,36 @@
+require 'json'
+
+module Convoy
+    module Setup
+        module Configuration
+            class Reader
+                attr_reader :path
+
+                def initialize(path)
+                    @path = path
+                end
+
+                def read
+                    data = {}
+                    data = load_config_at_path if path
+                    Instance.new(path, data)
+                end
+
+                private
+
+                def load_config_at_path
+                    data = {}
+                    begin
+                        json = File.read(path)
+                        hash = ::JSON.parse(json)
+                        data = Convoy::Utils.symbolize_keys(hash)
+                    rescue => e
+                        error_logger.warn { "Found config at #{path}, but failed to load it, perhaps your JSON syntax is invalid. Attempting to continue without..." }
+                        error_logger.debug(e)
+                    end
+                    data
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,46 @@
+require 'json'
+require 'fileutils'
+
+module Convoy
+    module Setup
+        module Configuration
+            class Writer
+                attr_reader :path, :data
+
+                def initialize(path, data)
+                    @path = path
+                    @data = data
+                end
+
+                def write
+                    if path && !File.exists?(path)
+                        save_to_file
+                        Instance.new(path, data)
+                    else
+                        Instance.blank
+                    end
+                end
+
+                def update
+                    current_data = {}
+                    if File.exists? path
+                        current_data = Reader.new(path).read.data
+                    end
+                    @data = Convoy::Setup::Configuration::MergeTool.new(data, current_data).config_hash
+                    save_to_file
+                    Instance.new(path, data)
+                end
+
+                private
+
+                def save_to_file
+                    current_path = File.expand_path(path)
+                    FileUtils.mkdir_p(File.dirname(current_path))
+                    File.open(current_path, "w") do |f|
+                        f.puts ::JSON.pretty_generate(data)
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/dsl/action.rb

@@ -0,0 +1,17 @@
+module Convoy
+    module Setup
+        module Dsl
+            class Action
+                class << self
+                    def action(command_name, instance, &block)
+                        instance.instance_variable_set(:"@block", block)
+                    end
+                end
+
+                def initialize(command_name = :global)
+                    @command_name = command_name
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/dsl/command.rb

@@ -0,0 +1,67 @@
+module Convoy
+    module Setup
+        module Dsl
+            class Command
+                def initialize(name, options = {}, &block)
+                    reset(name)
+                    @description = options[:description] || options[:desc] || ""
+                    @aliases = [options[:aliases] || []].flatten
+                    @requires_arguments ||= options[:requires_arguments]
+                    block.call(self) if block_given?
+                rescue => e
+                    raise Convoy::ClientError.new("Problem with syntax of command '#{@name}' configuration", e)
+                end
+
+                def options(&block)
+                    Options.options(@name, @options, &block)
+                end
+
+                def action(&block)
+                    Action.action(@name, @action, &block)
+                end
+
+                def command(name, options = {}, &block)
+                    options[:requires_arguments] = @requires_arguments
+                    command = Command.new(name.to_sym, options, &block)
+                    aliases = [options[:aliases] || []].flatten + [name]
+                    aliases.each do |name|
+                        @commands[name.to_sym] = command
+                    end
+                end
+
+                def requires_arguments(boolean = true)
+                    raise Convoy::ClientError.new("Parameter to 'requires_arguments' must be a boolean") unless [true, false].include?(boolean)
+                    @requires_arguments = boolean
+                    @commands.each do |command|
+                        command.requires_arguments(boolean)
+                    end
+                end
+
+                def summary(summary)
+                    @summary = summary
+                end
+
+                def description(description)
+                    @description = description
+                end
+
+                private
+
+                def reset(name)
+                    @name = name
+                    @summary = nil
+                    @description = nil
+                    @requires_arguments = false
+                    @commands = {}
+                    @options = Options.new(name)
+                    @action = Action.new(name)
+                    custom_reset
+                end
+
+                def custom_reset
+                    @aliases = []
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/dsl/config_file.rb

@@ -0,0 +1,13 @@
+module Convoy
+    module Setup
+        module Dsl
+            class ConfigFile
+                def initialize(name, options = {})
+                    @name = name
+                    #TODO possibly raise error if autocreate is not a boolean
+                    @autocreate = options[:autocreate] || false
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/dsl/global.rb

@@ -0,0 +1,29 @@
+module Convoy
+    module Setup
+        module Dsl
+            class Global < Command
+                def initialize(&block)
+                    reset(:global)
+                    block.call(self)
+                rescue => e
+                    raise Convoy::ClientError.new("Problem with syntax of global configuration", e)
+                end
+
+                def config_file(name, options = {})
+                    @config_file = ConfigFile.new(name, options)
+                end
+
+                def version(version)
+                    @version = version
+                end
+
+                private
+
+                def custom_reset
+                    @version = nil
+                    @config_file = nil
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup/dsl/options.rb

@@ -0,0 +1,81 @@
+module Convoy
+    module Setup
+        module Dsl
+            class Options
+                class << self
+                    def options(command_name, instance, &block)
+                        block.call(instance) if block_given?
+                    rescue => e
+                        raise Convoy::ClientError.new("Problem with syntax of #{instance.instance_variable_get(:"@command_name")} options block", e)
+                    end
+                end
+
+                def initialize(command_name = :global)
+                    @command_name = command_name
+                    @options = {}
+                    @dependencies = {}
+                    @conflicts = {}
+                    @validations = {}
+                end
+
+                def opt(name, desc="", opts={})
+                    opts[:desc] ||= desc
+                    @options[name] ||= opts
+                    dependency(name, :on => opts[:depends_on]) if opts[:depends_on]
+                    conflict(*[name, opts[:conflicts_with]].flatten) if opts[:conflicts_with]
+                end
+
+                def validate(name, description, &block)
+                    @validations[name] ||= []
+                    @validations[name] << {:desc => description, :block => block}
+                end
+
+                def dependency(option_name, opts = {})
+                    ensure_dependency_specification_syntax(opts)
+                    @dependencies[option_name] ||= []
+                    rules_as_array(opts).each do |rule|
+                        ensure_no_self_dependency(option_name, rule)
+                        @dependencies[option_name] << rule
+                    end
+                end
+
+                def conflict(*opts)
+                    opts.each do |opt|
+                        conflicts_for_opt = opts.reject { |value| value == opt }
+                        @conflicts[opt] ||= []
+                        @conflicts[opt] += conflicts_for_opt
+                        @conflicts[opt].uniq!
+                    end
+                end
+
+                private
+                def ensure_no_self_dependency(option_name, rule)
+                    case rule
+                        when Hash
+                            rule.each_pair do |rule_option, rule_option_value|
+                                handle_possible_self_dependency(option_name, rule_option)
+                            end
+                        else
+                            handle_possible_self_dependency(option_name, rule)
+                    end
+                end
+
+                def ensure_dependency_specification_syntax(opts)
+                    unless opts[:on]
+                        raise Convoy::ClientError.new("Problem with syntax of dependency specification in #{@command_name} options block, #{option_name} missing ':on' condition")
+                    end
+                end
+
+                def rules_as_array(opts)
+                    [opts[:on]].flatten
+                end
+
+                def handle_possible_self_dependency(option_name, rule)
+                    if option_name == rule
+                        raise Convoy::ClientError.new("Problem with syntax of dependency specification in #{@command_name} options block, #{option_name} is set to depend on itself")
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/convoy/setup_accessor.rb

@@ -0,0 +1,206 @@
+module Convoy
+    class SetupAccessor
+        attr_reader :global_instance
+
+        def initialize(global_instance)
+            @global_instance = global_instance
+        end
+
+        def options_for(context = [])
+            with_context(context) do |current_context|
+                options_hash_from(current_context)
+            end
+        end
+
+        def conflicting_options_for(context = [])
+            with_context(context) do |current_context|
+                conflicts_hash_for(current_context)
+            end
+        end
+
+        def validations_for(context = [])
+            with_context(context) do |current_context|
+                validations_hash_from(current_context)
+            end
+        end
+
+        def dependencies_for(context = [])
+            with_context(context) do |current_context|
+                dependencies_hash_from(current_context)
+            end
+        end
+
+        def command_names_for(context = [])
+            with_context(context) do |current_context|
+                command_names_from(current_context)
+            end
+        end
+
+        def canonical_command_names_for(context = [])
+            with_context(context) do |current_context|
+                canonical_command_names_from(current_context)
+            end
+        end
+
+        def action_for(context = [])
+            with_context(context) do |current_context|
+                action_block_from(current_context)
+            end
+        end
+
+        def arguments_required_for(context = [])
+            with_context(context) do |current_context|
+                context_requires_arguments(current_context)
+            end
+        end
+
+        def has_config_file?
+            config_file_object != nil
+        end
+
+        def config_file_autocreatable?
+            autocreatable = fetch_instance_variable_from(config_file_object, :autocreate)
+        end
+
+        def config_file
+            name = fetch_instance_variable_from(config_file_object, :name)
+        end
+
+        def version
+            version_string = fetch_instance_variable_from(global_instance, :version)
+        end
+
+        def summary_for(context = [])
+            with_context(context) do |current_context|
+                fetch_instance_variable_from(current_context, :summary)
+            end
+        end
+
+        def description_for(context = [])
+            with_context(context) do |current_context|
+                fetch_instance_variable_from(current_context, :description)
+            end
+        end
+
+        def command_description_for(command_name, context = [])
+            with_context(context) do |current_context|
+                commands = fetch_instance_variable_from(current_context, :commands)
+                fetch_instance_variable_from(commands[command_name], :description)
+            end
+        end
+
+        def command_summary_for(command_name, context = [])
+            with_context(context) do |current_context|
+                commands = fetch_instance_variable_from(current_context, :commands)
+                fetch_instance_variable_from(commands[command_name], :summary)
+            end
+        end
+
+        def command_aliases_for(command_name, context = [])
+            with_context(context) do |current_context|
+                commands = fetch_instance_variable_from(current_context, :commands)
+                description = fetch_instance_variable_from(commands[command_name], :aliases)
+            end
+        end
+
+        def add_global_option(name, desc, options = {})
+            with_context([]) do |current_context|
+                options_object = options_object_from(current_context)
+                options_object.opt name, desc, options
+            end
+        end
+
+        def add_global_command(name, options = {}, &block)
+            global_instance.command(name, options, &block)
+        end
+
+        private
+
+        def config_file_object
+            config_file = fetch_instance_variable_from(global_instance, :config_file)
+        end
+
+        def with_context(context = [], &block)
+            context = [] if context.nil? || context.empty?
+            context = [context] unless context.kind_of?(Array)
+            current_context = global_instance
+            context.each do |command_name|
+                commands = fetch_instance_variable_from(current_context, :commands)
+                current_context = commands[command_name.to_sym]
+            end
+            block.call(current_context)
+        end
+
+        def context_requires_arguments(context_object)
+            requires_arguments = fetch_instance_variable_from(context_object, :requires_arguments)
+        end
+
+        def action_block_from(context_object)
+            action_object = fetch_instance_variable_from(context_object, :action)
+            block = fetch_instance_variable_from(action_object, :block)
+            #TODO make sure that if there is no block we exit with a client error
+        end
+
+        def command_names_from(context_object)
+            commands = fetch_instance_variable_from(context_object, :commands)
+            commands.keys
+            #TODO make sure there can be no errors here and at worst it is an empty array
+        end
+
+        def canonical_command_names_from(context_object)
+            commands = fetch_instance_variable_from(context_object, :commands)
+            commands.select do |key, command|
+                aliases = fetch_instance_variable_from(command, :aliases)
+                !aliases.include?(key)
+            end.keys
+            #TODO make sure there can be no errors here and at worst it is an empty array
+        end
+
+        def options_hash_from(context_object)
+            ensure_context_object(context_object, {}) do
+                options_object = options_object_from(context_object)
+                fetch_instance_variable_from(options_object, :options)
+            end
+        end
+
+        def options_object_from(context_object)
+            ensure_context_object(context_object, nil) do
+                fetch_instance_variable_from(context_object, :options)
+            end
+        end
+
+        def conflicts_hash_for(context_object)
+            ensure_context_object(context_object, {}) do
+                options_object = options_object_from(context_object)
+                fetch_instance_variable_from(options_object, :conflicts)
+            end
+        end
+
+        def validations_hash_from(context_object)
+            ensure_context_object(context_object, {}) do
+                validations_object = fetch_instance_variable_from(context_object, :options)
+                fetch_instance_variable_from(validations_object, :validations)
+            end
+        end
+
+        def dependencies_hash_from(context_object)
+            ensure_context_object(context_object, {}) do
+                options_object = options_object_from(context_object)
+                fetch_instance_variable_from(options_object, :dependencies)
+            end
+        end
+
+        def fetch_instance_variable_from_setup(instance_variable)
+            fetch_instance_variable_from(global_instance, instance_variable)
+        end
+
+        def fetch_instance_variable_from(instance, instance_variable)
+            instance_variable_symbol = :"@#{instance_variable.to_s}"
+            instance.instance_variable_get(instance_variable_symbol)
+        end
+
+        def ensure_context_object(context_object, default_value, &block)
+            context_object ? block.call : default_value
+        end
+    end
+end