facets 1.8.54 → 2.0.0

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

@@ -0,0 +1,115 @@
+# TITLE:
+#
+#   Enumerable Collate
+#
+# DESCRIPTION:
+#
+#   Collate is a Hash collection method.
+#
+# AUTHORS:
+#
+#   CREDIT 7ransVent
+#
+# NOTES:
+#
+#   NOTE Hash#collate! is only useful for Hash. It is not generally
+#        applicable to Enumerable.
+#++
+
+module Enumerable
+
+  # Like <tt>#map</tt>/<tt>#collect</tt>, but generates a Hash.  The block
+  # is expected to return two values: the key and the value for the new hash.
+  #
+  #   numbers  = (1..3)
+  #   squares  = numbers.graph { |n| [n, n*n] }   # { 1=>1, 2=>4, 3=>9 }
+  #   sq_roots = numbers.graph { |n| [n*n, n] }   # { 1=>1, 4=>2, 9=>3 }
+
+  def collate(&yld)
+    if yld
+      inject({}) do |h,kv|
+        nk, nv = *yld[*kv].to_a.flatten
+        h[nk] = nv
+        h
+      end
+    else
+      Hash[*self.to_a.flatten]
+    end
+  end
+
+  # Alias for #collate (THIS WILL BE DEPRECATED)
+
+  alias :graph :collate
+
+  # Returns a new hash built by iterating through each key,value
+  # pair and updating the new hash.
+  #def collate  #:yield:
+  #  newhash = {}
+  #  each_pair{ |k,v| newhash.update(yield(k,v)) }
+  #  newhash
+  #end
+
+end
+
+
+class Hash
+
+  # In place version of #collate.
+
+  def collate!(&yld)
+    replace(collate(&yld))
+  end
+
+  # Alias for #collate! (THIS WILL BE DEPRECATED)
+
+  alias :graph! :collate!
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestEnumerableCollate < Test::Unit::TestCase
+
+    def test_collate_01
+      a = { :a => 1, :b => 2, :c => 3 }
+      e = { :a => 2, :b => 3, :c => 4 }
+      assert_equal( e, a.collate{ |k,v| { k => v+1 } } )
+    end
+
+    def test_collate_02
+      numbers  = (1..3)
+      squares  = numbers.collate{ |n| [n, n*n] }
+      assert_equal( {1=>1, 2=>4, 3=>9}, squares )
+    end
+
+    def test_collate_03
+      numbers  = (1..3)
+      sq_roots = numbers.collate{ |n| [n*n, n] }
+      assert_equal( {1=>1, 4=>2, 9=>3}, sq_roots )
+    end
+
+    def test_collate_01!
+      a = { :a => 1, :b => 2, :c => 3 }
+      e = { :a => 2, :b => 3, :c => 4 }
+      a.collate!{ |k,v| { k => v+1 } }
+      assert_equal( e, a )
+    end
+
+    def test_collate_02!
+      h  = {:a=>1,:b=>2,:c=>3}
+      h.collate!{ |k,v| [v, v*v] }
+      assert_equal( {1=>1, 2=>4, 3=>9}, h )
+    end
+
+  end
+
+=end

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

@@ -0,0 +1,155 @@
+# TITLE
+#
+#   Collect
+#
+# = DESCRIPTION
+#
+#   Enumerble collection extensions.
+#
+# = AUTHORS
+#
+#   CREDIT Florian Gross
+#   CREDIT Thomas Sawyer
+#   CREDIT Gavin Sinclair
+
+#
+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]
+  #
+  def collect_with_index
+    r = []
+    each_index do |i|
+      r << yield(self[i], i)
+    end
+    r
+  end
+
+  alias_method( :map_with_index, :collect_with_index )
+
+  # DEPRECATE?
+
+  # 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.
+
+  alias_method( :collect_with_counter, :collect_with_index )
+  alias_method( :map_with_counter, :collect_with_index )
+
+  # More appropriate naming since an enumerable is not
+  # neccesarily "indexed", as is an Array or Hash.
+
+  alias_method :each_with_counter, :each_with_index
+
+  # Collects/Maps and filters items out in one single step.
+  # You can use throw(:skip) in the supplied block to indicate that the
+  # current item should not end up in the resulting array.
+  #
+  #   # Return names of all person with an age of at least 18.
+  #   persons.filter_collect do |person|
+  #     throw(:skip) if person.age < 18
+  #     person.name
+  #   end
+  #
+  # Also see Enumerable#collect, Enumerable#find_all.
+  #
+  def filter_collect #:yield:
+    result = []
+    self.each do |item|
+      catch(:skip) do
+        new_item = yield(item)
+        result << new_item
+      end
+    end
+    return result
+  end
+
+  alias_method :filter_map, :filter_collect
+
+  # Collects/Maps and compacts items in one single step.
+  # The items for which the supplied block returns +nil+ will not
+  # end up in the resulting array.
+  #
+  #   # Return telephone numbers of all persons that have a telephone number.
+  #   persons.compact_collect { |person| person.telephone_no }
+  #
+  # Also see Enumerable#collect, Enumerable#map, Array#compact.
+  #
+  def compact_collect #:yield:
+    filter_collect do |item|
+      new_item = yield(item)
+      throw(:skip) if new_item.nil?
+      new_item
+    end
+  end
+
+  alias_method :compact_map, :compact_collect
+
+  # Say you want to count letters--
+  #
+  #    some_text.injecting(Hash.new(0) {|h,l| h[l] += 1}
+  #
+  # vs
+  #
+  #    some_text.inject(Hash.new(0)) {|h,l| h[l] +=1; h}
+  #
+  #--
+  # CREDIT Louis J Scoras
+  #++
+  def injecting(s)
+    inject(s) do |k, i|
+      yield(k, i); k
+    end
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestEnumerableCollect < Test::Unit::TestCase
+
+    def test_filter_collect
+      e = [3,4]
+      a = [1,2,3,4].filter_collect { |n|
+        throw(:skip) if n < 3
+        n
+      }
+      assert_equal( e, a )
+    end
+
+    def test_compact_collect
+      a = [1,2,nil,4].compact_collect { |e| e }
+      assert_equal( [1,2,4], a )
+    end
+
+    def test_filter_collect
+      e = [3,4]
+      a = [1,2,3,4].filter_collect { |n|
+        throw(:skip) if n < 3
+        n
+      }
+      assert_equal( e, a )
+    end
+
+    def test_compact_collect
+      a = [1,2,nil,4].compact_collect { |e| e }
+      assert_equal( [1,2,4], a )
+    end
+
+  end
+
+=end

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

