facets 2.0.5 → 2.1.0

data/WHATSNEW

@@ -0,0 +1,11 @@
+Facets 2.1.0 is in the wild!
+
+Major changes include a new and much-improved
+command.rb, a new BiCrypt class for simple two-way
+crypotgraphy, as well as attr_reader!, attr_writer!
+and attr_accessor! for flag attributes, plus
+alias_xxx methods for all attr_xxx methods.
+
+Enjoy!
+
+http://facets.rubyforge.org

data/lib/core/facets/enumerable/collect.rb

@@ -113,6 +113,12 @@ module Enumerable
     end
   end
 
+  # TODO Faster implementation? Verify equivalency.
+  #def injecting(res, &block)
+  #  ([res]*length).zip(to_a).each(&block)
+  #  res
+  #end
+
   # The #group_by method is best explained by example.
   #
   #   (1..5).partition_by { |n| n % 3 }
@@ -150,8 +156,7 @@ module Enumerable
   # CREDIT Erik Veenstra
 
   def cluster_by(&b)
-    #group_by(&b).values
-    group_by(&b).sort.transpose.pop
+    group_by(&b).sort.transpose.pop || []   # group_by(&b).values ?
   end
 
   # Split on matching pattern.

data/lib/core/facets/enumerable/permutation.rb

@@ -6,7 +6,6 @@
 #
 # AUTHORS:
 #   - Florian Gross
-#   - Thomas Sawyer
 
 require 'facets/integer/factorial'
 
@@ -17,6 +16,8 @@ module Enumerable
   # Each is index by a permutation number. The maximum number of
   # arrangements is the factorial of the size of the array.
   #
+  # CREDIT Florian Gross
+
   def permutation(number)
       arr = to_a
       out = arr[0..0]
@@ -34,7 +35,10 @@ module Enumerable
   end
   alias :permute :permutation
 
+  # Calculate permutation number.
   #
+  # CREDIT Florian Gross
+
   def permutation_number(original_array=self.to_a.sort)
       arr = to_a
       m = 1
@@ -62,6 +66,8 @@ module Enumerable
   #   cab
   #   cba
   #
+  # CREDIT Florian Gross
+
   def each_permutation()
       arr = to_a
       size = arr.size
@@ -98,28 +104,3 @@ module Enumerable
   #++
 
 end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-  require 'set'
-
-  class TestEnumerablePermutation < Test::Unit::TestCase
-
-    def test_permutation
-      o = Set.new
-      %w[a b c].each_permutation { |x| o << x.join('') }
-      r = Set.new(['abc','acb','bac','bca','cab','cba'])
-      assert_equal( r, o )
-    end
-
-  end
-
-=end

data/lib/core/facets/module/alias.rb

@@ -23,15 +23,6 @@ class Module
 
   private
 
-  # Like module_funtion but makes the instance method
-  # public rather than private. This can not work
-  # as a sectional modifier however.
-
-  def module_method *meth
-    module_function *meth
-    public *meth
-  end
-
   # As with alias_method, but alias both reader and writer.
   #
   #   attr_accessor :x
@@ -41,9 +32,42 @@ class Module
   #   self.y = 2
   #   x #=> 2
 
