mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/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/lib/gems/facets-2.4.5/lib/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/lib/gems/facets-2.4.5/lib/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/lib/gems/facets-2.4.5/lib/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/lib/gems/facets-2.4.5/lib/core/facets/hash/recursive_merge.rb

@@ -0,0 +1,33 @@
+class Hash
+
+  # Same as Hash#merge but recursively merges sub-hashes.
+
+  def recursive_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)
+      else
+        hash[key] = value
+      end
+    end
+    hash
+  end
+
+  # Same as Hash#merge! but recursively merges sub-hashes.
+
+  def recursive_merge!(other)
+    other.each do |key, value|
+      myval = self[key]
+      if value.is_a?(Hash) && myval.is_a?(Hash)
+        myval.recursive_merge!(value)
+      else
+        self[key] = value
+      end
+    end
+    self
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/hash/recursively.rb

@@ -0,0 +1,29 @@
+class Hash
+
+  # Apply a block to hash, and recursively apply that block
+  # to each subhash.
+  #
+  #   h = {:a=>1, :b=>{:b1=>1, :b2=>2}}
+  #   h.recursively{|h| h.rekey(&:to_s) }
+  #   => {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
+  #
+  def recursively(&block)
+    h = inject({}) do |hash, (key, value)|
+      if value.is_a?(Hash)
+        hash[key] = value.recursively(&block)
+      else
+        hash[key] = value
+      end
+      hash
+    end
+    yield h
+  end
+
+  #
+
+  def recursively!(&block)
+    replace(recursively(&block))
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/hash/rekey.rb

@@ -0,0 +1,59 @@
+require 'facets/symbol/to_proc'
+
+class Hash
+
+  # rekey(to_key, from_key)
+  # rekey{ |key| ... }
+  #
+  # If two keys are given, then the second key is changed to
+  # the first.
+  #
+  #   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 }
+  #
+  # If a block is given, converts all keys in the Hash accroding
+  # to the given block. If the block returns +nil+ for 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 }
+  #
+  #  CREDIT: Trans
+  #  CREDIT: Gavin Kistner
+
+  def rekey(*args, &block)
+    dup.rekey!(*args, &block)
+  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 }
+  #
+  #  CREDIT: Trans
+  #  CREDIT: 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
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/hash/select.rb

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

data/lib/gems/facets-2.4.5/lib/core/facets/hash/slice.rb

@@ -0,0 +1,33 @@
+require "facets/hash/except"
+
+class Hash
+
+  unless defined?(::ActiveSupport)  # ActiveSupport
+
+    # 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.
+    #
+    #   h = {:a=>1, :b=>2}
+    #   h.slice!(:a)  #=> {:a=>1}
+    #   h             #=> {:b=>2}
+    #
+    def slice!(*keep_keys)
+      removed = except(*keep_keys)
+      replace(slice(*keep_keys))
+      removed
+    end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/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/lib/gems/facets-2.4.5/lib/core/facets/hash/to_h.rb

@@ -0,0 +1 @@
+require 'facets/to_hash'

data/lib/gems/facets-2.4.5/lib/core/facets/hash/to_proc.rb

@@ -0,0 +1,41 @@
+class Hash
+
+  # 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
+  #
+  # CREDIT: Trans
+
+  def to_proc
+    lambda do |o|
+      self.each do |k,v|
+        ke = "#{k}="
+        o.__send__(ke, v)
+      end
+    end
+  end
+
+  # A fault-tolerent version of #to_proc.
+  #
+  # It works just like #to_proc, but the block will make
+  # sure# the object responds to the assignment.
+  #
+  # CREDIT: Trans
+
+  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
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/hash/to_struct.rb

@@ -0,0 +1,17 @@
+class Hash
+
+  # A method to convert a Hash into a Struct.
+  #
+  #   h = {:name=>"Dan","age"=>33,"rank"=>"SrA","grade"=>"E4"}
+  #   s = h.to_struct("Foo")
+  #
+  # TODO: Is this robust enough considerd hashes aren't ordered?
+  #
+  #  CREDIT: Daniel Berger
+
+  def to_struct(struct_name)
+    Struct.new(struct_name,*keys).new(*values)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/hash/traverse.rb

@@ -0,0 +1,41 @@
+class Hash
+
+  # Returns a new hash created by traversing the hash and its subhashes,
+  # executing the given block on the key and value. The block should
+  # return a 2-element array of the form +[key, value]+.
+  #
+  #   h = { "A"=>"A", "B"=>"B" }
+  #   g = h.traverse { |k,v| [k.downcase, v] }
+  #   g  #=> { "a"=>"A", "b"=>"B" }
+  #
+  # TODO: Contrast these to recursibely --we may not need both.
+  #
+  # TODO: Testing value to see if it is a Hash also catches subclasses of Hash.
+  #       This is probably not the right thing to do and should catch Hashes only (?)
+  #
+  #  CREDIT: Trans
+
+  def traverse(&b)
+    inject({}) do |h,(k,v)|
+      v = ( Hash === v ? v.traverse(&b) : v )
+      nk, nv = b[k,v]
+      h[nk] = nv #( Hash === v ? v.traverse(base,&b) : nv )
+      h
+    end
+  end
+
+  # In place version of traverse, which traverses the hash and its
+  # subhashes, executing the given block on the key and value.
+  #
+  #   h = { "A"=>"A", "B"=>"B" }
+  #   h.traverse! { |k,v| [k.downcase, v] }
+  #   h  #=> { "a"=>"A", "b"=>"B" }
+  #
+  #  CREDIT: Trans
+
+  def traverse!(&b)
+    self.replace( self.traverse(&b) )
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/hash/update.rb

@@ -0,0 +1,81 @@
+require 'facets/hash/op_push'  # for backward compatibility
+
+class Hash
+
+  # Iterates through each pair and updates a the hash
+  # in place. This is formally equivalent to #mash!
+  # But does not use #mash to accomplish the task.
+  # Hence #update_each is probably a touch faster.
+  #
+  #  CREDIT: Trans
+
+  def update_each  # :yield:
+    dup.each do |k,v|
+     update(yield(k,v))
+    end
+    self
+  end
+
+  # Iterate over hash updating just the keys.
+  #
+  #   h = {:a=>1, :b=>2}
+  #   h.update_keys{ |k| "#{k}!" }
+  #   h  #=> { "a!"=>1, "b!"=>2 }
+  #
+  #  CREDIT: Trans
+
+  def update_keys #:yield:
+    if block_given?
+      keys.each { |old_key| store(yield(old_key), delete(old_key)) }
+    else
+      to_enum(:update_keys)
+    end
+  end
+
+  # Iterate over hash updating just the values.
+  #
+  #   h = {:a=>1, :b=>2}
+  #   h.update_values{ |v| v+1 }
+  #   h  #=> { a:=>2, :b=>3 }
+  #
+  #  CREDIT: Trans
+
+  def update_values #:yield:
+    if block_given?
+      each{ |k,v| store(k, yield(v)) }
+    else
+      to_enum(:update_values)
+    end
+  end
+
+  # 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
+
+
+=begin :spec:
+
+require 'quarry/spec'
+
+Quarry.specification "Hash" do
+
+  demonstrate "<<" do
+    h = {}
+    (h << [:a,1]).assert == h
+    h[:a].assert == 1
+  end
+
+end
+
+=end
+