escort 0.1.0 → 0.2.0

data/lib/escort/formatter/command.rb

@@ -0,0 +1,87 @@
+module Escort
+  module Formatter
+    class Command
+      attr_reader :setup, :context, :name
+
+      def initialize(command_name, setup, context)
+        @setup = setup
+        @context = context
+        @name = command_name.to_sym
+      end
+
+      def name_with_aliases
+        [name, aliases].flatten.join(", ")
+      end
+
+      def outline
+        summary.empty? ? description : summary
+      end
+
+      def description
+        @description ||= setup.command_description_for(name, context) || ""
+      end
+
+      def summary
+        @summary ||= setup.command_summary_for(name, context) || ""
+      end
+
+      def aliases
+        @aliases ||= setup.command_aliases_for(name, context)
+      end
+
+      def has_aliases?
+        aliases && aliases.size > 0 ? true : false
+      end
+
+      def script_name
+        [canonical_script_name, context].flatten.join(" ")
+      end
+
+      def child_commands
+        @child_commands ||= setup.canonical_command_names_for(context) || []
+      end
+
+      def has_child_commands?
+        child_commands.length > 0
+      end
+
+      def requires_arguments?
+        @requires_arguments ||= setup.arguments_required_for(context)
+      end
+
+      def usage
+        [script_name_usage_string, parent_commands_usage_string, child_command_usage_string, arguments_usage_string].flatten.reject(&:empty?).join(" ")
+      end
+
+      private
+
+      def script_name_usage_string
+        "#{canonical_script_name} [options]"
+      end
+
+      def parent_commands_usage_string
+        context.map{|command_name| command_with_options(command_name)}.join(" ")
+      end
+
+      def child_command_usage_string
+        has_child_commands? ? "command [command_options]" : ""
+      end
+
+      def arguments_usage_string
+        requires_arguments? ? "arguments" : "[arguments]"
+      end
+
+      def command_with_options(command_name)
+        "#{command_name} [#{command_name}_options]"
+      end
+
+      def canonical_script_name
+        File.basename($0)
+      end
+
+      def alias_string
+        @alias_string ||= aliases.join(", ") if has_aliases?
+      end
+    end
+  end
+end

data/lib/escort/formatter/commands.rb

@@ -0,0 +1,36 @@
+module Escort
+  module Formatter
+    class Commands
+      include Enumerable
+
+      class << self
+        def command_for(setup, context)
+          if context.empty?
+            GlobalCommand.new(setup)
+          else
+            Command.new(context.last, setup, context)
+          end
+        end
+      end
+
+      attr_reader :setup, :context
+
+      def initialize(setup, context)
+        @setup = setup
+        @context = context
+      end
+
+      def each(&block)
+        setup.canonical_command_names_for(context).each do |command_name|
+          command = Command.new(command_name, setup, context)
+          block.call(command)
+        end
+      end
+
+      def count
+        setup.canonical_command_names_for(context).size
+      end
+      alias_method :size, :count
+    end
+  end
+end

data/lib/escort/formatter/default_help_formatter.rb

@@ -1,8 +1,6 @@
 module Escort
   module Formatter
     class DefaultHelpFormatter
-      include Escort::Formatter::Common
-
       attr_reader :setup, :context
 
       def initialize(setup, context)
@@ -11,95 +9,92 @@ module Escort
       end
 
       def print(parser)
-        option_strings = option_output_strings(parser)
-        command_strings = command_output_strings
+        options = Options.new(parser, setup, context)
+        commands = Commands.new(setup, context)
+        current_command = Commands.command_for(setup, context)
 
         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
+          name_help(current_command, d)
+          usage_help(current_command, d)
+          version_help(current_command, d)
+          options_help(options, d)
+          commands_help(commands, d)
         end
       end
 
-
       private
 
-      def script_name_with_command
-        result = []
-        result << script_name
-        result << current_command unless context.empty?
-        result.join(" ")
+      def name_help(current_command, d)
+        d.puts "NAME"
+        d.indent(4) do
+          d.table(:columns => 3, :newlines => 1) do |t|
+            t.row current_command.script_name, '-', current_command.summary
+          end
+          d.put(setup.description_for(context), :newlines => 2) if setup.description_for(context)
+        end
       end
 
-      def script_name
-        File.basename($0)
+      def usage_help(current_command, d)
+        d.puts "USAGE"
+        d.indent(4) do
+          d.put current_command.usage, :newlines => 2
+        end
       end
 
-      def current_command
-        context.last || :global
+      def version_help(current_command, d)
+        if setup.version
+          d.puts "VERSION"
+          d.indent(4) {
+            d.put setup.version, :newlines => 2
+          }
+        end
       end
 
