escort 0.0.1 → 0.1.0

data/lib/escort/action_command/base.rb

@@ -0,0 +1,79 @@
+module Escort
+  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 = []
+        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_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 < 1
+        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/escort/action_command/escort_utility_command.rb

@@ -0,0 +1,53 @@
+module Escort
+  module ActionCommand
+    class EscortUtilityCommand < 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)
+        Escort::Setup::Configuration::Writer.new(config_path, Escort::Setup::Configuration::Generator.new(setup).default_data).write
+      end
+
+      def create_default_config
+        Escort::Setup::Configuration::Writer.new(default_config_path, Escort::Setup::Configuration::Generator.new(setup).default_data).write
+      end
+
+      def update_config(path)
+        config_path = absolute_path(path)
+        Escort::Setup::Configuration::Writer.new(config_path, Escort::Setup::Configuration::Generator.new(setup).default_data).update
+      end
+
+      def update_default_config
+        Escort::Setup::Configuration::Writer.new(default_config_path, Escort::Setup::Configuration::Generator.new(setup).default_data).update
+      end
+
+      def absolute_path(path)
+        File.expand_path(path)
+      end
+
+      def default_config_path
+        Escort::Setup::Configuration::Loader.new(setup, nil).default_config_path
+      end
+    end
+  end
+end

data/lib/escort/app.rb

@@ -1,58 +1,111 @@
 module Escort
   class App
-    include Dsl
-    include GlobalDsl
-
+    #TODO ensure that every command must have an action
     class << self
-      def create(options_string = nil, &block)
-        self.new(options_string).tap do |app|
-          block.call(app)  #run the block to get the various sub blocks
-          begin
-            app.parse_options # parse the global options
-            app.current_command.parse_options # parse the current command options
-            app.execute_before_block(app.current_command.name, app.current_options, app.current_command.current_options, app.arguments)
-            app.current_command.perform_action(app.current_options, app.arguments)
-          rescue => e
-            app.execute_error_block(e)
-          end
-        end
+      def create(option_string = '', &block)
+        cli_app_configuration = Escort::Setup::Dsl::Global.new(&block)
+        setup = Escort::SetupAccessor.new(cli_app_configuration)
+        app = self.new(option_string, setup)
+        app.execute
+        exit(0)
+      end
+    end
+
+    attr_reader :setup, :option_string
+
+    def initialize(option_string, setup)
+      @setup = setup
+      @option_string = option_string
+    end
+
+    def execute
+      begin
+        AutoOptions.augment(setup)
+
+        cli_options = current_cli_options(option_string)
+
+        auto_options = Escort::GlobalPreParser.new(setup).parse(cli_options.dup)
+        Escort::Logger.setup_error_logger(auto_options)
+
+        #now we can start doing error logging everything above here has to be rock solid
+
+        configuration = Escort::Setup::Configuration::Loader.new(setup, auto_options).configuration
+
+        invoked_options, arguments = Escort::OptionParser.new(configuration, setup).parse(cli_options)
+        context = context_from_options(invoked_options[:global])
+        action = setup.action_for(context)
+        actual_arguments = Escort::Arguments.read(arguments, setup.arguments_required_for(context))
+      rescue => e
+        handle_escort_error(e)
       end
+      execute_action(action, invoked_options, actual_arguments, configuration.user)
     end
 
-    attr_reader :current_options
+    private
 
-    def initialize(options_string = nil)
-      @options_string = options_string || ARGV.dup
+    def current_cli_options(option_string)
+      passed_in_options = Escort::Utils.tokenize_option_string(option_string)
+      passed_in_options.empty? ? ARGV.dup : passed_in_options
     end
 
-    def arguments
-      @options_string
+    def execute_action(action, options, arguments, user_config)
+      begin
+        action.call(options, arguments, user_config)
+      rescue => e
+        handle_action_error(e)
+      end
     end
 
-    def parse_options
-      parser = Trollop::Parser.new(&@options_block)
-      parser.stop_on(@command_names)
+    def context_from_options(options)
+      commands_in_order(options)
+    end
 
-      @current_options = Trollop::with_standard_exception_handling(parser) do
-        parser.parse @options_string
+    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 current_command
-      return @current_command if @current_command
-      command_name = @options_string.shift.to_s
-      command_block = @command_blocks[command_name]
-      @current_command = Command.new(command_name, @options_string)
-      command_block.call(@current_command)
-      @current_command
+    def handle_escort_error(e)
+      if e.kind_of?(Escort::UserError)
+        print_escort_error_message(e)
+        error_logger.debug{ "Escort app failed to execute successfully, due to user error" }
+        exit(Escort::USER_ERROR_EXIT_CODE)
+      elsif e.kind_of?(Escort::ClientError)
+        print_escort_error_message(e)
+        error_logger.debug{ "Escort app failed to execute successfully, due to client setup error" }
+        exit(Escort::CLIENT_ERROR_EXIT_CODE)
+      else
+        print_escort_error_message(e)
+        error_logger.debug{ "Escort app failed to execute successfully, due to internal error" }
+        exit(Escort::INTERNAL_ERROR_EXIT_CODE)
+      end
+    end
+
+    def handle_action_error(e)
+      if e.kind_of?(Escort::Error)
+        print_escort_error_message(e)
+        error_logger.debug{ "Escort app failed to execute successfully, due to internal error" }
+        exit(Escort::INTERNAL_ERROR_EXIT_CODE)
+      else
+        print_stacktrace(e)
+        error_logger.debug{ "Escort app failed to execute successfully, due to unknown error" }
+        exit(Escort::EXTERNAL_ERROR_EXIT_CODE)
+      end
     end
 
