facets 2.8.4 → 2.9.0.pre.1

data/lib/core/facets/hash/{recursive_merge.rb → deep_merge.rb}

@@ -1,16 +1,13 @@
 class Hash
 
   # Same as Hash#merge but recursively merges sub-hashes.
-  #
-  # DEPRECATE: This method will be deprecated in favor of
-  # <code>recursive.merge</code>.
 
-  def recursive_merge(other)
+  def deep_merge(other)
     hash = self.dup
     other.each do |key, value|
       myval = self[key]
       if value.is_a?(Hash) && myval.is_a?(Hash)
-        hash[key] = myval.recursive_merge(value)
+        hash[key] = myval.deep_merge(value)
       else
         hash[key] = value
       end
@@ -19,15 +16,12 @@ class Hash
   end
 
   # Same as Hash#merge! but recursively merges sub-hashes.
-  #
-  # DEPRECATE: This method will be deprecated in favor of
-  # <code>recursive.merge!</code>.
 
-  def recursive_merge!(other)
+  def deep_merge!(other)
     other.each do |key, value|
       myval = self[key]
       if value.is_a?(Hash) && myval.is_a?(Hash)
-        myval.recursive_merge!(value)
+        myval.deep_merge!(value)
       else
         self[key] = value
       end

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

@@ -1,47 +1,4 @@
-class Hash
-
-  alias_method :delete_at, :delete
-
-  # Inverse of #delete_if.
-  #
-  #
-  #
-  # CREDIT: Daniel Schierbeck
-
-  def delete_unless #:yield:
-    delete_if{ |key, value| ! yield(key, value) }
-  end
-
-  # Minor modification to Ruby's Hash#delete method
-  # allowing it to take multiple keys.
-  #
-  #   hsh = { :a => 1, :b => 2 }
-  #   hsh.delete_values(1)
-  #   hsh  #=> { :b => 2 }
-  #
-  # CREDIT: Daniel Schierbeck
-
-  def delete_values(*values)
-    keys.map{ |key| delete(key) if values.include?(fetch(key)) }
-  end
-
-  # Minor modification to Ruby's Hash#delete method
-  # allowing it to take multiple keys.
-  #
-  # This works niely with hash#[] and Hash#[]= facets.
-  #
-  #    hsh[:a, :b, :c] = 1, 2, 3
-  #
-  #    a, b, c = hsh.delete_values_at(:a, :b, :c)
-  #
-  #    [a, b, c]  #=> [1, 2, 3]
-  #    hsh        #=> {}
-  #
-  # CREDIT: Daniel Schierbeck
-
-  def delete_values_at(*keys, &yld)
-    keys.map{|key| delete(key, &yld) }
-  end
-
-end
-
+# TODO: should we deprecate hash/delete?
+require 'facets/hash/delete_at'
+require 'facets/hash/delete_values'
+require 'facets/hash/delete_unless'

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

@@ -0,0 +1,7 @@
+class Hash
+
+  # Polymorphic with Array#delete_at.
+  alias_method :delete_at, :delete
+
+end
+

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

@@ -0,0 +1,17 @@
+class Hash
+
+  # Inverse of #delete_if.
+  #
+  #   h = { :a => 1, :b => 2, :c => 3 }
+  #   r = h.delete_unless{|k,v| v == 1}
+  #   r  #=> { :a => 1 }
+  #   h  #=> { :a => 1 }
+  #
+  # CREDIT: Daniel Schierbeck
+
+  def delete_unless #:yield:
+    delete_if{ |key, value| ! yield(key, value) }
+  end
+
+end
+

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

@@ -0,0 +1,32 @@
+class Hash
+
+  # Minor modification to Ruby's Hash#delete method
+  # allowing it to take multiple keys.
+  #
+  #   hsh = { :a => 1, :b => 2 }
+  #   hsh.delete_values(1)
+  #   hsh  #=> { :b => 2 }
+  #
+  # CREDIT: Daniel Schierbeck
+
+  def delete_values(*values)
+    keys.map{ |key| delete(key) if values.include?(fetch(key)) }
+  end
+
+  # Minor modification to Ruby's Hash#delete method
+  # allowing it to take multiple keys.
+  #
+  #    hsh = {:a=>1, :b=>2, :c=>3}
+  #
+  #    a, b, c = hsh.delete_values_at(:a, :b, :c)
+  #
+  #    [a, b, c]  #=> [1, 2, 3]
+  #    hsh        #=> {}
+  #
+  # CREDIT: Daniel Schierbeck
+
+  def delete_values_at(*keys, &yld)
+    keys.map{|key| delete(key, &yld) }
+  end
+
+end

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

