facets 1.8.20 → 1.8.49

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

@@ -1,2 +1,2 @@
 # stub
-require 'facet/string/upcase'
+require 'facets/core/string/upcase'

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

@@ -1,4 +1,4 @@
-require 'facet/string/blank'
+require 'facets/core/string/blank'
 
 class String
   alias_method :whitespace?, :blank?

data/lib/facets/core/string_as_array.rb

@@ -8,9 +8,10 @@
 #   "123".pop # => "12"
 #
 
-require 'facet/string/at'
-require 'facet/string/pop'
-require 'facet/string/push'
-require 'facet/string/shift'
-require 'facet/string/unshift'  # I hate this name
-require 'facet/string/slap'     # alias for it (better name?)
+require 'facets/core/string/at'
+require 'facets/core/string/pop'
+require 'facets/core/string/push'
+require 'facets/core/string/shift'
+require 'facets/core/string/unshift'  # I hate this name
+require 'facets/core/string/pot'      # here's an alias for it
+

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

@@ -1,5 +1,5 @@
 
-require 'facet/string/camelcase'
+require 'facets/core/string/camelcase'
 
 class Symbol
 

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

@@ -1,5 +1,5 @@
 
-require 'facet/string/camelize'
+require 'facets/core/string/camelize'
 
 class Symbol
 

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

@@ -1,5 +1,5 @@
 
-require 'facet/symbol/capitalized'
+require 'facets/core/symbol/capitalized'
 
 class Symbol
 

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

@@ -1,6 +1,6 @@
 
-require 'facet/string/capitalized'
-require 'facet/symbol/capitalize'
+require 'facets/core/string/capitalized'
+require 'facets/core/symbol/capitalize'
 
 class Symbol
 

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

@@ -1,5 +1,5 @@
 
-require 'facet/string/downcase'
+require 'facets/core/string/downcase'
 
 class Symbol
 

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

@@ -1,4 +1,4 @@
-require 'facet/string/to_const'
+require 'facets/core/string/to_const'
 
 class Symbol
 

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

@@ -1,5 +1,5 @@
 
-require 'facet/string/underscore'
+require 'facets/core/string/underscore'
 
 class Symbol
 

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

@@ -1,5 +1,5 @@
 
-require 'facet/string/upcase'
+require 'facets/core/string/upcase'
 
 class Symbol
 

data/lib/facets/core/time/self/stamp.rb

@@ -1,2 +1,2 @@
 # stub
-require 'facet/time/stamp'
+require 'facets/core/time/stamp'

data/lib/facets/core/time/to_s.rb

@@ -1,4 +1,4 @@
-require 'facet/time/stamp'
+require 'facets/core/time/stamp'
 
 class Time
   # Enhance #to_s by aliasing to #stamp.

data/lib/facets/more/arguments.rb

@@ -21,6 +21,8 @@
 #   TODO Move to console/arguments.rb, but I'm not sure yet
 #        if adding subdirectories to more/ is a good idea.
 
+# CREDIT Thomas Sawyer
+
 # Author::    Thomas Sawyer
 # Copyright:: Copyright (c) 2005 Thomas Sawyer
 # License::   Ruby License
@@ -43,16 +45,22 @@ class Console::Arguments
 
   attr :line
   attr :argv
+  attr :opts
+  attr :arity
 
-  def initialize( line=nil )
+  def initialize( line=nil, *opts_arity )
     @line, @argv = parse_line(line)
 
+    @opts, @arity = clean(*opts_arity)
+
     # caches
-    @words    = Hash.new #{|h,k| h[k]=[]}
-    @flags    = Hash.new #{|h,k| h[k]=[]}
-    @preflags = Hash.new #{|h,k| h[k]=[]}
+    #@words    = Hash.new #{|h,k| h[k]=[]}
+    #@flags    = Hash.new #{|h,k| h[k]=[]}
+    #@preflags = Hash.new #{|h,k| h[k]=[]}
   end
 
+  private
+
   # First pass parser to split the command line into an
   # array using Shellwords, if not already so divided.
 
