escort 0.0.1 → 0.1.0

data/lib/escort/formatter/common.rb

@@ -0,0 +1,58 @@
+module Escort
+  module Formatter
+    module Common
+      def option_output_strings(parser)
+        options = {}
+        parser.specs.each do |name, spec|
+          options[name] = "--#{spec[:long]}" +
+          (spec[:type] == :flag && spec[:default] ? ", --no-#{spec[:long]}" : "") +
+          (spec[:short] && spec[:short] != :none ? ", -#{spec[:short]}" : "") +
+          case spec[:type]
+          when :flag; ""
+          when :int; " <i>"
+          when :ints; " <i+>"
+          when :string; " <s>"
+          when :strings; " <s+>"
+          when :float; " <f>"
+          when :floats; " <f+>"
+          when :io; " <filename/uri>"
+          when :ios; " <filename/uri+>"
+          when :date; " <date>"
+          when :dates; " <date+>"
+          end
+        end
+
+        parser.order.each do |what, opt|
+          if what == :text
+            next
+          end
+          spec = parser.specs[opt]
+          desc = spec[:desc] + begin
+            default_s = case spec[:default]
+            when $stdout; "<stdout>"
+            when $stdin; "<stdin>"
+            when $stderr; "<stderr>"
+            when Array
+              spec[:default].join(", ")
+            else
+              spec[:default].to_s
+            end
+
+            if spec[:default]
+              if spec[:desc] =~ /\.$/
+                " (Default: #{default_s})"
+              else
+                " (default: #{default_s})"
+              end
+            else
+              ""
+            end
+          end
+          options[opt] = {:string => options[opt]}
+          options[opt][:desc] = desc
+        end
+        options
+      end
+    end
+  end
+end

data/lib/escort/formatter/default_help_formatter.rb

@@ -0,0 +1,106 @@
+module Escort
+  module Formatter
+    class DefaultHelpFormatter
+      include Escort::Formatter::Common
+
+      attr_reader :setup, :context
+
+      def initialize(setup, context)
+        @setup = setup
+        @context = context
+      end
+
+      def print(parser)
+        option_strings = option_output_strings(parser)
+        command_strings = command_output_strings
+
+        TerminalFormatter.display($stdout, Terminal.width) do |d|
+          d.puts "NAME"
+          d.indent(4) do
+            d.table(:columns => 3, :newlines => 1) do |t|
+              t.row script_name_with_command, '-', current_command_summary
+            end
+            d.put(setup.description_for(context), :newlines => 2) if setup.description_for(context)
+          end
+          d.puts "USAGE"
+          d.indent(4) do
+            context_usage_part = context.map { |command_name| "#{command_name} [#{command_name} options]" }.join(" ")
+            context_usage_part ||= ""
+            nested_command_part = "command [command options]" if !setup.canonical_command_names_for(context).nil? && setup.canonical_command_names_for(context).length > 0
+            nested_command_part ||= ""
+            usage_string = "#{script_name} [options] #{context_usage_part} #{nested_command_part} [arguments...]".gsub(/\s+/, ' ')
+            d.put usage_string, :newlines => 2
+          end
+          if setup.version
+            d.puts "VERSION"
+            d.indent(4) {
+              d.put setup.version, :newlines => 2
+            }
+          end
+          if option_strings.keys.size > 0
+            d.puts "OPTIONS"
+            d.indent(4) {
+              d.table(:columns => 3, :newlines => 1) do |t|
+                option_strings.each_pair do |key, value|
+                  t.row value[:string], '-', value[:desc] || ''
+                end
+              end
+            }
+          end
+          if command_strings.keys.size > 0
+            d.puts "COMMANDS"
+            d.indent(4) {
+              d.table(:columns => 3, :newlines => 1) do |t|
+                command_strings.each_pair do |command_name, values_array|
+                  t.row values_array[0], '-', command_outline(values_array)
+                end
+              end
+            }
+          end
+        end
+      end
+
+
+      private
+
+      def script_name_with_command
+        result = []
+        result << script_name
+        result << current_command unless context.empty?
+        result.join(" ")
+      end
+
+      def script_name
+        File.basename($0)
+      end
+
+      def current_command
+        context.last || :global
+      end
+
+      def command_outline(command_data)
+        result = command_data[1] || ''
+        result = command_data[2] || '' if result.nil? || result.empty?
+        result
+      end
+
+      def current_command_summary
+        setup.summary_for(context) || ''
+      end
+
+      def command_output_strings
+        commands = {}
+        setup.canonical_command_names_for(context).each do |command_name|
+          command_description = setup.command_description_for(command_name, context) || ""
+          command_summary = setup.command_summary_for(command_name, context) || ""
+          command_aliases = setup.command_aliases_for(command_name, context)
+          command_alias_string = command_aliases.join(", ") if command_aliases && command_aliases.size > 0
+          command_string = (command_aliases && command_aliases.size > 0 ? "#{command_name}, #{command_alias_string}" : "#{command_name}" )
+          command_name = command_name.to_s
+          commands[command_name] = [command_string, command_summary, command_description]
+        end
+        commands
+      end
+    end
+  end
+end

