facets 1.8.54 → 2.0.0

data/lib/core/facets/class/initializer.rb

@@ -0,0 +1,66 @@
+
+class Class
+
+  # Automatically create an initializer assigning the given
+  # arguments.
+  #
+  #   class MyClass
+  #     initializer(:a, "b", :c)
+  #   end
+  #
+  # _is equivalent to_
+  #
+  #   class MyClass
+  #     def initialize(a, b, c)
+  #       @a,@b,@c = a,b,c
+  #     end
+  #   end
+  #
+  # Downside: Initializers defined like this can't take blocks.
+  # This can be fixed when Ruby 1.9 is out.
+  #
+  # The initializer will not raise an Exception when the user
+  # does not supply a value for each instance variable. In that
+  # case it will just set the instance variable to nil. You can
+  # assign default values or raise an Exception in the block.
+  #
+  def initializer(*attributes, &block)
+    define_method(:initialize) do |*args|
+      attributes.zip(args) do |sym, value|
+        instance_variable_set("@#{sym}", value)
+      end
+
+      instance_eval(&block) if block
+    end
+  end
+
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    def test_initializer
+      cc = Class.new
+      cc.class_eval {
+        initializer :ai
+        attr_reader :ai
+      }
+      c = cc.new(10)
+      assert_equal( 10, c.ai )
+    end
+
+  end
+
+=end

data/lib/core/facets/comparable.rb

@@ -0,0 +1,2 @@
+require 'facets/comparable/cmp.rb'
+require 'facets/comparable/bound.rb'

data/lib/core/facets/comparable/bound.rb

@@ -0,0 +1,120 @@
+# +FILE+
+#
+#   bound.rb
+#
+# +DESCRIPTION+
+#
+#   Limit comparisons.
+#
+# +AUTHORS+
+#
+#   CREDIT Florian Gross
+#
+# +NOTES+
+#
+#   NOTE Are the module methods better as parameterized mixins?
+#
+#   TODO Maybe improve the naming or the module methods.
+
+#
+module Comparable
+
+  # Returns the lower of self or x.
+  #
+  #   4.at_least(5)  #=> 5
+  #   6.at_least(5)  #=> 6
+  #
+  def at_least(x)
+    (self >= x) ? self : x
+  end
+
+  # Returns the greater of self or x.
+  #
+  #   4.at_most(5)  #=> 4
+  #   6.at_most(5)  #=> 5
+  #
+  def at_most(x)
+    (self <= x) ? self : x
+  end
+
+  # Returns self if above the given lower bound, or
+  # within the given lower and upper bounds,
+  # otherwise returns the the bound of which the
+  # value falls outside.
+  #
+  #   4.clip(3)    #=> 4
+  #   4.clip(5)    #=> 5
+  #   4.clip(2,7)  #=> 4
+  #   9.clip(2,7)  #=> 7
+  #   1.clip(2,7)  #=> 2
+  #
+  def clip(lower, upper=nil)
+    return lower if self < lower
+    return self unless upper
+    return upper if self > upper
+    return self
+  end
+
+  alias bound clip
+
+  # Returns the greater of self or x.
+  #
+  #   4.cap(5)  #=> 4
+  #   6.cap(5)  #=> 5
+  #
+  def cap(upper)
+    (self <= upper) ? self : upper
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestComparable < Test::Unit::TestCase
+
+    def test_at_most
+      assert_equal( 3, 3.at_most(4) )
+      assert_equal( 4, 4.at_most(4) )
+      assert_equal( 4, 5.at_most(4) )
+    end
+
+    def test_at_least
+      assert_equal( 4, 3.at_least(4) )
+      assert_equal( 4, 4.at_least(4) )
+      assert_equal( 5, 5.at_least(4) )
+    end
+
+    def test_clip
+      assert_equal( 4, 3.clip(4) )
+      assert_equal( 4, 4.clip(4) )
+      assert_equal( 5, 5.clip(4) )
+      assert_equal( 4, 4.clip(3,5) )
+      assert_equal( 3, 3.clip(3,5) )
+      assert_equal( 5, 5.clip(3,5) )
+      assert_equal( 3, 2.clip(3,5) )
+      assert_equal( 5, 6.clip(3,5) )
+      assert_equal( 'd', 'd'.clip('c','e') )
+      assert_equal( 'c', 'c'.clip('c','e') )
+      assert_equal( 'e', 'e'.clip('c','e') )
+      assert_equal( 'c', 'b'.clip('c','e') )
+      assert_equal( 'e', 'f'.clip('c','e') )
+    end
+
+    def test_cap
+      assert_equal( 3, 3.cap(4) )
+      assert_equal( 4, 4.cap(4) )
+      assert_equal( 4, 5.cap(4) )
+    end
+
+  end
+
+=end

