facets 2.5.1 → 2.5.2

data/lib/core/facets/hash/dearray_values.rb

@@ -0,0 +1,46 @@
+class Hash
+
+  # Any array values with be replaced with the first element of the array.
+  # Arrays with no elements will be set to nil.
+  #
+  #   h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
+  #   h.dearray_values  #=> { :a=>1, :b=>1, :c=>3, :d=>nil }
+  #
+  # CREDIT: Trans
+
+  def dearray_values(index=0)
+    h = {}
+    each do |k,v|
+      case v
+      when Array
+        h[k] = v[index] || v[-1]
+      else
+        h[k] = v
+      end
+    end
+    h
+  end
+
+  # Any array values with one or no elements will be set to the element
+  # or nil.
+  #
+  #   h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
+  #   h.dearray_singular_values  #=> { :a=>1, :b=>[1,2], :c=>3, :d=>nil }
+  #
+  # CREDIT: Trans
+
+  def dearray_singular_values
+    h = {}
+    each do |k,v|
+      case v
+      when Array
+        h[k] = (v.size < 2) ? v[0] : v
+      else
+        h[k] = v
+      end
+    end
+    h
+  end
+
+end
+

data/lib/core/facets/to_hash.rb

@@ -1,51 +1,6 @@
 require 'enumerator' if RUBY_VERSION < "1.9"
 
-class Hash
-
-  # Any array values with less one or no elements will have the element
-  # or nil set as the value instead.
-  #
-  #   h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
-  #   h.dearray_values  #=> { :a=>1, :b=>1, :c=>3, :d=>nil }
-  #
-  # CREDIT: Trans
-
-  def dearray_values(index=0)
-    h = {}
-    each do |k,v|
-      case v
-      when Array
-        h[k] = v[index] || v[-1]
-      else
-        h[k] = v
-      end
-    end
-    h
-  end
-
-  # Any array values with less one or no elements will have the element
-  # or nil set as the value instead.
-  #
-  #   h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
-  #   h.dearray_singluar_values  #=> { :a=>1, :b=>[1,2], :c=>3, :d=>nil }
-  #
-  # CREDIT: Trans
-
-  def dearray_singluar_values
-    h = {}
-    each do |k,v|
-      case v
-      when Array
-        h[k] = (v.size < 2) ? v[0] : v
-      else
-        h[k] = v
-      end
-    end
-    h
-  end
-
-end
-
+require 'facets/hash/dearray_values'
 
 class Array
 
@@ -193,7 +148,7 @@ class Array
   #   a = [ [:a,1,2], [:b,2], [:c], :d ]
   #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
   #
-  # If the fist entry of any subelements are the same, then
+  # If the first entry of any subelements are the same, then
   # the value will be set to the last occuring value.
   #
   #   a = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
@@ -213,11 +168,11 @@ class Array
   #   a = [ [:a,1,2], [:b,2], [:c], :d ]
   #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
   #
-  # If the fist entry of the subelements is the same, then
+  # If the first entry of the subelements is the same, then
   # the values will be merged using #concat.
   #
   #   a = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
-  #   a.to_h_multi  #=> { :a=>[1,2,3,4,nil,nil] }
+  #   a.to_h_multi  #=> { :a=>[1,2,3,4] }
   #
   def to_h_multi
     h = {}
@@ -253,6 +208,12 @@ class Hash
 
   def to_h; rehash; end
 
+  # Returns _self_.
+  #
+  # CREDIT: Trans
+
+  def to_hash; self; end
+
 end
 
 module Enumerable
@@ -266,6 +227,26 @@ module Enumerable
     to_a.to_h(mode)
   end
 
+  def to_h_auto
+    to_a.to_h_auto
+  end
+
+  def to_h_splat
+    to_a.to_h_splat
+  end
+
+  def to_h_flat
+    to_a.to_h_flat
+  end
+
+  def to_h_assoc
+    to_a.to_h_assoc
+  end
+
+  def to_h_multi
+    to_a.to_h_multi
+  end
+
   #def to_hash
   #  to_a.to_hash
   #end
@@ -290,37 +271,71 @@ if RUBY_VERSION < "1.9"
 
   class Enumerable::Enumerator
   
