facets 2.1.3 → 2.2.0

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

@@ -1,17 +1,3 @@
-# TITLE:
-#
-#   Reverse Merge
-#
-# SUMMARY:
-#
-#   Like merge, but give the parameter priority over the
-#   reciever.
-#
-# CREDITS:
-#
-#   - Gavin Sinclair
-#   - Thomas Sawyer
-
 class Hash
 
   # Allows for reverse merging where its the keys in the
@@ -30,34 +16,14 @@ class Hash
     other.merge(self)
   end
 
+  # Inplace form of #reverse_merge.
+
   def reverse_merge!(other)
     replace(reverse_merge(other))
   end
 
+  # Obvious alias for reverse_merge!
+
   alias_method :reverse_update, :reverse_merge!
 
 end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestHashReverseMerge < Test::Unit::TestCase
-
-    def test_reverse_merge
-      h1 = { :a=>1, :b=>2, :c=>2 }
-      h2 = { :c=>3 }
-      h3 = h1.reverse_merge(h2) )
-      assert_equal( 2, h3[:c] )
-    end
-
-  end
-
-=end

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

@@ -1,17 +1,3 @@
-# TITLE:
-#
-#   Hash Constructor Extensions
-#
-# SUMMARY:
-#
-#   Alternate constructors for Hash.
-#
-# CREDIT:
-#
-#   - Jan Molic
-#   - Ara.T.Howard
-
-#
 class Hash
 
   #  Hash which auto initializes it's children.
@@ -28,6 +14,8 @@ class Hash
   #   p ah['section one'].keys
   #   # ["param one", "param four", "param three", "param two"]
   #
+  #   CREDIT: Trans
+  #   CREDIT: Jan Molic
 
   def self.autonew(*args)
     #new(*args){|a,k| a[k] = self.class::new(*args)}
@@ -41,6 +29,9 @@ class Hash
   #   Hash.zipnew(["a","b","c"], [1,2,3])
   #     #=> { "a"=>1, "b"=>2, "c"=>3 }
   #
+  #   CREDIT: Trans
+  #   CREDIT: Ara.T.Howard
+
   def self.zipnew(keys,values) # or some better name
     h = {}
     keys.size.times{ |i| h[ keys[i] ] = values[i] }
@@ -48,27 +39,3 @@ class Hash
   end
 
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestHashNew < Test::Unit::TestCase
-
-    def test_zipnew
-      a = [1,2,3]
-      b = [4,5,6]
-      assert_equal( {1=>4,2=>5,3=>6}, Hash.zipnew(a,b) )
-    end
-
-  end
-
-=end

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

@@ -1,26 +1,9 @@
-# TITLE:
-#
-#   Hash Operators
-#
-# SUMMARY:
-#
-#   Operators for common methods, such as merge and update,
-#   plus some usefule variaions like reverse_merge.
-#
-# CREDITS:
-#
-#   - Thomas Sawyer
-#
-# TODO:
-#
-#   - Rewrite #diff to be more readable.
-#   - Rename #diff to #difference or something else?
-
-#
 class Hash
 
   # Can be used like update, or passed
   # as two-element [key,value] array.
+  #
+  #   CREDIT: Trans
 
   def <<(other)
     if other.respond_to?(:to_ary)
@@ -43,6 +26,8 @@ class Hash
   # The later form is similar to #pairs_at. The differ only
   # in that #pairs_at will return a nil value for a key
   # not in the hash, but #& will not.
+  #
+  #   CREDIT: Trans
 
   def &(other)
     case other
@@ -57,13 +42,17 @@ class Hash
     end
   end
 
-  # Operator for reverse_merge.
+  # Operator for #reverse_merge.
+  #
+  #   CREDIT: Trans
 
   def |(other)
     other.merge(self)
   end
 
-  # Operator for merge.
+  # Operator for #merge.
+  #
+  #   CREDIT: Trans
 
   def +(other)
     merge(other)
@@ -72,6 +61,8 @@ class Hash
   # Operator for remove hash paris. If another hash is given
   # the pairs are only removed if both key and value are equal.
   # If an array is given then mathcing keys are removed.
+  #
+  #   CREDIT: Trans
 
   def -(other)
     h = self.dup
@@ -96,60 +87,23 @@ class Hash
   #
   #   h1 + h2  #=> { :a=>2, :b=>3 }
   #   h1 * h2  #=> { :a=>1, :b=>3 }
