facets 2.9.1 → 2.9.2

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

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

data/src/core/facets/hash/op_or.rb

@@ -0,0 +1,12 @@
+class Hash
+
+  # Operator for #reverse_merge.
+  #
+  # CREDIT: Trans
+
+  def |(other)
+    other.merge(self)
+  end
+
+end
+

data/src/core/facets/hash/op_push.rb

@@ -0,0 +1,17 @@
+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)
+      self.store(*other)
+    else
+      update(other)
+    end
+    self
+  end
+
+end

data/src/core/facets/hash/op_sub.rb

@@ -0,0 +1,26 @@
+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 matching keys are removed.
+  #
+  # CREDIT: Trans
+
+  def -(other)
+    h = self.dup
+    if other.respond_to?(:to_ary)
+      other.to_ary.each do |k|
+        h.delete(k)
+      end
+    else
+      other.each do |k,v|
+        if h.key?(k)
+          h.delete(k) if v == h[k]
+        end
+      end
+    end
+    h
+  end
+
+end
+

data/src/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(*types, &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/src/core/facets/hash/recursively.rb

@@ -0,0 +1,61 @@
+require 'facets/functor'
+require 'facets/enumerable/recursively'
+
+class Hash
+
+  # 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=>{: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(*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
+    end
+  end
+
+## 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/src/core/facets/hash/rekey.rb

@@ -0,0 +1,79 @@
+require 'facets/symbol/to_proc'
+require 'facets/na'
+
+class Hash
+
+  # Rekey a hash, ...
+  #
+  #   rekey()
+  #   rekey(from_key => to_key, ...)
+  #   rekey{|from_key| to_key}
+  #
+  # 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=>: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 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                      #=>  { :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(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                       #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #
+  # CREDIT: Trans, Gavin Kistner
+
+  def rekey!(key_map=nil, &block)
+    replace(rekey(key_map, &block))
+  end
+
+end

data/src/core/facets/hash/replace_each.rb

@@ -0,0 +1,16 @@
+class Hash
+
+  # Same as #update_each, but deletes the key element first.
+  #
+  # CREDIT: Trans
+
+  def replace_each  # :yield:
+    dup.each do |k,v|
+      delete(k)
+      update(yield(k,v))
+    end
+    self
+  end
+
+end
+

data/src/core/facets/hash/reverse_merge.rb

@@ -0,0 +1,30 @@
+class Hash
+
+  # Allows for reverse merging where its the keys in the
+  # calling hash that wins over those in the <tt>other_hash</tt>.
+  # This is particularly useful for initializing an incoming
+  # option hash with default values:
+  #
+  #   def setup(options = {})
+  #     options.reverse_merge! :size => 25, :velocity => 10
+  #   end
+  #
+  # The default :size and :velocity is only set if the +options+
+  # passed in doesn't already have those keys set.
+
+  def reverse_merge(other)
+    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
+

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

@@ -0,0 +1,17 @@
+class Hash
+
+  unless method_defined?(:select!)
+
+    # In-place version of Hash#select.  The opposite of the built-in
+    # Hash#reject!.
+    #
+    # CREDIT: Gavin Sinclair, Noah Gibbs
+
+    def select!
+      reject! { |k,v| not yield(k,v) }
+    end
+
+  end
+
+end
+

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

@@ -0,0 +1,37 @@
+class Hash
+
+  # Returns a new hash with only the given keys.
+  #
+  #   h = {:a=>1, :b=>2}
+  #   h.slice(:a)  #=> {:a=>1}
+  #
+  def slice(*keep_keys)
+    hash = {}
+    keep_keys.each do |key|
+      hash[key] = fetch(key)
+    end
+    hash
+  end
+
+  # Replaces hash with a new hash having only the given keys.
+  # This return the hash of keys removed.
+  #
+  #   h = {:a=>1, :b=>2}
+  #   h.slice!(:a)  #=> {:b=>2}
+  #   h             #=> {:a=>1}
+  #
+  # Returns a Hash of the removed pairs.
+  def slice!(*keep_keys)
+    rejected = keys - keep_keys
+    removed = {}
+    rejected.each{ |k| removed[k] = delete(k) }
+    removed
+  end
+
+end
+
+# NOTE: ActiveSupport defines this method but adds a check for #convert_key.
+#       If the method id defined, then it converts the keys with it. However
+#       it doesn't look to be supported by all Hash methods, just
+#       HashWithIndifferentAccess. I'm not so sure support for this kind of
+#       things is appropriate for Facets.

data/src/core/facets/hash/stringify_keys.rb

@@ -0,0 +1 @@
+require 'facets/hash/symbolize_keys'

data/src/core/facets/hash/subset.rb

@@ -0,0 +1,24 @@
+class Hash
+
+  # Take a subset of the hash, based on keys given or a block
+  # that evaluates to true for each hash key.
+  #
+  #   {'a'=>1, 'b'=>2}.subset('a')            #=> {'a'=>1}
+  #   {'a'=>1, 'b'=>2}.subset{|k| k == 'a' }  #=> {'a'=>1}
+  #
+  # CREDIT: Alexey Petrushin
+  def subset(keys=nil, &block)
+    h = {}
+    if keys
+      self.each do |k, v|
+        h[k] = v if keys.include?(k)
+      end
+    else
+      self.each do |k, v|
+        h[k] = v if block.call(k)
+      end
+    end
+    h
+  end
+
+end

data/src/core/facets/hash/swap.rb

@@ -0,0 +1,17 @@
+class Hash
+
+  # Swap the values of a pair of keys in place.
+  #
+  #   {: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]
+    self[key2] = tmp
+    self
+  end
+
+end
+

data/src/core/facets/hash/symbolize_keys.rb

@@ -0,0 +1,92 @@
+class Hash
+
+  # NOTE: These are provided because of their prevalence with Rails users.
+  # We strongly encourage using #rekey instead.
+
+
+  # Return a new hash with all keys converted to symbols. With a +select+ block,
+  # limits conversion to only a certain selection of keys.
+  #
+  #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
+  #   foo.symbolize_keys    #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #   foo                   #=>  { :name =>"Gavin", "wife"=>:Lisa }
+  #
+  # If the key does not respond to #to_sym, then #to_s will be used first.
+  #
+  # For a more versatile method, see #rekey instead.
+
+  def symbolize_keys(&select)
+    dup.symbolize_keys!(&select)
+  end
+
+  # Destructively convert all keys to symbols. This is the same as
+  # Hash#symbolize_keys, but modifies the receiver in place and returns it.
+  # With a +select+ block, limits conversion to only selected keys.
+  #
+  #   foo = { 'name'=>'Gavin', 'wife'=>:Lisa }
+  #   foo.symbolize_keys!    #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #   foo                    #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #
+  # If the key does not respond to #to_sym, then #to_s will be used first.
+  #
+  # For a more versatile method, see #rekey instead.
+
+  def symbolize_keys!(&select)
+    if select
+      keys.each do |key|
+        if select[key]
+          new_key = (key.to_sym rescue key.to_s.to_sym)
+          self[new_key] = delete(key)
+        end
+      end       
+    else
+      keys.each do |key|
+        new_key = (key.to_sym rescue key.to_s.to_sym)
+        self[new_key] = delete(key)
+      end
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings. Converts all keys
+  # in the Hash to Strings, returning a new Hash. With a +select+ block,
+  # limits conversion to only a certain selection of keys.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.stringify_keys    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo                   #=>  { :name =>"Gavin", :wife=>:Lisa }
+  #
+  # This method is considered archaic. Use #rekey instead.
+
+  def stringify_keys(&select)
+    dup.stringify_keys!(&select)
+  end
+
+  # Destructively convert all keys to strings. This is the same as
+  # Hash#stringify_keys, but modifies the receiver in place and
+  # returns it. With a +select+ block, limits conversion to only
+  # certain keys.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.stringify_keys!    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo                    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #
+  # This method is considered archaic. Use #rekey instead.
+
+  def stringify_keys!(&select)
+    if select
+      keys.each do |key|
+        if select[key]
+          self[key.to_s] = delete(key)
+        end
+      end
+    else
+      keys.each do |key|
+        self[key.to_s] = delete(key)
+      end
+    end
+    self
+  end
+
+end
+