@@ -71,7 +79,8 @@ class Console::Arguments
     end
     return line, argv
   end
-  private :parse_line
+
+  public
 
   # Parse off the front flags of a command line.
   #
@@ -93,11 +102,11 @@ class Console::Arguments
   #   keys #=> [["level", 4]]
   #
 
-  def preflags( *opts_arity )
-    opts, arity  = clean(*opts_arity)
+  def preflags #( *opts_arity )
+    #opts, arity  = clean(*opts_arity)
 
-    @preflags[opts] ||= (
-      preflags, args = *parse_preflags(argv, *opts_arity)
+    @preflags ||= (
+      preflags, args = *parse_preflags(argv) #, *opts_arity)
       preflags
     )
   end
@@ -105,11 +114,11 @@ class Console::Arguments
   # Like preflags but will remove preflags from
   # the argumuments array (argv).
 
-  def preflags!( *opts_arity )
-    opts, arity  = clean(*opts_arity)
+  def preflags! #( *opts_arity )
+    #opts, arity  = clean(*opts_arity)
 
-    @preflags[opts] ||= (
-      preflags, args = *parse_preflags(argv, *opts_arity)
+    @preflags ||= (
+      preflags, args = *parse_preflags(argv) #, *opts_arity)
       @argv = args
       preflags
     )
@@ -118,30 +127,39 @@ class Console::Arguments
   #
 
   def words( *opts_arity )
-    opts, arity  = clean(*opts_arity)
+    #opts, arity  = clean(*opts_arity)
 
-    @words[opts] ||= (
-      parse( opts, arity )
-      @words[opts]
+    @words ||= (
+      parse #( opts, arity )
+      @words
     )
   end
 
   #
 
   def flags( *opts_arity )
-    opts, arity  = clean(*opts_arity)
+    #opts, arity  = clean(*opts_arity)
 
-    @flags[opts] ||= (
-      parse( opts, arity )
-      @flags[opts]
+    @flags ||= (
+      parse #( opts, arity )
+      @flags
     )
   end
 
-  # Basic parser.
-  #
-  # Partitions the command line into flags and arguments.
-  # Flags are converted to a associative array and then the
-  # two parts are returned.
+  # Returns the parsed command line as an array + hash collection
+  # of parameters, like what a Ruby method accepts. Because of the
+  # use of the hash for flags and options parameters, repeat entries
+  # can be used with this, in that case use #parse directly.
+
+  def parameters
+    args, keys = parse
+    args.flatten << keys unless keys.empty?
+    return *args
+  end
+
+  # Basic parser partitions the command line into flags and
+  # arguments. Flags are converted to a associative array
+  # and then the two parts are returned.
   #
   #   line = "--trace stamp --file=VERSION"
   #
@@ -151,17 +169,17 @@ class Console::Arguments
   #   keys #=> [["trace",true], ["file","VERSION"]]
   #
 
-  def parse( *opts_arity )
-    opts, arity  = clean(*opts_arity)
+  def parse #( *opts_arity )
+    #opts, arity  = clean(*opts_arity)
 
-    args = associate_flags(argv, *opts_arity)
+    args = associate_flags(argv) #, *opts_arity)
 
     flags, words = args.partition{ |a| Array === a }
 
     flags = format_flags(flags) unless opts.include?(:repeat)
 
-    @words[opts] = words
-    @flags[opts] = flags
+    @words = words
+    @flags = flags
 
     return words, flags
   end
@@ -178,10 +196,10 @@ class Console::Arguments
   # the chain could have it's own arity settings. So '=' must be
   # used to set a flag parameter.
 
-  def multicommand( *opts_arity )
-    opts, arity  = clean(*opts_arity)
+  def multi_command #( *opts_arity )
+    #opts, arity  = clean(*opts_arity)
 
-    pflags = preflags(*opts_arity)
+    pflags = preflags #(*opts_arity)
 
     args = argv.dup
     args = multi_flag(args) unless opts.include?(:simple)
@@ -201,7 +219,7 @@ class Console::Arguments
         i = -1
         subopts = args[0..-1]
       end
-      keys = format_flags(associate_flags(subopts, *opts_arity))
+      keys = format_flags(associate_flags(subopts)) #, *opts_arity))
       cmds << [cmd, keys]
     end
 
@@ -300,8 +318,8 @@ class Console::Arguments
   #   parse_flags(line) #=> [ [foo,true], hello, ["try","this"] ]
   #
 
-  def associate_flags( args, *opts_arity )
-    opts, arity  = clean(*opts_arity)
+  def associate_flags( args ) #, *opts_arity )
+    #opts, arity  = clean(*opts_arity)
 
     args = args.dup
     args = multi_flag(args) unless opts.include?(:simple)
@@ -425,8 +443,8 @@ end
 
     def test_repeat
       line = "-x baz --foo=9 bar"
-      cargs = Arguments.new(line)
-      args, keys = cargs.parse(:repeat)
+      cargs = Arguments.new(line, :repeat)
+      args, keys = cargs.parse
       assert_equal(['baz','bar'],args)
       assert_equal([['x',true],['foo','9']],keys)
     end
@@ -450,10 +468,10 @@ end
       assert_equal({'foo'=>'7'},keys)
     end
 
-    def test_multicommand
+    def test_multi_command
       line = "-x baz --foo=6 bar --zoo='xx'"
       cargs = Arguments.new(line)
-      cmds, preflags = cargs.multicommand
+      cmds, preflags = cargs.multi_command
 
       assert_equal({'x'=>true},preflags)
 
@@ -468,8 +486,8 @@ end
 
     def test_with_arity
       line = "-q baz --aq 5 bar"
-      cargs = Arguments.new(line)
-      words, flags = cargs.parse('aq'=>1)
+      cargs = Arguments.new(line,'aq'=>1)
+      words, flags = cargs.parse
       assert_equal(['baz','bar'],words)
       assert_equal({'q'=>true,'aq'=>'5'},flags)
     end

data/lib/facets/more/buildingblock.rb

@@ -15,6 +15,8 @@
 #
 # * Thomas Sawyer
 
+# CREDIT Thomas Sawyer
+
 # Author::    Thomas Sawyer
 # Copyright:: Copyright (c) 2007 Thomas Sawyer
 # License::   Ruby License
@@ -26,22 +28,20 @@
 #   require 'facets'
 #   require 'xmlhelper'
 #
-#   build = BuildingBlocks.new(XMLHelper, :element)
-#
-#       doc = build.html do
+#   builder = BuildingBlocks.new(XMLHelper, :element)
 #
-#           head do
-#               title "Test"
-#           end
+#   doc = builder.html do
 #
-#           body do
-#               i "Hello"
-#               br
-#               _text "Test"
-#               _text "Hey"
-#           end
+#     head do
+#       title "Test"
+#     end
 #
-#       end
+#     body do
+#       i "Hello"
+#       br
+#       text "Test"
+#       text "Hey"
+#     end
 #
 #   end
 #
@@ -49,28 +49,43 @@
 #
 #   <html><head><title>Test</title><body><i>Hello</i><br />TestHey</body></html>
 #
-# All calls within the block are routed to the Helper Module's constructor method,
-# unless preceeded by an underscore, in which case they are passed to Helper Module.
+# All calls within the block are routed via the Helper Module's constructor method
+# (#element in the above example) unless they are defined by the helper module, in which
+# case they are sent to the helper module directly. The results of these invocations are
+# appended to the output buffer. To prevent this, prefix the method with 'call_'.
 #
 # Sometimes keywords can get in the way of a construction. In these cases you can
-# ensure use of constructor method by suffixing an underscore '_' to the call.
-# All of Ruby's built-in keywords (eg. 'while', 'if', 'until', etc.) and the following
-# methods are treated as keywords.
+# ensure use of constructor method by calling the special #build! command. You can
+# also add verbatium text to the output via the #<< operator. All of Ruby's built-in
+# keywords (eg. 'while', 'if', 'until', etc.) and the following methods are treated as
+# keywords.
 #
-#      singleton_method_undefined
 #      method_missing
 #      initialize
 #      inspect
 #      to_str
 #      to_s
 #      respond_to?
+#      singleton_method_undefined
 #
 # This work was of course inspired by many great minds, and represents a concise and simple
 # means of accomplishing this pattern of design, which is unique to Ruby.
 
 class BuildingBlock
 
-  def initialize(helper_module, constructor_method)
+  ESCAPE = [
+    'singleton_method_undefined',
+    'method_missing',
+    'respond_to?',
+    'initialize',
+    'inspect',
+    'to_str',
+    'to_s',
+    '<<',
+    'build!'
+  ] # 'to_ary', 'p' ]
+
+  def initialize(helper_module, constructor_method, output_buffer=nil)
     @module = helper_module
     @constructor = constructor_method
     @instance_eval = method(:instance_eval)
@@ -78,7 +93,7 @@ class BuildingBlock
     @method = {}
 
     meths = []
-    meths.concat singleton_methods
+    #meths.concat singleton_methods
     meths.concat public_methods
     meths.concat protected_methods
     meths.concat private_methods
@@ -87,18 +102,9 @@ class BuildingBlock
     end
 
     class << self
-      escape = []
-      #escape << 'p'
-      escape << 'singleton_method_undefined'
-      escape << 'method_missing'
-      escape << 'initialize'
-      escape << 'inspect'
-      escape << 'to_str'
-      escape << 'to_s'
-      #escape << 'to_ary'
-      escape << 'respond_to?'
+      escape = ESCAPE
       meths = []
-      meths.concat singleton_methods
+      #meths.concat singleton_methods
       meths.concat public_instance_methods
       meths.concat protected_instance_methods
       meths.concat private_instance_methods
@@ -108,36 +114,44 @@ class BuildingBlock
     end
 
     @stack = []
-    @out = ''
+    @out = output_buffer || ''
   end
 
-  def method_missing(o, *a, &b)
-    o = o.to_s
+  def method_missing(s, *a, &b)
+    s = s.to_s
 
     if b
       @stack << @out
       @out = ''
       @instance_eval.call(&b)
-      s = @out
+      out = @out
       @out = @stack.pop
-      a.unshift(s)
+      a.unshift(out)
     end
 
-    if o[-1,1] == '_'
-      m = o[0..-2].to_sym
-      @out << @module.send(@constructor, m, *a).to_s
-    elsif o[0,1] == '_'
-      m = o[1..-1].to_sym
-      @out << @module.send(m, *a, &b).to_s
+    if s =~ /^call_/
+      m = s[5..-1].to_sym
+      @module.send(m, *a, &b).to_s
+    elsif @module.respond_to?(s) #o =~ /^build_/
+      @out << @module.send(s, *a, &b).to_s
     else
-      o = o.chomp('?') if o[-1,1] == '?'
-      @out << @module.send(@constructor, o, *a).to_s
+      s = s.chomp('?') if s[-1,1] == '?'
+      @out << @module.send(@constructor, s, *a).to_s
     end
   end
 
   def to_s() @out end
   def to_str() @out end
 
+  def <<(s)
+    @out << s.to_s
+  end
+
+  # If creating and XML/HTML builder, you'll want to alias this to tag!.
+  def build!(m, *a)
+    @out << @module.send(@constructor, m, *a).to_s
+  end
+
   # Could improve.
 
   def inspect
@@ -149,6 +163,7 @@ class BuildingBlock
 end
 
 
+
 #  _____         _
 # |_   _|__  ___| |_
 #   | |/ _ \/ __| __|
@@ -157,6 +172,7 @@ end
 #
 
 =begin test
+  require 'test/unit'
 
   class TestBuildingBlock < Test::Unit::TestCase
 
@@ -176,9 +192,9 @@ end
 
         body do
           i "Hello"
-          not_
-          _t "Test"
-          _t "Hey"
+          build! :not
+          t "Test"
+          t "Hey"
         end
       end