facets 1.7.46 → 1.8.0

data/lib/facets/more/command.rb

@@ -1,4 +1,4 @@
-# = consoleapp.rb
+# = command.rb
 #
 # == Copyright (c) 2005 Thomas Sawyer
 #
@@ -18,7 +18,7 @@
 #
 # == Developer Notes
 #
-#   TODO Add documentation features. (NOT SO SURE NOW!)
+#   TODO Add help/documentation features.
 #
 #   TODO Move to console/command.rb, but I'm not sure yet if
 #        adding subdirectories to more/ is a good idea.
@@ -28,6 +28,9 @@
 # Copyright:: Copyright (c) 2005 Thomas Sawyer
 # License::   Ruby License
 
+require 'shellwords'
+#require 'facets/core/string/modulize'
+
 # = Console
 #
 # Console namespace for use by tools specifically designed
@@ -35,6 +38,8 @@
 
 module Console ; end
 
+# Initialize common globals to avoid warnings.
+
 # = Console Command
 #
 # Console::Command provides a clean and easy way
@@ -48,7 +53,8 @@ module Console ; end
 #
 #   #!/usr/bin/env ruby
 #
-#   require 'facet/console_command'
+#   require 'facets'
+#   require 'command'
 #
 #   MyCmd << Console::Command
 #
@@ -70,13 +76,102 @@ module Console ; end
 #
 # Then on the command line:
 #
-#   > mycmd jump
+#   % mycmd jump
 #   Jump
 #
-#   > mycmd -v jump
+#   % mycmd -v jump
+#   JUMP! JUMP! JUMP!
+#
+# == Subcommands
+#
+# Commands can take subcommand and suboptions. To do this
+# simply add a module to your class with the same name
+# as the subcommand, in which the suboption methods are defined.
+#
+#   MyCmd << Console::Command
+#
+#     def initialize
+#       @height = 1
+#     end
+#
+#     def _v
+#       $VERBOSE = true
+#     end
+#
+#     def jump
+#       if $VERBOSE
+#         puts "JUMP!" * @height
+#       else
+#         puts "Jump" * @height
+#       end
+#     end
+#
+#     module Jump
+#       def __height(h)
+#         @height = h.to_i
+#       end
+#     end
+#
+#   end
+#
+#   MyCmd.start
+#
+# Then on the command line:
+#
+#   % mycmd jump -h 2
+#   Jump Jump
+#
+#   % mycmd -v jump -h 3
 #   JUMP! JUMP! JUMP!
 #
+# Another thing to notice about this example is that #start is an alias
+# for #execute.
+#
+# == Missing Subcommands
+#
+# You can use #method_missing to catch missing subcommand calls.
+#
+# == Main and Default
+#
+# If your command does not take subcommands then simply define
+# a #main method to dispatch action. All options will be treated globablly
+# in this case and any remaining comman-line arguments will be passed
+# to #main.
+#
+# If on the other hand your command does take subcommands but none is given,
+# the #default method will be called, if defined. If not defined
+# an error will be raised (but only reported if $DEBUG is true).
+#
+# == Global Options
+#
+# You can define <i>global options</i> which are options that will be
+# processed no matter where they occur in the command line. In the above
+# examples only the options occuring before the subcommand are processed
+# globally. Anything occuring after the subcommand belonds strictly to
+# the subcommand. For instance, if we had added the following to the above
+# example:
+#
+#   global_option :_v
+#
+# Then -v could appear anywhere in the command line, even on the end,
+# and still work as expected.
+#
+#   % mycmd jump -h 3 -v
+#
+# == Missing Options
+#
+# You can use #option_missing to catch any options that are not explicility
+# defined.
+#
+# Be aware that when using subcommand modules, the same option_missing 
+# method will catch missing options for global options and subcommand
+# options too unless an option_missing method is also defined in the
+# subcommand module.
+#
 #--
+#
+# == Help Documentation
+#
 # You can also add help information quite easily. If the following code
 # is saved as 'foo' for instance.
 #
@@ -94,7 +189,7 @@ module Console ; end
 #
 #   end
 #
-#   MyCmd.go
+#   MyCmd.execute
 #
 # then by running 'foo help' on the command line, standard help information
 # will be displayed.
@@ -111,183 +206,243 @@ class Console::Command
     # Starts the command execution.
 
     def execute( *args )
-      new.execute( *args )
+      new(global_options).execute( *args )
     end
 
     # Alias for #execute.
 
     alias_method :start, :execute
+
+    # Change the option mode.
+
+    def global_option( *names )
+      names.each{ |name| global_options << name.to_sym }
+    end
+
+    def global_options
+      @global_options ||= []
+    end
   end
 
   # Do not let this pass through to
   # any included module.
 
-  def initialize ; end
+  def initialize(global_options)
+    @global_options = global_options
+  end
 
   # Execute the command.
 
-  def execute( *argv )
-    argv = argv.empty? ? ARGV : argv
+  def execute( line=nil )
+    case line
+    when String
+      arguments = Shellwords.shellwords(line)
+    when Array
+      arguments = line
+    else
+      arguments = ARGV
+    end
 