data/lib/escort/formatter/options.rb

@@ -0,0 +1,13 @@
+module Escort
+  module Formatter
+    class Options
+      attr_reader :setup, :context, :parser
+
+      def initialize(setup, context, parser)
+        @setup = setup
+        @context = context
+        @parser = parser
+      end
+    end
+  end
+end

data/lib/escort/formatter/string_splitter.rb

@@ -0,0 +1,30 @@
+module Escort
+  module Formatter
+    class StringSplitter
+      attr_reader :max_segment_width
+
+      def initialize(max_segment_width)
+        @max_segment_width = max_segment_width
+      end
+
+      def split(string)
+        string.split("\n").map { |s| split_string(s) }.flatten
+      end
+
+      private
+
+      def split_string(string)
+        result = []
+        if string.length > max_segment_width
+          first_part = string.slice(0, max_segment_width)
+          second_part = string.slice(max_segment_width..-1)
+          result << first_part
+          result << split_string(second_part)
+        else
+          result << string
+        end
+        result
+      end
+    end
+  end
+end

data/lib/escort/formatter/terminal.rb

@@ -0,0 +1,22 @@
+require 'curses'
+
+module Escort
+  module Formatter
+    class Terminal
+      DEFAULT_WIDTH = 80
+
+      class << self
+        def width
+          screen_size = self::DEFAULT_WIDTH
+          Curses.init_screen
+          begin
+            screen_size = Curses.cols
+          ensure
+            Curses.close_screen
+          end
+          screen_size
+        end
+      end
+    end
+  end
+end

data/lib/escort/formatter/terminal_formatter.rb

@@ -0,0 +1,52 @@
+module Escort
+  module Formatter
+    class TerminalFormatter
+      class << self
+        def display(stream = $stdout, max_width = Terminal::DEFAULT_WIDTH, &block)
+          formatter = self.new(stream, max_width)
+          block.call(formatter)
+        end
+      end
+
+      attr_reader :stream, :indent_char, :indent_count, :terminal_columns
+
+      def initialize(stream = $stdout, max_width = Terminal::DEFAULT_WIDTH)
+        @stream = stream
+        @indent_char = " "
+        @indent_count = 0
+        @terminal_columns = (max_width < Terminal::DEFAULT_WIDTH/2 ? Terminal::DEFAULT_WIDTH/2 : max_width)
+      end
+
+      def put(data, options = {:newlines => 0})
+        segments = StringSplitter.new(terminal_columns - current_indent_string.size - 1).split(data.to_s)
+        segments.each do |segment|
+          stream.print "#{current_indent_string}#{segment}"
+        end
+        newline(options[:newlines])
+      end
+
+      def puts(data)
+        put(data, :newlines => 1)
+      end
+
+      def indent(count, &block)
+        @indent_count += count
+        block.call
+        @indent_count -= count
+      end
+
+      def table(options = {}, &block)
+        BorderlessTable.new(self, options).output(&block)
+        newline(options[:newlines] || 1)
+      end
+
+      def newline(newline_count = 1)
+        stream.print("\n" * newline_count)
+      end
+
+      def current_indent_string
+        indent_char * indent_count
+      end
+    end
+  end
+end

