simple_commander 0.0.1

data/lib/simple_commander/configure.rb

@@ -0,0 +1,14 @@
+module Commander
+  def configure(*configuration_opts, &configuration_block)
+    configuration_module = Module.new
+    configuration_module.extend Commander::Methods
+
+    configuration_module.class_exec(*configuration_opts, &configuration_block)
+
+    configuration_module.class_exec do
+      run!
+    end
+  end
+
+  module_function :configure
+end

data/lib/simple_commander/core_ext.rb

@@ -0,0 +1,2 @@
+require 'commander/core_ext/array'
+require 'commander/core_ext/object'

data/lib/simple_commander/core_ext/array.rb

@@ -0,0 +1,24 @@
+class Array
+  ##
+  # Split _string_ into an array. Used in
+  # conjunction with Highline's #ask, or #ask_for_array
+  # methods, which must respond to #parse.
+  #
+  # This method allows escaping of whitespace. For example
+  # the arguments foo bar\ baz will become ['foo', 'bar baz']
+  #
+  # === Example
+  #
+  #   # ask invokes Array#parse
+  #   list = ask 'Favorite cookies:', Array
+  #
+  #   # or use ask_for_CLASS
+  #   list = ask_for_array 'Favorite cookies: '
+  #
+
+  def self.parse(string)
+    # Using reverse + lookahead to work around Ruby 1.8's lack of lookbehind
+    # TODO: simplify now that we don't support Ruby 1.8
+    string.reverse.split(/\s(?!\\)/).reverse.map { |s| s.reverse.gsub('\\ ', ' ') }
+  end
+end

data/lib/simple_commander/core_ext/object.rb

@@ -0,0 +1,8 @@
+class Object
+  ##
+  # Return the current binding.
+
+  def get_binding
+    binding
+  end
+end

data/lib/simple_commander/delegates.rb

@@ -0,0 +1,25 @@
+module Commander
+  module Delegates
+    %w(
+      add_command
+      command
+      program
+      run!
+      global_option
+      alias_command
+      default_command
+      always_trace!
+      never_trace!
+    ).each do |meth|
+      eval <<-END, binding, __FILE__, __LINE__
+        def #{meth}(*args, &block)
+          ::Commander::Runner.instance.#{meth}(*args, &block)
+        end
+      END
+    end
+
+    def defined_commands(*args, &block)
+      ::Commander::Runner.instance.commands(*args, &block)
+    end
+  end
+end

data/lib/simple_commander/help_formatters.rb

@@ -0,0 +1,49 @@
+module Commander
+  module HelpFormatter
+    autoload :Base, 'commander/help_formatters/base'
+    autoload :Terminal, 'commander/help_formatters/terminal'
+    autoload :TerminalCompact, 'commander/help_formatters/terminal_compact'
+
+    class Context
+      def initialize(target)
+        @target = target
+      end
+
+      def get_binding
+        @target.instance_eval { binding }.tap do |bind|
+          decorate_binding(bind)
+        end
+      end
+
+      # No-op, override in subclasses.
+      def decorate_binding(_bind)
+      end
+    end
+
+    class ProgramContext < Context
+      def decorate_binding(bind)
+        bind.eval("max_command_length = #{max_command_length(bind)}")
+        bind.eval("max_aliases_length = #{max_aliases_length(bind)}")
+      end
+
+      def max_command_length(bind)
+        max_key_length(bind.eval('@commands'))
+      end
+
+      def max_aliases_length(bind)
+        max_key_length(bind.eval('@aliases'))
+      end
+
+      def max_key_length(hash, default = 20)
+        longest = hash.keys.max_by(&:size)
+        longest ? longest.size : default
+      end
+    end
+
+    module_function
+
+    def indent(amount, text)
+      text.to_s.gsub("\n", "\n" + (' ' * amount))
+    end
+  end
+end

data/lib/simple_commander/help_formatters/base.rb