-    # process options
+    # duplicate arguments to work on them in-place.
 
-    argv2 = argv.collect { |arg|
-      if md = %r{^-(\w+)}.match( arg )
-        if md[1].size > 1
-          md[1].split(//).collect { |c| "-#{c}" }
-        else
-          arg
-        end
+    argv = arguments.dup
+
+    # Split single letter option groupings into separate options.
+    # ie. -xyz => -x -y -z
+
+    argv = argv.collect { |arg|
+      if md = /^-(\w{2,})/.match( arg )
+        md[1].split(//).collect { |c| "-#{c}" }
       else
         arg
       end
     }.flatten
 
-    args = argv2.dup
-
-    i = 0;
-    while i < args.size
-      if md = %r{^[-]}.match( args[i] )
-        opt = args[i].gsub('-','_')
-        if self.respond_to?( opt )
-          m = method( opt )
-          c = m.arity
-          if c > 0
-            m.call(*args[i+1..i+c])
-            args[i..i+c] = nil
-            i += c
-          else
-            m.call
-            args[i] = nil
-          end
-        else
-          $stderr << "Unknown option '#{args[i]}'\n"
-          exit -1
-        end
+    # process global options
+    global_options.each do |name|
+      o = name.to_s.sub('__','--').sub('_','-')
+      m = method(name)
+      c = m.arity
+      while i = argv.index(o)
+        args = argv.slice!(i,c+1)
+        args.shift
+        m.call(*args)
       end
-      i += 1
     end
 
-    args.compact!
+    # Does this command take subcommands?
+    subcommand = !respond_to?(:main)
 
-    # no secondary commands
+    # process primary options
+    argv = execute_options( argv, subcommand )
 
-    if self.respond_to?(:main)
-      main( *args )
+    # In not subcommand remaining arguments are arguments.
+    return send(:main,*argv) unless subcommand
 
-    # secondary commands
-
-    elsif not args.empty?
-      if self.respond_to?( args.first )
-        __send__( *args )
+    # What to do if there is nothing else?
+    if argv.empty?
+      if respond_to?(:default)
+        return __send__(:default)
       else
-        if self.private_methods.include?( "no_command_error" )
-          no_command_error( *args )
-        else
-          $stderr << "Non-applicable command #{args.join(' ')}\n"
-          exit -1
-        end
+        $strderr << "Nothing to do."
+        return
       end
+    end
 
-    # default secondary command
+    # Remaining arguments are subcommand and suboptions.
 
-    elsif self.respond_to?( :default )
-      default(*args)
+    subcmd = argv.shift.gsub('-','_')
 
-    # error
+    # Extend subcommand option module
+    subconst = subcmd.gsub(/\W/,'_').capitalize
+    if self.class.const_defined?(subconst)
+      submod = self.class.const_get(subconst)
+      self.extend submod
+    end
+
+    # process subcommand options
+    argv = execute_options( argv )
 
+    # This is a little tricky. The method has to be defined by a subclass.
+    if self.respond_to?( subcmd ) and not Console::Command.public_instance_methods.include?( subcmd.to_s )
+      __send__(subcmd, *argv)
     else
-      if self.private_methods.include?( "no_action_error" )
-        no_action_error( *args )
+      #begin
+        method_missing(subcmd, *argv)
+      #rescue NoMethodError => e
+        #if self.private_methods.include?( "no_command_error" )
+        #  no_command_error( *args )
+        #else
+      #    $stderr << "Non-applicable command -- #{argv.join(' ')}\n"
+      #    exit -1
+        #end
+      #end
+    end
+
+#   rescue => err
+#     if $DEBUG
+#       raise err
+#     else
+#       msg = err.message.chomp('.') + '.'
+#       msg[0,1] = msg[0,1].capitalize
+#       msg << " (#{err.class})" if $VERBOSE
+#       $stderr << msg
+#     end
+  end
+
+  private
+
+  #
+
+  def global_options
+    @global_options
+  end
+
+  #
+
+  def execute_options( argv, subcmd=false )
+    argv = argv.dup
+    argr = []
+    until argv.empty?
+      a = argv.first
+      if a[0,1] != '-'
+        if subcmd
+          argr = argv
+          break
+        else
+          argr << argv.shift
+        end
+      end
+      name = a.gsub('-','_')
+      if respond_to?(name)
+        m = method(name)
+        c = m.arity
+        args = argv.slice!(0,c+1)
+        args.shift
+        m.call(*args)
+      elsif respond_to?(:option_missing)
+        c = option_missing(a.gsub(/^[-]+/,''), argv) || 1
+        argv.slice!(0,c)
       else
-        $stderr << "Nothing to do.\n"
+        $stderr << "Unknown option '#{a}'.\n"
         exit -1
       end
+    end
+    return argr
+  end
+
+  public
+
+=begin
+  # We include a module here so you can define your own help
+  # command and call #super to utilize this one.
+
+  module Help
+
+    def help
+      opts = help_options
+      s = ""
+      s << "#{File.basename($0)}\n\n"
+      unless opts.empty?
+        s << "OPTIONS\n"
+        s << help_options
+        s << "\n"
+      end
+      s << "COMMANDS\n"
+      s << help_commands
+      puts s
+    end
+
+    private
 
+    def help_commands
+      help = self.class.help
+      bufs = help.keys.collect{ |a| a.to_s.size }.max + 3
+      lines = []
+      help.each { |cmd, str|
+        cmd = cmd.to_s
+        if cmd !~ /^_/
+          lines << "  " + cmd + (" " * (bufs - cmd.size)) + str
+        end
+      }
+      lines.join("\n")
     end
 
-  rescue ArgumentError => ex
-    if $TRACE
-      raise ex
-    else
-      $stderr << "Could not run #{args.first}. #{ex.message.capitalize.chomp('.')}.\n"
+    def help_options
+      help = self.class.help
+      bufs = help.keys.collect{ |a| a.to_s.size }.max + 3
+      lines = []
+      help.each { |cmd, str|
+        cmd = cmd.to_s
+        if cmd =~ /^_/
+          lines << "  " + cmd.gsub(/_/,'-') + (" " * (bufs - cmd.size)) + str
+        end
+      }
+      lines.join("\n")
     end
-  end
 
-  #
+    module ClassMethods
+
+      def help( str=nil )
+        return (@help ||= {}) unless str
+        @current_help = str
+      end
+
+      def method_added( meth )
+        if @current_help
+          @help ||= {}
+          @help[meth] = @current_help
+          @current_help = nil
+        end
+      end
+
+    end
 
-  def __trace
-    $TRACE = true
   end
 
-#   # We include a module here so you can define your own help command
-#   # and call #super to utilize this one.
-#
-#   module Help
-#
-#     def help
-#       opts = help_options
-#       s = ""
-#       s << "#{File.basename($0)}\n\n"
-#       unless opts.empty?
-#         s << "OPTIONS\n"
-#         s << help_options
-#         s << "\n"
-#       end
-#       s << "COMMANDS\n"
-#       s << help_commands
-#       puts s
-#     end
-#
-#     private
-#
-#     def help_commands
-#       help = self.class.help
-#       bufs = help.keys.collect{ |a| a.to_s.size }.max + 3
-#       lines = []
-#       help.each { |cmd, str|
-#         cmd = cmd.to_s
-#         if cmd !~ /^_/
-#           lines << "  " + cmd + (" " * (bufs - cmd.size)) + str
-#         end
-#       }
-#       lines.join("\n")
-#     end
-#
-#     def help_options
-#       help = self.class.help
-#       bufs = help.keys.collect{ |a| a.to_s.size }.max + 3
-#       lines = []
-#       help.each { |cmd, str|
-#         cmd = cmd.to_s
-#         if cmd =~ /^_/
-#           lines << "  " + cmd.gsub(/_/,'-') + (" " * (bufs - cmd.size)) + str
-#         end
-#       }
-#       lines.join("\n")
-#     end
-#
-#     module ClassMethods
-#
-#       def help( str=nil )
-#         return (@help ||= {}) unless str
-#         @current_help = str
-#       end
-#
-#       def method_added( meth )
-#         if @current_help
-#           @help ||= {}
-#           @help[meth] = @current_help
-#           @current_help = nil
-#         end
-#       end
-#
-#     end
-#
-#   end
-#
-#   include Help
-#   extend Help::ClassMethods
+  include Help
+  extend Help::ClassMethods
+=end
 
 end
 
@@ -304,22 +459,53 @@ end
 
   require 'test/unit'
 
-  class TCCommand < Test::Unit::TestCase
+  class TestCommand < Test::Unit::TestCase
+
+    #
+
+    class MyCmd1 < Console::Command
+      def _x ; @x = true ; end
+      def _y ; @y = true ; end
+      def _z(n) ; @z = n ; end
+
+      global_option :_x
+
+      # subcommand
+      def go ; $output = [@x, @y, @z, @p] ; end
+
+      module Go
+        def _p(n)
+          @p = n.to_i
+        end
+      end
+    end
+
+    MyCmd1.execute( '-xy -z HERE go -p 1' )
+
+    def test_001
+      assert_equal( [true, true, 'HERE', 1], $output )
+    end
 
-    class MyCmd < Console::Command
+    #
 
-      def _x ; $X = true ; end
+    class MyCmd2 < Console::Command
+      def __here ; @here = true ; end
 
-      def _y ; $Y = true ; end
+      # subcommand
 
-      def go ; $output = [$X, $Y] ; end
+      module Go
+        def _p(n)
+          @p = n.to_i
+        end
+      end
 
+      def go ; $output = [@here, @p] ; end
     end
 
-    MyCmd.execute( '-x', '-y', 'go' )
+    MyCmd2.execute( '--here go -p 1' )
 
     def test_001
-      assert_equal( [true, true], $output )
+      assert_equal( [true, 1], $output )
     end
 
   end