facets 2.1.3 → 2.2.0

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

@@ -1,7 +1,3 @@
-# LOG:
-#   - 2007.11.01 Trans
-#     Deprecated #each_uniq_pair, just use #each_combination instead.
-
 require 'facets/integer/factorial'
 
 module Enumerable
@@ -27,7 +23,7 @@ module Enumerable
   #   ["b", "x", "x"]
   #   ["b", "x", "y"]
   #
-  #   CREDIT Florian Gross
+  #   CREDIT: Florian Gross
 
   def self.combinations(head, *rest)
     crest = rest.empty? ? [[]] : combinations(*rest)
@@ -50,7 +46,7 @@ module Enumerable
   #   ["a", "c", "d"]
   #   ["b", "c", "d"]
   #
-  #   CREDIT Florian Gross
+  #   CREDIT: Florian Gross
 
   def each_combination(k=2)
     s = to_a
@@ -67,42 +63,44 @@ module Enumerable
     end
   end
 
-#   # Processes each unique pair (of indices, not value)
-#   # in the array by yielding them to the supplied block.
-#   #
-#   #   a = [1,2,3,4]
-#   #   a.each_unique_pair{ |a,b| puts a+','+b }
-#   #
-#   # produces
-#   #
-#   #   1,2
-#   #   1,3
-#   #   1,4
-#   #   2,3
-#   #   2,4
-#   #   3,4
-#   #
-#   # This does not guarantee the uniqueness of values.
-#   # For example:
-#   #
-#   #   a = [1,2,1]
-#   #   a.each_unique_pair{ |a,b| puts a+','+b }
-#   #
-#   # prduces
-#   #
-#   #   1,2
-#   #   1,1
-#   #   2,1
-#   #
-#   # This is equivalent to <tt>each_combination(2){ ... }</tt>.
-#
-#   def each_unique_pair(&yld)
-#     self.each_combination(2,&yld)
-#     #s = self.to_a
-#     #self.each_with_index{ |a,i|
-#     #  self[(i+1)..-1].each{ |b| yield a,b }
-#     #}
-#   end
+  # NOTE: Deprecated #each_uniq_pair, just use #each_combination instead.
+  #
+  #   # Processes each unique pair (of indices, not value)
+  #   # in the array by yielding them to the supplied block.
+  #   #
+  #   #   a = [1,2,3,4]
+  #   #   a.each_unique_pair{ |a,b| puts a+','+b }
+  #   #
+  #   # produces
+  #   #
+  #   #   1,2
+  #   #   1,3
+  #   #   1,4
+  #   #   2,3
+  #   #   2,4
+  #   #   3,4
+  #   #
+  #   # This does not guarantee the uniqueness of values.
+  #   # For example:
+  #   #
+  #   #   a = [1,2,1]
+  #   #   a.each_unique_pair{ |a,b| puts a+','+b }
+  #   #
+  #   # prduces
+  #   #
+  #   #   1,2
+  #   #   1,1
+  #   #   2,1
+  #   #
+  #   # This is equivalent to <tt>each_combination(2){ ... }</tt>.
+  #
+  #   def each_unique_pair(&yld)
+  #     self.each_combination(2,&yld)
+  #     #s = self.to_a
+  #     #self.each_with_index{ |a,i|
+  #     #  self[(i+1)..-1].each{ |b| yield a,b }
+  #     #}
+  #   end
 
 end
 

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

@@ -1,35 +1,80 @@
-# TITLE:
-#
-#   Enumerable Counting
-#
-# SUMMARY:
-#
-#   Extensions related to counting and uniquness.
-#
-# AUTHORS:
-#
-#   - Florian Gross
-#   - Thomas Sawyer
-#   - Gavin Sinclair
-#   - Gavin Kistner
-
-#
 module Enumerable
 