-      def command_outline(command_data)
-        result = command_data[1] || ''
-        result = command_data[2] || '' if result.nil? || result.empty?
-        result
+      def options_help(options, d)
+        if options.count > 0
+          d.puts "OPTIONS"
+          d.indent(4) {
+            d.table(:columns => 3, :newlines => 1) do |t|
+              options.each do |option|
+                t.row option.usage, '-', option.description
+                option_conflicts_help(option, t)
+                option_dependencies_help(option, t)
+                option_validations_help(option, t)
+              end
+            end
+          }
+        end
+      end
+
+      def option_conflicts_help(option, t)
+        if option.has_conflicts?
+          t.row '', '', "- #{option.conflicts}"
+        end
       end
 
-      def current_command_summary
-        setup.summary_for(context) || ''
+      def option_dependencies_help(option, t)
+        if option.has_dependencies?
+          t.row '', '', "- #{option.dependencies}"
+        end
+      end
+
+      def option_validations_help(option, t)
+        if option.has_validations?
+          t.row '', '', "- #{option.validations}"
+        end
       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]
+      def commands_help(commands, d)
+        if commands.count > 0
+          d.puts "COMMANDS"
+          d.indent(4) {
+            d.table(:columns => 3, :newlines => 1) do |t|
+              commands.each do |command|
+                t.row command.name_with_aliases, '-', command.outline
+              end
+            end
+          }
         end
-        commands
       end
     end
   end

data/lib/escort/formatter/global_command.rb

@@ -0,0 +1,17 @@
+module Escort
+  module Formatter
+    class GlobalCommand < Command
+      def initialize(setup)
+        super(:global, setup, [])
+      end
+
+      def summary
+        @summary ||= setup.summary_for(context) || ""
+      end
+
+      def description
+        @description ||= setup.description_for(context) || ""
+      end
+    end
+  end
+end

data/lib/escort/formatter/option.rb