@@ -1,7 +1,13 @@
 class Hash
 
   # Difference comparison of two hashes.
-
+  #
+  #   h1 = {:a=>1,:b=>2}
+  #   h2 = {:a=>1,:b=>3}
+  #
+  #   h1.diff(h2)  #=> {:b=>2}
+  #   h2.diff(h1)  #=> {:b=>3}
+  #
   def diff(hash)
     h1 = self.dup.delete_if{ |k,v| hash[k] == v }
     h2 = hash.dup.delete_if{ |k,v| has_key?(k) }

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

@@ -1,26 +1,24 @@
 class Hash
 
   # Returns a new hash less the given keys.
-
   def except(*less_keys)
-    slice(*keys - less_keys)
+    hash = dup
+    less_keys.each{ |k| hash.delete(k) }
+    hash
   end
 
-  unless defined?(::ActiveSupport)
-
-    # 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
-
+  # 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}
+  #
+  # Returns a Hash of the removed pairs.
+  def except!(*rejected)
+    removed = {}
+    rejected.each{ |k| removed[k] = delete(k) }
+    removed
   end
 
 end

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

@@ -4,10 +4,13 @@ class Hash
   #
   #   h = {"a"=>3, "b"=>3, "c"=>3, "d"=>2, "e"=>9, "f"=>3, "g"=>9}
   #
-  #   h.invert                #=> {2=>"d", 3=>"f", 9=>"g"}
-  #   h.inverse               #=> {2=>"d", 3=>["f", "c", "b", "a"], 9=>["g", "e"]}
-  #   h.inverse.inverse       #=> {"a"=>3, "b"=>3, "c"=>3, "d"=>2, "e"=>9, "f"=>3, "g"=>9}
-  #   h.inverse.inverse == h  #=> true
+  #   h.invert           #=> {2=>"d", 3=>"f", 9=>"g"}
+  #   h.inverse          #=> {2=>"d", 3=>["f", "c", "b", "a"], 9=>["g", "e"]}
+  #   h.inverse.inverse  #=> {"a"=>3, "b"=>3, "c"=>3, "d"=>2, "e"=>9, "f"=>3, "g"=>9}
+  #
+  # Of course the inverse of the inverse should be the same.
+  #
+  #   (h.inverse.inverse == h)  #=> true
   #
   # CREDIT: Tilo Sloboda
 

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

@@ -2,13 +2,16 @@ class Hash
 
   # Like Array#join but specialized to Hash.
   #
+  # NOTE: Without Ruby 1.9 this would be difficult to rely on becuase
+  # hashes did not have a strict order.
+  #
   # CREDIT: Mauricio Fernandez
 
-  def join(pair_divider='', elem_divider='')
+  def join(pair_divider='', elem_divider=nil)
+    elem_divider ||= pair_divider
     s = []
-    each_pair { |k,v| s << "#{k}#{pair_divider}#{v}" }
+    each{ |k,v| s << "#{k}#{pair_divider}#{v}" }
     s.join(elem_divider)
   end
 
 end
-

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

@@ -3,7 +3,7 @@ class Hash
   # Instantiate a new hash with a default
   # value determined by the block.
   # 
-  # Hash.new_with { [] } 
+  # Hash.new_with{ [] } 
   #
   # CREDIT: Pit Capitan
 

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

@@ -3,12 +3,12 @@ class Hash
   # Hash intersection. Two hashes intersect
   # when their pairs are equal.
   #
-  #   {:a=>1,:b=>2} & {:a=>1,:c=>3}  #=> {:a=>1}
+  #   ({:a=>1,:b=>2} & {:a=>1,:c=>3})  #=> {:a=>1}
   #
   # A hash can also be intersected with an array
   # to intersect keys only.
   #
