facets 1.8.49 → 1.8.51

data/PROJECT

@@ -29,7 +29,7 @@ scm: darcs
 changelog  : doc/CHANGES
 stamp      : VERSION
 
-#distribute: [ -doc/rdoc, -test/lib ]
+distribute: [ -work, -test/lib ]
 
 package: [ gem, tgz ]
 
@@ -37,6 +37,9 @@ notes:
   labels: [ TODO, FIXME, CREDIT ]
 
 rdoc:
+  output   : doc/rdoc/core
+  title    : Facets/CORE
+  files    : [ '[A-Z]*', 'lib/facets/core/**/*' ]
   template : jamis
   options  : ['--all', '--inline-source']
 

data/Rakefile

@@ -4,12 +4,6 @@
 
 require 'autorake'
 
-#
-# Redirect, extact tests and run tests
-#
-
-#task :prepare => [ :redirect, :extest, :test ]
-
 #
 # Generate facet/ redirection files
 #
@@ -42,25 +36,7 @@ task :redirect do
   puts "Created #{count} redirection files in #{REDIR}/ folder."
 end
 
-#
-# Extract tests
-#
-
-#desc "ectract units tests"
-#task :extest do
-#  project.extract(:files=>'lib/facets/**/*.rb')
-#end
-
-#
-# Run tests
-#
-
-#desc "run tests"
-#task :test do
-#  project.test
-#end
 
-=begin
 #
 # Generate API documentation
 #
@@ -68,31 +44,32 @@ end
 # where teh deafult it 'all'.
 #
 
-desc "rdoc all libs"
-task :rdoc => [:rdoc_core, :rdoc_more]
-
-desc "rdoc core lib"
-task :rdoc_core do
-  project.rdoc(YAML.load(<<-END))
-    title: Facets/CORE
-    include:
-      - 'lib/facets/core/**/*'
-      - '[A-Z]*'
-    output: doc/rdoc/core
-  END
-end
+#desc "rdoc all libs"
+#task :rdocs => [:rdoc_core, :rdoc_more] do 
+#end
+
+#desc "rdoc for core lib"
+#task :rdocs_core do
+#  project.rdoc(YAML.load(<<-END))
+#    title: Facets/CORE
+#    include:
+#      - 'lib/facets/core/**/*'
+#      - '[A-Z]*'
+#    output: doc/rdoc/core
+#  END
+#end
+
+#desc "rdocs for more lib"
+#task :rdocs_more do
+#  project.rdoc(YAML.load(<<-END))
+#    title: Facets/MORE
+#    include:
+#      - 'lib/facets/more/**/*'
+#      - '[A-Z]*'
+#    output: doc/rdoc/more
+#  END
+#end
 
-desc "rdoc more lib"
-task :rdoc_more do
-  project.rdoc(YAML.load(<<-END))
-    title: Facets/MORE
-    include:
-      - 'lib/facets/more/**/*'
-      - '[A-Z]*'
-    output: doc/rdoc/more
-  END
-end
-=end
 
 #
 # List core methods

data/VERSION

@@ -1 +1 @@
-1.8.49 stable (2007-02-16)
+1.8.51 stable (2007-02-19)

data/doc/AUTHORS

@@ -37,6 +37,7 @@
 * Tim Pease
 * Jonas Pfenniger
 * Ryan Platte
+* Tyler Rick
 * Thomas Sawyer
 * Daniel Schierbeck
 * Gavin Sinclair

data/doc/CHANGES

@@ -1,3 +1,9 @@
+Mon Feb 19 12:40:55 EST 2007  Trans <transfire@gmail.com>
+  * significant improvements to command.rb thanks to Tyler Rick
+
+Fri Feb 16 04:10:35 EST 2007  Trans <transfire@gmail.com>
+  * added tests to elementwise and tap
+
 Fri Feb 16 01:10:15 EST 2007  Trans <transfire@gmail.com>
   * fixed test for elementwise and op_tilde_self
 

data/lib/facets/core/kernel/tap.rb

