facets 2.9.3 → 3.0.0

data/lib/core/facets/hash/each_with_key.rb

@@ -0,0 +1,12 @@
+class Hash
+
+  # 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/core/facets/hash/fetch_nested.rb

@@ -0,0 +1,20 @@
+class Hash
+
+  # Similar to Hash#fetch but supports nested lookup and is `nil` safe.
+  #
+  #     {}.fetch_nested('anything','at','all')  #=> nil
+  #
+  #     h = {'hello'=>{'world'=>42}}
+  #     h.fetch_nested(*['hello','world'])  #=> 42
+  #
+  # CREDIT: T. Yamada and Sean Mackesey
+
+  def fetch_nested(*keys)
+    begin
+      keys.reduce(self){|accum, k| accum.fetch(k)}
+	rescue (RUBY_VERSION<'1.9' ? IndexError : KeyError)
+      block_given? ? yield(*keys) : nil
+    end
+  end
+
+end

data/lib/core/facets/hash/keys.rb

@@ -9,12 +9,12 @@ class Hash
   #
   # CREDIT: Trans
 
-  def has_keys?(*check_keys)
+  def keys?(*check_keys)
     unknown_keys = check_keys - self.keys
     return unknown_keys.empty?
   end
 
-  alias_method :keys?, :has_keys?
+  alias_method :has_keys?, :keys?
 
   # Returns true if the hash contains
   # _only_ the given keys, otherwise false.
@@ -25,21 +25,12 @@ class Hash
   #
   # CREDIT: Trans
 
-  def has_only_keys?(*check_keys)
+  def 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
+  alias_method :has_only_keys?, :only_keys?
 
 end
 

data/lib/core/facets/hash/only_keys.rb

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

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

@@ -7,11 +7,19 @@ class Hash
 
   def <<(other)
     if other.respond_to?(:to_ary)
-      self.store(*other)
+      store(*other)
     else
       update(other)
     end
     self
   end
 
+  #def <<(pairs)
+  #  if Array === pairs
+  #    merge! Hash[*pairs]
+  #  else
+  #    merge! pairs
+  #  end
+  #end
+
 end

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

@@ -1,6 +1,6 @@
 class Hash
 
-  # Operator for remove hash paris. If another hash is given
+  # Operator for removing hash pairs. 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.
   #

data/lib/core/facets/hash/recursively.rb

@@ -6,16 +6,16 @@ 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]]]]
+  #     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"]]]]
+  #     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)

data/lib/core/facets/hash/rekey.rb

@@ -1,15 +1,11 @@
-require 'facets/symbol/to_proc'
-require 'facets/na'
-
 class Hash
 
-  # TODO: Improve Hash#rekey code!!!
-
   # Rekey a hash:
   #
   #   rekey()
   #   rekey(from_key => to_key, ...)
   #   rekey{|from_key| to_key}
+  #   rekey{|from_key, value| to_key}
   #
   # If a key map is given, then the first key is changed to the second key.
   #
@@ -19,8 +15,7 @@ class Hash
   #   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.
+  # given block procedure.
   #
   #   foo = { :name=>'Gavin', :wife=>:Lisa }
   #   foo.rekey{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
@@ -29,49 +24,46 @@ class Hash
   # 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.
+  # Raises an ArgumentError if both a +key_map+ and a block are given.
+  # If both are needed just call #rekey twice.
+  #
+  # TODO: If `nil` is returned by block should the key be set to `nil` or the orignal key?
   #
   # CREDIT: Trans, Gavin Kistner
 
   def rekey(key_map=nil, &block)
+    raise ArgumentError, "argument or block" if key_map && block
+
     if !(key_map or block)
       block = lambda{|k| k.to_sym}
     end
 
