facets 2.9.2 → 2.9.3

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

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

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

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

@@ -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/src/core/facets/hash/symbolize_keys.rb

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

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

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

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

@@ -1,33 +0,0 @@
-class Hash
-
-  # Convert a hash into a module.
-  #
-  #   {:a=>1, :b=>2}.to_mod
-  #
-  # Can take a block accepting key, value pairs which will be
-  # evaluated in the context of the module.
-  #
-  #   h = {:a=>1, :b=>2}
-  #   m = h.to_mod{ |k,v| module_function k }
-  #   m.a #=> 1
-  #   m.b #=> 2
-  #
-  # CREDIT: Jay Fields
-  #--
-  # TODO: Consider #to_obj?
-  #++
-
-  def to_mod(&block)
-    hash = self
-    Module.new do
-      hash.each do |key, value|
-        define_method key do
-          value #.to_object
-        end
-        instance_exec(key, value, &block) if block
-      end
-    end
-  end
-
-end
-

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

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

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

@@ -1,39 +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.
-  #
-  #   c = Class.new do
-  #     attr_accessor :a
-  #   end
-  #
-  #   h = {:a => 1}
-  #   o = c.new
-  #   h.to_proc.call(o)
-  #   o.a  #=> 1
-  #
-  # If +response+ is set to +true+, then assignment will only occur
-  # if receiver responds_to? the writer method.
-  #
-  # CREDIT: Trans
-
-  def to_proc(response=false)
-    if response
-      lambda do |o|
-        self.each do |k,v|
-          ke = "#{k}="
-          o.__send__(ke, v) if respond_to?(ke)
-        end
-      end
-    else
-      lambda do |o|
-        self.each do |k,v|
-          ke = "#{k}="
-          o.__send__(ke, v)
-        end
-      end
-    end
-  end
-
-end
-

data/src/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/src/core/facets/hash/traverse.rb

@@ -1,47 +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", "C"=>{"X"=>"X"}}
-  #
-  #   g = h.traverse{ |k,v| [k.downcase, v] }
-  #
-  #   g  #=> {"a"=>"A", "b"=>"B", "c"=>{"x"=>"X"}}
-  #
-  # NOTE: Hash#traverse is the same as `recursive.graph` and
-  # might be deprecated in the future (if it ever works!)
-  #
-  # CREDIT: Trans
-
-  def traverse(&block)
-    inject({}) do |h,(k,v)|
-      if Hash === v
-        v = v.traverse(&block)
-      elsif v.respond_to?(:to_hash)
-        v = v.to_hash.traverse(&block)
-      end
-      nk, nv = block.call(k,v)
-      h[nk] = 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!(&block)
-    replace(traverse(&block))
-  end
-
-end
-

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

@@ -1,6 +0,0 @@
-# -- for backward compatibility. To be deprecated.
-require 'facets/hash/op_push'
-require 'facets/hash/update_each'
-require 'facets/hash/update_keys'
-require 'facets/hash/update_values'
-

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

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

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

@@ -1,20 +0,0 @@
-class Hash
-
-  # 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
-
-end
-

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

@@ -1,20 +0,0 @@
-class Hash
-
-  # 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
-
-end
-

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

@@ -1,76 +0,0 @@
-class Hash
-
-  # Weave is a very uniqe hash operator. I is designed
-  # to merge to complex hashes in according to sensible,
-  # regular pattern. The effect is akin to inheritance.
-  #
-  # Two hashes are weaved together to produce a new hash.
-  # The two hashes need to be compatible according to the
-  # following rules for each node: ...
-  #
-  #   hash,   hash    => hash (recursive +)
-  #   hash,   array   => error
-  #   hash,   value   => error
-  #   array,  hash    => error
-  #   array,  array   => array + array
-  #   array,  value   => array << value
-  #   value,  hash    => error
-  #   value,  array   => array.unshift(valueB)
-  #   value1, value2  => value2
-  #
-  # Here is a basic example:
-  #
-  #   h1 = { :a => 1, :b => [ 1 ], :c => { :x => 1 } }
-  #   h2 = { :a => 2, :b => [ 2 ], :c => { :x => 2 } }
-  #
-  #   h1.weave(h2)
-  #   #=> {:b=>[1, 2], :c=>{:x=>2}, :a=>2}
-  #
-  # Weave follows the most expected pattern of unifying two complex
-  # hashes. It is especially useful for implementing overridable
-  # configuration schemes.
-  #
-  # CREDIT: Thomas Sawyer
-
-  def weave(h)
-    raise ArgumentError, "Hash expected" unless h.kind_of?(Hash)
-    s = self.clone
-    h.each { |k,node|
-      node_is_hash = node.kind_of?(Hash)
-      node_is_array = node.kind_of?(Array)
-      if s.has_key?(k)
-        self_node_is_hash = s[k].kind_of?(Hash)
-        self_node_is_array = s[k].kind_of?(Array)
-        if self_node_is_hash
-          if node_is_hash
-            s[k] = s[k].weave(node)
-          elsif node_is_array
-            raise ArgumentError, 'Incompatible hash addition' #self[k] = node
-          else
-            raise ArgumentError, 'Incompatible hash addition' #self[k] = node
-          end
-        elsif self_node_is_array
-          if node_is_hash
-            raise ArgumentError, 'Incompatible hash addition' #self[k] = node
-          elsif node_is_array
-            s[k] += node
-          else
-            s[k] << node
-          end
-        else
-          if node_is_hash
-            raise ArgumentError, 'Incompatible hash addition' #self[k] = node
-          elsif node_is_array
-            s[k].unshift( node )
-          else
-            s[k] = node
-          end
-        end
-      else
-        s[k] = node
-      end
-    }
-    s
-  end
-
-end

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

@@ -1,18 +0,0 @@
-class Hash
-
-  # Creates a new hash from two separate arrays, a +keys+ array and
-  # a +values+ array.
-  #
-  #   Hash.zip(["a","b","c"], [1,2,3])
-  #   # => { "a"=>1, "b"=>2, "c"=>3 }
-  #
-  # CREDIT: Trans, Ara T. Howard
-
-  def self.zip(keys,values) # or some better name
-    h = {}
-    keys.size.times{ |i| h[ keys[i] ] = values[i] }
-    h
-  end
-
-end
-