+  #
+  #   CREDIT: Trans
 
   def *(other)
     other.merge(self)
   end
 
   # Difference comparison of two hashes.
+  #
+  #   CREDIT: ?
+  #
+  # TODO:
+  #   - Rewrite #diff to be more readable.
+  #   - Rename #diff to #difference or something else?
 
   def diff(h2)
     dup.send(:delete_if){|k,v| h2[k] == v}.send(:merge,h2.dup.send(:delete_if){ |k,v| has_key?(k) })
   end
 
 end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestHashOperate < Test::Unit::TestCase
-
-    def test_op_and_hash
-      a = { :a => 1, :b => 2 }
-      b = { :a => 1 }
-      r = { :a => 1 }
-      assert_equal( r, a & b )
-    end
-
-    def test_op_and_hash_subarray
-      a = { :a => [1], :b => [2] }
-      b = { :a => [1] }
-      r = { :a => [1] }
-      assert_equal( r, a & b )
-    end
-
-    def test_op_and_array
-      a = { :a => 1, :b => 2 }
-      b = [ :a ]
-      r = { :a => 1 }
-      assert_equal( r, a & b )
-    end
-
-    def test_shift_update
-      a = { :a => 1, :b => 2, :c => 3 }
-      b = { :a => 0, :d => 4 }
-      e = { :a => 0, :b => 2, :c => 3, :d => 4 }
-      assert_equal( e, a << b )
-    end
-
-  end
-
-=end

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

@@ -1,19 +1,5 @@
-# TITLE:
-#
-#   Hash Rekeying Extensions
-#
-# SUMMARY:
-#
-#   Extensions for rekeying a Hash (exluding #update_keys).
-#
-# CREDITS:
-#
-#   - Gavin Sinclair
-#   - Thomas Sawyer
-
 require 'facets/conversion'
 
-#
 class Hash
 
   # Converts all keys in the Hash accroding to the given block.
@@ -24,6 +10,7 @@ class Hash
   #   foo.rekey{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
   #   foo.inspect              #=>  { :name =>"Gavin", :wife=>:Lisa }
   #
+  #   CREDIT: Trans
 
   def rekey( meth=nil, &block )
     raise ArgumentError, "2 for 1" if meth and block
@@ -36,6 +23,7 @@ class Hash
   #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
   #   foo.inspect               #=>  { "name"=>"Gavin", "wife"=>:Lisa }
   #
+  #   CREDIT: Trans
 
   def rekey!( meth=nil, &block )
     meth = :to_sym unless meth or block
@@ -48,8 +36,6 @@ class Hash
     self
   end
 
-  # CREDIT Gavin Sinclair
-
   # Modifies the receiving Hash so that the value previously referred to by
   # _oldkey_ is also referenced by _newkey_; _oldkey_ is retained in the Hash.
   # If _oldkey_ does not exist as a key in the Hash, no change is effected.
@@ -67,6 +53,9 @@ class Hash
   #
   # Note that if the _oldkey_ is reassigned, the reference will no longer exist,
   # and the _newkey_ will remain as it was.
+  #
+  #   CREDIT: Gavin Sinclair
+
   def alias!( newkey, oldkey )
     self[newkey] = self[oldkey] if self.has_key?(oldkey)
     self
@@ -76,6 +65,8 @@ class Hash
   #
   #   {:a=>1,:b=>2}.swap!(:a,:b)  #=> {:a=>2,:b=>1}
   #
+  #   CREDIT: Gavin Sinclair
+
   def swap!( key1, key2 )
     tmp = self[key1]
     self[key1] = self[key2]
@@ -83,8 +74,6 @@ class Hash
     self
   end
 
-  # CREDIT Gavin Sinclair
-
   # Modifies the receiving Hash so that the value previously referred to by
   # _oldkey_ is referenced by _newkey_; _oldkey_ is removed from the Hash.
   # If _oldkey_ does not exist as a key in the Hash, no change is effected.
@@ -95,6 +84,8 @@ class Hash
   #   foo.swapkey!('a',:a)       #=> { 'a'=>1, :b=>2 }
   #   foo.swapkey!('b',:b)       #=> { 'a'=>1, 'b'=>2 }
   #   foo.swapkey!('foo','bar')  #=> { 'a'=>1, 'b'=>2 }
