facets 2.0.2 → 2.0.3

data/lib/core/facets/stackable.rb

@@ -27,7 +27,7 @@ module Stackable
     slice(0)
   end
 
-  alias :shift :pull
+  alias_method :shift, :pull
 
   #
 
@@ -35,7 +35,7 @@ module Stackable
     insert(0,x)
   end
 
-  alias :unshift :poke
+  alias_method :unshift, :poke
 
   #
 
@@ -44,3 +44,4 @@ module Stackable
   end
 
 end
+

data/lib/core/facets/string/format.rb

@@ -17,13 +17,12 @@
 #
 class String
 
-  # CREDIT George Moschovitis
-
   # Returns short abstract of long strings (first 'count'
   # characters, chopped at the nearest word, appended by '...')
   # force_cutoff: break forcibly at 'count' chars. Does not accept
   # count < 2
-
+  #
+  #   CREDIT George Moschovitis
   def brief(count = 128, force_cutoff = false, ellipsis="...")
     return nil if count < 2
 
@@ -148,9 +147,6 @@ class String
   #     return wrapped_string
   #   end
 
-  # CREDIT Gavin Kistner
-  # CREDIT Dayne Broderson
-
   # Word wrap a string not exceeding max width.
   #
   #   puts "this is a test".word_wrap(4)
@@ -161,6 +157,8 @@ class String
   #   is a
   #   test
   #
+  #   CREDIT Gavin Kistner
+  #   CREDIT Dayne Broderson
   def word_wrap( col_width=80 )
     self.dup.word_wrap!( col_width )
   end

data/lib/core/facets/string/tabs.rb

@@ -20,6 +20,32 @@ class String
     gsub(/^ */, ' ' * n)
   end
 
+  alias_method :taballto, :tab
+
+  # Expands tabs to +n+ spaces.  Non-destructive.  If +n+ is 0, then tabs are
+  # simply removed.  Raises an exception if +n+ is negative.
+  #
+  # Thanks to GGaramuno for a more efficient algorithm.  Very nice.
+  #
+  #   CREDIT Noah Gibbs
+  #   CREDIT Gavin Sinclair
+  #   CREDIT GGaramuno
+
+  def expand_tabs(n=8)
+    n = n.to_int
+    raise ArgumentError, "n must be >= 0" if n < 0
+    return gsub(/\t/, "") if n == 0
+    return gsub(/\t/, " ") if n == 1
+    str = self.dup
+    while
+      str.gsub!(/^([^\t\n]*)(\t+)/) { |f|
+        val = ( n * $2.size - ($1.size % n) )
+        $1 << (' ' * val)
+      }
+    end
+    str
+  end
+
   # Preserves relative tabbing.
   # The first non-empty line ends up with n spaces before nonspace.
 
@@ -42,6 +68,14 @@ class String
     end
   end
 
+  # Outdent just indents a negative number of spaces.
+  #
+  # CREDIT Noah Gibbs
+
+  def outdent(n)
+    indent(-n)
+  end
+
   # Provides a margin controlled string.
   #
   #   x = %Q{

data/lib/core/facets/symbol.rb

@@ -3,3 +3,4 @@ require 'facets/symbol/succ.rb'
 require 'facets/symbol/not.rb'
 require 'facets/symbol/generate.rb'
 require 'facets/symbol/chomp.rb'
+require 'facets/symbol/to_proc.rb'

data/lib/core/facets/symbol/succ.rb

@@ -1,21 +1,3 @@
-# TITLE:
-#
-#   Symbol Generation
-#
-# DESCRIPTION:
-#
-#    Symbol generation extensions.
-#
-# AUTHORS:
-#
-#   CREDIT Thomas Sawyer
-#
-# NOTES:
-#
-#   TODO Is Symbol#chomp worth having? Are the any other
-#        String methods that Symbols really should have too?
-
-#
 class Symbol
 
   # Successor method for symobol. This simply converts
@@ -26,7 +8,7 @@ class Symbol
   #
   #--
   # In the future I would like this to work more like
-  # a simple chracerter dial.
+  # a simple character dial.
   #++
 
   def succ