@@ -0,0 +1,24 @@
+module Commander
+  ##
+  # = Help Formatter
+  #
+  # Commander's help formatters control the output when
+  # either the help command, or --help switch are called.
+  # The default formatter is Commander::HelpFormatter::Terminal.
+
+  module HelpFormatter
+    class Base
+      def initialize(runner)
+        @runner = runner
+      end
+
+      def render
+        'Implement global help here'
+      end
+
+      def render_command(command)
+        "Implement help for #{command.name} here"
+      end
+    end
+  end
+end

data/lib/simple_commander/help_formatters/terminal.rb

@@ -0,0 +1,19 @@
+require 'erb'
+
+module Commander
+  module HelpFormatter
+    class Terminal < Base
+      def render
+        template(:help).result(ProgramContext.new(@runner).get_binding)
+      end
+
+      def render_command(command)
+        template(:command_help).result(Context.new(command).get_binding)
+      end
+
+      def template(name)
+        ERB.new(File.read(File.join(File.dirname(__FILE__), 'terminal', "#{name}.erb")), nil, '-')
+      end
+    end
+  end
+end

data/lib/simple_commander/help_formatters/terminal/command_help.erb

@@ -0,0 +1,35 @@
+
+  <%= $terminal.color "NAME", :bold %>:
+
+    <%= @name %>
+<% if @syntax -%>
+
+  <%= $terminal.color "SYNOPSIS", :bold %>:
+
+    <%= @syntax -%>
+
+<% end -%>
+
+  <%= $terminal.color "DESCRIPTION", :bold %>:
+
+    <%= Commander::HelpFormatter.indent 4, (@description || @summary || 'No description.') -%>
+
+<% unless @examples.empty? -%>
+
+  <%= $terminal.color "EXAMPLES", :bold %>:
+	<% for description, command in @examples -%>
+
+    # <%= description %>
+    <%= command %>
+	<% end -%>
+<% end -%>
+<% unless @options.empty? -%>
+
+  <%= $terminal.color "OPTIONS", :bold %>:
+	<% for option in @options -%>
+
+    <%= option[:switches].join ', ' %> 
+        <%= Commander::HelpFormatter.indent 8, option[:description] %>
+	<% end -%>
+<% end -%>
+

data/lib/simple_commander/help_formatters/terminal/help.erb

@@ -0,0 +1,36 @@
+  <%= $terminal.color "NAME", :bold %>:
+
+    <%= program :name %>
+
+  <%= $terminal.color "DESCRIPTION", :bold %>:
+
+    <%= Commander::HelpFormatter.indent 4, program(:description) %>
+
+  <%= $terminal.color "COMMANDS", :bold %>:
+<% for name, command in @commands.sort -%>
+	<% unless alias? name %>
+    <%= "%-#{max_command_length}s %s" % [command.name, command.summary || command.description] -%>
+	<% end -%>
+<% end %>
+<% unless @aliases.empty? %>
+  <%= $terminal.color "ALIASES", :bold %>:
+  <% for alias_name, args in @aliases.sort %>
+    <%= "%-#{max_aliases_length}s %s %s" % [alias_name, command(alias_name).name, args.join(' ')] -%>
+  <% end %>
+<% end %>
+<% unless @options.empty? -%>
+  <%= $terminal.color "GLOBAL OPTIONS", :bold %>:
+	<% for option in @options -%>
+
+    <%= option[:switches].join ', ' %> 
+        <%= option[:description] %>
+	<% end -%>
+<% end -%>
+<% if program :help -%>
+  <% for title, body in program(:help) %>
+  <%= $terminal.color title.to_s.upcase, :bold %>:
+
+    <%= body %>
+  <% end -%>
+<% end -%>
+

data/lib/simple_commander/help_formatters/terminal_compact.rb

@@ -0,0 +1,11 @@
+require 'erb'
+
+module Commander
+  module HelpFormatter
+    class TerminalCompact < Terminal
+      def template(name)
+        ERB.new(File.read(File.join(File.dirname(__FILE__), 'terminal_compact', "#{name}.erb")), nil, '-')
+      end
+    end
+  end
+end