-  #   {:a=>1,:b=>2} & [:a,:c]  #=> {:a=>1}
+  #   ({:a=>1,:b=>2} & [:a,:c])  #=> {:a=>1}
   #
   # The later form is similar to #pairs_at. The differ only
   # in that #pairs_at will return a nil value for a key

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

@@ -2,11 +2,11 @@ class Hash
 
   # Like merge operator '+' but merges in reverse order.
   #
-  #   h1 = { :a=>1 }
-  #   h2 = { :a=>2, :b=>3 }
+  #   h1 = {:a=>1}
+  #   h2 = {:a=>2, :b=>3}
   #
-  #   h1 + h2  #=> { :a=>2, :b=>3 }
-  #   h1 * h2  #=> { :a=>1, :b=>3 }
+  #   (h1 + h2) #=> { :a=>2, :b=>3 }
+  #   (h1 * h2)  #=> { :a=>1, :b=>3 }
   #
   # CREDIT: Trans
 

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

@@ -0,0 +1,29 @@
+class Hash
+
+  # Apply a block to hash, and recursively apply that block
+  # to each sub-hash or +types+.
+  #
+  #   h = {:a=>1, :b=>{:b1=>1, :b2=>2}}
+  #   g = h.recurse{|h| h.inject({}){|h,(k,v)| h[k.to_s] = v; h} }
+  #   g  #=> {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
+  #
+  def recurse(*types, &block)
+    types = [self.class] if types.empty?
+    h = inject({}) do |hash, (key, value)|
+      case value
+      when *types
+        hash[key] = value.recurse(&block)
+      else
+        hash[key] = value
+      end
+      hash
+    end
+    yield h
+  end
+
+  # In place form of #recurse.
+  def recurse!(&block)
+    replace(recurse(&block))
+  end
+
+end

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

@@ -1,29 +1,61 @@
+require 'facets/functor'
+require 'facets/enumerable/recursively'
+
 class Hash
 
-  # Apply a block to hash, and recursively apply that block
-  # to each subhash.
+  # Apply a block to a hash, and recursively apply that block
+  # to each sub-hash:
+  #
+  #   h = {:a=>1, :b=>{:x=>1, :y=>2}}
+  #   h.recursively.map{ |k,v| [k.to_s, v] }
+  #   #=> [["a", 1], ["b", [["y", 2], ["x", 1]]]]
+  #
+  # The recursive iteration can be treated separately from the non-recursive
+  # iteration by passing a block to the #recursive method:
   #
-  #   h = {:a=>1, :b=>{:b1=>1, :b2=>2}}
-  #   h.recursively{|h| h.rekey(&:to_s) }
-  #   => {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
+  #   h = {:a=>1, :b=>{:x=>1, :y=>2}}
+  #   h.recursively{ |k,v| [k.to_s, v] }.map{ |k,v| [k.to_s, v.to_s] }
+  #   #=> [["a", "1"], ["b", [["y", "2"], ["x", "1"]]]]
   #
-  def recursively(&block)
-    warn "Use #recusive instead of #recursively for future versions"
-    h = inject({}) do |hash, (key, value)|
-      if value.is_a?(Hash)
-        hash[key] = value.recursively(&block)
-      else
-        hash[key] = value
+  def recursively(*types, &block)
+    Recursor.new(self, *types, &block)
+  end
+
+  class Recursor < Enumerable::Recursor #:nodoc:
+    def method_missing(op, &yld)
+      yld = yld    || lambda{ |k,v| [k,v] }  # ? to_enum
+      rec = @block || yld #lambda{ |k,v| [k,v] }
+      @enum.__send__(op) do |k,v|
+        case v
+        when String # b/c of 1.8
+          yld.call(k,v)
+        when *@types
+          res = v.recursively(*@types, &@block).__send__(op,&yld)
+          rec.call(k, res)
+        else
+          yld.call(k,v)
+        end
       end
-      hash
     end
-    yield h
   end
 