@@ -1,12 +1,42 @@
 
 module Kernel
 
-  # Yeild self and return self.
+  # Yield self and return self.
+
+  def tap &b
+    if b.arity == 1
+      yield self
+    else
+      instance_eval(&b)
+    end
 
-  def tap
-    yield self
     return self
   end
 
 end
 
+
+
+
+=begin test
+
+  require 'test/unit'
+
+  class TestTap < Test::Unit::TestCase
+
+    def test_tap
+      x = "foo"
+      r = ("foobar".tap{ gsub! /bar/, '' })
+      assert_equal(x, r)
+    end
+
+    def test_tap_array
+      x = [1,2,3]
+      x.tap{ |a|
+        assert_equal(x, a)
+      }
+    end
+  end
+
+=end
+

data/lib/facets/more/command.rb

@@ -14,7 +14,8 @@
 #
 # == Author(s)
 #
-# * Thomas Sawyer
+#   CREDIT Thomas Sawyer
+#   CREDIT Tyler Rick
 #
 # == Developer Notes
 #
@@ -24,12 +25,11 @@
 #        adding subdirectories to more/ is a good idea.
 #
 
-# Author::    Thomas Sawyer
-# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# Author::    Thomas Sawyer, Tyler Rick
+# Copyright:: Copyright (c) 2005-2007
 # License::   Ruby License
 
 require 'shellwords'
-#require 'facets/core/string/modulize'
 
 # = Console
 #
@@ -38,8 +38,6 @@ require 'shellwords'
 
 module Console ; end
 
-# Initialize common globals to avoid warnings.
-
 # = Console Command
 #
 # Console::Command provides a clean and easy way
@@ -163,7 +161,28 @@ module Console ; end
 # 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 
+# The method signature should look like:
+#
+#   option_missing(option_name, args)
+#
+# Example:
+#   def option_missing(option_name, args)
+#     p args if $debug
+#     case option_name
+#       when 'p'
+#         @a = args[0].to_i
+#         @b = args[1].to_i
+#         2
+#       else
+#         raise InvalidOptionError(option_name, args)
+#     end
+#   end
+#
+# Its return value should be the effective "arity" of that options -- that is,
+# how many arguments it consumed ("-p a b", for example, would consume 2 args:
+# "a" and "b"). An arity of 1 is assumed if nil or false is returned.
+#
+# 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.
@@ -202,122 +221,129 @@ module Console ; end
 
 class Console::Command
 
-  class << self
-    # Starts the command execution.
-
-    def 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(global_options)
-    @global_options = global_options
-  end
-
-  # Execute the command.
-
-  def execute( line=nil )
-    case line
-    when String
-      arguments = Shellwords.shellwords(line)
-    when Array
-      arguments = line
-    else
-      arguments = ARGV
-    end
-
-    # duplicate arguments to work on them in-place.
-
-    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
-
-    # 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
-    end
-
-    # Does this command take subcommands?
-    subcommand = !respond_to?(:main)
-
-    # process primary options
-    argv = execute_options( argv, subcommand )
-
-    # In not subcommand remaining arguments are arguments.
-    return send(:main,*argv) unless subcommand
-
-    # What to do if there is nothing else?
-    if argv.empty?
-      if respond_to?(:default)
-        return __send__(:default)
-      else
-        $strderr << "Nothing to do."
-        return
-      end
-    end
-
-    # Remaining arguments are subcommand and suboptions.
-
-    subcmd = argv.shift.gsub('-','_')
-
-    # 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
-      #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
+ class << self
+   # Starts the command execution.
+
+   def 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(global_options)
+   @global_options = global_options
+ end
+
+ # Execute the command.
+
+ def execute( line=nil )
+   case line
+   when String
+     arguments = Shellwords.shellwords(line)
+   when Array
+     arguments = line
+   else
+     arguments = ARGV
+   end
+
+   # duplicate arguments to work on them in-place.
+
+   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
+
+   # 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
+   end
+
+   # Does this command take subcommands?
+   subcommand = !respond_to?(:main)
+
+   # process primary options
+   argv = execute_options( argv, subcommand )
+
+   # If this command doesn't take subcommands, then the remaining arguments are arguments for main().
+   return send(:main, *argv) unless subcommand
+
+   # What to do if there is nothing else?
+   if argv.empty?
+     if respond_to?(:default)
+       return __send__(:default)
+     else
+       $stderr << "Nothing to do."
+       return
+     end
+   end
+
+   # Remaining arguments are subcommand and suboptions.
+
+   subcmd = argv.shift.gsub('-','_')
+   #puts "subcmd = #{subcmd}"
+
+   # Extend subcommand option module
+   subconst = subcmd.gsub(/\W/,'_').capitalize
+   #puts self.class.name
+   if self.class.const_defined?(subconst)
+     puts "Extending self (#{self.class}) with subcommand module #{subconst}" if $debug
+     submod = self.class.const_get(subconst)
+     self.extend submod
+   end
+
+   # process subcommand options
+   #puts "Treating the rest of the args as subcommand options:"
+   #p argv
+   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 )
+     puts "Calling #{subcmd}(#{argv.inspect})" if $debug
+     __send__(subcmd, *argv)
+   else
+     #begin
+       puts "Calling method_missing with #{subcmd}, #{argv.inspect}" if $debug
+       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
@@ -328,120 +354,138 @@ class Console::Command
 #       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 << "Unknown option '#{a}'.\n"
