mack-facets 0.8.1 → 0.8.2

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

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

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

@@ -0,0 +1,31 @@
+class Hash
+
+  # Modifies the receiving Hash so that the value previously referred to by
+  # _oldkey_ is also referenced by _newkey_; _oldkey_ is retained in the Hash.
+  # If _oldkey_ does not exist as a key in the Hash, no change is effected.
+  #
+  # Returns a reference to the Hash.
+  #
+  #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
+  #   foo.alias!('name',:name)     => { :name=>'Gavin', 'name'=>'Gavin', 'wife'=>:Lisa }
+  #
+  #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
+  #   foo.alias!('spouse','wife')  => { :name=>'Gavin', 'wife'=>:Lisa, 'spouse'=>:Lisa }
+  #
+  #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
+  #   foo.alias!('bar','foo')      => { :name=>'Gavin', 'wife'=>:Lisa }
+  #
+  # Note that if the _oldkey_ is reassigned, the reference will no longer exist,
+  # and the _newkey_ will remain as it was.
+  #
+  #  CREDIT: Gavin Sinclair
+  #
+  # TODO: Rename to #aliaskey or something else.
+
+  def alias!(newkey, oldkey)
+    self[newkey] = self[oldkey] if self.has_key?(oldkey)
+    self
+  end
+
+end
+

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

@@ -0,0 +1,22 @@
+class Hash
+
+  # Turn a hash into arguments.
+  #
+  #   h = { :list => [1,2], :base => "HI" }
+  #   h.argumentize #=> [ [], { :list => [1,2], :base => "HI" } ]
+  #   h.argumentize(:list)   #=> [ [1,2], { :base => "HI" } ]
+  #   h.argumentize(:base)   #=> [ ["HI"], { :list => [1,2] } ]
+  #
+  def argumentize(args_field=nil)
+    config = dup
+    if args_field
+      args = [config.delete(args_field)].flatten.compact
+    else
+      args = []
+    end
+    args << config
+    return args
+  end
+
+end
+

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

@@ -0,0 +1,8 @@
+class Hash
+
+  # Alias for fetch for greater polymorphism with Array.
+  #
+  alias_method :at, :[]
+
+end
+

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

@@ -0,0 +1,42 @@
+class Hash
+
+  #  Hash which auto initializes it's children.
+  #
+  #   ah = Hash.autonew
+  #   ah['section one']['param one'] = 4
+  #   ah['section one']['param two'] = 5
+  #   ah['section one']['param three'] = 2
+  #   ah['section one']['param four'] = 3
+  #
+  #   p ah
+  #   # {"section one"=>{"param one"=>4, "param four"=>3, "param three"=>2, "param two"=>5}}
+  #
+  #   p ah['section one'].keys
+  #   # ["param one", "param four", "param three", "param two"]
+  #
+  #  CREDIT: Trans
+  #  CREDIT: Jan Molic
+
+  def self.autonew(*args)
+    #new(*args){|a,k| a[k] = self.class::new(*args)}
+    leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
+    new(*args,&leet)
+  end
+
+  # Creates a new hash from two arrays --a keys array and
+  # a values array.
+  #
+  #   Hash.zipnew(["a","b","c"], [1,2,3])
+  #     #=> { "a"=>1, "b"=>2, "c"=>3 }
+  #
+  #  CREDIT: Trans
+  #  CREDIT: Ara T. Howard
+
+  def self.zipnew(keys,values) # or some better name
+    h = {}
+    keys.size.times{ |i| h[ keys[i] ] = values[i] }
+    h
+  end
+
+end
+

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

@@ -0,0 +1,45 @@
+class Hash
+
+  # Merge the values of this hash with those from another, setting all values
+  # to be arrays representing the values from both hashes.
+  #
+  #   { :a=>1, :b=>2 }.collate :a=>3, :b=>4, :c=>5
+  #   #=> { :a=>[1,3], :b=>[2,4], :c=>[5] }
+  #
+  #  CREDIT: Gavin Kistner (Phrogz)
+
+  def collate(other_hash)
+    dup.collate!(other_hash)
+  end
+
+  # The same as #collate, but modifies the receiver in place.
+
+  def collate!(other_hash)
+    # Prepare, ensuring every existing key is already an Array
+    each do |key, value|
+      if value.is_a?(Array)
+        self[key] = value
+      else
+        self[key] = [value]
+      end
+    end
+    # Collate with values from other_hash
+    other_hash.each do |key, value|
+      if self[key]
+        if value.is_a?(Array)
+          self[key].concat( value )
+        else
+          self[key] << value
+        end
+      elsif value.is_a?(Array)
+        self[key] = value
+      else
+        self[key] = [value]
+      end
+    end
+    #each{ |key, value| value.uniq! } if options[ :uniq ]
+    self
+  end
+
+end
+

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

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

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