@@ -0,0 +1,138 @@
+module Escort
+  module Formatter
+    class Option
+      attr_reader :name, :details, :setup, :context
+
+      def initialize(name, details, setup, context)
+        @name = name.to_sym
+        @details = details
+        @setup = setup
+        @context = context
+      end
+
+      def usage
+        [long_string, short_string, type_string].select{|item| !item.empty?}.join(" ")
+      end
+
+      def description
+        [base_description_string, description_default_string].select{|item| !item.empty?}.join(" ")
+      end
+
+      def has_conflicts?
+        !conflicts_list.empty?
+      end
+
+      def conflicts
+        has_conflicts? ? "conflicts with: #{conflicts_list.map{|option| "--#{option}"}.join(', ')}" : ''
+      end
+
+      def has_dependencies?
+        !dependencies_list.empty?
+      end
+
+      def dependencies
+        has_dependencies? ? "depends on: #{format_dependency_list(dependencies_list).join(', ')}" : ''
+      end
+
+      def has_validations?
+        !validations_list.empty?
+      end
+
+      def validations
+        has_validations? ? "#{validation_messages.join("\n- ")}" : ''
+      end
+
+      private
+      def validation_messages
+        validations_list.map{|validation| validation[:desc]}
+      end
+
+      def validations_list
+        setup.validations_for(context)[name] || []
+      end
+
+      def format_dependency_list(dependency_list)
+        dependencies_list.map do |option|
+          case option
+          when Hash
+            option.inject([]){|acc, (key, value)| acc << "--#{key}=#{value}"}.join(', ')
+          else
+            "--#{option}"
+          end
+        end
+      end
+
+      def dependencies_list
+        setup.dependencies_for(context)[name] || []
+      end
+
+      def conflicts_list
+        setup.conflicting_options_for(context)[name] || []
+      end
+
+      def base_description_string
+        details[:desc] || details[:description] || ''
+      end
+
+      def description_default_string
+        if details[:default]
+          base_description_string =~ /\.$/ ? "(Default: #{default_string})" : "(default: #{default_string})"
+        else
+          ""
+        end
+      end
+
+      def default_string
+        case details[:default]
+        when $stdout; "<stdout>"
+        when $stdin; "<stdin>"
+        when $stderr; "<stderr>"
+        when Array
+          details[:default].join(", ")
+        else
+          details[:default].to_s
+        end
+      end
+
+      def short_string
+        details[:short] && details[:short] != :none ? "-#{details[:short]}" : ""
+      end
+
+      def long_string
+        if flag_with_default_true?
+          "#{base_long_string}, --no-#{details[:long]}"
+        else
+          base_long_string
+        end
+      end
+
+      def base_long_string
+        "--#{details[:long]}"
+      end
+
+      def type_string
+        case details[: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
+
+      def flag_with_default_true?
+        flag? && details[:default]
+      end
+
+      def flag?
+        details[:type] == :flag
+      end
+    end
+  end
+end

data/lib/escort/formatter/options.rb

@@ -1,13 +1,27 @@
 module Escort
   module Formatter
     class Options
-      attr_reader :setup, :context, :parser
+      include Enumerable
 
-      def initialize(setup, context, parser)
+      attr_reader :parser, :setup, :context
+
+      def initialize(parser, setup, context)
+        @parser = parser
         @setup = setup
         @context = context
-        @parser = parser
       end
+
+      def each(&block)
+        parser.specs.each do |option_name, details|
+          option = Option.new(option_name, details, setup, context)
+          block.call(option)
+        end
+      end
+
+      def count
+        parser.specs.keys.size
+      end
+      alias_method :size, :count
     end
   end
 end

data/lib/escort/formatter/shell_command_executor.rb

@@ -0,0 +1,49 @@
+require 'open3'
+
+module Escort
+  module Formatter
+    class ShellCommandExecutor
+      attr_reader :command
+
+      def initialize(command)
+        @command = command
+      end
+
+      def execute_in_current_shell(success_callback = nil, error_callback = nil)
+        begin
+          result = `#{command}`
+          process_status = $?
+          raise Escort::InternalError.new("Shell command exited with a non-zero (#{process_status.exitstatus}) exit code") if process_status.exitstatus != 0
+          success_callback.call(command, result) if success_callback
+        rescue => e
+          error_callback.call(command, e) if error_callback
+          nil
+        end
+      end
+
+      #def execute_in_new_shell(success_callback = nil, error_callback = nil)
+        #stdin, stdout, stderr = nil, nil, nil
+        #begin
+          #stdin, stdout, stderr, thread = ensure_successful_exit do
+            #Open3.popen3(command)
+          #end
+          #success_callback.call(command, stdin, stdout, stderr) if success_callback
+        #rescue => e
+          #error_callback.call(command, e) if error_callback
+          #nil
+        #ensure
+          #[stdin, stdout, stderr].each {|io| io.close if io}
+        #end
+      #end
+
+      #private
+
+      #def ensure_successful_exit(&block)
+        #stdin, stdout, stderr, thread = block.call
+        #process_status = thread.value
+        #raise Escort::InternalError.new("Shell command exited with a non-zero (#{process_status.exitstatus}) exit code") if process_status.exitstatus != 0
+        #[stdin, stdout, stderr, thread]
+      #end
+    end
+  end
+end

data/lib/escort/formatter/terminal.rb

@@ -1,5 +1,3 @@
-require 'curses'
-
 module Escort
   module Formatter
     class Terminal
@@ -7,14 +5,24 @@ module Escort
 
       class << self
         def width
-          screen_size = self::DEFAULT_WIDTH
-          Curses.init_screen
-          begin
-            screen_size = Curses.cols
-          ensure
-            Curses.close_screen
+          tput_width
+        end
+
+        private
+
+        def tput_width
+          ShellCommandExecutor.new('/usr/bin/env tput cols').execute_in_current_shell(tput_cols_command_success_callback, tput_cols_command_error_callback) || DEFAULT_WIDTH
+        end
+
+        def tput_cols_command_success_callback
+          lambda {|command, result| result.to_i}
+        end
+
+        def tput_cols_command_error_callback
+          lambda do |command, e|
+            error_logger.debug {e}
+            error_logger.info {"Unable to find terminal width via '#{command}', using default of #{DEFAULT_WIDTH}"}
           end
-          screen_size
         end
       end
     end

data/lib/escort/formatter/terminal_formatter.rb

@@ -1,3 +1,9 @@
+#TODO rename to StreamOutputFormatter
+#get rid of the display method, it doesn't really add anything
+#the max_width should be max_line_width not terminal_columns, there should be no default max_width
+#indent_count should be indent_width
+#probably don't really need indent_char, we can assume it is a space
+#this will only work well with ASCII chars only!!!
 module Escort
   module Formatter
     class TerminalFormatter

data/lib/escort/logger.rb

@@ -41,20 +41,20 @@ module Escort
 
       def basic_error_formatter
         proc do |severity, datetime, progname, msg|
-          "\"#{msg2str(msg)}\"\n"
+          "#{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)
+          sprintf("%-8s #{msg2str(msg, 10)}\n", severity)
         end
       end
 
       def output_formatter
         proc do |severity, datetime, progname, msg|
-          "\"#{msg}\"\n"
+          "#{msg}\n"
         end
       end
 
@@ -64,7 +64,7 @@ module Escort
           msg
         when ::Exception
           "#{msg.message} (#{ msg.class })\n" <<
-          (msg.backtrace || []).map{|line| sprintf("%#{backtrace_indent}s#{line}", " ")}.join("\n")
+          (msg.backtrace || []).map{|line| sprintf("%#{backtrace_indent}s#{line}", "")}.join("\n")
         else
           msg.inspect
         end