@@ -0,0 +1,154 @@
+# TITLE:
+#   Combination
+#
+# DESCRIPTION:
+#   Enumerble combination extensions.
+#
+# AUTHORS:
+#   - Florian Gross
+#   - Thomas Sawyer
+
+require 'facets/integer/factorial'
+
+#
+module Enumerable
+
+  # Produces an array of arrays of all possible combinations
+  # of the given arrays in the positions given. (Imagine
+  # it like a slot machine dial. This gives evey combination
+  # that could come up.)
+  #
+  #   a = %w|a b|
+  #   b = %w|a x|
+  #   c = %w|x y|
+  #   Array.combinations(a, b, c).each { |x| p x }
+  #
+  # produces
+  #
+  #   ["a", "a", "x"]
+  #   ["a", "a", "y"]
+  #   ["a", "x", "x"]
+  #   ["a", "x", "y"]
+  #   ["b", "a", "x"]
+  #   ["b", "a", "y"]
+  #   ["b", "x", "x"]
+  #   ["b", "x", "y"]
+  #
+  def self.combinations(head, *rest)
+    crest = rest.empty? ? [[]] : combinations(*rest)
+    head.inject([]) { |combs, item|
+      combs + crest.map { |comb| [item] + comb }
+    }
+  end
+
+  # Yields the block to each unique combination of _n_ elements.
+  #
+  #   a = %w|a b c d|
+  #   a.each_combination(3) do |c|
+  #     p c
+  #   end
+  #
+  # produces
+  #
+  #   ["a", "b", "c"]
+  #   ["a", "b", "d"]
+  #   ["a", "c", "d"]
+  #   ["b", "c", "d"]
+  #
+  def each_combination(k=2)
+    s = to_a
+    n = s.size
+    return unless (1..n) === k
+    idx = (0...k).to_a
+    loop do
+      yield s.values_at(*idx)
+      i = k - 1
+      i -= 1 while idx[i] == n - k + i
+      break if i < 0
+      idx[i] += 1
+      (i + 1 ... k).each {|j| idx[j] = idx[i] + j - i}
+    end
+  end
+
+  # TODO Change name of each_unique_pair.
+
+  # 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
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+  require 'set'
+
+  class TestEnumerableCombination < Test::Unit::TestCase
+
+    def test_combinations_01
+      a = [1,2]
+      b = [3,4]
+      z = Enumerable.combinations(a,b)
+      r = [[1,3],[1,4],[2,3],[2,4]]
+      assert_equal( r, z )
+    end
+
+    def test_combinations_02
+      a = %w|a b|
+      b = %w|a x|
+      c = %w|x y|
+      z = Enumerable.combinations(a, b, c)
+      r = [ ["a", "a", "x"],
+            ["a", "a", "y"],
+            ["a", "x", "x"],
+            ["a", "x", "y"],
+            ["b", "a", "x"],
+            ["b", "a", "y"],
+            ["b", "x", "x"],
+            ["b", "x", "y"] ]
+      assert_equal( r, z )
+    end
+
+  end
+
+=end

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

@@ -0,0 +1,252 @@
+# 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
+  end
+
+  # Returns an array of elements for the elements that occur n times.
+  # Or according to the results of a given block.
+  #
+  #   [1,1,2,3,3,4,5,5].occur(1)             #=> [2,4]
+  #   [1,1,2,3,3,4,5,5].occur(2)             #=> [1,3,5]
+  #   [1,1,2,3,3,4,5,5].occur(3)             #=> []
+  #
+  #   [1,2,2,3,3,3].occur(1..1)              #=> [1]
+  #   [1,2,2,3,3,3].occur(2..3)              #=> [2,3]
+  #
+  #   [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]
+  #
+  def occur(n=nil) #:yield:
+    result = Hash.new { |hash, key| hash[key] = Array.new }
+    self.each do |item|
+      key = item
+      result[key] << item
+    end
+    if block_given?
+      result.reject! { |key, values| ! yield(values.size) }
+    else
+      raise ArgumentError unless n
+      if Range === n
+        result.reject! { |key, values| ! n.include?(values.size) }
+      else
+        result.reject! { |key, values| values.size != n }
+      end
+    end
+    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
+
+  def sum
+    v = 0
+    each{ |n| v+=n }
+    v
+  end
+
+  # CREDIT Martin DeMello
+
+  #
+  def nonuniq
+    h1 = {}
+    h2 = {}
+    each {|i|
+      h2[i] = true if h1[i]
+      h1[i] = true
+    }
+    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.
+
+  def duplicates
+    inject(Hash.new(0)){|h,v| h[v]+=1; h}.reject{|k,v| v==1}.keys
+  end
+
+  # Like #uniq, but determines uniqueness based on a given block.
+  #
+  #   (-5..5).to_a.uniq_by {|i| i*i }
+  #
+  # produces
+  #
+  #   [-5, -4, -3, -2, -1, 0]
+  #
+  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