facets 0.6.3

data/lib/facet/string/to_const.rb

@@ -0,0 +1,16 @@
+require 'facet/symbol/to_const'
+class String
+  # Get a constant by a given string name.
+  #
+  #   require 'facet/string/to_const'
+  #
+  #   "Class".to_const   #=> Class
+  #
+  # Note this method is not as verstile as it should be,
+  # since it can not access contants relative to the current 
+  # execution context. But without a binding_of_caller that
+  # does not seem possible.
+  def to_const
+    split('::').inject(Object){ |namespace,name| namespace.const_get(name) }
+  end
+end

data/lib/facet/string/to_proc.rb

@@ -0,0 +1,25 @@
+class String
+  # Evaluates a String as a Proc.
+  #
+  #   require 'facet/string/to_proc'
+  #
+  #   xyp = "|x,y| x + y".to_proc
+  #   xyp.class      #=> Proc
+  #   xyp.call(1,2)  #=> 3
+  #
+  #--
+  # Note: Sure would be nice if this could
+  # grab the caller's context!
+  #++
+  def to_proc(context=nil)
+    if context
+      if context.kind_of?(Binding) or context.kind_of?(Proc)
+        Kernel.eval "proc { #{self} }", context
+      else context
+        context.instance_eval "proc { #{self} }"
+      end
+    else
+      Kernel.eval "proc { #{self} }"
+    end
+  end
+end

data/lib/facet/string/to_re.rb

@@ -0,0 +1,13 @@
+class String
+  # Turns a string into a regular expression.
+  # By default it will escape all characters.
+  # Use <tt>false</tt> argument to turn off escaping.
+  #
+  #   require 'facet/string/to_re'
+  #
+  #   "[".to_re  #=> /\[/
+  #
+  def to_re(esc=true)
+    Regexp.new((esc ? Regexp.escape(self) : self))
+  end
+end

data/lib/facet/string/unix_crypt.rb

@@ -0,0 +1,12 @@
+require 'facet/string/rand_letter'
+class String
+  # Common Unix cryptography method.
+  def unix_crypt
+    self.crypt(String.rand_letter + String.rand_letter)
+  end
+  # Common Unix cryptography in-place method.
+  def unix_crypt!
+    self.replace(unix_crypt)
+  end
+end
+

data/lib/facet/string/unpack.rb

@@ -0,0 +1,15 @@
+class String
+  alias_method( :unpack_from_orgin, :unpack )
+  # Upack with offset. Extends #unpack to allow a string 
+  # to be unpacked starting at an offset position within it.
+  #
+  #   require 'facet/string/unpack'
+  #
+  def unpack(format, offset=nil)
+    if offset.nil?
+      unpack_from_orgin(format)
+    else
+      self[offset..-1].unpack_from_orgin(format)
+    end
+  end
+end

data/lib/facet/string/word_filter!.rb

@@ -0,0 +1,20 @@
+class String
+  # In place word filter.
+  #
+  #   require 'facet/string/word_filter!'
+  #
+  #   "a string".word_filter! { |word| ... }
+  #
+  def word_filter! #:yield:
+    rest_of_string = self
+    wordfind = /(\w+)/
+    offset = 0
+    while wmatch = wordfind.match(rest_of_string)
+      word = wmatch[0]
+      range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
+      rest_of_string = wmatch.post_match
+      self[range] = yield( word )
+      offset = self.length - rest_of_string.length
+    end
+  end
+end

data/lib/facet/string/word_wrap.rb

