convoy 1.0.0

data/lib/convoy.rb

@@ -0,0 +1,83 @@
+autoload :Nesty, "nesty"
+
+module Convoy
+    autoload :Trollop, "convoy/trollop"
+    autoload :Utils, "convoy/utils"
+    autoload :Arguments, "convoy/arguments"
+    autoload :Logger, "convoy/logger"
+    autoload :SetupAccessor, "convoy/setup_accessor"
+    autoload :OptionDependencyValidator, "convoy/option_dependency_validator"
+    autoload :Validator, "convoy/validator"
+    autoload :AutoOptions, "convoy/auto_options"
+    autoload :GlobalPreParser, "convoy/global_pre_parser"
+    autoload :OptionParser, "convoy/option_parser"
+    autoload :App, "convoy/app"
+
+    autoload :Error, "convoy/error/error"
+    autoload :BaseError, "convoy/error/error"
+    autoload :UserError, "convoy/error/error"
+    autoload :InternalError, "convoy/error/error"
+    autoload :ClientError, "convoy/error/error"
+    autoload :TransientError, "convoy/error/error"
+
+    module Formatter
+        autoload :Option, "convoy/formatter/option"
+        autoload :Options, "convoy/formatter/options"
+        autoload :Command, "convoy/formatter/command"
+        autoload :Commands, "convoy/formatter/commands"
+        autoload :GlobalCommand, "convoy/formatter/global_command"
+        autoload :ShellCommandExecutor, "convoy/formatter/shell_command_executor"
+        autoload :Terminal, "convoy/formatter/terminal"
+        autoload :StringSplitter, "convoy/formatter/string_splitter"
+        autoload :CursorPosition, "convoy/formatter/cursor_position"
+        autoload :StreamOutputFormatter, "convoy/formatter/stream_output_formatter"
+        autoload :StringGrid, "convoy/formatter/string_grid"
+        autoload :DefaultHelpFormatter, "convoy/formatter/default_help_formatter"
+    end
+
+    module Setup
+        module Dsl
+            autoload :Options, "convoy/setup/dsl/options"
+            autoload :Action, "convoy/setup/dsl/action"
+            autoload :Command, "convoy/setup/dsl/command"
+            autoload :ConfigFile, "convoy/setup/dsl/config_file"
+            autoload :Global, "convoy/setup/dsl/global"
+        end
+
+        module Configuration
+            module Locator
+                autoload :Base, "convoy/setup/configuration/locator/base"
+                autoload :DescendingToHome, "convoy/setup/configuration/locator/descending_to_home"
+                autoload :ExecutingScriptDirectory, "convoy/setup/configuration/locator/executing_script_directory"
+                autoload :SpecifiedDirectory, "convoy/setup/configuration/locator/specified_directory"
+                autoload :Chaining, "convoy/setup/configuration/locator/chaining"
+            end
+
+            autoload :MergeTool, "convoy/setup/configuration/merge_tool"
+            autoload :Instance, "convoy/setup/configuration/instance"
+            autoload :Reader, "convoy/setup/configuration/reader"
+            autoload :Writer, "convoy/setup/configuration/writer"
+            autoload :Generator, "convoy/setup/configuration/generator"
+            autoload :Loader, "convoy/setup/configuration/loader"
+        end
+    end
+
+    module ActionCommand
+        autoload :Base, "convoy/action_command/base"
+        autoload :ConvoyUtilityCommand, "convoy/action_command/convoy_utility_command"
+    end
+end
+
+at_exit do
+    Convoy::Logger.close
+end
+
+def error_logger
+    Convoy::Logger.error
+end
+
+def output_logger
+    Convoy::Logger.output
+end
+
+

data/lib/convoy/action_command/base.rb