data/lib/core/facets/comparable/cmp.rb

@@ -0,0 +1,172 @@
+# TITLE:
+#
+#   Cmp and Succ/Pred
+#
+# SUMMARY:
+#
+#   Comparison and Succ/Pred extensions.
+#
+# AUTHORS:
+#
+#   - Florian Gross
+#   - Thomas Sawyer
+#
+# NOTES:
+#
+#   - NOTE Are the module methods better as parameterized mixins?
+#
+#   - TODO Maybe improve the naming or the module methods.
+
+#
+class Integer
+  # This is needed to allow Integer to look back to
+  # its Numeric ancestor for the new definition of #succ.
+
+  remove_method( :succ )
+end
+
+#
+module Comparable
+  # Alternate name for comparison operator #<=>.
+  #
+  #   3.cmp(1)   #=>  1
+  #   3.cmp(3)   #=>  0
+  #   3.cmp(10)  #=> -1
+  #
+  # This fundamental compare method is used to keep
+  # comparison compatible with <tt>#succ</tt>.
+
+  def cmp(o)
+    self<=>o
+  end
+end
+
+class String    # Compare method that takes length into account.
+
+  # Compare method that takes length into account.
+  # Unlike #<=>, this is compatible with #succ.
+  #
+  #   "abc".cmp("abc")   #=>  0
+  #   "abcd".cmp("abc")  #=>  1
+  #   "abc".cmp("abcd")  #=> -1
+  #   "xyz".cmp("abc")   #=>  1
+
+  def cmp(other)
+    return -1 if length < other.length
+    return 1 if length > other.length
+    self <=> other  # alphabetic compare
+  end
+
+  # Allows #succ to take _n_ step increments.
+  #
+  #   "abc".succ      #=> "abd"
+  #   "abc".succ(4)   #=> "abg"
+  #   "abc".succ(24)  #=> "aca"
+
+  def succ(n=1)
+    s = self
+    n.times { s = s.next }
+    s
+  end
+end
+
+class Numeric
+  # Returns the distance between self an another value.
+  # This is the same as #- but it provides an alternative
+  # for common naming between variant classes.
+  #
+  #   4.distance(3)  #=> 1
+  #
+  def distance( other )
+    self - other
+  end
+
+  # Allows #succ to take _n_ increments.
+  #
+  #   3.succ(2)  #=> 5
+  #
+  def succ(n=nil)
+    n ||= 1
+    self + n
+  end
+
+  # Provides #pred as the opposite of #succ.
+  #
+  #   3.pred(2)  #=> 1
+  #
+  def pred(n=nil)
+    n ||= 1
+    self - n
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestComparable < Test::Unit::TestCase
+
+    def test_cmp
+      assert_equal( -1, 3.cmp(4) )
+      assert_equal(  0, 3.cmp(3) )
+      assert_equal(  1, 3.cmp(2) )
+    end
+
+  end
+
+  class TestStringCompare < Test::Unit::TestCase
+
+    def test_cmp
+      assert_equal( 0, "abc".cmp("abc") )
+      assert_equal( -1, "abc".cmp("abcd") )
+      assert_equal( 1, "abcd".cmp("abc") )
+      assert_equal( -1, "abc".cmp("bcd") )
+      assert_equal( 1, "bcd".cmp("abc") )
+    end
+
+    def test_succ
+      assert_equal( "b", "a".succ )
+      assert_equal( "b", "a".succ(1) )
+      assert_equal( "c", "a".succ(2) )
+      assert_equal( "d", "a".succ(3) )
+    end
+
+  end
+
+  class TestNumericCompare < Test::Unit::TestCase
+
+    def test_distance
+      assert_equal( 4, 10.distance(6) )
+      assert_equal( 2, 10.distance(8) )
+      assert_equal( -2, 7.distance(9) )
+    end
+
+
+    def test_pred
+      assert_equal(  3,  4.pred )
+      assert_equal( -3, -2.pred )
+      assert_equal(  2,  4.pred(2) )
+      assert_equal( -4, -2.pred(2) )
+      assert_equal(  6,  4.pred(-2) )
+      assert_equal(  0, -2.pred(-2) )
+    end
+
+    def test_succ
+      assert_equal(  5,  4.succ )
+      assert_equal( -1, -2.succ )
+      assert_equal(  6,  4.succ(2) )
+      assert_equal(  0, -2.succ(2) )
+      assert_equal(  2,  4.succ(-2) )
+      assert_equal( -4, -2.succ(-2) )
+    end
+
+  end
+
+=end