data/lib/simple_commander/help_formatters/terminal_compact/command_help.erb

@@ -0,0 +1,27 @@
+
+  <%= @name %>
+<% if @syntax -%>
+
+  Usage: <%= @syntax %>
+<% end -%>
+<% if @description || @summary -%>
+
+  <%= @description || @summary %>
+<% end -%>
+<% unless @examples.empty? -%>
+
+  Examples:
+	<% for description, command in @examples -%>
+
+    # <%= description %>
+    <%= command %>
+	<% end -%>
+<% end -%>
+<% unless @options.empty? -%>
+
+  Options:
+<% for option in @options -%>
+    <%= "%-20s %s" % [option[:switches].join(', '), option[:description]] %> 
+<% end -%>
+<% end -%>
+

data/lib/simple_commander/help_formatters/terminal_compact/help.erb

@@ -0,0 +1,29 @@
+  <%= program :name %>
+
+  <%= program :description %>
+
+  Commands:
+<% for name, command in @commands.sort -%>
+<% unless alias? name -%>
+    <%= "%-#{max_command_length}s %s" % [command.name, command.summary || command.description] %>
+<% end -%>
+<% end -%>
+<% unless @aliases.empty? %>
+  Aliases:
+<% for alias_name, args in @aliases.sort -%>
+    <%= "%-#{max_aliases_length}s %s %s" % [alias_name, command(alias_name).name, args.join(' ')] %>
+<% end -%>
+<% end %>
+<% unless @options.empty? -%>
+  Global Options:
+<% for option in @options -%>
+    <%= "%-20s %s" % [option[:switches].join(', '), option[:description]] -%> 
+<% end -%>
+<% end -%>
+<% if program :help -%>
+  <% for title, body in program(:help) %>
+  <%= title %>:
+    <%= body %>
+  <% end %>
+<% end -%>
+

data/lib/simple_commander/import.rb

@@ -0,0 +1,5 @@
+require 'simple_commander'
+
+include Commander::Methods
+
+at_exit { run! }

data/lib/simple_commander/methods.rb

@@ -0,0 +1,11 @@
+module Commander
+  module Methods
+    include Commander::UI
+    include Commander::UI::AskForClass
+    include Commander::Delegates
+
+    if $stdin.tty? && (cols = $terminal.output_cols) >= 40
+      $terminal.wrap_at = cols - 5
+    end
+  end
+end

data/lib/simple_commander/platform.rb

@@ -0,0 +1,7 @@
+module Commander
+  module Platform
+    def self.jruby?
+      defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'jruby')
+    end
+  end
+end

data/lib/simple_commander/runner.rb

