facets 2.5.0 → 2.5.1

data/lib/core/facets/array/product.rb

@@ -1,24 +1,16 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+class Array
 
-  class Array
+  if RUBY_VERSION < '1.9'
 
-    # Provides the cross-product of two or more Enumerables.
-    # This is the class-level method. The instance method
-    # calls on this.
-    #
-    #   Enumerable.cartesian_product([1,2], [4], ["apple", "banana"])
-    #   #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-    #
-    #   Enumerable.cartesian_product([1,2], [3,4])
-    #   #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
+    # Provides the cartesian product of two or more arrays.
     #
     #   a = []
-    #   [1,2].cart([4,5]){|elem| a << elem }
+    #   [1,2].product([4,5])
     #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
     #
     # CREDIT: Thomas Hafner
 
-    def product(*enums, &block)
+    def product(*enums)
       enums.unshift self
       result = [[]]
       while [] != enums
@@ -30,20 +22,11 @@ unless (RUBY_VERSION[0,3] == '1.9')
           end
         end
       end
-      if block_given?
-        result.each{ |e| block.call(e) }
-      else
-        result
-      end
+      result
     end
 
   end
 
-end
-
-
-class Array
-
   # Operator alias for cross-product.
   #
   #   a = [1,2] ** [4,5]

data/lib/core/facets/enumerable/collect.rb

@@ -1,54 +1,4 @@
-module Enumerable
-
-  # Same as #collect but with an iteration counter.
-  #
-  #   a = [1,2,3].collect_with_index { |e,i| e*i }
-  #   a  #=> [0,2,6]
-  #
-  # CREDIT: Gavin Sinclair
-
-  def collect_with_index
-    r = []
-    each_index do |i|
-      r << yield(self[i], i)
-    end
-    r
-  end
-
-  # Alias for collect_with_index.
-
-  alias_method :map_with_index, :collect_with_index
-
-  # A more versitle #compact method. It can be used to
-  # collect and filter items out in one single step.
-  #
-  #   [1,2,3].compact_map do |n|
-  #     n < 1 ? nil : n
-  #   end
-  #
-  # _produces_
-  #
-  #   [2,3]
-  #
-  # NOTE: Perhaps nicer to have as added functionality for #compact.
-  #
-  # CREDIT: Trans
-
-  def compact_map(trash=nil, &block)
-    y = []
-    if block_given?
-      each do |*a|
-        r = yield(*a)
-        y << r unless trash == r
-      end
-    else
-      each do |r|
-        y << r unless trash == r
-      end
-    end
-    y
-  end
-
-  alias_method :compact_collect, :compact_map
-end
+# to be deprecated
+require 'facets/enumerable/map_with_index'
+require 'facets/enumerable/compact_map'
 

data/lib/core/facets/enumerable/compact_map.rb

@@ -0,0 +1,35 @@
+module Enumerable
+
+  # A more versitle #compact method. It can be used to
+  # collect and filter items out in one single step.
+  #
+  #   [1,2,3].compact_map do |n|
+  #     n < 1 ? nil : n
+  #   end
+  #
+  # _produces_
+  #
+  #   [2,3]
+  #
+  # NOTE: Perhaps nicer to have as added functionality for #compact.
+  #
+  # CREDIT: Trans
+
+  def compact_map(trash=nil, &block)
+    y = []
+    if block_given?
+      each do |*a|
+        r = yield(*a)
+        y << r unless trash == r
+      end
+    else
+      each do |r|
+        y << r unless trash == r
+      end
+    end
+    y
+  end
+
+  alias_method :compact_collect, :compact_map
+end
+

data/lib/core/facets/enumerable/map_with_index.rb

@@ -0,0 +1,23 @@
+module Enumerable
+
+  # Same as #collect but with an iteration counter.
+  #
+  #   a = [1,2,3].collect_with_index { |e,i| e*i }
+  #   a  #=> [0,2,6]
+  #
+  # CREDIT: Gavin Sinclair
+
+  def map_with_index
+    r = []
+    each_index do |i|
+      r << yield(self[i], i)
+    end
+    r
+  end
+
+  # Alias for map_with_index.
+
+  alias_method :collect_with_index, :map_with_index
+
+end
+

data/lib/core/facets/enumerable/split.rb

@@ -8,8 +8,8 @@ module Enumerable
   # CREDIT: Trans
 
   def split(pattern)
-    sect = []
     memo = []
+    sect = []
     each do |obj|
       if pattern === obj
         memo << sect
@@ -18,8 +18,8 @@ module Enumerable
         sect << obj
       end
     end
-    memo << sect #unless sect.empty?
-    memo.pop while memo.last.empty?
+    memo << sect
+    memo.pop while memo.last == []
     memo
   end
 

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

@@ -6,40 +6,71 @@ class Hash
   #   { :a=>1, :b=>2 }.collate :a=>3, :b=>4, :c=>5
   #   #=> { :a=>[1,3], :b=>[2,4], :c=>[5] }
   #
+  # CREDIT: Tilo Sloboda
   # 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)
+    h = Hash.new
     # Prepare, ensuring every existing key is already an Array
     each do |key, value|
       if value.is_a?(Array)
-        self[key] = value
+        h[key] = value
       else
-        self[key] = [value]
+        h[key] = [value]
       end
     end
     # Collate with values from other_hash
     other_hash.each do |key, value|
-      if self[key]
+      if h[key]
         if value.is_a?(Array)
-          self[key].concat( value )
+          h[key].concat(value)
         else
-          self[key] << value
+          h[key] << value
         end
       elsif value.is_a?(Array)
-        self[key] = value
+        h[key] = value
       else
-        self[key] = [value]
+        h[key] = [value]
       end
     end
     #each{ |key, value| value.uniq! } if options[ :uniq ]