+  #
+  #   CREDIT: Gavin Sinclair
 
   def swapkey!( newkey, oldkey )
     self[newkey] = self.delete(oldkey) if self.has_key?(oldkey)
@@ -102,72 +93,3 @@ class Hash
   end
 
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestHashRekey < Test::Unit::TestCase
-
-    def test_alias!
-      foo = { 'a'=>1, 'b'=>2 }
-      assert_equal( { 'a'=>1, 'b'=>2, 'c'=>2 }, foo.alias!('c','b') )
-      foo = { 'a'=>1, 'b'=>2 }
-      assert_equal( { :a=>1, 'a'=>1, 'b'=>2 }, foo.alias!(:a,'a') )
-      foo = { :a=>1, :b=>2 }
-      assert_equal( { :a=>1, :b=>2 }, foo.alias!('bar','foo') )
-    end
-
-    def test_rekey_01
-      foo = { :a=>1, :b=>2 }
-      assert_equal( { "a"=>1, "b"=>2 }, foo.rekey{|k|k.to_s} )
-      assert_equal( { :a =>1, :b=>2 }, foo  )
-    end
-
-    def test_rekey_02
-      foo = { :a=>1, :b=>2 }
-      assert_equal( { "a"=>1, "b"=>2 }, foo.rekey!{|k|k.to_s}  )
-      assert_equal( { "a"=>1, "b"=>2 }, foo )
-    end
-
-    def test_rekey_03
-      foo = { :a=>1, :b=>2 }
-      assert_equal( { "a"=>1, "b"=>2 }, foo.rekey(:to_s) )
-      assert_equal( { :a =>1, :b=>2 }, foo  )
-    end
-
-    def test_rekey_04
-      foo = { :a=>1, :b=>2 }
-      assert_equal( { "a"=>1, "b"=>2 }, foo.rekey!(:to_s) )
-      assert_equal( { "a"=>1, "b"=>2 }, foo )
-    end
-
-    def test_rekey_05
-      foo = { "a"=>1, "b"=>2 }
-      assert_equal( { :a=>1, :b=>2 }, foo.rekey! )
-      assert_equal( { :a=>1, :b=>2 }, foo )
-    end
-
-    def test_swap!
-      h = { :a=>1, :b=>2 }
-      assert_equal( { :a=>2, :b=>1 }, h.swap!(:a, :b) )
-    end
-
-    def test_swapkeys!
-      foo = { :a=>1, :b=>2 }
-      assert_equal( { 'a'=>1, :b=>2 }, foo.swapkey!('a', :a) )
-      assert_equal( { 'a'=>1, 'b'=>2 }, foo.swapkey!('b', :b) )
-      assert_equal( { 'a'=>1, 'b'=>2 }, foo.swapkey!('foo','bar') )
-    end
-
-  end
-
-=end

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

@@ -3,8 +3,8 @@ class Hash
   # In-place version of Hash#select.  The opposite of the built-in
   # Hash#reject!.
   #
-  #   CREDIT Noah Gibbs
   #   CREDIT Gavin Sinclair
+  #   CREDIT Noah Gibbs
 
   def select!
     reject! { |k,v| not yield(k,v) }

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

@@ -0,0 +1,42 @@
+class Hash
+
+  # Returns a new hash with only the given keys.
+
+  def slice(*keep_keys)
+    h = {}
+    keep_keys.each do |key|
+      h[key] = fetch(key)
+    end
+    h
+  end
+
+  # Replaces hash with a new hash having only the given keys.
+  # This return the hash of keys removed.
+
+  def slice!(*keep_keys)
+    removed = except(*keep_keys)
+    replace(slice(*keep_keys))
+    removed
+  end
+
+  # Returns a new hash less the given keys.
+
+  def except(*less_keys)
+    slice(*keys - less_keys)
+  end
+
+  # Replaces hash with new hash less the given keys.
+  # This returns the hash of keys removed.
+  #
+  #   h = {:a=>1, :b=>2, :c=>3}
+  #   h.except!(:a)  #=> {:a=>1}
+  #   h              #=> {:b=>2,:c=>3}
+  #
+  def except!(*less_keys)
+    removed = slice(*less_keys)
+    replace(except(*less_keys))
+    removed
+  end
+
+end
+