@@ -0,0 +1,85 @@
+module Convoy
+    module ActionCommand
+        class Base
+            attr_reader :options, :arguments, :config
+
+            def initialize(options, arguments, config={})
+                @options = options
+                @arguments = arguments
+                @config = config
+                @command_context = nil
+                @command_options = nil
+                @parent_options = nil
+                @grandparent_options = nil
+                @global_options = nil
+            end
+
+            protected
+
+            def command_context
+                return @command_context if @command_context
+                @command_context = []
+                options[:global] ||= {}
+                current_command_hash = options[:global][:commands] || {}
+                until current_command_hash.keys.empty?
+                    key = current_command_hash.keys.first
+                    @command_context << key
+                    current_command_hash = current_command_hash[key][:commands] || {}
+                end
+                @command_context
+            end
+
+            def command_name
+                command_context.last || :global
+            end
+
+            def command_options
+                @command_options ||= context_hash(command_context)[:options] || {}
+            end
+
+            def global_options
+                @global_options ||= (options[:global] || {})[:options] || {}
+            end
+
+            def parent_options
+                @parent_options ||= ensure_parent { |parent_context| context_hash(parent_context)[:options] || {} }
+            end
+
+            def grandparent_options
+                @grandparent_options ||= ensure_grandparent { |grandparent_context| context_hash(grandparent_context)[:options] || {} }
+            end
+
+            #generation_number 1 is parent, 2 is grandparent and so on
+            #default is 3 for great grandparent
+            def ancestor_options(generation_number = 3)
+                ensure_ancestor(generation_number) { |ancestor_context| context_hash(ancestor_context)[:options] || {} }
+            end
+
+            private
+
+            def context_hash(context)
+                context_hash = options[:global]
+                context.each do |command_name|
+                    context_hash = context_hash[:commands][command_name]
+                end
+                context_hash
+            end
+
+            def ensure_parent(&block)
+                ensure_ancestor(1, &block)
+            end
+
+            def ensure_grandparent(&block)
+                ensure_ancestor(2, &block)
+            end
+
+            def ensure_ancestor(generation_number, &block)
+                return {} if generation_number < 0
+                #return {} if generation_number == 0
+                return {} unless command_context.size >= generation_number
+                ancestor_context = command_context.dup.slice(0, command_context.size - generation_number)
+                block.call(ancestor_context)
+            end
+        end
+    end
+end

data/lib/convoy/action_command/escort_utility_command.rb

@@ -0,0 +1,53 @@
+module Convoy
+    module ActionCommand
+        class ConvoyUtilityCommand < Base
+            attr_reader :setup
+
+            def initialize(setup, options, arguments, config = {})
+                super(options, arguments, config)
+                @setup = setup
+            end
+
+            def execute
+                current_command_options = command_options
+                if current_command_options[:create_config_given]
+                    create_config(current_command_options[:create_config])
+                elsif current_command_options[:create_default_config_given]
+                    create_default_config
+                elsif current_command_options[:update_config_given]
+                    update_config(current_command_options[:update_config])
+                elsif current_command_options[:update_default_config_given]
+                    update_default_config
+                end
+            end
+
+            private
+
+            def create_config(path)
+                config_path = absolute_path(path)
+                Convoy::Setup::Configuration::Writer.new(config_path, Convoy::Setup::Configuration::Generator.new(setup).default_data).write
+            end
+
+            def create_default_config
+                Convoy::Setup::Configuration::Writer.new(default_config_path, Convoy::Setup::Configuration::Generator.new(setup).default_data).write
+            end
+
+            def update_config(path)
+                config_path = absolute_path(path)
+                Convoy::Setup::Configuration::Writer.new(config_path, Convoy::Setup::Configuration::Generator.new(setup).default_data).update
+            end
+
+            def update_default_config
+                Convoy::Setup::Configuration::Writer.new(default_config_path, Convoy::Setup::Configuration::Generator.new(setup).default_data).update
+            end
+
+            def absolute_path(path)
+                File.expand_path(path)
+            end
+
+            def default_config_path
+                Convoy::Setup::Configuration::Loader.new(setup, nil).default_config_path
+            end
+        end
+    end
+end

data/lib/convoy/app.rb