-  # In place form of #recursively.
-
-  def recursively!(&block)
-    replace(recursively(&block))
+## TODO: When no longer need 1.8.6 support.
+=begin
+  def recursively(*types, &block)
+    types = types.empty? ? [self.class] : types
+    Functor.new do |op, &yld|
+      rec = block || yld
+      __send__(op) do |k,v|
+        case v
+        when *types
+          rec.call(k, v.recursively(*types, &block).__send__(op,&yld))
+        else
+          yld.call(k,v)
+        end
+      end
+    end
   end
+=end
 
 end
+

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

@@ -1,63 +1,79 @@
 require 'facets/symbol/to_proc'
+require 'facets/na'
 
 class Hash
 
-  # Rekey a hash.
+  # Rekey a hash, ...
   #
   #   rekey()
-  #   rekey(to_key, from_key)
-  #   rekey{ |key| ... }
+  #   rekey(from_key => to_key, ...)
+  #   rekey{|from_key| to_key}
   #
-  # If no arguments or block are given, then all keys are converted
-  # to Symbols.
-  #
-  # If two keys are given, then the second key is changed to
-  # the first. You can think of it as +alias+ for hash keys.
+  # If a key map is given, then the first key is changed to the second key.
   #
   #   foo = { :a=>1, :b=>2 }
-  #   foo.rekey('a',:a)       #=> { 'a'=>1, :b=>2 }
-  #   foo.rekey('b',:b)       #=> { 'a'=>1, 'b'=>2 }
-  #   foo.rekey('foo','bar')  #=> { 'a'=>1, 'b'=>2 }
+  #   foo.rekey(:a=>'a')       #=> { 'a'=>1, :b=>2 }
+  #   foo.rekey(:b=>:x)        #=> { :a =>1, :x=>2 }
+  #   foo.rekey('foo'=>'bar')  #=> { :a =>1, :b=>2 }
   #
-  # If a block is given, converts all keys in the Hash accroding
-  # to the given block. If the block returns +nil+ for given key,
+  # If a block is given, converts all keys in the Hash accroding to the
+  # given block procedure. If the block returns +NA+ for a given key,
   # then that key will be left intact.
   #
   #   foo = { :name=>'Gavin', :wife=>:Lisa }
   #   foo.rekey{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #   foo.inspect              #=>  { :name =>"Gavin", :wife=>:Lisa }
+  #   foo                      #=>  { :name =>"Gavin", :wife=>:Lisa }
+  #
+  # If no key map or block is given, then all keys are converted
+  # to Symbols.
+  #
+  # Note that if both a +key_map+ and a block are given, the +key_map+ is 
+  # applied first then the block.
   #
   # CREDIT: Trans, Gavin Kistner
 
-  def rekey(*args, &block)
-    dup.rekey!(*args, &block)
+  def rekey(key_map=nil, &block)
+    if !(key_map or block)
+      block = lambda{|k| k.to_sym}
+    end
+
+    key_map ||= {} 
+
+    hash = {}
+
+    (keys - key_map.keys).each do |key|
+      hash[key] = self[key]
+    end
+
+    key_map.each do |from, to|
+      hash[to] = self[from] if key?(from)
+    end
+
+    hash2 = {}
+
+    if block
+      hash.each do |k, v|
+        nk = block[k]
+        nk = (NA == nk ? k : nk)
+        hash2[nk] = v
+      end
+    else
+      hash2 = hash
+    end
+
+    hash2
   end
 
   # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
   #
   #   foo = { :name=>'Gavin', :wife=>:Lisa }
   #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #   foo.inspect               #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo                       #=>  { "name"=>"Gavin", "wife"=>:Lisa }
   #
   # CREDIT: Trans, Gavin Kistner
 
-  def rekey!(*args, &block)
-    # for backward comptability (TODO: DEPRECATE).
-    block = args.pop.to_sym.to_proc if args.size == 1
-    # if no args use block.
-    if args.empty?
-      block = lambda{|k| k.to_sym} unless block
-      keys.each do |k|
-        nk = block[k]
-        self[nk]=delete(k) if nk
-      end
-    else
-      raise ArgumentError, "3 for 2" if block
-      to, from = *args
-      self[to] = self.delete(from) if self.has_key?(from)
-    end
-    self
+  def rekey!(key_map=nil, &block)
+    replace(rekey(key_map, &block))
   end
 
 end
-