@@ -0,0 +1,477 @@
+require 'optparse'
+
+module Commander
+  class Runner
+    #--
+    # Exceptions
+    #++
+
+    class CommandError < StandardError; end
+    class InvalidCommandError < CommandError; end
+
+    ##
+    # Array of commands.
+
+    attr_reader :commands
+
+    ##
+    # Global options.
+
+    attr_reader :options
+
+    ##
+    # Hash of help formatter aliases.
+
+    attr_reader :help_formatter_aliases
+
+    ##
+    # Initialize a new command runner. Optionally
+    # supplying _args_ for mocking, or arbitrary usage.
+
+    def initialize(args = ARGV)
+      @args, @commands, @aliases, @options = args, {}, {}, []
+      @help_formatter_aliases = help_formatter_alias_defaults
+      @program = program_defaults
+      @always_trace = false
+      @never_trace = false
+      create_default_commands
+    end
+
+    ##
+    # Return singleton Runner instance.
+
+    def self.instance
+      @singleton ||= new
+    end
+
+    ##
+    # Run command parsing and execution process.
+
+    def run!
+			trace = @always_trace || false
+      require_program :version, :description
+      trap('INT') { abort program(:int_message) } if program(:int_message)
+      trap('INT') { program(:int_block).call } if program(:int_block)
+      global_option('-h', '--help', 'Display help documentation') do
+        args = @args - %w(-h --help)
+        command(:help).run(*args)
+        return
+      end
+      global_option('-v', '--version', 'Display version information') do
+        say version
+        return
+      end
+      global_option('-t', '--trace', 'Display backtrace when an error occurs') { trace = true } unless @never_trace || @always_trace
+      parse_global_options
+      remove_global_options options, @args
+			have_action?
+      if trace
+        run_active_command
+      else
+        begin
+          run_active_command
+        rescue InvalidCommandError => e
+          abort "#{e}. Use --help for more information"
+        rescue \
+          OptionParser::InvalidOption,
+          OptionParser::InvalidArgument,
+          OptionParser::MissingArgument => e
+          abort e.to_s
+        rescue => e
+          if @never_trace
+            abort "error: #{e}."
+          else
+            abort "error: #{e}. Use --trace to view backtrace"
+          end
+        end
+      end
+    end
+
+		##
+		# tests if the current active command have an action block
+
+		def have_action?
+			goto_child_command if active_command.has_no_action?
+		end
+
+		##
+		# make the child command the active_command 
+		# and remove the current command from the @args
+		
+		def goto_child_command 
+			@args.shift
+			@__active_command = nil
+			@__command_name_from_args = nil
+			have_action?
+		end
+
+    ##
+    # Return program version.
+
+    def version
+      format('%s %s', program(:name), program(:version))
+    end
+
+    ##
+    # Enable tracing on all executions (bypasses --trace)
+
+    def always_trace!
+      @always_trace = true
+      @never_trace = false
+    end
+
+    ##
+    # Hide the trace option from the help menus and don't add it as a global option
+
+    def never_trace!
+      @never_trace = true
+      @always_trace = false
+    end
+
+    ##
+    # Assign program information.
+    #
+    # === Examples
+    #
+    #   # Set data
+    #   program :name, 'Commander'
+    #   program :version, Commander::VERSION
+    #   program :description, 'Commander utility program.'
+    #   program :help, 'Copyright', '2008 TJ Holowaychuk'
+    #   program :help, 'Anything', 'You want'
+    #   program :int_message 'Bye bye!'
+    #   program :help_formatter, :compact
+    #   program :help_formatter, Commander::HelpFormatter::TerminalCompact
+    #
+    #   # Get data
+    #   program :name # => 'Commander'
+    #
+    # === Keys
+    #
+    #   :version         (required) Program version triple, ex: '0.0.1'
+    #   :description     (required) Program description
+    #   :name            Program name, defaults to basename of executable
+    #   :help_formatter  Defaults to Commander::HelpFormatter::Terminal
+    #   :help            Allows addition of arbitrary global help blocks
+    #   :int_message     Message to display when interrupted (CTRL + C)
+    #
+
+    def program(key, *args, &block)
+      if key == :help && !args.empty?
+        @program[:help] ||= {}
+        @program[:help][args.first] = args.at(1)
+      elsif key == :help_formatter && !args.empty?
+        @program[key] = (@help_formatter_aliases[args.first] || args.first)
+      elsif block
+        @program[key] = block
+      else
+        unless args.empty?
+          @program[key] = (args.count == 1 && args[0]) || args
+        end
+        @program[key]
+      end
+    end
+
+    ##
+    # Creates and yields a command instance when a block is passed.
+    # Otherwise attempts to return the command, raising InvalidCommandError when
+    # it does not exist.
+    #
+    # === Examples
+    #
+    #   command :my_command do |c|
+    #     c.when_called do |args|
+    #       # Code
+    #     end
+    #   end
+    #
+
+    def command(name, &block)
+			Commander::Command.new(name).tap do |cmd|
+				add_command(cmd) if block
+				cmd.super_self = self
+				cmd.instance_eval &block if block
+			end
+			#add_command(Commander::Command.new(name)) if block
+      #yield add_command(Commander::Command.new(name)) if block
+      @commands[name.to_s]
+    end
+
+    ##
+    # Add a global option; follows the same syntax as Command#option
+    # This would be used for switches such as --version, --trace, etc.
+
+    def global_option(*args, &block)
+      switches, description = Runner.separate_switches_from_description(*args)
+      @options << {
+        args: args,
+        proc: block,
+        switches: switches,
+        description: description,
+      }
+    end
+
+    ##
+    # Alias command _name_ with _alias_name_. Optionally _args_ may be passed
+    # as if they were being passed straight to the original command via the command-line.
+
+    def alias_command(alias_name, name, *args)
+      @commands[alias_name.to_s] = command name
+      @aliases[alias_name.to_s] = args
+    end
+
+    ##
+    # Default command _name_ to be used when no other
+    # command is found in the arguments.
+
+    def default_command(name)
+      @default_command = name
+    end
+
+    ##
+    # Add a command object to this runner.
+
+    def add_command(command)
+      @commands[command.name] = command
+    end
+
+    ##
+    # Check if command _name_ is an alias.
+
+    def alias?(name)
+      @aliases.include? name.to_s
+    end
+
+    ##
+    # Check if a command _name_ exists.
+
+    def command_exists?(name)
+      @commands[name.to_s]
+    end
+
+    #:stopdoc:
+
+    ##
+    # Get active command within arguments passed to this runner.
+		
+    def active_command
+      @__active_command ||= command(command_name_from_args)
+    end
+
+    ##
+    # Attempts to locate a command name from within the arguments.
+    # Supports multi-word commands, using the largest possible match.
+
+    def command_name_from_args
+      @__command_name_from_args ||= (valid_command_names_from(*@args.dup).sort.last || @default_command)
+    end
+
+    ##
+    # Returns array of valid command names found within _args_.
+
+    def valid_command_names_from(*args)
+      arg_string = args.delete_if { |value| value =~ /^-/ }.join ' '
+      commands.keys.find_all { |name| name if /^#{name}\b/.match arg_string }
+    end
+
+    ##
+    # Help formatter instance.
+
+    def help_formatter
+      @__help_formatter ||= program(:help_formatter).new self
+    end
+
+    ##
+    # Return arguments without the command name.
+
+    def args_without_command_name
+      removed = []
+      parts = command_name_from_args.split rescue []
+      @args.dup.delete_if do |arg|
+        removed << arg if parts.include?(arg) && !removed.include?(arg)
+      end
+    end
+
+    ##
+    # Returns hash of help formatter alias defaults.
+
+    def help_formatter_alias_defaults
+      {
+        compact: HelpFormatter::TerminalCompact,
+      }
+    end
+
+    ##
+    # Returns hash of program defaults.
+
+    def program_defaults
+      {
+        help_formatter: HelpFormatter::Terminal,
+        name: File.basename($PROGRAM_NAME),
+      }
+    end
+
+    ##
+    # Creates default commands such as 'help' which is
+    # essentially the same as using the --help switch.
+
+    def create_default_commands
+			command :help do
+        syntax = 'commander help [command]'
+        description = 'Display global or [command] help documentation'
+        example 'Display global help', 'command help'
+        example "Display help for 'foo'", 'command help foo'
+        when_called do |args, _options|
+          UI.enable_paging
+          if args.empty?
+            say help_formatter.render
+          else
+            command = command args.join(' ')
+            begin
+              require_valid_command command
+            rescue InvalidCommandError => e
+              abort "#{e}. Use --help for more information"
+            end
+            say help_formatter.render_command(command)
+          end
+        end
+      end
+    end
+
+    ##
+    # Raises InvalidCommandError when a _command_ is not found.
+
+    def require_valid_command(command = active_command)
+      fail InvalidCommandError, 'invalid command', caller if command.nil?
+    end
+
+    ##
+    # Removes global _options_ from _args_. This prevents an invalid
+    # option error from occurring when options are parsed
+    # again for the command.
+
+    def remove_global_options(options, args)
+      # TODO: refactor with flipflop, please TJ ! have time to refactor me !
+      options.each do |option|
+        switches = option[:switches].dup
+        next if switches.empty?
+
+        if (switch_has_arg = switches.any? { |s| s =~ /[ =]/ })
+          switches.map! { |s| s[0, s.index('=') || s.index(' ') || s.length] }
+        end
+
+        switches = expand_optionally_negative_switches(switches)
+
+        past_switch, arg_removed = false, false
+        args.delete_if do |arg|
+          if switches.any? { |s| s[0, arg.length] == arg }
+            arg_removed = !switch_has_arg
+            past_switch = true
+          elsif past_switch && !arg_removed && arg !~ /^-/
+            arg_removed = true
+          else
+            arg_removed = true
+            false
+          end
+        end
+      end
+    end
+
+    # expand switches of the style '--[no-]blah' into both their
+    # '--blah' and '--no-blah' variants, so that they can be
+    # properly detected and removed
+    def expand_optionally_negative_switches(switches)
+      switches.reduce([]) do |memo, val|
+        if val =~ /\[no-\]/
+          memo << val.gsub(/\[no-\]/, '')
+          memo << val.gsub(/\[no-\]/, 'no-')
+        else
+          memo << val
+        end
+      end
+    end
+
+    ##
+    # Parse global command options.
+
+    def parse_global_options
+      parser = options.inject(OptionParser.new) do |options, option|
+        options.on(*option[:args], &global_option_proc(option[:switches], &option[:proc]))
+      end
+
+      options = @args.dup
+      begin
+        parser.parse!(options)
+      rescue OptionParser::InvalidOption => e
+        # Remove the offending args and retry.
+        options = options.reject { |o| e.args.include?(o) }
+        retry
+      end
+    end
+
+    ##
+    # Returns a proc allowing for commands to inherit global options.
+    # This functionality works whether a block is present for the global
+    # option or not, so simple switches such as --verbose can be used
+    # without a block, and used throughout all commands.
+
+    def global_option_proc(switches, &block)
+      lambda do |value|
+        unless active_command.nil?
+          active_command.proxy_options << [Runner.switch_to_sym(switches.last), value]
+        end
+        yield value if block && !value.nil?
+      end
+    end
+
+    ##
+    # Raises a CommandError when the program any of the _keys_ are not present, or empty.
+
+    def require_program(*keys)
+      keys.each do |key|
+        fail CommandError, "program #{key} required" if program(key).nil? || program(key).empty?
+      end
+    end
+
+    ##
+    # Return switches and description separated from the _args_ passed.
+
+    def self.separate_switches_from_description(*args)
+      switches = args.find_all { |arg| arg.to_s =~ /^-/ }
+      description = args.last if args.last.is_a?(String) && !args.last.match(/^-/)
+      [switches, description]
+    end
+
+    ##
+    # Attempts to generate a method name symbol from +switch+.
+    # For example:
+    #
+    #   -h                 # => :h
+    #   --trace            # => :trace
+    #   --some-switch      # => :some_switch
+    #   --[no-]feature     # => :feature
+    #   --file FILE        # => :file
+    #   --list of,things   # => :list
+    #
+
+    def self.switch_to_sym(switch)
+      switch.scan(/[\-\]](\w+)/).join('_').to_sym rescue nil
+    end
+
+    ##
+    # Run the active command.
+
+    def run_active_command
+      require_valid_command
+      if alias? command_name_from_args
+        active_command.run(*(@aliases[command_name_from_args.to_s] + args_without_command_name))
+      else
+        active_command.run(*args_without_command_name)
+      end
+    end
+
+    def say(*args) #:nodoc:
+      $terminal.say(*args)
+    end
+  end
+end