@@ -0,0 +1,127 @@
+module Convoy
+    class App
+        #TODO ensure that every command must have an action
+        class << self
+            def create(option_string = '', &block)
+                self.new(option_string, &block).setup_application.execute
+                exit(0)
+            end
+        end
+
+        attr_reader :setup, :option_string
+
+        def initialize(option_string, &block)
+            @option_string = option_string
+            @setup = nil
+            @block = block
+        end
+
+        def setup_application
+            old_error_sev_threshold = error_logger.sev_threshold
+            begin
+                error_logger.sev_threshold = ::Logger::DEBUG
+                cli_app_configuration = Convoy::Setup::Dsl::Global.new(&@block)
+                @setup = Convoy::SetupAccessor.new(cli_app_configuration)
+                self
+            rescue => e
+                handle_convoy_error(e)
+            ensure
+                error_logger.sev_threshold = old_error_sev_threshold
+            end
+        end
+
+        def execute
+            begin
+                AutoOptions.augment(setup)
+
+                cli_options = current_cli_options(option_string)
+
+                auto_options = Convoy::GlobalPreParser.new(setup).parse(cli_options.dup)
+                Convoy::Logger.setup_error_logger(auto_options)
+
+                #now we can start doing error logging everything above here has to be rock solid
+
+                configuration = Convoy::Setup::Configuration::Loader.new(setup, auto_options).configuration
+
+                invoked_options, arguments = Convoy::OptionParser.new(configuration, setup).parse(cli_options)
+                context = context_from_options(invoked_options[:global])
+                action = setup.action_for(context)
+                current_command = context.empty? ? :global : context.last
+                raise Convoy::ClientError.new("No action defined for command '#{current_command}'") unless action
+                actual_arguments = Convoy::Arguments.read(arguments, setup.arguments_required_for(context))
+            rescue => e
+                handle_convoy_error(e)
+            end
+            execute_action(action, invoked_options, actual_arguments, configuration.user)
+        end
+
+        private
+
+        def current_cli_options(option_string)
+            passed_in_options = Convoy::Utils.tokenize_option_string(option_string)
+            passed_in_options.empty? ? ARGV.dup : passed_in_options
+        end
+
+        def execute_action(action, options, arguments, user_config)
+            begin
+                #execute before servants here
+                action.call(options, arguments, user_config)
+                    #execute after servants here
+            rescue => e
+                handle_action_error(e)
+            end
+        end
+
+        def context_from_options(options)
+            commands_in_order(options)
+        end
+
+        def commands_in_order(options, commands = [])
+            if options[:commands].keys.empty?
+                commands
+            else
+                command = options[:commands].keys.first
+                commands << command
+                commands_in_order(options[:commands][command], commands)
+            end
+        end
+
+        def handle_convoy_error(e)
+            if e.kind_of?(Convoy::UserError)
+                print_stacktrace(e)
+                error_logger.debug {'Convoy app failed to execute successfully, due to user error'}
+                exit(Convoy::USER_ERROR_EXIT_CODE)
+            elsif e.kind_of?(Convoy::ClientError)
+                print_stacktrace(e)
+                error_logger.debug {'Convoy app failed to execute successfully, due to client setup error'}
+                exit(Convoy::CLIENT_ERROR_EXIT_CODE)
+            else
+                print_convoy_error_message(e)
+                error_logger.debug {'Convoy app failed to execute successfully, due to internal error'}
+                exit(Convoy::INTERNAL_ERROR_EXIT_CODE)
+            end
+        end
+
+        def handle_action_error(e)
+            if e.kind_of?(Convoy::Error)
+                print_convoy_error_message(e)
+                error_logger.debug {'Convoy app failed to execute successfully, due to internal error'}
+                exit(Convoy::INTERNAL_ERROR_EXIT_CODE)
+            else
+                print_stacktrace(e)
+                error_logger.debug {'Convoy app failed to execute successfully, due to unknown error'}
+                exit(Convoy::EXTERNAL_ERROR_EXIT_CODE)
+            end
+        end
+
+        def print_stacktrace(e)
+            error_logger.error { e.message }
+            error_logger.debug { e }
+        end
+
+        def print_convoy_error_message(e)
+            print_stacktrace(e)
+            error_logger.warn {"\n  \x1B[48;5;196m ERROR \x1B[0m An internal Convoy error occurred.\n\n    You should probably report it to \x1B[38;5;222mAlbert Rannetsperger\x1B[0m or create an issue on his \x1B[38;5;222mGitHub\x1B[0m page (https://github.com/alb3rtuk).\n    Make sure to include the stacktrace above (although it probably won't be very helpful).bp\n\n"}
+        end
+    end
+end