-  def alias_accessor(name, target)
-    alias_method(name, target)
-    alias_method("#{name}=", "#{target}=")
+  def alias_accessor(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method(name, orig)
+      alias_method("#{name}=", "#{orig}=")
+    end
+  end
+
+  # As with alias_accessor, but just for the reader.
+
+  def alias_reader(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method(name, orig)
+    end
+  end
+
+  # As with alias_method but does the writer instead.
+
+  def alias_writer(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}=", "#{orig}=")
+    end
+  end
+
+  # Like module_funtion but makes the instance method
+  # public rather than private. This can not work
+  # as a sectional modifier however.
+
+  def module_method *meth
+    module_function *meth
+    public *meth
   end
 
   # Alias a module function so that the alias is also

data/lib/core/facets/module/attr.rb

@@ -1,6 +1,6 @@
 # TITLE:
 #
-#   Attributes Methods
+#   Extra Attributes Methods
 #
 # SUMMARY:
 #
@@ -9,9 +9,6 @@
 # AUTHORS:
 #
 #   - Thomas Sawyer
-#
-# TODO:
-#   - Need better name for attr_toggler, since it's not realy a "toggle".
 
 #
 class Module
@@ -30,7 +27,16 @@ class Module
       end
       made << "#{symbol}=".to_sym
     end
-    return *made
+    made
+  end
+
+  def alias_validator(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method(name, orig)
+      alias_method("#{name}=", "#{orig}=")
+    end
   end
 
   # TODO Perhaps need to make a check against overriding annotated version.
@@ -62,31 +68,62 @@ class Module
       made << "#{a}".to_sym
     end
     module_eval code
-    return *made
+    made
+  end
+
+  def alias_setter(*args)
+    args = args - [orig]
+    args.each do |name|
+      alias_method(name, orig)
+    end
   end
 
-  # Create an tester attribute. This creates two methods for
-  # each given variable name. One is used to test
-  # the attribute and the other is used to set or toggle it.
+  # Create a toggle attribute. This creates two methods for
+  # each given name. One is a form of tester and the other
+  # is used to toggle the value.
   #
-  #   attr_tester :a
+  #   attr_accessor! :a
   #
   # is equivalent to
   #
   #   def a?
-  #     @a ? true : @a
+  #     @a
   #   end
   #
-  #   def a!(switch=Exception)
-  #     if switch == Exception
-  #       @a = !@a
-  #     else
-  #       @a = switch ? true : @a
-  #       self
-  #     end
+  #   def a!(value=true)
+  #     @a = value
+  #     self
+  #   end
+
+  def attr_accessor!(*args)
+    attr_reader!(*args) + attr_writer!(*args)
+  end
+  alias_method :attr_switcher, :attr_accessor!
+  alias_method :attr_toggler,  :attr_accessor!
+
+  def alias_accessor!(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}?", "#{orig}?")
+      alias_method("#{name}!", "#{orig}!")
+    end
+  end
+  alias_method :alias_switcher, :alias_accessor!
+  alias_method :alias_toggler,  :alias_accessor!
+
+  # Create an tester attribute. This creates a single methods
+  # used to test the attribute for truth.
+  #
+  #   attr_reader! :a
+  #
+  # is equivalent to
+  #
+  #   def a?
+  #     @a ? true : @a
   #   end
 
-  def attr_tester(*args)
+  def attr_reader!(*args)
     code, made = '', []
     args.each do |a|
       code << %{
@@ -97,43 +134,54 @@ class Module
       made << "#{a}?".to_sym
     end
     module_eval code
-    return *made
+    made
   end
+  alias_method :attr_reader?, :attr_reader!
+  alias_method :attr_tester, :attr_reader!
 
-  # Create a toggle attribute. This creates two methods for
-  # each given name. One is a form of tester and the other
-  # is used to toggle the value.
+  def alias_reader!(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}?", "#{orig}?")
+    end
+  end
+  alias_method :alias_reader?, :alias_reader!
+  alias_method :alias_tester, :alias_reader!
+
+  # Create a flaggable attribute. This creates a single methods
+  # used to set an attribute to "true".
   #
-  #   attr_toggler :a
+  #   attr_writer! :a
   #
   # is equivalent to
   #
-  #   def a?
-  #     @a
-  #   end
-  #
   #   def a!(value=true)
   #     @a = value
   #     self
   #   end
 
-  def attr_toggler(*args)
+  def attr_writer!(*args)
     code, made = '', []
     args.each do |a|
       code << %{
         def #{a}!(value=true)
-          @a = value
+          @#{a} = value
           self
         end
-        def #{a}?
-          @#{a}
-        end
       }
       made << "#{a}!".to_sym
-      made << "#{a}?".to_sym
     end
     module_eval code
-    return *made
+    made
+  end
+
+  def alias_writer!(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}!", "#{orig}!")
+    end
   end
 
 end

data/lib/core/facets/module/include.rb

@@ -10,6 +10,16 @@ class Module
   #
   alias_method :is, :include
 
+# TODO
+#   def is(*mods)
+#     mods.each do |mod|
+#       if mod.const_defined?(:Self)
+#         extend mod.const_get(:Self)
+#       end
+#     end
+#     include(*mods)
+#   end
+
   # Expirmental idea for #is.
   #
   # If the module has #append_function_function

data/lib/methods/facets/module/alias_accessor.rb

@@ -1 +1 @@
-require 'facets/module/alias.rb'
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/alias_reader.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/alias_setter.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/alias_switcher.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/alias_tester.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/alias_toggler.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/alias_validator.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/alias_writer.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/attr_accessor.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/attr_reader.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/attr_switcher.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/methods/facets/module/attr_writer.rb

@@ -0,0 +1 @@
+require 'facets/module/attr.rb'

data/lib/more/facets/arguments.rb

@@ -58,7 +58,7 @@ class Console::Arguments
   # Takes the command line string (or array) and options.
   # Options have flags and end with a hash of option arity.
   #
-  def initialize( line=nil, arity=nil )
+  def initialize(line=nil, arity=nil)
     @line, @argv  = parse_line(line)
     @arity = parse_arity(arity||{})
     parse
@@ -237,6 +237,7 @@ class Console::Arguments
         key, val = key.split('=')
       elsif a = arity[key]
         val = args.slice!(0,a)
+        val = val.first if a == 1
       else
         val = true
       end

data/lib/more/facets/command.rb

@@ -20,182 +20,323 @@
 #
 # AUTHORS:
 #
-#   - 7rans
-#   - Tyler Rick
+#   - Trans
 #
-# TODOs:
+# TODO:
 #
-#   - Add help/documentation features.
-#   - Problem with exit -1 when testing. See IMPORTANT!!! remark below.
-#
-# LOG:
-#
-#   - 2007.10.31 TRANS
-#     Re-added support for __option notation.
+#   - Add global options to master command, or "all are master options" flag?
+#   - Add usage/help/documentation/man features.
 
-require 'shellwords'
 #require 'facets/annotations' # for help ?
+#require 'facets/module/attr'
+#require 'facets/kernel/constant'
+#require 'shellwords'
+require 'facets/arguments'
 
 module Console
 
-  # Base command class.
-  #
-  #   class MyCommand < Command
-  #
-  #     class JumpOptions < Command::Options
-  #       attr_accessor :height
-  #     end
-  #
-  #     help :jump, "this is the jump command"
+  # For CommandOptions, but defined external to it, so
+  # that it is easy to access from user defined commands.
+  # (This lookup issue should be fixed in Ruby 1.9+, and then
+  # the class can be moved back into Command namespace.)
+
+  class NoOptionError < NoMethodError
+    def initialize(name, *arg)
+      super("unknown option -- #{name}", name, *args)
+    end
+  end
+
+  class NoCommandError < NoMethodError
+    def initialize(name, *arg)
+      super("unknown subcommand -- #{name}", name, *args)
+    end
+  end
+
+  # Here is an example of usage:
   #
-  #     opts :jump, JumpOptions
+  #   # General Options
   #
-  #     def jump
-  #       puts "jump #{options.height} feet!"
-  #     end
+  #   module GeneralOptions
+  #     attr_accessor :dryrun ; alias_accessor :n, :noharm, :dryrun
+  #     attr_accessor :quiet  ; alias_accessor :q, :quiet
+  #     attr_accessor :force
+  #     attr_accessor :trace
   #   end
   #
-  # A little more conveniently:
+  #   # Build Subcommand
   #
-  #   class MyCommand < Command
+  #   class BuildCommand < Console::Command
+  #     include GeneralOptions
   #
-  #     help :jump, "this is the jump command"
+  #     # metadata files
+  #     attr_accessor  :file     ; alias_accessor :f, :file
+  #     attr_accessor  :manifest ; alias_accessor :m, :manifest
   #
-  #     opts :jump do
-  #       attr_accessor :height
+  #     def call
+  #       # do stuf here
   #     end
+  #   end
   #
-  #     def jump
-  #       puts "jump #{options.height} feet!"
-  #     end
+  #   # Box Master Command
+  #
+  #   class BoxCommand < Console::MasterCommand
+  #     subcommand :build,     BuildCommand
   #   end
   #
+  #   BoxCommand.start
 
-  class Command
+  class MasterCommand
+
+    #
 
-    # Command Syntax DSL
+    module UniversalOptions
+    end
 
-    module Syntax
+    #
 
-      # Starts the command execution.
-      def execute(*args)
-        cmd = new()
-        #cmd.instance_variable_set("@global_options",global_options)
-        cmd.execute(*args)
+    def self.option_arity(arity_hash=nil)
+      if arity_hash
+        (@option_arity ||= {}).merge!(arity_hash)
       end
-      alias_method :start, :execute
+      @option_arity
+    end
+
+    #
 
-      # Change the option mode.
-      def global_option( *names )
-        names.each{ |name| global_options << name.to_sym }
+    def self.start(line=nil)
+      cargs = Console::Arguments.new(line || ARGV, option_arity)
+      pre = cargs.preoptions
+      cmd, argv  = *cargs.subcommand
+      args, opts = *argv
+      if is_a?(UniversalOptions)
+        new(pre, opts).call(cmd, args, opts)
+      else
+        new(pre).call(cmd, args, opts)
       end
-      alias_method :global_options, :global_option
+    end
 
-      # Define a set of options. This can be a Command::Options subclass,
-      # or a block whihc will be used to create an Command::Options subclass.
+    #
 
-      def options(name, klass=nil, &block)
-        raise ArgumentError if klass && block
-        if block
-          command_options[name.to_sym] = Class.new(Options, &block)
-        else
-          command_options[name.to_sym] = klass
-        end
+    def self.subcommand(name, command_class, options=nil)
+      options ||= {}
+      if options[:no_merge]
+        file, line = __FILE__, __LINE__+1
+        code = %{
+          def #{name}(args, opts)
+            #{command_class}.new(args, opts).call
+          end
+        }
+      else
+        file, line = __FILE__, __LINE__+1
+        code = %{
+          def #{name}(args, opts)
+            opts.merge(master_options)
+            #{command_class}.new(args, opts).call
+          end
+        }
       end
-      alias_method :opts, :options
-      alias_method :opt, :options
+      class_eval(code, file, line)
+    end
+
+    private
 
-      #
+    attr :master_options
 
-      def command_options
-        @_command_options ||= {}
+    #
+
+    def initialize(*options)
+      initialize_options(*options)
+    end
+
+    #
+
+    def initialize_options(*options)
+      options = options.inject{ |h,o| h.merge(o) }
+      begin
+        opt, val = nil, nil
+        options.each do |opt, val|
+          send("#{opt}=", val)
+        end
+      rescue NoMethodError
+        option_missing(opt, val)
       end
+      @master_options = options
+    end
+
+    public
 
-      #
+    #
 
-      def global_options
-        @_global_options ||= []
+    def call(cmd, args, opts)
+      cmd = :default if cmd.nil?
+      begin
+        subcommand = method(cmd)
+        parameters = [args, opts]
+      rescue NameError
+        subcommand = method(:subcommand_missing)
+        parameters = [cmd, args, opts]
+      end
+      if subcommand.arity < 0
+        subcommand.call(*parameters[0..subcommand.arity])
+      else
+        subcommand.call(*parameters[0,subcommand.arity])
       end
     end
 
-    extend Syntax
+    #
+
+    def help; end
 
-    #def initialize #(global_options=nil)
-    #  #@global_options = global_options || []
-    #end
+    def default ; help ; end
+
+    private
 
     #
 
-    def execute(line=ARGV)
-      argv = line
+    def subcommand_missing(cmd, args, opt)
+      help
+      #raise NoCommandError.new(cmd, args << opt)
+    end
 
-      g_opts = Command::Options.new(self)
-      g_keys = self.class.global_options
+    #
 
-      # Deal with global options.
-      if g_keys && ! g_keys.empty?
-        argv = g_opts.parse(argv, :only => g_keys)
-      end
+    def option_missing(opt, arg=nil)
+      raise NoOptionError.new(opt)
+    end
 
-      # Sole main command or has subcommands?
-      if respond_to?(:main)
-        argv = g_opts.parse(argv, :pass => true)
-        cmd = :main
-      else
-        argv = g_opts.parse(argv, :stop => true)
-        cmd = argv.find{ |s| s !~ /^-/ }
-              argv.delete_at(argv.index(cmd)) if cmd
-        cmd = :default unless cmd
-        cmd = cmd.to_sym
-      end
+  end
+
+  # = Command base class
+  #
+  # See MasterCommand for example.
 
-      keys = self.class.command_options
+  class Command
 
-      if keys.key?(cmd)
-        opts = keys[cmd].new
-        argv = opts.parse(argv)
-      end
+    def self.start(line=nil)
+      cargs = Console::Argument.new(line || ARGV)
+      pre = cargs.preoptions
+      args, opts = *cargs.parameters
+      new(args, opts).call
+    end
 
-      argv = g_opts.parse_missing(argv)
+    attr :arguments
+    attr :options
 
-      call(cmd, argv, opts)
+    #
+
+    def call
+      puts "Not implemented yet."
     end
 
+  private
+
     #
 
-    def call(subcmd, argv, opts)
-      @options = opts  # should we use this it fill in instance vars?
+    def initialize(arguments, options=nil)
+      initialize_arguments(*arguments)
+      initialize_options(options)
+    end
 
-      # 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 "# call: #{subcmd}(*#{argv.inspect})" if $debug
-        __send__(subcmd, *argv)
-      else
-        begin
-          puts "# call: method_missing(#{subcmd.inspect}, #{argv.inspect})" if $debug
-          method_missing(subcmd.to_sym, *argv)
-        rescue NoMethodError => e
-          #if self.private_methods.include?( "no_command_error" )
-          #  no_command_error( *args )
-          #else
-            $stderr << "Unrecognized subcommand -- #{subcmd}\n"
-            exit -1
-          #end
+    #
+
+    def initialize_arguments(*arguments)
+      @arguments = arguments
+    end
+
+    #
+
+    def initialize_options(options)
+      options = options || {}
+      begin
+        opt, val = nil, nil
+        options.each do |opt, val|
+          send("#{opt}=", val)
         end
+      rescue NoMethodError
+        option_missing(opt, val)
       end
+      @options = options
     end
 
-    #def global_options
-    #  self.class.global_options
-    #end
+    #
 
     def option_missing(opt, arg=nil)
-      raise InvalidOptionError.new(opt)
+      raise NoOptionError.new(opt)
+    end
+
+  end
+
+end
+
+
+class Array
+
+  # Not empty?
+
+  def not_empty?
+    !empty?
+  end
+
+  # Convert an array into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+
+  def to_console
+    flags = (Hash===last ? pop : {})
+    flags = flags.to_console
+    flags + ' ' + join(" ")
+  end
+
+end
+
+
+class Hash
+
+  # Convert an array into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+
+  def to_console
+    flags = collect do |f,v|
+      m = f.to_s.size == 1 ? '-' : '--'
+      case v
+      when Array
+        v.collect{ |e| "#{m}#{f}='#{e}'" }.join(' ')
+      when true
+        "#{m}#{f}"
+      when false, nil
+        ''
+      else
+        "#{m}#{f}='#{v}'"
+      end
     end
+    flags.join(" ")
+  end
 
+  # Turn a hash into arguments.
+  #
+  #   h = { :list => [1,2], :base => "HI" }
+  #   h.argumentize #=> [ [], { :list => [1,2], :base => "HI" } ]
+  #   h.argumentize(:list) #=> [ [1,2], { :base => "HI" } ]
+  #
+  def argumentize(args_field=nil)
+    config = dup
+    if args_field
+      args = [config.delete(args_field)].flatten.compact
+    else
+      args = []
+    end
+    args << config
+    return args
   end
 
+end
+
+
+# SCRAP CODE FOR REFERENCE TO POSSIBLE ADD FUTURE FEATURES
+
 =begin
+
   # We include a module here so you can define your own help
   # command and call #super to utilize this one.
 
@@ -264,248 +405,12 @@ module Console
 
   include Help
   extend Help::ClassMethods
-=end
-
-
-  # = Command::Options
-  #
-  # CommandOptions provides the basis for Command to Object Mapping (COM).
-  # It is an commandline options parser that uses method definitions
-  # as means of interprting command arguments.
-  #
-  # == Synopsis
-  #
-  # Let's make an executable called 'mycmd'.
-  #
-  #   #!/usr/bin/env ruby
-  #
-  #   require 'facets/command_options'
-  #
-  #   class MyOptions < CommandOptions
-  #     attr_accessor :file
-  #
-  #     def v!
-  #       @verbose = true
-  #     end
-  #   end
-  #
-  #   opts = MyOptions.parse("-v --file hello.rb")
-  #
-  #   opts.verbose  #=> true
-  #   opts.file     #=> "hello.rb"
-  #
-  #--
-  # == 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.
-  #
-  # 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.
-
-  class Command::Options
-
-    def self.parse(*line_and_options)
-      o = new
-      o.parse(*line_and_options)
-      o
-    end
-
-    def initialize(delegate=nil)
-      @__self__ = delegate || self
-    end
-
-    # Parse line for options in the context self.
-    #
-    # Options:
-    #
-    #   :pass => true || false
-    #
-    # Setting this to true prevents the parse_missing routine from running.
-    #
-    #   :only => [ global options, ... ]
-    #
-    # When processing global options, we only want to parse selected options.
-    # This also set +pass+ to true.
-    #
-    #   :stop => true || false
-    #
-    # If we are parsing options for the *main* command and we are allowing
-    # subcommands, then we want to stop as soon as we get to the first non-option,
-    # because that non-option will be the name of our subcommand and all options that
-    # follow should be parsed later when we handle the subcommand.
-    # This also set +pass+ to true.
-
-    def parse(*line_and_options)
-      __self__ = @__self__
-
-      if Hash === line_and_options.last
-        options = line_and_options.pop
-        line    = line_and_options.first
-      else
-        options = {}
-        line    = line_and_options.first
-      end
 
-      case line
-      when String
-        argv = Shellwords.shellwords(line)
-      when Array
-        argv = line.dup
-      else
-        argv = ARGV.dup
-      end
-
-      only = options[:only]                      # only parse these options
-      stop = options[:stop]                      # stop at first non-option
-      pass = options[:pass] || only || stop      # don't run options_missing
-
-      if $debug
-        puts(only ? "\nGlobal parsing..." : "\nParsing...")
-      end
-
-      puts "# line: #{argv.inspect}" if $debug
-
-      # 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
-
-      index = 0
-
-      until index >= argv.size
-        arg = argv.at(index)
-        break if arg == '--'  # POSIX compliance
-        if arg[0,1] == '-'
-          puts "# option: #{arg}" if $debug
-          cnt = (arg[0,2] == '--' ? 2 : 1)
-          #opt  = Option.new(arg)
-          #name = opt.methodize
-          name = arg.sub(/^-{1,2}/,'')
-          skip = only && only.include?(name)
-          unam = ('__'*cnt)+name
-          if __self__.respond_to?(unam)
-            puts "# method: #{uname}" if $debug
-            meth = method(unam)
-            arity = meth.arity
-            if arity < 0
-              meth.call(*argv.slice(index+1..-1)) unless skip
-              arity[index..-1] = nil # Get rid of the *name* and values
-            elsif arity == 0
-              meth.call unless skip
-              argv.delete_at(index) # Get rid of the *name* of the option
-            else
-              meth.call(*argv.slice(index+1, arity)) unless skip
-              #argv.delete_at(index) # Get rid of the *name* of the option
-              #arity.times{ argv.delete_at(index) } # Get rid of the *value* of the option
-              arity[index,arity] = nil
-            end
-          elsif __self__.respond_to?(name+'=')
-            puts "# method: #{name}=" if $debug
-            __self__.send(name+'=', *argv.slice(index+1, 1)) unless skip
-            argv.delete_at(index) # Get rid of the *name* of the option
-            argv.delete_at(index) # Get rid of the *value* of the option
-          elsif __self__.respond_to?(name+'!')
-            puts "# method: #{name}!" if $debug
-            __self__.send(name+'!') unless skip
-            argv.delete_at(index) # Get rid of the *name* of the option
-          else
-             index += 1
-          end
-        else
-          index += 1
-          break if stop
-        end
-      end
-      # parse missing ?
-      argv = parse_missing(argv) unless pass
-      # return the remaining argv
-      puts "# return: #{argv.inspect}" if $debug
-      return argv
-    end
-
-    #
-
-    def parse_missing(argv)
-      argv.each_with_index do |a,i|
-        if a =~ /^-/
-          #raise InvalidOptionError.new(a) unless @__self__.respond_to?(:option_missing)
-          kept = @__self__.option_missing(a, *argv[i+1,1])
-          argv.delete_at(i) if kept  # delete if value kept
-          argv.delete_at(i)          # delete option
-        end
-      end
-      return argv
-    end
-
-    #
-
-    def option_missing(opt, arg=nil)
-      raise InvalidOptionError.new(opt)
-      #  #$stderr << "Unknown option '#{arg}'.\n"
-      #  #exit -1
-    end
-
-    #
-
-    def to_h
-      opts = @__self__.public_methods(true).select{ |m| m =~ /^[A-Za-z0-9]+[=!]$/ || m =~ /^[_][A-Za-z0-9]+$/ }
-      #opts.reject!{ |k| k =~ /_$/ }
-      opts.collect!{ |m| m.chomp('=').chomp('!') }
-      opts.inject({}) do |h, m|
-        k = m.sub(/^_+/, '')
-        v = @__self__.send(m)
-        h[k] = v if v
-        h
-      end
+=end
 
-      #@__self__.instance_variables.inject({}) do |h, v|
-      #  next h if v == "@__self__"
-      #  h[v[1..-1]] = @__self__.instance_variable_get(v); h
-      #end
-    end
+=begin
 
-    # Provides a very basic usage help string.
+   # Provides a very basic usage help string.
     #
     # TODO Add support for __options.
     def usage
@@ -559,48 +464,6 @@ module Console
       return c
     end
 
-#     # Single Option
-#
-#     class Option < String
-#
-#       def initialize(option)
-#         @flag = option
-#         @long = (/^--/ =~ option)
-#         super(option.sub(/^-{1,2}/,''))
-#       end
-#
-#       def long?
-#         @long
-#       end
-#
-#       def short?
-#         !@long
-#       end
-#
-#       #def demethodize
-#       #  sub('__','--').sub('_','-')
-#       #end
-#
-#       def methodize
-#         @flag.sub(/^-{1,2}/,'')
-#       end
-#
-#     end
-
-  end
-
-  # For CommandOptions, but defined external to it, so
-  # that it is easy to access from user defined commands.
-  # (This lookup issue should be fixed in Ruby 1.9+, and then
-  # the class can be moved back into Command namespace.)
-
-  class InvalidOptionError < StandardError
-    def initialize(option_name)
-      @option_name = option_name
-    end
-    def message
-      "Unknown option '#{@option_name}'."
-    end
   end
 
-end
+=end