data/lib/escort/global_pre_parser.rb

@@ -0,0 +1,43 @@
+module Escort
+  class GlobalPreParser
+    attr_reader :setup
+
+    def initialize(setup)
+      @setup = setup
+    end
+
+    def parse(cli_options)
+      AutoOptions.new(parse_global_options(cli_options))
+    end
+
+    private
+
+    def parse_global_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.version(setup.version)                                   #set the version if it was provided
+      parser.help_formatter(Escort::Formatter::DefaultHelpFormatter.new(setup, context))
+      parsed_options = parse_options_string(parser, cli_options)
+    end
+
+    def init_parser(stop_words)
+      Trollop::Parser.new.tap do |parser|
+        parser.stop_on(stop_words)
+      end
+    end
+
+    def add_setup_options_to(parser, context = [])
+      setup.options_for(context).each do |name, opts|
+        parser.opt name, opts[:desc] || "", opts
+      end
+      parser
+    end
+
+    def parse_options_string(parser, cli_options)
+      Trollop::with_standard_exception_handling(parser) do
+        parser.parse(cli_options)
+      end
+    end
+  end
+end

data/lib/escort/logger.rb

@@ -0,0 +1,75 @@
+require 'logger'
+
+module Escort
+  class Logger
+    class << self
+      def close
+        error.close
+        output.close
+      end
+
+      def error
+        @error_logger ||= ::Logger.new($stderr).tap do |l|
+          #l.formatter = advanced_error_formatter
+          l.formatter = basic_error_formatter
+          l.sev_threshold = ::Logger::WARN
+        end
+      end
+
+      def output
+        @output_logger ||= ::Logger.new($stdout).tap do |l|
+          l.formatter = output_formatter
+          l.sev_threshold = ::Logger::DEBUG
+          l.instance_eval do
+            def puts(message = nil, &block)
+              if block_given?
+                fatal(&block)
+              else
+                fatal(message || "")
+              end
+            end
+          end
+        end
+      end
+
+      def setup_error_logger(auto_options)
+        error.formatter = send(:"#{auto_options.error_formatter}_error_formatter")
+        error.sev_threshold = ::Logger.const_get(auto_options.verbosity)
+      end
+
+      private
+
+      def basic_error_formatter
+        proc do |severity, datetime, progname, msg|
+          "\"#{msg2str(msg)}\"\n"
+        end
+      end
+
+      #"#{severity} [#{datetime.strftime("%d/%b/%Y %H:%M:%S")}] \"#{msg}\"\n"
+      def advanced_error_formatter
+        proc do |severity, datetime, progname, msg|
+          sprintf("%-8s \"#{msg2str(msg, 10)}\"\n", severity)
+        end
+      end
+
+      def output_formatter
+        proc do |severity, datetime, progname, msg|
+          "\"#{msg}\"\n"
+        end
+      end
+
+      def msg2str(msg, backtrace_indent = 0)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{msg.message} (#{ msg.class })\n" <<
+          (msg.backtrace || []).map{|line| sprintf("%#{backtrace_indent}s#{line}", " ")}.join("\n")
+        else
+          msg.inspect
+        end
+      end
+    end
+  end
+end
+

data/lib/escort/option_parser.rb

@@ -0,0 +1,145 @@
+module Escort
+  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(Escort::Formatter::DefaultHelpFormatter.new(setup, context))
+      parsed_options = parse_options_string(parser, cli_options)
+      Escort::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 = [])
+      setup.conflicting_options_for(context).each do |conflict_list|
+        parser.conflicts *conflict_list
+      end
+      parser
+    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