data/lib/convoy/arguments.rb

@@ -0,0 +1,20 @@
+require 'readline'
+
+module Convoy
+    class Arguments
+        class << self
+            def read(arguments, requires_arguments=false)
+                if arguments.empty? && requires_arguments
+                    while command = Readline.readline("> ", true)
+                        arguments << command
+                    end
+                    arguments = arguments.compact.keep_if { |value| value.length > 0 }
+                    if arguments.empty?
+                        raise Convoy::UserError.new("You must provide some arguments to this script")
+                    end
+                end
+                arguments
+            end
+        end
+    end
+end

data/lib/convoy/auto_options.rb

@@ -0,0 +1,71 @@
+module Convoy
+    class AutoOptions
+        class << self
+            def augment(setup)
+                if setup.has_config_file?
+                    setup.add_global_option :config, "Configuration file to use for this execution", :short => :none, :long => '--config', :type => :string
+
+                    setup.add_global_command :convoy, :aliases => [] do |command|
+                        command.summary "Auto created utility command"
+                        command.description "Auto created utility command"
+                        command.requires_arguments false
+
+                        command.options do |opts|
+                            opts.opt :create_config, "Create configuration file at specified location", :short => :none, :long => '--create-config', :type => :string
+                            opts.opt :create_default_config, "Create a default configuration file", :short => :none, :long => '--create-default-config', :type => :boolean, :default => false
+                            opts.opt :update_config, "Update configuration file at specified location", :short => :none, :long => '--update-config', :type => :string
+                            opts.opt :update_default_config, "Update the default configuration file", :short => :none, :long => '--update-default-config', :type => :boolean, :default => false
+
+                            opts.conflict :create_config, :create_default_config, :update_config, :update_default_config
+                        end
+
+                        command.action do |options, arguments|
+                            ActionCommand::ConvoyUtilityCommand.new(setup, options, arguments).execute
+                        end
+                    end
+                end
+                setup.add_global_option :verbosity, 'Verbosity level of output for current execution (e.g. INFO, DEBUG)', :short => :none, :long => '--verbosity', :type => :string, :default => 'WARN'
+                setup.add_global_option :error_output_format, 'The format to use when outputting errors (e.g. basic, advanced)', :short => :none, :long => '--error-output-format', :type => :string, :default => 'basic'
+            end
+        end
+
+        attr_reader :options
+
+        def initialize(options)
+            @options = options
+        end
+
+        def non_default_config_path
+            if options[:config_given] && File.exists?(config_path)
+                config_path
+            elsif !options[:config_given]
+                nil
+            else
+                error_logger.warn "The given config file '#{options[:config]}' does not exist, falling back to default"
+                nil
+            end
+        end
+
+        def verbosity
+            error_verbosity.upcase
+        end
+
+        def error_formatter
+            error_output_format.to_sym
+        end
+
+        private
+
+        def config_path
+            File.expand_path(options[:config])
+        end
+
+        def error_output_format
+            options[:error_output_format]
+        end
+
+        def error_verbosity
+            options[:verbosity]
+        end
+    end
+end

data/lib/convoy/error/error.rb

@@ -0,0 +1,33 @@
+module Convoy
+    INTERNAL_ERROR_EXIT_CODE = 1
+    CLIENT_ERROR_EXIT_CODE = 2
+    USER_ERROR_EXIT_CODE = 3
+    EXTERNAL_ERROR_EXIT_CODE = 10
+
+    #module to tag all exceptions coming out of Convoy with
+    module Error
+    end
+
+    #all our exceptions will supported nesting other exceptions
+    #also all our exception will be a kind_of? Convoy::Error
+    class BaseError < StandardError
+        include Nesty::NestedError
+        include Error
+    end
+
+    #user did something invalid
+    class UserError < BaseError
+    end
+
+    #for errors with convoy itself
+    class InternalError < BaseError
+    end
+
+    #for errors with how convoy is being used
+    class ClientError < BaseError
+    end
+
+    #a dependency is temporarily unavailable
+    class TransientError < BaseError
+    end
+end