@@ -35,26 +17,3 @@ class Symbol
 
 end
 
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestSymbol < Test::Unit::TestCase
-
-    def test_succ
-      assert_equal( :b, :a.succ )
-      assert_equal( :aab, :aaa.succ )
-      assert_equal( :"2", :"1".succ )
-    end
-
-  end
-
-=end
-

data/lib/core/facets/symbol/to_proc.rb

@@ -0,0 +1,34 @@
+class Symbol
+
+  # Turn a symbol into a proc calling the method to
+  # which it refers.
+  #
+  #   up = :upcase.to_proc
+  #   up.call("hello")  #=> HELLO
+  #
+  # More useful is the fact that this allows <tt>&</tt>
+  # to be used to coerce Symbol into Proc. 
+  #
+  #   %w{foo bar qux}.map(&:upcase)   #=> ["FOO","BAR","QUX"]
+  #   [1, 2, 3].inject(&:+)           #=> 6
+  #
+  # And other conveniences such as:
+  #
+  #   %{john terry fiona}.map(&:capitalize)   # -> %{John Terry Fiona}
+  #   sum = numbers.inject(&:+)
+  #
+  # TODO This will be deprecated as of Ruby 1.9, since it will become standard Ruby.
+  #
+  #   CREDIT Florian Gross (orignal)
+  #   CREDIT Nobuhiro Imai (current)
+
+  def to_proc
+    Proc.new{|*args| args.shift.__send__(self, *args)}
+  end
+
+  #def to_proc
+  #  proc { |obj, *args| obj.send(self, *args) }
+  #end
+
+end
+

data/lib/methods/facets/array/contains.rb

@@ -0,0 +1 @@
+require 'facets/array/indexable.rb'

data/lib/methods/facets/facets/require_core.rb

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

data/lib/methods/facets/file/writelines.rb

@@ -0,0 +1 @@
+require 'facets/file/write.rb'

data/lib/methods/facets/io/writelines.rb

@@ -0,0 +1 @@
+require 'facets/io/write.rb'

data/lib/methods/facets/kernel/not_nil.rb

@@ -0,0 +1 @@
+require 'facets/kernel/val.rb'

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

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

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

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

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

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

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

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

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

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

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

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

data/lib/methods/facets/string/expand_tabs.rb

@@ -0,0 +1 @@
+require 'facets/string/tabs.rb'

data/lib/methods/facets/string/outdent.rb

@@ -0,0 +1 @@
+require 'facets/string/tabs.rb'

data/lib/methods/facets/string/taballto.rb

@@ -0,0 +1 @@
+require 'facets/string/tabs.rb'

data/lib/more/facets/arguments.rb

@@ -78,7 +78,7 @@ class Console::Arguments
     @options
   end
 
-  # Returns [operands, ottions], which is good for plugging
+  # Returns [operands, options], which is good for plugging
   # directly into a method.
 
   def parameters

data/lib/more/facets/association.rb

@@ -155,49 +155,3 @@ end
 #   remove_method :>>
 # end
 #++
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TC01 < Test::Unit::TestCase
-
-    def setup
-      @complex_hierarchy = [
-        'parent' >> 'child',
-        'childless',
-        'another_parent' >> [
-          'subchildless',
-          'subparent' >> 'subchild'
-        ]
-      ]
-    end
-
-    def test_ohash
-      k,v = [],[]
-      ohash = [ 'A' >> '3', 'B' >> '2', 'C' >> '1' ]
-      ohash.each { |e1,e2| k << e1 ; v << e2 }
-      assert_equal( ['A','B','C'], k )
-      assert_equal( ['3','2','1'], v )
-    end
-
-    def test_complex
-      complex = [ 'Drop Menu' >> [ 'Button 1', 'Button 2', 'Button 3' ], 'Help' ]
-      assert_equal( 'Drop Menu', complex[0].index )
-    end
-
-    def test_associations
-      complex = [ :a >> :b, :a >> :c ]
-      assert_equal( [ :b, :c ], :a.associations )
-    end
-
-  end
-
-=end

data/lib/more/facets/autoarray.rb

@@ -57,31 +57,3 @@ class Autoarray < Array
   end
 
 end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin test