@@ -0,0 +1,11 @@
+class Hash
+
+  # Difference comparison of two hashes.
+
+  def diff(hash)
+    h1 = self.dup.delete_if{ |k,v| hash[k] == v }
+    h2 = hash.dup.delete_if{ |k,v| has_key?(k) }
+    h1.merge(h2)
+  end
+
+end

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

@@ -0,0 +1,27 @@
+class Hash
+
+  # Returns a new hash less the given keys.
+
+  def except(*less_keys)
+    slice(*keys - less_keys)
+  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
+
+  end
+
+end
+

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

@@ -0,0 +1,19 @@
+class Hash
+
+  # As with #store but only if the key isn't
+  # already in the hash.
+  #
+  # TODO: Would #store? be a better name?
+  #
+  #  CREDIT: Trans
+
+  def insert(name, value)
+    if key?(name)
+      false
+    else
+      store(name,value)
+      true
+    end
+  end
+
+end

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

@@ -0,0 +1,27 @@
+class Hash
+
+  # Create a "true" inverse hash by storing mutliple values in Arrays.
+  #
+  #   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
+  #
+  #   CREDIT: Tilo Sloboda
+
+  def inverse
+    i = Hash.new
+    self.each_pair{ |k,v|
+      if (Array === v)
+        v.each{ |x| i[x] = ( i.has_key?(x) ? [k,i[x]].flatten : k ) }
+      else
+        i[v] = ( i.has_key?(v) ? [k,i[v]].flatten : k )
+      end
+    }
+    return i
+  end
+
+end
+

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

@@ -0,0 +1,14 @@
+class Hash
+
+  # Like Array#join but specialized to Hash.
+  #
+  #  CREDIT: Mauricio Fernandez
+
+  def join(pair_divider='', elem_divider='')
+    s = []
+    each_pair { |k,v| s << "#{k}#{pair_divider}#{v}" }
+    s.join(elem_divider)
+  end
+
+end
+

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

@@ -0,0 +1,45 @@
+class Hash
+
+  # Returns true or false whether the hash
+  # contains the given keys.
+  #
+  #   h = { :a => 1, :b => 2 }
+  #   h.has_keys?( :a )   #=> true
+  #   h.has_keys?( :c )   #=> false
+  #
+  #   CREDIT: Trans
+
+  def has_keys?(*check_keys)
+    unknown_keys = check_keys - self.keys
+    return unknown_keys.empty?
+  end
+
+  alias_method :keys?, :has_keys?
+
+  # Returns true if the hash contains
+  # _only_ the given keys, otherwise false.
+  #
+  #   h = { :a => 1, :b => 2 }
+  #   h.has_only_keys?( :a, :b )   #=> true
+  #   h.has_only_keys?( :a )       #=> false
+  #
+  #   CREDIT: Trans
+
+  def has_only_keys?(*check_keys)
+    unknown_keys = self.keys - check_keys
+    return unknown_keys.empty?
+  end
+
+  alias_method :only_keys?, :has_only_keys?
+
+  # Each with key is like each_pair but reverses the order
+  # the parameters to [value,key] instead of [key,value].
+  #
+  #  CREDIT: Trans
+
+  def each_with_key( &yld )
+    each_pair{ |k,v| yld.call(v,k) }
+  end
+
+end
+

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

@@ -0,0 +1,18 @@
+require 'facets/enumerable/mash'
+
+class Hash
+
+  # In place version of #mash.
+  #
+  #   NOTE: Hash#mash! is only useful for Hash. It is not generally
+  #         applicable to Enumerable.
+
+  def mash!(&yld)
+    replace(mash(&yld))
+  end
+
+  # Alias for #mash!. This is the original name for this method.
+  alias_method :graph!, :mash!
+
+end
+

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

@@ -0,0 +1,7 @@
+require 'facets/hash/op_and'
+require 'facets/hash/op_or'
+require 'facets/hash/op_add'
+require 'facets/hash/op_sub'
+require 'facets/hash/op_mul'
+require 'facets/hash/op_push'
+

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

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

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

@@ -0,0 +1,33 @@
+class Hash
+
+  # Hash intersection. Two hashes intersect
+  # when their pairs are equal.
+  #
+  #   {: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}
+  #
+  # The later form is similar to #pairs_at. The differ only
+  # in that #pairs_at will return a nil value for a key
+  # not in the hash, but #& will not.
+  #
+  #   CREDIT: Trans
+
+  def &(other)
+    case other
+    when Array
+      k = (keys & other)
+      Hash[*(k.zip(values_at(*k)).flatten)]
+    else
+      x = (to_a & other.to_a).inject([]) do |a, kv|
+        a.concat kv; a
+      end
+      Hash[*x]
+    end
+  end
+
+end
+