data/lib/core/facets/continuation.rb

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

data/lib/core/facets/conversion.rb

@@ -0,0 +1,699 @@
+# TITLE:
+#
+#   Conversions
+#
+# SUMMERY:
+#
+#   Conversion extensions.
+#
+# CREDITS:
+#
+#   - Thomas Sawyer
+#   - Willian James
+#   - Daniel Berger
+#   - Forian Gross
+#   - Mauricio Fernandez
+#   - Nobuhiro Imai
+
+require 'facets/functor'
+
+#
+class Array
+
+  # Converts a two-element associative array into a hash.
+  #
+  #   a = [ [:a,1], [:b,2] ]
+  #   a.to_h  #=> { :a=>1, :b=>2 }
+  #
+  # If +arrayed+ is set it will maintain trailing arrays.
+  #
+  #   a = [ [:a,1,2], [:b,3] ]
+  #   a.to_h(true)  #=> { :a=>[1,2], :b=>[3] }
+  #
+  # NOTE: the use of a values parameter has been deprecated
+  # because that functionality is as simple as:
+  #
+  #   array1.zip(array2).to_h
+  #
+  def to_h(arrayed=nil)
+    h = {}
+    if arrayed #or (flatten.size % 2 == 1)
+      #each{ |e| h[e.first] = e.slice(1..-1) }
+      each{ |k,*v| h[k] = v }
+    else
+      h = Hash[*(self.flatten)]
+    end
+    h
+  end
+
+  # Turn an array into a file path.
+
+  def to_path
+    File.join( *(self.compact) )
+  end
+
+end
+
+#
+class Class
+
+  # CREDIT Daniel Schierbeck
+
+  # Convert instatiation of a class into a Proc.
+  #
+  #  class Person
+  #     def initialize(name)
+  #       @name = name
+  #     end
+  #
+  #     def inspect
+  #       @name.to_str
+  #     end
+  #   end
+  #
+  #   %w(john bob jane hans).map(&Person) => [john, bob, jane, hans]
+  #
+
+  def to_proc
+    proc{|*args| new(*args)}
+  end
+
+end
+
+#
+module Enumerable
+
+  # Produces a hash from an Enumerable with index for keys.
+  #
+  #   enu = 'a'..'b'
+  #   enu.to_hash  #=> { 0=>'a', 1=>'b' }
+  #
+  # If a block is passed, the hash values will be set by
+  # calling the block with the enumerated element and it's
+  # counter.
+  #
+  #   enu = 'a'..'b'
+  #   enu.to_hash{ |e,i| e }  #=> { 0=>'a', 1=>'b' }
+  #
+  # See also #graph.
+
+  def to_hash( &blk )
+    h = {}
+    if blk
+      each_with_index{ |e,i| h[i] = blk.call(e,i) }
+    else
+      each_with_index{ |e,i| h[i] = e }
+    end
+    h
+  end
+
+  #
+
+  def to_h(arrayed=nil)
+    to_a.to_h(arrayed)
+  end
+
+end
+
+#
+class Hash
+
+  # Like Array#join but specialized to Hash.
+  #
+  def join(pair_divider='', elem_divider='')
+    s = []
+    each_pair { |k,v| s << "#{k}#{pair_divider}#{v}" }
+    s.join(elem_divider)
+  end
+
+  # Return a rehashing of _self_.
+  #
+  #   {"a"=>1,"b"=>2}.to_h  #=> {"b"=>2,"a"=>1}
+  #
+  #--
+  # A horse is a horse, a horse of course.
+  #++
+  def to_h; rehash; end
+
+  # CREDIT Forian Gross
+  # CREDIT Mauricio Fernandez
+
+  # Constructs a Proc object from a hash such
+  # that the parameter of the Proc is assigned
+  # the hash keys as attributes.
+  #
+  #   h = { :a => 1 }
+  #   p = h.to_proc
+  #   o = OpenStruct.new
+  #   p.call(o)
+  #   o.a  #=> 1
+  #
+
+  def to_proc
+    lambda do |o|
+      self.each do |k,v|
+        ke = "#{k}="
+        o.__send__(ke, v)
+      end
+    end
+  end
+
+  def to_proc_with_reponse
+    lambda do |o|
+      self.each do |k,v|
+        ke = "#{k}="
+        o.__send__(ke, v) if respond_to?(ke)
+      end
+    end
+  end
+
+  # CREDIT Daniel Berger
+
+  # A method to convert a Hash into a Struct.
+  #
+  #   h = {:name=>"Dan","age"=>33,"rank"=>"SrA","grade"=>"E4"}
+  #   s = h.to_struct("Foo")
+
+  def to_struct(struct_name)
+    Struct.new(struct_name,*keys).new(*values)
+  end
+
+end
+
+
+#
+class NilClass
+
+  # Why doesn't Ruby have therese already?
+
+  # Allows <tt>nil</tt> to respond to #to_f.
+  # Always returns <tt>0</tt>.
+  #
+  #  nil.to_f   #=> 0.0
+  #
+  def to_f; 0.0; end
+
+  # Allows <tt>nil</tt> to create an empty hash,
+  # similar to #to_a and #to_s.
+  #
+  #  nil.to_h    #=> {}
+  #
+  def to_h; {}; end
+
+end
+
+
+class Proc
+
+  # Build a hash out of a Proc.
+  #
+  #   l = lambda { |s|
+  #     s.a = 1
+  #     s.b = 2
+  #     s.c = 3
+  #   }
+  #   l.to_h  #=> {:a=>1, :b=>2, :c=>3}
+  #
+
+  def to_h
+    h = {}
+    f = Functor.new{ |op, arg| h[op.to_s.chomp('=').to_sym] = arg }
+    call( f )
+    h
+  end
+
+end
+
+#
+class Range
+
+  # A thing really should know itself.
+  # This simply returns _self_.
+  #
+  def to_r
+    self
+  end
+
+  # A thing really should know itself.
+  # This simply returns _self_.
+  #
+  # Note: This does not internally effect the Ruby
+  # interpretor such that it can coerce Range-like
+  # objects into a Range.
+  #
+  def to_range
+    self
+  end
+
+end
+
+#
+class Regexp
+
+  # Simply returns itself. Helpful when converting
+  # strings to regular expressions, where regexp
+  # might occur as well --in the same vien as using
+  # #to_s on symbols. The parameter is actaully a
+  # dummy parameter to coincide with String#to_re.
+  #
+  #   /abc/.to_re  #=> /abc/
+  #
+  def to_re( esc=false )
+    self  # Of course, things really should know how to say "I" ;)
+  end
+
+  # Like #to_re, but following Ruby's formal definitions,
+  # only a Regular expression type object will respond to this.
+  #
+  # Note: To be of much real use this should be defined in core Ruby.
+  def to_regexp
+    self
+  end
+
+end
+
+#
+class String
+
+  # Get a constant by a given string name.
+  #
+  #   "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
+
+  # Parse data from string.
+  #
+  def to_date
+    require 'date'
+    require 'parsedate'
+    ::Date::civil(*ParseDate.parsedate(self)[0..2])
+  end
+
+  # Parse string to time.
+  #
+  def to_time
+    require 'time'
+    Time.parse(self)
+  end
+
+  # Turns a string into a regular expression.
+  # By default it will escape all characters.
+  # Use <tt>false</tt> argument to turn off escaping.
+  #
+  #   "[".to_re  #=> /\[/
+  #
+  def to_re(esc=true)
+    Regexp.new((esc ? Regexp.escape(self) : self))
+  end
+
+  # Turns a string into a regular expression.
+  # Unlike #to_re this will not escape characters.
+  #
+  #   "a?".to_rx  #=> /a?/
+  #
+  def to_rx
+    Regexp.new(self)
+  end
+
+  # Evaluates a String as a 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
+
+  # Essentially makes #to_a an alias for split,
+  # with the excpetion that if no divider is given
+  # then the array is split on charaters, and
+  # NOT on the global input record divider ($/).
+  #
+  # WARNING There is a slight chance of
+  # incompatability with other libraries which
+  # depend on spliting with $/ (although doing
+  # so is a very bad idea!).
+
+  #def to_a(div=//,limit=0)
+  #  split(div,limit)
+  #end
+
+end
+
+#
+class Symbol
+
+  # Get a constant by a given symbol name.
+  #
+  #   :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.split('::').inject(Object){ |namespace,name| namespace.const_get(name) }
+  end
+
+  # CREDIT Florian Gross
+  # CREDIT Nobuhiro Imai
+
+  # NOTE Symbol#to_proc is already in 1.9+.
+
+  # 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
+
+  def to_proc
+    Proc.new{|*args| args.shift.__send__(self, *args)}
+  end
+
+  # Same functionality as before, just a touch more efficient.
+  #
+  #--
+  # CHANGE transami@gmail.com - removed #freeze from #id2name
+  # BAD BAD. Somehow it breaks things. Very weired breaks too,
+  # like making Time#parse alwsy output Time.now _after_ first use.
+  #++
+  #def to_s
+  #  @to_s || (@to_s = id2name)
+  #end
+
+  # 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.
+  #
+  # NOTE This cause Struct.new to bomb!
+  #++
+  #def to_str
+  #  String( self )
+  #end
+
+end
+
+#
+class Time
+
+  #--
+  # CHANGE 2006-12-10 <transfire@gmail.com>
+  # * Added FORMAT constant to make more flexible.
+  #++
+
+  unless const_defined?('FORMAT')
+  FORMAT = {
+    :db      => "%Y-%m-%d %H:%M:%S",
+    :dbase   => "%Y-%m-%d %H:%M:%S",
+    :datbase => "%Y-%m-%d %H:%M:%S",
+    :utc     => "%Y-%m-%d %H:%M:%S",
+    :short   => "%d %b %H:%M",
+    :long    => "%B %d, %Y %H:%M",
+    :day1st  => "%d-%m-%Y %H:%M",
+    :dmYHM   => "%d-%m-%Y %H:%M",
+    :rfc822  => "%a, %d %b %Y %H:%M:%S %z",
+    nil      => "%a %b %d %H:%M:%S %Z %Y"
+  }
+  end
+
+  def stamp( fmt = nil )
+    unless String === fmt
+      fmt = FORMAT[fmt]
+    end
+    strftime(fmt).strip
+  end
+
+  def self.stamp(*args)
+    now.stamp(*args)
+  end
+
+  # Enhance #to_s by aliasing to #stamp.
+  alias_method :to_s, :stamp
+
+  # Convert a Time to a Date. Time is a superset of Date.
+  # It is the year, month and day that are carried over.
+  def to_date
+    require 'date'
+    ::Date.new(year, month, day)
+  end
+
+  # To be able to keep Dates and Times interchangeable
+  # on conversions.
+  def to_time
+    self
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+
+  class TestArrayConversion < Test::Unit::TestCase
+
+    def test_to_h_1
+      k = [1,3,5]
+      v = [2,4,6]
+      assert_equal( { 1=>2, 3=>4, 5=>6 }, k.zip(v).to_h )
+    end
+
+    def test_to_h_2
+      a = [[1,2],[3,4],[5,6]]
+      assert_equal( { 1=>2, 3=>4, 5=>6 }, a.to_h )
+    end
+
+    def test_to_hash
+      a = [:a,:b,:c]
+      assert_equal( { 0=>:a, 1=>:b, 2=>:c }, a.to_hash )
+    end
+
+  end
+
+
+  class TestClassConversion < Test::Unit::TestCase
+
+    Person = Struct.new(:name)
+
+    def test_to_proc
+      people = ["joe"].map(&Person)
+      assert_equal("joe", people[0].name)
+    end
+
+  end
+
+
+  class TestEnumerableConversion < Test::Unit::TestCase
+
+    def test_to_hash
+      a = [:a,:b,:c]
+      assert_equal( { 0=>:a, 1=>:b, 2=>:c }, a.to_h )
+    end
+
+  end
+
+
+  class TestHashConversion < Test::Unit::TestCase
+
+    def test_to_h
+      a = { :a => 1, :b => 2, :c => 3 }
+      assert_equal( a, a.to_h )
+    end
+
+  end
+
+
+  class TestNilClassConversion < Test::Unit::TestCase
+
+    def test_to_f
+      assert_equal( 0, nil.to_f )
+    end
+
+    def test_to_h
+      assert_equal( {}, nil.to_h )
+    end
+
+  end
+
+
+  class TestRangeConversion < Test::Unit::TestCase
+
+    def test_to_r
+      a = (0..10)
+      assert_equal( a, a.to_r )
+    end
+
+    def test_to_range
+      a = (0..10)
+      assert_equal( a, a.to_range )
+    end
+
+  end
+
+
+  class TestRegexpConversion < Test::Unit::TestCase
+
+    def test_to_re
+      r = /0..10/
+      assert_equal( r, r.to_re )
+    end
+
+    def test_to_regexp
+      r = /0..10/
+      assert_equal( r, r.to_regexp )
+    end
+
+  end
+
+
+  class TestStringConversion < Test::Unit::TestCase
+
+    TestConst = 4
+
+    def test_to_const
+      assert_equal( 4, "TestStringConversion::TestConst".to_const )
+    end
+
+    def test_to_date
+      s = "2005-10-31"
+      d = s.to_date
+      assert_equal( 31, d.day )
+      assert_equal( 10, d.month )
+      assert_equal( 2005, d.year )
+    end
+
+    def test_to_time
+      s = "2:31:15 PM"
+      t = s.to_time
+      assert_equal( 14, t.hour )
+      assert_equal( 31, t.min )
+      assert_equal( 15, t.sec )
+    end
+
+    def test_to_re
+      assert_equal( /abc/, "abc".to_re )
+      assert_equal( /a\+bc/, "a+bc".to_re )
+      assert_equal( /a+bc/, "a+bc".to_re(false) )
+    end
+
+    def test_to_proc
+      assert_nothing_raised { @add = '|x,y| x + y'.to_proc }
+      assert_equal(4, @add.call(2,2))
+      @t = 3
+      @multi = '|y| @t * y'.to_proc(self)
+      assert_equal(6, @multi.call(2))
+      x = 4
+      @div = '|y| x / y'.to_proc(binding)
+      assert_equal(2, @div.call(2))
+    end
+
+    #def test_to_a
+    #  arr = 'abc'
+    #  assert_equal( ['a','b','c'], arr.to_a )
+    #end
+
+  end
+
+
+  class TestSymbolConversion < Test::Unit::TestCase
+
+    TESTCONST = 1
+
+    def test_to_const
+      assert_equal( 1, :"TestSymbolConversion::TESTCONST".to_const )
+    end
+
+    def test_proc_01
+      assert_instance_of(Proc, up = :upcase.to_proc )
+      assert_equal( "HELLO", up.call("hello") )
+    end
+
+    def test_proc_02
+      q = [[1,2,3], [4,5,6], [7,8,9]].map(&:reverse)
+      a = [[3, 2, 1], [6, 5, 4], [9, 8, 7]]
+      assert_equal( a, q )
+    end
+
+    # Deprecated b/c of stringe issues.
+
+    #def test_to_str
+    #  assert_equal( "a", :a.to_str )
+    #  assert_equal( "abc", :abc.to_str )
+    #  assert_equal( '#$%', :'#$%'.to_str )
+    #end
+
+  end
+
+
+  require 'time'
+
+  class TestTimeConversion < Test::Unit::TestCase
+
+    def setup
+      @t = Time.parse('4/20/2005 15:37')
+    end
+
+    # FIXME Problem with Timezone on different systems.
+
+    #def test_stamp_01
+    #  assert_equal( "Wed Apr 20 15:37:00 PDT 2005", @t.stamp )
+    #end
+
+    def test_stamp_02
+      assert_equal( "April 20, 2005 15:37", @t.stamp(:long) )
+    end
+
+    def test_stamp_03
+      assert_equal( "20 Apr 15:37", @t.stamp(:short) )
+    end
+
+    def test_to_date
+      assert_instance_of( ::Date, @t.to_date )
+    end
+
+    #def test_to_s
+    #  assert_equal( "Wed Apr 20 15:37:00 EDT 2005", @t.to_s )
+    #end
+
+    def test_to_time
+      assert_instance_of( ::Time, @t.to_time )
+    end
+
+  end
+
+=end