@@ -0,0 +1,43 @@
+class String
+  # Word wrap a string not exceeding max width.
+  #
+  #   require 'facet/string/word_wrap'
+  #
+  #   puts "this is a test".word_wrap(4)
+  #
+  # _produces_
+  #
+  #   this
+  #   is a
+  #   test
+  #
+  def word_wrap(max=80)
+    c = dup
+    c.word_wrap!(max)
+    c
+  end
+  
+  # Like #word_wrap, but modifies the string in place.
+  def word_wrap!(max=80)
+    raise ArgumentError, "Wrap margin too low: #{n}" if max <= 2
+    #gsub!( Regexp.new( "(.{1,#{max-1}}\\w)\\b\\s*" ), "\\1\n")
+    gsub!( /(.{1,#{max-1}}\S)([ ]|\n)/, "\\1\n")
+  end
+end
+
+
+=begin
+# --- dev test ---
+
+if $0 == __FILE__
+
+s = "PackMule is a rake front-end thisisaverylongwordtoseeifgetsdivededornot"
+s << " tool that makes it easy to 'pack-out' your Ruby packages. PackMule can run tests, build"
+s << " .tgz and .zip packages, create gem packages, perform a manual"
+s << " install, generate rdocs and publish them, and CVS support"
+s << " might be added soon."
+
+puts s.word_wrap(60)
+
+end
+=end

data/lib/facet/symbol.rb

@@ -0,0 +1,14 @@
+
+# base
+require 'facet/symbol/~'
+
+# common
+require 'facet/symbol/gen'
+require 'facet/symbol/to_proc'
+
+# uncommon
+#require 'facet/symbol/pad'
+#require 'facet/symbol/camelcase'
+#require 'facet/symbol/to_str'
+#require 'facet/symbol/succ'
+#require 'facet/symbol/pad'

data/lib/facet/symbol/camelcase.rb

@@ -0,0 +1,24 @@
+class Symbol
+  # Converts a symbol to camelcase. By default capitalization
+  # occurs on whitespace and underscores. By setting the first
+  # parameter to <tt>true</tt> the first character can also be
+  # captizlized. The second parameter can be assigned a valid
+  # Regualr Expression characeter set to determine which 
+  # characters to match for capitalizing subsequent parts of
+  # the string.
+  #
+  #   require 'facet/string/camelcase'
+  #
+  #   "this_is a test".camelCase              #=> "ThisIsATest"
+  #   "this_is a test".camelCase(false)       #=> "thisIsATest"
+  #   "this_is a test".camelCase(false, ' ')  #=> "This_isATest"
+  #
+  def camelcase(first=false, on='_\s')
+    if first
+      (to_s.gsub(/(^|[#{on}]+)([A-Za-z])/){ $2.upcase }).to_sym
+    else
+      (to_s.gsub(/([#{on}]+)([A-Za-z])/){ $2.upcase }).to_sym
+    end
+  end
+  alias_method( :camelCase, :camelcase )
+end 

data/lib/facet/symbol/gen.rb

@@ -0,0 +1,23 @@
+class Symbol
+  # Generates a new symbol that is unique among the 
+  # method names of a given class or object. If no
+  # parameter is given then Object class is assumed.
+  #
+  #   require 'facet/symbol/gen'
+  #
+  #   :class.gen => :clast
+  #
+  def gen( obj=nil )
+    s = self.to_s
+    if Class === obj
+      while klass.method_defined?( s )
+        s = s.succ
+      end
+    else
+      while obj.respond_to?( s )
+        s = s.succ
+      end
+    end
+    return s.to_sym
+  end
+end 

data/lib/facet/symbol/pad.rb

@@ -0,0 +1,20 @@
+class Symbol
+  # Easily manipulate undercores on symbols.
+  #
+  #   require 'facet/symbol/pad'
+  #
+  #   :a.pad(2)         #=> :__a__
+  #   :__a__.pad(-1)    #=> :_a_
+  #
+  def pad(i=1)
+    return self if i == 0
+    s = self.to_s
+    if i > 0
+      return ( ('_'*i) + self.to_s + ('_'*i) ).to_sym
+    else
+      i *= -1
+      return s[i..-i-1].to_sym if s[0..i-1] == ('_'*i) and s[-i..-1] == ('_'*i)
+      return self
+    end
+  end
+end

data/lib/facet/symbol/succ.rb

@@ -0,0 +1,17 @@
+class Symbol
+  # Successor method for symobol. This simply converts
+  # the symbol to a string uses String#succ and then
+  # converts it back to a symbol.
+  #
+  #   require 'facet/symbol/succ'
+  #
+  #   :a.succ => :b
+  #
+  #--
+  # In the future I would like this to work more like
+  # a simple dial.
+  #++
+  def succ
+    self.to_s.succ.intern
+  end
+end

data/lib/facet/symbol/to_const.rb

@@ -0,0 +1,16 @@
+require 'facet/string/to_const'
+class Symbol
+  # Get a constant by a given symbol name.
+  #
+  #   require 'facet/symbol/to_const'
+  #
+  #   :Class.to_const   #=> Class
+  #
+  # Note this method is not as verstile as it should be,
+  # since it can not access contants relative to the current 
+  # execution context. But without a binding_of_caller that
+  # does not seem possible.
+  def to_const
+    to_s.to_const
+  end
+end

data/lib/facet/symbol/to_proc.rb

@@ -0,0 +1,22 @@
+#--
+# Credit goes to Florian Gross (flgr).
+#++
+class Symbol
+  # Turn a symbol into a proc calling the method to
+  # which it refers.
+  #
+  #   require 'facet/symbol/to_proc'
+  #
+  #   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
+  #
+  def to_proc
+    proc { |obj, *args| obj.send(self, *args) }
+  end
+end

data/lib/facet/symbol/to_str.rb

@@ -0,0 +1,12 @@
+class Symbol
+  # Symbol's really are just simplified strings.
+  # Thus #to_str seems quite reasonable.
+  # This uses the Kernal#String method.
+  #--
+  # Maybe just change to #to_s?
+  # BTW: This would be lots faster, I bet, if implemented in core.
+  #++
+  def to_str
+    String( self )
+  end
+end

data/lib/facet/symbol/~.rb

@@ -0,0 +1,8 @@
+class Symbol
+  def ~@
+    return :"~#{self}"
+  end
+  def not?
+    self.to_s[0,1] == '~'
+  end
+end

data/lib/facet/time.rb

@@ -0,0 +1,7 @@
+
+# base
+
+# common
+
+# uncommon
+#require 'facet/time/custom_format'

data/lib/facet/time/custom_format.rb

@@ -0,0 +1,111 @@
+require 'time'  # requires time extension
+
+class Time
+
+  MONTH_NAMES = %w| January February March April May June July August September October November December |
+  DAY_NAMES   = %w| Sunday Monday Tuesday Wednesday Thursday Friday Saturday |
+
+  # Replaces every token in _formatString_ with its corresponding value. See the table below.
+  #
+  #    token:     description:             example:
+  #    #YYYY#     4-digit year             2004
+  #    #YY#       2-digit year             04
+  #    #MMMM#     full month name          February
+  #    #MMM#      3-letter month name      Feb
+  #    #MM#       2-digit month number     02
+  #    #M#        month number             2
+  #    #DDDD#     full weekday name        Wednesday
+  #    #DDD#      3-letter weekday name    Wed
+  #    #DD#       2-digit day number       09
+  #    #D#        day number               9
+  #    #th#       day ordinal suffix       nd
+  #    #hhh#      military/24-based hour   17
+  #    #hh#       2-digit hour             05
+  #    #h#        hour                     5
+  #    #mm#       2-digit minute           07
+  #    #m#        minute                   7
+  #    #ss#       2-digit second           09
+  #    #s#        second                   9
+  #    #ampm#     "am" or "pm"             pm
+  #    #AMPM#     "AM" or "PM"             PM
+  #
+  # Non-tokens are left untouched in the output string.
+  #
+  #   require 'facet/time/custom_format'
+  #
+  #   time = Time.parse('2/3/2004 15:37')
+  #   time.custom_format('#DDDD#, #MMMM# #D##th# @ #h#:#mm##ampm#')
+  #      #=>  'Tuesday, February 3rd @ 3:37pm'
+  #   time.custom_format('#YYYY#-#MMM#-#D#')
+  #      #=>  '2004-Feb-3'
+  #   time.custom_format('#MM#/#DD#/#YY#')
+  #      #=>  '02/03/04'
+  #
+  def custom_format(formatString)
+    zYY   = (zYYYY=self.year.to_s)[-2..-1]
+    zMM   = (zM=self.mon)<10 ? ('0'+zM.to_s) : zM.to_s
+    zMMM  = (zMMMM=MONTH_NAMES[zM-1])[0...3]
+    zDD   = (zD=self.day)<10 ? ('0'+zD.to_s) : zD.to_s
+    zDDD  = (zDDDD=DAY_NAMES[wday])[0...3]
+    zth   = (zD>=10&&zD<=20) ? 'th' : ((dMod=zD%10)==1) ? 'st' : (dMod==2) ? 'nd' : (dMod==3) ? 'rd' : 'th'
+  
+    zh    = (zhhh=self.hour)==0 ? 24 : zhhh; zh-=12 if (zh>12)
+    zhh   = zh<10 ? ('0'+zh.to_s) : zh.to_s
+    zmm   = (zm=self.min)<10 ? ('0'+zm.to_s) : zm.to_s
+    zss   = (zs=self.sec)<10 ? ('0'+zs.to_s) : zs.to_s
+    zAMPM = (zampm=zhhh<12 ? 'am' : 'pm').upcase
+
+    f=formatString
+    f.gsub!(/#YYYY#/,zYYYY)
+    f.gsub!(/#YY#/,zYY)
+    f.gsub!(/#MMMM#/,zMMMM)
+    f.gsub!(/#MMM#/,zMMM)
+    f.gsub!(/#MM#/,zMM.to_s)
+    f.gsub!(/#M#/,zM.to_s)
+    f.gsub!(/#DDDD#/,zDDDD)
+    f.gsub!(/#DDD#/,zDDD)
+    f.gsub!(/#DD#/,zDD)
+    f.gsub!(/#D#/,zD.to_s)
+    f.gsub!(/#th#/,zth)
+    f.gsub!(/#hhh#/,zhhh.to_s)
+    f.gsub!(/#hh#/,zhh)
+    f.gsub!(/#h#/,zh.to_s)
+    f.gsub!(/#mm#/,zmm)
+    f.gsub!(/#m#/,zm.to_s)
+    f.gsub!(/#ss#/,zss)
+    f.gsub!(/#s#/,zs.to_s)
+    f.gsub!(/#ampm#/,zampm)
+    f.gsub!(/#AMPM#/,zAMPM);f
+  end
+
+end
+
+
+=begin :nodoc:
+# --- devlopment testing ---
+
+if $0 == __FILE__
+
+  #require 'test/unit'
+  
+  #require 'raspberry/atom/time/custom_format'
+  
+  class TC_Time < Test::Unit::TestCase
+  
+    # custom_format
+    
+    def test_custom_format
+    p Time.methods.sort
+      time = Time::parse('2/3/2004 15:37')
+      cf = time.custom_format('#DDDD#, #MMMM# #D##th# @ #h#:#mm##ampm#')
+      assert_equal( 'Tuesday, February 3rd @ 3:37pm', cf )
+      cf = time.custom_format('#YYYY#-#MMM#-#D#')
+      assert_equal( '2004-Feb-3', cf )
+      cf = time.custom_format('#MM#/#DD#/#YY#')
+      assert_equal( '02/03/04', cf )
+    end
+    
+  end
+
+end
+=end