mack-facets 0.8.2 → 0.8.3

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

@@ -1,18 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

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

@@ -1,41 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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
-