-
-  require 'test/unit'
-
-  class TC_Autoarray
-
-    def test_001
-      a = Autoarray.new
-      assert_equal( 12, a[1][2][3] = 12 )
-      assert_equal( [nil, [nil, nil, [nil, nil, nil, 12]]], a )
-      assert_equal( [], a[2][3][4] )
-      assert_equal( [nil, [nil, nil, [nil, nil, nil, 12]]], a )
-      assert_equal( "Negative", a[1][-2][1] = "Negative" )
-      assert_equal( [nil, [nil, [nil, "Negative"], [nil, nil, nil, 12]]], a )
-    end
-
-  end
-
-=end

data/lib/more/facets/command.rb

@@ -19,15 +19,21 @@
 #   PURPOSE.
 #
 # AUTHORS:
-#   - Thomas Sawyer
+#
+#   - 7rans
 #   - Tyler Rick
 #
 # TODOs:
+#
 #   - Add help/documentation features.
-#   - Problem wiht exit -1 when testing. See IMPORTANT!!! remark below.
+#   - Problem with exit -1 when testing. See IMPORTANT!!! remark below.
+#
+# LOG:
+#
+#   - 2007.10.31 TRANS
+#     Re-added support for __option notation.
 
 require 'shellwords'
-require 'facets/command_options'
 #require 'facets/annotations' # for help ?
 
 module Console
@@ -72,10 +78,10 @@ module Console
     module Syntax
 
       # Starts the command execution.
-      def execute( *args )
+      def execute(*args)
         cmd = new()
         #cmd.instance_variable_set("@global_options",global_options)
-        cmd.execute( *args )
+        cmd.execute(*args)
       end
       alias_method :start, :execute
 
@@ -90,7 +96,7 @@ module Console
       def options(name, klass=nil, &block)
         raise ArgumentError if klass && block
         if block
-          command_options[name.to_sym] = Class.new(CommandOptions, &block)
+          command_options[name.to_sym] = Class.new(Options, &block)
         else
           command_options[name.to_sym] = klass
         end
@@ -119,10 +125,10 @@ module Console
 
     #
 
-    def execute(line)
+    def execute(line=ARGV)
       argv = line
 
-      g_opts = CommandOptions.new(self)
+      g_opts = Command::Options.new(self)
       g_keys = self.class.global_options
 
       # Deal with global options.
@@ -259,4 +265,331 @@ module Console
   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
+      #writers = public_methods.sellect{ |m| m =~ /=$/ }
+      instance_variables.inject({}) do |h, v|
+        h[v[1,-1]] = instance_variable_get(v); h
+      end
+    end
+
+    # Provides a very basic usage help string.
+    #
+    # TODO Add support for __options.
+    def usage
+      str = []
+      public_methods(false).sort.each do |meth|
+        meth = meth.to_s
+        case meth
+        when /^_/
+          opt = meth.sub(/^_+/, '')
+          meth = method(meth)
+          if meth.arity == 0
+            str << (opt.size > 1 ? "[--#{opt}]" : "[-#{opt}]")
+          elsif meth.arity == 1
+            str << (opt.size > 1 ? "[--#{opt} value]" : "[-#{opt} value]")
+          elsif meth.arity > 0
+            v = []; meth.arity.times{ |i| v << 'value' + (i + 1).to_s }
+            str << (opt.size > 1 ? "[--#{opt} #{v.join(' ')}]" : "[-#{opt} #{v.join(' ')}]")
+          else
+            str << (opt.size > 1 ? "[--#{opt} *values]" : "[-#{opt} *values]")
+          end
+        when /=$/
+          opt = meth.chomp('=')
+          str << (opt.size > 1 ? "[--#{opt} value]" : "[-#{opt} value]")
+        when /!$/
+          opt = meth.chomp('!')
+          str << (opt.size > 1 ? "[--#{opt}]" : "[-#{opt}]")
+        end
+      end
+      return str.join(" ")
+    end
+
+    #
+
+    def self.usage_class(usage)
+      c = Class.new(self)
+      argv = Shellwords.shellwords(usage)
+      argv.each_with_index do |name, i|
+        if name =~ /^-/
+          if argv[i+1] =~ /^[(.*?)]/
+            c.class_eval %{
+              attr_accessor :#{name}
+            }
+          else
+            c.class_eval %{
+              attr_reader :#{name}
+              def #{name}! ; @#{name} = true ; end
+            }
+          end
+        end
+      end
+      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