-    # Convert an Enumerable::Enumerator object directly into a hash.
+    # Convert an Enumerable::Enumerator object into a hash.
+    # This is equivalent to Array#to_h.
+    #
+    #   e1 = [[1,:a],[2,:b],[3,:c]].to_enum
+    #   e1.to_h #=> { 1=>:a, 2=>:b, 3=>:c }
     # 
-    #   e = [1,2,3,4,5].to_enum
-    #   e.to_h  #=> {5=>nil, 1=>2, 3=>4}
-    #   e2 = [1,2,1,3,1,5].to_enum
-    #   e2.to_h #=> {1=>5}
-    #   e3 = [[1,:a],[2,:b],[3,:c]].to_enum
-    #   e3.to_h #=> { 1=>:a, 2=>:b, 3=>:c }
+    #   e2 = [1,2,3,4,5].to_enum
+    #   e2.to_h  #=> {5=>nil, 1=>2, 3=>4}
+    #
+    #   e3 = [1,2,1,3,1,5].to_enum
+    #   e3.to_h #=> {1=>5}
     #
     # CREDIT: Sandor Szücs
 
     def to_h(mode=nil)
       to_a.to_h(mode)
     end
+
+    # This is equivalent to Array#to_h_auto.
+    #
+    def to_h_auto
+      to_a.to_h_auto
+    end
+
+    # This is equivalent to Array#to_h_splat.
+    #
+    def to_h_splat
+      to_a.to_h_splat
+    end
+
+    # This is equivalent to Array#to_h_flat.
+    #
+    def to_h_flat
+      to_a.to_h_flat
+    end
+
+    # This is equivalent to Array#to_h_assoc.
+    #
+    def to_h_assoc
+      to_a.to_h_assoc
+    end
+
+    # This is equivalent to Array#to_h_multi.
+    #
+    def to_h_multi
+      to_a.to_h_multi
+    end
+
   end
 
 else
 
   class Enumerator
 
-    # Convert an Enumerator object directly into a hash.
-    # 
-    #   e3 = [[1,:a],[2,:b],[3,:c]].to_enum
-    #   e3.to_h #=> { 1=>:a, 2=>:b, 3=>:c }
+    # Convert an Enumerator object into a hash.
+    # This is equivalent to Array#to_h.
     #
-    #   e1 = [1,2,3,4,5].to_enum
-    #   e1.to_h  #=> {5=>nil, 1=>2, 3=>4}
+    #   e1 = [[1,:a],[2,:b],[3,:c]].to_enum
+    #   e1.to_h #=> { 1=>:a, 2=>:b, 3=>:c }
     #
-    #   e2 = [1,2,1,3,1,5].to_enum
-    #   e2.to_h #=> {1=>5}
+    #   e2 = [1,2,3,4,5].to_enum
+    #   e2.to_h  #=> {5=>nil, 1=>2, 3=>4}
     #
+    #   e3 = [1,2,1,3,1,5].to_enum
+    #   e3.to_h #=> {1=>5}
     #
     # CREDIT: Sandor Szücs
 
@@ -328,16 +343,36 @@ else
       to_a.to_h(mode)
     end
 
-    #def to_h
-    #  h = {}
-    #  loop do
-    #    x,y = self.next
-    #    h[x] ||= nil
-    #    y = self.next unless y
-    #    h[x] = y
-    #  end
-    #  return h
-    #end
+    # This is equivalent to Array#to_h_auto.
+    #
+    def to_h_auto
+      to_a.to_h_auto
+    end
+
+    # This is equivalent to Array#to_h_splat.
+    #
+    def to_h_splat
+      to_a.to_h_splat
+    end
+
+    # This is equivalent to Array#to_h_flat.
+    #
+    def to_h_flat
+      to_a.to_h_flat
+    end
+
+    # This is equivalent to Array#to_h_assoc.
+    #
+    def to_h_assoc
+      to_a.to_h_assoc
+    end
+
+    # This is equivalent to Array#to_h_multi.
+    #
+    def to_h_multi
+      to_a.to_h_multi
+    end
+
   end
 
 end

data/task/setup.rake

@@ -1,13 +1,20 @@
-begin
-  require 'setup'
-  $setup_installed = true  
-rescue => LoadError
-  $setup_installed = false
-puts "NOTP"
+
+def load_setup
+  begin
+    require 'setup'
+    $setup_installed = true
+  rescue LoadError
+    $setup_installed = false
+    puts "NOTP"
+  end
 end
 
+private :load_setup
+
 desc "install to ruby site location"