-        exit -1
-      end
-    end
-    return argr
-  end
-
-  public
+ end
+
+ private
+
+ #
+
+ def global_options
+   @global_options
+ end
+
+ #
+
+ def execute_options( argv, subcmd=false )
+   puts "in execute_options:" if $debug
+   argv = argv.dup
+   args_to_return = []
+   until argv.empty?
+     arg = argv.first
+     if arg[0,1] == '-'
+       puts "'#{arg}' -- is an option" if $debug
+
+       name = arg.gsub('-','_')
+       puts "  responds_to(#{name})?" if $debug
+       if respond_to?(name)
+         m = method(name)
+         arity = m.arity
+         #puts "{argv before slice: #{argv.inspect}" if $debug
+         args_for_current_option = argv.slice!(0, arity+1)
+         #puts "}argv after slice: #{argv.inspect}" if $debug
+         #puts "{args_for_current_option before shift: #{args_for_current_option.inspect}" if $debug
+         args_for_current_option.shift
+         #puts "}args_for_current_option after shift: #{args_for_current_option.inspect}" if $debug
+         #puts "  arity=#{m.arity}" if $debug
+         #puts "  calling #{name} with #{args_for_current_option.inspect}" if $debug
+         m.call(*args_for_current_option)
+       elsif respond_to?(:option_missing)
+         puts "  option_missing(#{argv.inspect})" if $debug
+         arity = option_missing(arg.gsub(/^[-]+/,''), argv[1..-1]) || 1
+         puts "  arity == #{arity}" if $debug
+         argv.slice!(0, arity)
+         argv.shift  # Get rid of the *name* of the option
+       else
+         $stderr << "Unknown option '#{arg}'.\n"
+         exit -1
+       end
+     else
+       puts "'#{arg}' -- not an option. Adding to args_to_return..." if $debug
+       if subcmd
+         args_to_return = argv
+         #puts "subcommand. args_to_return=#{args_to_return.inspect}" if $debug
+         break
+       else
+         args_to_return << argv.shift
+         puts "args_to_return=#{args_to_return.inspect}" if $debug
+       end
+     end
+   end
+   puts "Returning #{args_to_return.inspect}" if $debug
+   return args_to_return
+ 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
-
-    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
+ # 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
 =end
 
 end
@@ -457,57 +501,249 @@ end
 
 =begin test
 