-    def execute_before_block(command_name, global_options, command_options, arguments)
-      @before_block.call(command_name, global_options, command_options, arguments) if @before_block
+    def print_stacktrace(e)
+      error_logger.error{ e }
     end
 
-    def execute_error_block(error)
-      @error_block.call(error)
+    def print_escort_error_message(e)
+      print_stacktrace(e)
+      error_logger.warn{ "\n\n" }
+      error_logger.warn{ "An internal Escort error has occurred, you should probably report it by creating an issue on github!" }
     end
   end
 end

data/lib/escort/arguments.rb

@@ -0,0 +1,20 @@
+require 'readline'
+
+module Escort
+  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 Escort::UserError.new("You must provide some arguments to this script")
+          end
+        end
+        arguments
+      end
+    end
+  end
+end

data/lib/escort/auto_options.rb

@@ -0,0 +1,71 @@
+module Escort
+  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 :escort, :description => "Auto created utility command", :aliases => [] do |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
+            end
+
+            command.conflicting_options :create_config, :create_default_config, :update_config, :update_default_config
+
+            command.action do |options, arguments|
+              ActionCommand::EscortUtilityCommand.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"
+        #TODO validations for the output format and the verbosity
+      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/escort/error/error.rb

@@ -0,0 +1,50 @@
+module Escort
+  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 Escort with
+  module Error
+  end
+
+  #all our exceptions will supported nesting other exceptions
+  #also all our exception will be a kind_of? Escort::Error
+  class BaseError < StandardError
+    include Error
+    attr_reader :original
+
+    def initialize(msg, original=$!)
+      super(msg)
+      @original = original
+    end
+
+    def set_backtrace(bt)
+      if original
+        original.backtrace.reverse.each do |line|
+          bt.last == line ? bt.pop : break
+        end
+        original_first = original.backtrace.shift
+        bt.concat ["#{original_first}: #{original.message}"]
+        bt.concat original.backtrace
+      end
+      super(bt)
+    end
+  end
+
+  #user did something invalid
+  class UserError < BaseError
+  end
+
+  #for errors with escort itself
+  class InternalError < BaseError
+  end
+
+  #for errors with how escort is being used
+  class ClientError < BaseError
+  end
+
+  #a dependency is temporarily unavailable
+  class TransientError < BaseError
+  end
+end

data/lib/escort/formatter/borderless_table.rb

@@ -0,0 +1,102 @@
+module Escort
+  module Formatter
+    class BorderlessTable
+      attr_reader :column_count, :formatter
+      attr_accessor :rows
+
+      def initialize(formatter, options = {})
+        @formatter = formatter
+        @column_count = options[:columns] || 3
+        @rows = []
+      end
+
+      def row(*column_values)
+        rows << column_values.map(&:to_s)
+        #TODO raise error if column values size doesn't match columns
+      end
+
+      def output(&block)
+        block.call(self)
+
+        rows.each do |cells|
+          virtual_row = normalize_virtual_row(virtual_row_for(cells))
+          physical_row_count_for(virtual_row).times do |physical_count|
+            physical_row = format_physical_row_values(physical_row_for(virtual_row, physical_count))
+            formatter.put physical_row.join("").chomp, :newlines => 1
+          end
+        end
+      end
+
+      private
+
+      def format_physical_row_values(physical_row)
+        physical_row.each_with_index.map do |value, index|
+          cell_value(value, index)
+        end
+      end
+
+      def physical_row_for(virtual_row, index)
+        virtual_row.map {|physical| physical[index]}
+      end
+
+      def virtual_row_for(column_values)
+        virtual_row = []
+        column_values.each_with_index do |cell, index|
+          virtual_row << Escort::Formatter::StringSplitter.new(column_width(index) - 1).split(cell)
+        end
+        normalize_virtual_row(virtual_row)
+      end
+
+      def normalize_virtual_row(virtual_row)
+        virtual_row.map do |physical|
+          while physical.size < physical_row_count_for(virtual_row)
+            physical << ""
+          end
+          physical
+        end
+      end
+
+      def physical_row_count_for(virtual_row)
+        virtual_row.map {|physical| physical.size}.max
+      end
+
+      def column_width(column_index)
+        #TODO raise error if index out of bounds
+        width = fair_column_width(column_index)
+        if column_index == column_count - 1
+          width = last_column_width
+        end
+        width
+      end
+
+      def fair_column_width(index)
+        #TODO raise error if index out of bounds
+        width = values_in_column(index).map(&:length).max
+        width = width + 1
+        width > max_column_width ? max_column_width : width
+      end
+
+      def last_column_width
+        full_fair_column_width = max_column_width * column_count
+        all_but_last_fair_column_width = 0
+        (column_count - 1).times do |index|
+          all_but_last_fair_column_width += fair_column_width(index)
+        end
+        full_fair_column_width - all_but_last_fair_column_width
+      end
+
+      def values_in_column(column_index)
+        #TODO raise error if index out of bounds
+        rows.map{|cells| cells[column_index]}
+      end
+
+      def max_column_width
+        (formatter.terminal_columns - 1 - formatter.current_indent_string.length)/column_count
+      end
+
+      def cell_value(value, column_index)
+        sprintf("%-#{column_width(column_index)}s", value.strip)
+      end
+    end
+  end
+end