-    key_map ||= {} 
-
-    hash = dup.replace({})  # to keep default_proc
-
-    (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
-
     if block
-      hash2 = dup.replace({})
-      case block.arity
-      when 2  # TODO: is this condition needed?
-        hash.each do |k, v|
-          nk = block.call(k,v)
-          nk = (NA == nk ? k : nk)
-          hash2[nk] = v
+      hash = dup.clear
+      if block.arity.abs == 1
+        each_pair do |k, v|
+          hash[block[k]] = v     #hash[block[k] || k] = v
         end
       else
-        hash.each do |k, v|
-          nk = block.call(k)
-          nk = (NA == nk ? k : nk)
-          hash2[nk] = v
+        each_pair do |k, v|
+          hash[block[k,v]] = v   #hash[block[k,v] || k] = v
         end
       end
     else
-      hash2 = hash
+      #hash = dup.clear  # to keep default_proc
+      #(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
+      hash = dup  # to keep default_proc
+      key_map.each_pair do |from, to|
+        hash[to] = hash.delete(from) if hash.key?(from)
+      end
     end
 
-    hash2
+    hash
   end
 
   # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).

data/lib/core/facets/hash/revalue.rb

@@ -0,0 +1,61 @@
+class Hash
+
+  # Generates a new hash where the values are the result of the passed in
+  # block.  The block takes both the key and value of the current entry as
+  # arguments.
+  #
+  #     hash = { a: 1, b: 2 }
+  #     hash.revalue { |v| v + 1 }  # => { a: 2, b: 3 }
+  #
+  # Returns [Hash].
+  #
+  # Credit: Sean Mackesey
+
+  def revalue(val_map=nil, &block)
+    raise ArgumentError, "argument or block, not both" if val_map && block
+
+    if !(val_map or block)
+      raise ArgumentError, "must provide Hash arguments or a block"
+      #block = lambda{|v| v.to_s}
+    end
+
+    if block
+      hash = dup.clear  # to keep default_proc
+      if block.arity.abs == 1
+        each_pair do |k, v|
+          hash[k] = block[v]     #hash[k] = block[v] || v
+        end
+      else
+        each_pair do |k, v|
+          hash[k] = block[k,v]   #hash[k] = block[k,v] || v
+        end
+      end
+    else
+      hash = dup.clear  # to keep default_proc
+      each do |k,v|
+        if val_map.key?(v)
+          hash[k] = val_map[v]
+        else
+          hash[k] = v
+        end
+      end
+    end
+
+    hash
+  end
+
+  # The in-place version of Hash#revalue.
+  #
+  #     hash = { a: 1, b: 2 }
+  #     hash.revalue! { |v| v + 1 }
+  #     hash  # => { a: 2, b: 3 }
+  #
+  # Returns [Hash].
+  #
+  # Credit: Sean Mackesey
+
+  def revalue!(val_map=nil, &block)
+    replace(revalue(val_map, &block))
+  end
+
+end

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

@@ -2,13 +2,20 @@ class Hash
 
   # Returns a new hash with only the given keys.
   #
-  #   h = {:a=>1, :b=>2}
-  #   h.slice(:a)  #=> {:a=>1}
+  #   h = {:a=>1, :b=>2, :c=>3}
+  #   h.slice(:a, :c)  #=> {:a=>1, :c=>3}
+  #   h.slice(:a, :d)  #=> {:a=>1}
   #
   def slice(*keep_keys)
+    if block_given?
+      each do |k, v|
+        keep_keys << k if yield(k, v)
+      end
+    end
+
     hash = {}
     keep_keys.each do |key|
-      hash[key] = fetch(key)
+      hash[key] = fetch(key) if key?(key)
     end
     hash
   end
@@ -22,6 +29,12 @@ class Hash
   #
   # Returns a Hash of the removed pairs.
   def slice!(*keep_keys)
+    if block_given?
+      each do |k, v|
+        keep_keys << k if yield(k, v)
+      end
+    end
+
     rejected = keys - keep_keys
     removed = {}
     rejected.each{ |k| removed[k] = delete(k) }

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

@@ -4,21 +4,24 @@ class Hash
   # 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}
+  #   {'a'=>1, 'b'=>2}.subset{|k| k == 'a'}   #=> {'a'=>1}
   #
   # CREDIT: Alexey Petrushin
-  def subset(keys=nil, &block)
+  def subset(*keys, &block)
     h = {}
-    if keys
-      self.each do |k, v|
-        h[k] = v if keys.include?(k)
+
+    if block
+      raise ArgumentError, "subset arguments and block are exclusive parameters" unless keys.empty?
+      each do |k, v|
+        h[k] = v if block.call(k)
       end
     else
-      self.each do |k, v|
-        h[k] = v if block.call(k)
+      each do |k, v|
+        h[k] = v if keys.include?(k)
       end
     end
-    h
+
+    return h
   end
 
 end

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

@@ -1,6 +1,6 @@
 class Hash
 
-  # Iterates through each pair and updates a the hash
+  # Iterates through each pair and updates 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.

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

@@ -1,6 +1,6 @@
 class Hash
 
-  # Weave is a very uniqe hash operator. I is designed
+  # Weave is a very unique hash operator. It is designed
   # to merge to complex hashes in according to sensible,
   # regular pattern. The effect is akin to inheritance.
   #

data/lib/core/facets/indexable.rb

@@ -1,16 +1,16 @@
 # Indexable is a mixin that provides index based methods,
-# working soley with four methods: #index, #slice, #splice
+# working solely with four methods: #index, #slice, #splice
 # and #size.
 #
 # These methods work in harmony. Where #index returns a
 # position of a given element, #slice returns elements
 # for given positions. #splice is like #slice but replaces
-# the given position with new values. This mehtod is not
+# the given position with new values. This method is not
 # part of ruby core, but it generally just an alias for #[]=,
 # just as #slice is an alias of #[]. #size of course simply
 # returns the total length of the indexable object.
 #
-# NOTE: To test the folowing methods Indexable needs to be
+# NOTE: To test the following methods Indexable needs to be
 # included into Array and array must have #splice defined.
 #
 #   require 'facets/array/splice'
@@ -49,7 +49,7 @@ module Indexable
     slice(-1,1)
   end
 
-  # Returns an array of the first element upto,
+  # Returns an array of the first element up to,
   # but not including, the last element.
   #
   #   [1,2,3].body  #=> [1,2]
@@ -74,7 +74,7 @@ module Indexable
   #
   # In other words, If there are an even number of elements the
   # higher-indexed of the two center elements is indexed as
-  # orgin (0).
+  # origin (0).
   #
   def mid(offset=0)
     slice((size / 2) + offset)
@@ -103,7 +103,7 @@ module Indexable
     end
   end
 
-  # Fetch values from a start index thru an end index.
+  # Fetch values from a start index through an end index.
   #
   #   [1,2,3,4,5].thru(0,2)  #=> [1,2,3]
   #   [1,2,3,4,5].thru(2,4)  #=> [3,4,5]

data/lib/core/facets/integer.rb

@@ -1,11 +1,7 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'integer/bit.rb'
 require_relative 'integer/bitmask.rb'
-require_relative 'integer/even.rb'
 require_relative 'integer/factorial.rb'
 require_relative 'integer/multiple.rb'
-require_relative 'integer/odd.rb'
 require_relative 'integer/of.rb'
 require_relative 'integer/ordinal.rb'
 #require_relative 'integer/roman.rb'     # uncommon

data/lib/core/facets/kernel.rb

@@ -1,5 +1,3 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'kernel/as.rb'
 require_relative 'kernel/ask.rb'
 require_relative 'kernel/assign.rb'
@@ -19,7 +17,7 @@ require_relative 'kernel/disable_warnings.rb'
 require_relative 'kernel/eigen.rb'
 #require_relative 'kernel/eigenclass.rb'        # uncommon
 require_relative 'kernel/enable_warnings.rb'
-require_relative 'kernel/equate.rb'
+#require_relative 'kernel/equate.rb'
 require_relative 'kernel/ergo.rb'
 require_relative 'kernel/extend.rb'
 require_relative 'kernel/extension.rb'
@@ -31,7 +29,10 @@ require_relative 'kernel/in.rb'
 require_relative 'kernel/instance_assign.rb'
 require_relative 'kernel/instance_class.rb'
 #require_relative 'kernel/instance_exec.rb'     # uncommon
+require_relative 'kernel/instance_extract.rb'
+require_relative 'kernel/instance_replace.rb'
 require_relative 'kernel/instance_send.rb'
+require_relative 'kernel/like.rb'
 require_relative 'kernel/load_all.rb'
 require_relative 'kernel/load_relative.rb'
 require_relative 'kernel/maybe.rb'
@@ -52,13 +53,11 @@ require_relative 'kernel/presence.rb'
 require_relative 'kernel/present.rb'
 require_relative 'kernel/qua_class.rb'
 require_relative 'kernel/require_all.rb'
-require_relative 'kernel/require_relative.rb'
 require_relative 'kernel/respond.rb'
 require_relative 'kernel/returning.rb'
 require_relative 'kernel/silence.rb'
 require_relative 'kernel/silence_warnings.rb'
 require_relative 'kernel/singleton_class.rb'
-require_relative 'kernel/source_location.rb'
 require_relative 'kernel/super_method.rb'
 require_relative 'kernel/tap.rb'
 require_relative 'kernel/temporarily.rb'
@@ -70,10 +69,8 @@ require_relative 'kernel/with.rb'
 require_relative 'kernel/writers.rb'
 #require_relative 'kernel/y.rb'                 # uncommon
 require_relative 'kernel/yes.rb'
-require_relative 'kernel/__callee__.rb'
 require_relative 'kernel/__class__.rb'
 require_relative 'kernel/__dir__.rb'
 require_relative 'kernel/__get__.rb'
-require_relative 'kernel/__method__.rb'
 require_relative 'kernel/__set__.rb'