-  require 'test/unit'
+ require 'test/unit'
+ require 'stringio'
+
+ class TestCommand < Test::Unit::TestCase
+   def setup
+     $output = nil
+     $stderr = StringIO.new
+   end
+
+   #
+
+   class SimpleCommand < Console::Command
+     def __here ; @here = true ; end
+
+     def main(*args)
+       $output = [@here] | args
+     end
+   end
+
+   def test_SimpleCommand
+     SimpleCommand.execute( '--here file1 file2' )
+     assert_equal( [true, 'file1', 'file2'], $output )
+   end
+
+   #
+
+   class CommandWithMethodMissingSubcommand < Console::Command
+     def __here ; @here = true ; end
+
+     def method_missing(subcommand, *args)
+       $output = [@here, subcommand] | args
+     end
+   end
+
+   def test_CommandWithMethodMissingSubcommand
+     CommandWithMethodMissingSubcommand.execute( '--here go file1' )
+     assert_equal( [true, 'go', 'file1'], $output )
+   end
+
+   #
 
-  class TestCommand < Test::Unit::TestCase
+   class CommandWithSimpleSubcommand < Console::Command
+     def __here ; @here = true ; end
 
-    #
+     # subcommand
 
-    class MyCmd1 < Console::Command
-      def _x ; @x = true ; end
-      def _y ; @y = true ; end
-      def _z(n) ; @z = n ; end
+     module Go
+       def _p(n)
+         @p = n.to_i
+       end
+     end
 
-      global_option :_x
+     def go ; $output = [@here, @p] ; end
+   end
 
-      # subcommand
-      def go ; $output = [@x, @y, @z, @p] ; end
+   def test_CommandWithSimpleSubcommand
+     CommandWithSimpleSubcommand.execute( '--here go -p 1' )
+     assert_equal( [true, 1], $output )
+   end
 
-      module Go
-        def _p(n)
-          @p = n.to_i
-        end
-      end
-    end
+   #
 
-    MyCmd1.execute( '-xy -z HERE go -p 1' )
+   # Global options can be anywhere, right? Even after subcommands? Let's find out.
+   class CommandWithGlobalOptionsAfterSubcommand < Console::Command
+     def _x ; @x = true ; end
+     global_option :_x
 
-    def test_001
-      assert_equal( [true, true, 'HERE', 1], $output )
-    end
+     def go ; $output = [@x, @p] ; end
 
-    #
+     module Go
+       def _p(n)
+         @p = n.to_i
+       end
+     end
+   end
 
-    class MyCmd2 < Console::Command
-      def __here ; @here = true ; end
+   def test_CommandWithGlobalOptionsAfterSubcommand
+     CommandWithGlobalOptionsAfterSubcommand.execute( 'go -x -p 1' )
+     assert_equal( [true, 1], $output )
 
-      # subcommand
+     CommandWithGlobalOptionsAfterSubcommand.execute( 'go -p 1 -x' )
+     assert_equal( [true, 1], $output )
+   end
 
-      module Go
-        def _p(n)
-          @p = n.to_i
-        end
-      end
+   #
 
-      def go ; $output = [@here, @p] ; end
-    end
+   class GivingUnrecognizedOptions < Console::Command
+     def _x ; @x = true ; end
+     def go ; $output = [@x, @p] ; end
+   end
 
-    MyCmd2.execute( '--here go -p 1' )
+   def test_GivingUnrecognizedOptions
+     assert_raise(SystemExit) do
+       GivingUnrecognizedOptions.execute( '--an-option-that-wont-be-recognized -x go' )
+     end
+     assert_equal "Unknown option '--an-option-that-wont-be-recognized'.\n", $stderr.string
+     assert_equal( nil, $output )
+   end
+   #
 
-    def test_001
-      assert_equal( [true, 1], $output )
-    end
+   class PassingMultipleSingleCharOptionsAsOneOption < Console::Command
+     def _x ; @x = true ; end
+     def _y ; @y = true ; end
+     def _z(n) ; @z = n ; end
+
+     global_option :_x
+
+     def go ; $output = [@x, @y, @z, @p] ; end
 