-  # Count the number of items in an enumerable
-  # equal (==) to the given object.
-  #
-  #   e = [ 'a', '1', 'a' ]
-  #   e.count('1')    #=> 1
-  #   e.count('a')    #=> 2
-  #
-  # Count can also handle multiple-valued blocks.
-  #
-  #   e = { 'a' => 2, 'a' => 2, 'b' => 1 }
-  #   e.count('a',2)  #=> 1
-  #
-  def count(*c)
-    self.select{ |*i| i == c }.length
+  unless (RUBY_VERSION[0,3] == '1.9')
+
+    # Count the number of items in an enumerable
+    # equal (==) to the given object.
+    #
+    #   e = [ 'a', '1', 'a' ]
+    #   e.count('1')    #=> 1
+    #   e.count('a')    #=> 2
+    #
+    # Count can also handle multiple-valued blocks.
+    #
+    #   e = { 'a' => 2, 'a' => 2, 'b' => 1 }
+    #   e.count('a',2)  #=> 1
+    #
+    #   CREDIT: Trans
+
+    def count(*c)
+      self.select{ |*i| i == c }.length
+    end
+
+    # Enumerable#one? returns +true+ if and only if <em>exactly one</em>
+    # element in the collection satisfies the given predicate.
+    #
+    # If no predicate is provided, Enumerable#one? returns +true+ if
+    # and only if <em>exactly one</em> element has a true value
+    # (i.e. not +nil+ or +false+).
+    #
+    #   [].one?                      # false
+    #   [nil].one?                   # false
+    #   [5].one?                     # true
+    #   [5,8,9].one?                 # false
+    #   (1...10).one? { |n| n == 5 } # true
+    #   (1...10).one? { |n| n < 5 }  # false
+    #
+    #   CREDIT: Gavin Sinclair
+
+    def one?  # :yield: e
+      matches = 0
+      if block_given?
+        self.each do |e|
+          if yield(e)
+            matches += 1
+            return false if matches > 1
+          end
+        end
+        return (matches == 1)
+      else
+        one? { |e| e }
+      end
+    end
+
+    # Enumerable#none? is the logical opposite of the builtin method
+    # Enumerable#any?.  It returns +true+ if and only if _none_ of
+    # the elements in the collection satisfy the predicate.
+    #
+    # If no predicate is provided, Enumerable#none? returns +true+
+    # if and only if _none_ of the elements have a true value
+    # (i.e. not +nil+ or +false+).
+    #
+    #   [].none?                      # true
+    #   [nil].none?                   # true
+    #   [5,8,9].none?                 # false
+    #   (1...10).none? { |n| n < 0 }  # true
+    #   (1...10).none? { |n| n > 0 }  # false
+    #
+    #   CREDIT: Gavin Sinclair
+
+    def none?  # :yield: e
+      if block_given?
+        not self.any? { |e| yield e }
+      else
+        not self.any?
+      end
+    end
+
   end
 
   # Returns an array of elements for the elements that occur n times.
@@ -45,6 +90,8 @@ module Enumerable
   #   [1,1,2,3,3,4,5,5].occur { |n| n == 1 } #=> [2,4]
   #   [1,1,2,3,3,4,5,5].occur { |n| n > 1 }  #=> [1,3,5]
   #
+  #   CREDIT: ?
+
   def occur(n=nil) #:yield:
     result = Hash.new { |hash, key| hash[key] = Array.new }
     self.each do |item|
@@ -64,12 +111,12 @@ module Enumerable
     return result.values.flatten.uniq
   end
 
-  # CREDIT Gavin Kistner
-
   # Uses #+ to sum the enumerated elements.
   #
   #   [1,2,3].sum  #=> 6
   #   [3,3,3].sum  #=> 9
+  #
+  #   CREDIT: Gavin Kistner
 
   def sum
     v = 0
@@ -77,9 +124,12 @@ module Enumerable
     v
   end
 
-  # CREDIT Martin DeMello
-
+  # Returns a list on non-unique,
+  #
+  #   [1,1,2,2,3,4,5].nonuniq  #=> [1,2]
   #
+  #   CREDIT: Martin DeMello
+
   def nonuniq
     h1 = {}
     h2 = {}
@@ -90,19 +140,21 @@ module Enumerable
     h2.keys
   end
 
-#   #
-#   def nonuniq!
-#     raise unless respond_to?(:replace)
-#     h1 = {}
-#     h2 = {}
-#     each {|i|
-#       h2[i] = true if h1[i]
-#       h1[i] = true
-#     }
-#     self.replace(h2.keys)
-#   end
+  #   #
+  #   def nonuniq!
+  #     raise unless respond_to?(:replace)
+  #     h1 = {}
+  #     h2 = {}
+  #     each {|i|
+  #       h2[i] = true if h1[i]
+  #       h1[i] = true
+  #     }
+  #     self.replace(h2.keys)
+  #   end
 
   # Return list of dulicate elements.
+  #
+  #   CREDIT: Thibaut Barrère
 
   alias_method :duplicates, :nonuniq
 
@@ -114,137 +166,10 @@ module Enumerable
   #
   #   [-5, -4, -3, -2, -1, 0]
   #
+  #   CREDIT: ?
+
   def uniq_by #:yield:
     h = {}; inject([]) {|a,x| h[yield(x)] ||= a << x}
   end
 