-    self
+    h
   end
 
+  # The same as #collate, but modifies the receiver in place.
+
+  def collate!(other_hash)
+    result = self.collate(other_hash)
+    self.replace(result)
+  end
+
+  # Old version.
+  #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/core/facets/hash/group_by_value.rb

@@ -0,0 +1,65 @@
+class Hash
+
+  # Like group_by, but allows hash values to be grouped with weeding out the keys.
+  #
+  #   Example:
+  #
+  #   birthdays = {...}   # Maps each person to his/her birthday.
+  #
+  # Now I want to have the list of people that have their birthday
+  # on a specific date. This can be done by creating a hash first,
+  # using group_by:
+  #
+  #   birthdays.group_by{|person, birthday| birthday}
+  #
+  # This returns:
+  #
+  # {date=>[[person1, date], [person2, date], [person3, date]]}
+  #
+  # ... which is a bit inconvient. Too many dates. I would rather
+  # like to have:
+  #
+  #   {date=>[person1, person2, person3]]}
+  #
+  # This can be achieved by:
+  #
+  #   birthdays.inject!({}){|h, (person, date)| (h[date] ||= []) << person}
+  #
+  # I've used this pattern just once too often, so I moved the code
+  # to Hash (and Enumerable, for associative arrays). Here's the
+  # cleaner code:
+  #
+  # birthdays.group_by_value
+  #
+  #   h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2, "F"=>2, "G"=>3, "H"=>3, "I"=>3}
+  #
+  #   h.group_by{|k, v| v}    # ==> {1=>[["A", 1], ["B", 1], ["C", 1]], 2=>[["D", 2], ["E", 2], ["F", 2]], 3=>[["G", 3], ["H", 3], ["I", 3]]}
+  #   h.group_by_value        # ==> {1=>["A", "B", "C"], 2=>["D", "E", "F"], 3=>["G", "H", "I"]}
+  #   h.sort.group_by_value   # ==> [[1, ["A", "B", "C"]], [2, ["D", "E", "F"]], [3, ["G", "H", "I"]]]
+  #
+  # CREDIT: Erik Veenstra
+  
+  def group_by_value
+    res = {}
+    each{|k, v| (res[v] ||= []) << k}
+    res
+  end
+
+end
+
+
+# Not sure this is a good idea for enumerable.
+#
+#module Enumerable
+#
+#  # For associative arrays, like the result of Hash#sort.
+#  #
+#  def group_by_value
+#    kv  = k = v = nil
+#    res = []
+#    each{|k, v| (res.assoc(v) || (res << kv=[v, []]; kv)).last << k}
+#    res
+#  end
+#
+#end
+

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

@@ -0,0 +1,15 @@
+class Hash
+
+  # Instantiate a new hash with a default
+  # value determined by the block.
+  # 
+  # Hash.new_with { [] } 
+  #
+  # CREDIT: Pit Capitan
+
+  def self.new_with #:yield:
+    new { |h, k| h[k] = yield }
+  end
+
+end
+

data/lib/core/facets/module/extend.rb

@@ -0,0 +1,11 @@
+class Module
+
+  alias_method :_extend, :extend
+
+  def extend(mod=nil, &blk)
+    _extend mod if mod
+    _extend Module.new(&blk) if blk
+  end
+
+end
+

data/lib/core/facets/string/align.rb

@@ -14,8 +14,9 @@ class String
   end
 
   # Align a string to the right.
-  # The defualt alignment seperation is a new line ("/n")
-  # This can be changes as can be the padding string which
+  #
+  # The default alignment separation is a new line ("\n").
+  # This can be changed as can be the padding string which
   # defaults to a single space (' ').
   #
   #   s = <<-EOS
@@ -24,28 +25,28 @@ class String
   #     so on
   #   EOS
   #
-  #   puts s.align_right(2)
+  #   puts s.align_right(14)
   #
   # _produces_
   #
-  #     This is a test
-  #                and
-  #              so on
+  #   This is a test
+  #              and
+  #            so on
   #
   # CREDIT: Trans
 
   def align_right(n, sep="\n", c=' ')
     return rjust(n.to_i,c.to_s) if sep==nil
-    q = split(sep.to_s).collect { |line|
+    q = split(sep.to_s).map do |line|
       line.rjust(n.to_i,c.to_s)
-    }
+    end
     q.join(sep.to_s)
   end
 
   # Align a string to the left.
   #
-  # The defualt alignment seperation is a new line ("/n")
-  # This can be changes as can be the padding string which
+  # The default alignment separation is a new line ("\n").
+  # This can be changed as can be the padding string which
   # defaults to a single space (' ').
   #
   #   s = <<-EOS
@@ -54,27 +55,27 @@ class String
   #     so on
   #   EOS
   #
-  #   puts s.align_left(2)
+  #   puts s.align_left(20, "\n", '.')
   #
   # _produces_
   #
-  #     This is a test
-  #     and
-  #     so on
+  #   This is a test......
+  #   and.................
+  #   so on...............
   #
   # CREDIT: Trans
 
   def align_left(n, sep="\n", c=' ')
     return ljust(n.to_i,c.to_s) if sep==nil
-    q = split(sep.to_s).collect { |line|
-      line.ljust(n.to_i,c.to_s)
-    }
+    q = split(sep.to_s).map do |line|
+      line.strip.ljust(n.to_i,c.to_s)
+    end
     q.join(sep.to_s)
   end
 
   # Centers each line of a string.
   #
-  # The defualt alignment seperation is a new line ("/n")
+  # The default alignment separation is a new line ("\n").
   # This can be changed as can be the padding string which
   # defaults to a single space (' ').
   #