-  end
+     module Go
+       def _p(n)
+         @p = n.to_i
+       end
+     end
+   end
+
+   def test_PassingMultipleSingleCharOptionsAsOneOption
+     PassingMultipleSingleCharOptionsAsOneOption.execute( '-xy -z HERE go -p 1' )
+     assert_equal( [true, true, 'HERE', 1], $output )
+   end
+
+   #
+
+   class CommandWithOptionUsingEquals < Console::Command
+     module Go
+       def __mode(mode) ; @mode = mode ; end
+     end
+     def go ; $output = [@mode] ; end
+   end
+
+   def test_CommandWithOptionUsingEquals
+     CommandWithOptionUsingEquals.execute( 'go --mode smart' )
+     assert_equal( ['smart'], $output )
+
+     # I would expect this to work too, but currently it doesn't.
+     #assert_nothing_raised { CommandWithOptionUsingEquals.execute( 'go --mode=smart' ) }
+     #assert_equal( ['smart'], $output )
+   end
+
+   #
+
+   class CommandWithSubcommandThatTakesArgs < Console::Command
+     def go(arg1, *args) ; $output = [arg1] | args ; end
+   end
+
+   def test_CommandWithSubcommandThatTakesArgs
+     CommandWithSubcommandThatTakesArgs.execute( 'go file1 file2 file3' )
+     assert_equal( ['file1', 'file2', 'file3'], $output )
+   end
+
+   #
+
+   class CommandWith2OptionalArgs < Console::Command
+     def __here ; @here = true ; end
+
+     module Go
+       def _p(n)
+         @p = n.to_i
+       end
+     end
+
+     def go(required1 = nil, optional2 = nil) ; $output = [@here, @p, required1, optional2 ] ; end
+   end
+
+   def test_CommandWith2OptionalArgs
+     CommandWith2OptionalArgs.execute( '--here go -p 1 to' )
+     assert_equal( [true, 1, 'to', nil], $output )
+   end
+
+   #
+
+   class CommandWithVariableArgs < Console::Command
+     def __here ; @here = true ; end
+
+     module Go
+       def _p(n)
+         @p = n.to_i
+       end
+     end
+
+     def go(*args) ; $output = [@here, @p] | args ; end
+   end
+
+   def test_CommandWithVariableArgs
+     CommandWithVariableArgs.execute( '--here go -p 1 to bed' )
+     assert_equal( [true, 1, 'to', 'bed'], $output )
+   end
+
+   #
+
+   class CommandWithOptionMissing < Console::Command
+     def __here ; @here = true ; end
+
+     module Go
+       def option_missing(option_name, args)
+         p args if $debug
+         case option_name
+           when 'p'
+             @p = args[0].to_i
+             1
+           else
+             raise InvalidOptionError(option_name, args)
+         end
+       end
+     end
+
+     def go(*args) ; $output = [@here, @p] | args ; end
+   end
+
+   def test_CommandWithOptionMissing
+     CommandWithOptionMissing.execute( '--here go -p 1 to bed right now' )
+     assert_equal( [true, 1, 'to', 'bed', 'right', 'now'], $output )
+   end
+
+   #
+
+   class CommandWithOptionMissingArityOf2 < Console::Command
+     def __here ; @here = true ; end
+
+     module Go
+       def option_missing(option_name, args)
+         p args if $debug
+         case option_name
+           when 'p'
+             @p1 = args[0].to_i
+             @p2 = args[1].to_i
+             2
+           when 'q'
+             @q = args[0].to_i
+             nil # Test default arity
+           else
+             raise InvalidOptionError(option_name, args)
+         end
+       end
+     end
+
+     def go(*args) ; $output = [@here, @p1, @p2, @q] | args ; end
+   end
+
+   def test_CommandWithOptionMissingArityOf2
+     CommandWithOptionMissingArityOf2.execute( '--here go -p 1 2 -q 3 to bed right now' )
+     assert_equal( [true, 1, 2, 3, 'to', 'bed', 'right', 'now'], $output )
+   end
+ end
 
 =end