-  # Enumerable#one? returns +true+ if and only if <em>exactly one</em>
-  # element in the collection satisfies the given predicate.
-  #
-  # If no predicate is provided, Enumerable#one? returns +true+ if
-  # and only if <em>exactly one</em> element has a true value
-  # (i.e. not +nil+ or +false+).
-  #
-  #   [].one?                      # false
-  #   [nil].one?                   # false
-  #   [5].one?                     # true
-  #   [5,8,9].one?                 # false
-  #   (1...10).one? { |n| n == 5 } # true
-  #   (1...10).one? { |n| n < 5 }  # false
-  #
-  #--
-  # Credit goes to Gavin Sinclair.
-  #++
-  def one?  # :yield: e
-    matches = 0
-    if block_given?
-      self.each do |e|
-        if yield(e)
-          matches += 1
-          return false if matches > 1
-        end
-      end
-      return (matches == 1)
-    else
-      one? { |e| e }
-    end
-  end
-
-  # Enumerable#none? is the logical opposite of the builtin method
-  # Enumerable#any?.  It returns +true+ if and only if _none_ of
-  # the elements in the collection satisfy the predicate.
-  #
-  # If no predicate is provided, Enumerable#none? returns +true+
-  # if and only if _none_ of the elements have a true value
-  # (i.e. not +nil+ or +false+).
-  #
-  #   [].none?                      # true
-  #   [nil].none?                   # true
-  #   [5,8,9].none?                 # false
-  #   (1...10).none? { |n| n < 0 }  # true
-  #   (1...10).none? { |n| n > 0 }  # false
-  #
-  #--
-  # Credit goes to Gavin Sinclair.
-  #++
-  def none?  # :yield: e
-    if block_given?
-      not self.any? { |e| yield e }
-    else
-      not self.any?
-    end
-  end
-
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestEnumerableCount < Test::Unit::TestCase
-
-    def test_occur
-      arr = [:a,:b,:a]
-      assert_equal( [:b], arr.occur(1) )
-      assert_equal( [:a], arr.occur(2) )
-      assert_equal( [:b], arr.occur(1..1) )
-      assert_equal( [:a], arr.occur{ |n| n % 2 == 0 } )
-    end
-
-    def test_count_01
-      e = [ 'a', '1', 'a' ]
-      assert_equal( 1, e.count('1') )
-      assert_equal( 2, e.count('a') )
-    end
-
-    def test_count_02
-      e = [ ['a',2], ['a',2], ['a',2], ['b',1] ]
-      assert_equal( 3, e.count(['a',2]) )
-    end
-
-    def test_count_03
-      e = { 'a' => 2, 'a' => 2, 'b' => 1 }
-      assert_equal( 1, e.count('a',2) )
-    end
-
-    def test_uniq_by
-      a = [-5, -4, -3, -2, -1, 0]
-      r = (-5..5).to_a.uniq_by{|i| i*i }
-      assert_equal( a, r )
-    end
-
-    def test_one?
-      a = [nil, true]
-      assert( a.one? )
-      a = [true, false]
-      assert( a.one? )
-      a = [true, true]
-      assert( ! a.one? )
-      a = [true, 1]
-      assert( ! a.one? )
-      a = [1, 1]
-      assert( ! a.one? )
-    end
-
-    def test_none?
-      a = [nil, nil]
-      assert( a.none? )
-      a = [false, false]
-      assert( a.none? )
-      a = [true, false]
-      assert( ! a.none? )
-      a = [nil, 1]
-      assert( ! a.none? )
-    end
-
-  end
-
-=end

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

@@ -0,0 +1,86 @@
+# TODO:
+#
+#   - Remove require 'enumerator' for Ruby 1.9.
+#   - Suggest Enumerator's #each_slice use block arity if no parameter is given.
+
+require 'enumerator' # for each_slice
+
+module Enumerable
+
+  # Iterate through slices. If slicing +step+ is not
+  # given, the the arity if the block is used.
+  #
+  #   x = []
+  #   [1,2,3,4].each_by{ |a,b| x << [a,b] }
+  #   x  #=> [ [1,2], [3,4] ]
+  #
+  #   x = []
+  #   [1,2,3,4,5,6].each_by(3){ |a| x << a }
+  #   x  #=> [ [1,2,3], [4,5,6] ]
+  #
+  #   CREDIT: Trans
+
+  def each_by(step=nil, &yld)
+    if step
+      each_slice(step,&yld)
+    else
+      step = yld.arity.abs
+      each_slice(step,&yld)
+    end
+  end
+
+  # Iterators over each element pairing.
+  #
+  #   [:a,:b,:c,:d].each_pair { |a,b|  puts "#{a} -> #{b}" }
+  #
+  # _produces_
+  #
+  #   a -> b
+  #   c -> d
+  #
+  #   CREDIT: Martin DeMello
+
+  def each_pair #:yield:
+    e1 = nil
+    each_with_index do |e,i|
+      if i % 2 == 0
+        e1 = e
+        next
+      else
+        yield(e1,e)
+      end
+    end
+  end
+
+  # Collect each n items based on arity.
+  #
+  #   [1,2,3,4].eachn do |x, y|
+  #     [x,y]
+  #   end
+  #
+  # _produces_
+  #
+  #   [1,2]
+  #   [3,4]
+  #
+  #   CREDIT: Martin DeMello
+
+  def eachn(&block)
+    n = block.arity.abs
+    each_slice(n) {|i| block.call(*i)}
+  end
+
+
+  # DEPRECATED
+  #
+  #   # Why the term counter? There may be a change in Ruby 2.0
+  #   # to use this word instead of index. Index will
+  #   # still be used for Array, since that is the proper meaning
+  #   # in that context. In the mean time, aliases are provided.
+  #
+  #   # More appropriate naming since an enumerable is not
+  #   # neccesarily "indexed", as is an Array or Hash.
+  #   alias_method :each_with_counter, :each_with_index
+
+end
+