-task "setup:install" do
+task :install do
+  load_setup
+  
   if $setup_installed
     sh "setup.rb all"
   else
@@ -18,7 +25,9 @@ task "setup:install" do
 end
 
 desc "uninstall from ruby site location"
-task "setup:uninstall" do
+task :uninstall do
+  load_setup
+
   if $setup_installed
     sh "setup.rb uninstall"
   else
@@ -27,4 +36,3 @@ task "setup:uninstall" do
     puts "or 'gem install setup'."
   end
 end
-

data/test/core/hash/test_dearray_values.rb

@@ -0,0 +1,19 @@
+require 'facets/hash/dearray_values'
+require 'test/unit'
+
+class TestHashDearrayValues < Test::Unit::TestCase
+
+  def test_dearray_values
+    h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
+    x = { :a=>1, :b=>1, :c=>3, :d=>nil }
+    assert_equal(x, h.dearray_values)    
+  end
+  
+  def test_dearray_singular_values
+    h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
+    x = { :a=>1, :b=>[1,2], :c=>3, :d=>nil }
+    assert_equal(x, h.dearray_singular_values )
+  end
+
+end
+

data/test/core/test_to_hash.rb

@@ -14,6 +14,21 @@ class TestArrayConversion < Test::Unit::TestCase
   #  assert_raise(ArgumentError) { [[1,:a],:b].to_h }
   #end
 
+  def test_to_h_auto
+    a0 = [ [:a,1], [:b,2] ]
+    x0 = { :a=>1, :b=>2 }
+
+    a1 = [ [:a,1,2], [:b,2], [:c], [:d] ]
+    x1 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+
+    a2 = [ [:a,1,2], 2, :b, [:c,3], 9 ]
+    x2 = { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
+
+    assert_equal(x0, a0.to_h_auto)
+    assert_equal(x1, a1.to_h_auto)
+    assert_equal(x2, a2.to_h_auto)  
+  end
+
   def test_to_h_flat
     a = [[1,2],3,4,5]
     x = {1=>2,3=>4,5=>nil}
@@ -27,15 +42,33 @@ class TestArrayConversion < Test::Unit::TestCase
   end
 
   def test_to_h_assoc
-    a = [[:a,1],[:b,2],[:c],:d,[:a,5]]
-    x = {:a=>[5],:b=>[2],:c=>[],:d=>[]}
-    assert_equal(x, a.to_h_assoc)
+    a0 = [[:a,1],[:b,2],[:c],:d,[:a,5]]
+    x0 = {:a=>[5],:b=>[2],:c=>[],:d=>[]}
+
+    a1 = [ [:a,1,2], [:b,2], [:c], :d ]
+    x1 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+
+    a2 = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
+    x2 = { :x=>[4] }
+
+    assert_equal(x0, a0.to_h_assoc)
+    assert_equal(x1, a1.to_h_assoc)
+    assert_equal(x2, a2.to_h_assoc)
   end
 
   def test_to_h_multi
-    a = [[:a,1],[:b,2],[:c],:d,[:a,5]]
-    x = {:a=>[1,5],:b=>[2],:c=>[],:d=>[]}
-    assert_equal(x, a.to_h_multi)
+    a0 = [[:a,1],[:b,2],[:c],:d,[:a,5]]
+    x0 = {:a=>[1,5],:b=>[2],:c=>[],:d=>[]}
+
+    a1 = [ [:a,1,2], [:b,2], [:c], :d ]
+    x1 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+
+    a2 = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
+    x2 = { :a=>[1,2,3,4] }
+
+    assert_equal(x0, a0.to_h_multi)
+    assert_equal(x1, a1.to_h_multi)
+    assert_equal(x2, a2.to_h_multi)
   end
 
   #def test_to_h_assoc_arrayed
@@ -113,18 +146,6 @@ class TestHashConversion < Test::Unit::TestCase
     assert_equal( a, a.to_h )
   end
 
-  def test_dearray_values
-    h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
-    x = { :a=>1, :b=>1, :c=>3, :d=>nil }
-    assert_equal(x, h.dearray_values)    
-  end
-  
-  def test_dearray_singluar_values
-    h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
-    x = { :a=>1, :b=>[1,2], :c=>3, :d=>nil }
-    assert_equal(x, h.dearray_singluar_values )
-  end
-
 end
 
 
@@ -138,15 +159,86 @@ end
 
 
 class TestEnumeratorConversion < Test::Unit::TestCase
-  
+
   def test_to_h
+    e0 = [1,2,3,4].to_enum
+    x0 = {1=>2,3=>4}
     e1 = [[1,:a],[2,:b],[3,:c]].to_enum
-    e2 = [1,2,3,4].to_enum
-    e3 = [:a,1,:b].to_enum
-    assert_equal( { 1=>:a, 2=>:b, 3=>:c }, e1.to_h )
-    assert_equal( {1=>2, 3=>4}, e2.to_h)
-    assert_equal( {:a=>1,:b=>nil}, e3.to_h)
+    x1 = { 1=>:a, 2=>:b, 3=>:c }
+    e2 = [:a,1,:b].to_enum
+    x2 = {:a=>1,:b=>nil}
+    assert_equal(x0, e0.to_h)
+    assert_equal(x1, e1.to_h)
+    assert_equal(x2, e2.to_h)
   end
   
+  def test_to_h_auto
+    e0 = [ [:a,1], [:b,2] ].to_enum
+    x0 = { :a=>1, :b=>2 }
+    e1 = [ [:a,1,2], [:b,2], [:c], [:d] ].to_enum
+    x1 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    e2 = [ [:a,1,2], 2, :b, [:c,3], 9 ].to_enum
+    x2 = { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
+    assert_equal(x0, e0.to_h_auto)
+    assert_equal(x1, e1.to_h_auto)
+    assert_equal(x2, e2.to_h_auto)  
+  end  
+
+  def test_to_h_flat
+    e1 = [[1,2],3,4,5].to_enum
+    x1 = {1=>2,3=>4,5=>nil}
+    e2 = [:a,1,[:b,2,:c]].to_enum
+    x2 = { :a=>1, :b=>2, :c=>nil }        
+    e3 = [[:a,1],[:b,2]].to_enum
+    x3 = { :a=>1, :b=>2 }    
+    assert_equal(x1, e1.to_h_flat)
+    assert_equal(x1, e1.to_h(:flat))
+    assert_equal(x2, e2.to_h_flat)
+    assert_equal(x2, e2.to_h(:flat))
+    assert_equal(x3, e3.to_h_flat)
+    assert_equal(x3, e3.to_h(:flat))
+  end
+
+  def test_to_h_splat
+    e1 = [1,2,3,4,[5,6]].to_enum
+    x1 = { 1=>2, 3=>4, [5,6]=>nil }
+    e2 = [:a,1,:b,2,:c].to_enum
+    x2 = { :a=>1, :b=>2, :c=>nil }
+    assert_equal(x1, e1.to_h_splat)
+    assert_equal(x1, e1.to_h(:splat))
+    assert_equal(x2, e2.to_h_splat)
+    assert_equal(x2, e2.to_h(:splat))
+  end
+
+  def test_to_h_assoc
+    e1 = [[:a,1],[:b,2],[:c],:d,[:a,5]].to_enum
+    x1 = {:a=>[5],:b=>[2],:c=>[],:d=>[]}
+    e2 = [ [:a,1,2], [:b,2], [:c], :d ].to_enum
+    x2 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    e3 = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ].to_enum
+    x3 = { :x=>[4] }
+    assert_equal(x1, e1.to_h_assoc)
+    assert_equal(x1, e1.to_h(:assoc))
+    assert_equal(x2, e2.to_h_assoc)
+    assert_equal(x2, e2.to_h(:assoc))
+    assert_equal(x3, e3.to_h_assoc)
+    assert_equal(x3, e3.to_h(:assoc))
+  end
+
+  def test_to_h_multi
+    e1 = [[:a,1],[:b,2],[:c],:d,[:a,5]].to_enum
+    x1 = {:a=>[1,5],:b=>[2],:c=>[],:d=>[]}
+    e2 = [ [:a,1,2], [:b,2], [:c], :d ]
+    x2 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    e3 = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
+    x3 = { :a=>[1,2,3,4] }
+    assert_equal(x1, e1.to_h_multi)
+    assert_equal(x1, e1.to_h(:multi))
+    assert_equal(x2, e2.to_h_multi)
+    assert_equal(x2, e2.to_h(:multi))
+    assert_equal(x3, e3.to_h_multi)
+    assert_equal(x3, e3.to_h(:multi))
+  end
+ 
 end