facets 2.1.3 → 2.2.0

data/lib/core/facets/dir/multiglob.rb

@@ -1,16 +1,3 @@
-# TITLE:
-#
-#   Multiglob
-#
-# SUMMARY:
-#
-#    Dir extensions for globbing multiple locations at once.
-#
-# CREDITS:
-#
-#   - Thomas Sawyer
-
-#
 class Dir
 
   # Like +glob+ but can take multiple patterns.

data/lib/core/facets/dir/traverse.rb

@@ -1,60 +1,40 @@
-# TITLE:
-#
-#  Dir Travserse Extensions
-#
-# SUMMARY:
-#
-#   Travsersal extensions for Dir class.
-#
-# CREDITS:
-#
-#   - Thomas Sawyer
-#   - Daniel Berger
-#   - Jeffrey Schwab
-#   - George Moschovitis
+# TODO:
+#   - Make instance method versions.
 
-#
 class Dir
 
   # Is a path parental to another?
-  #--
-  # TODO Needs work
-  #++
-  def ancestor?(parent_path, child_path)
+  #
+  #   TODO: Needs improvement.
+
+  def self.ancestor?(parent_path, child_path)
     %r|^#{Regexp.escape(parent_path)}| =~ child_path
   end
 
   # Is a path parental to another?
-  #--
-  # TODO Needs work
-  #++
-  def parent?(parent_path, child_path)
-    %r|^#{Regexp.escape(parent_path)}| =~ child_path
-  end
+  #
+  #   TODO: Needs improvement.
 
-  # Recursively scan a directory and pass each file
-  # to the given block.
-  def ls_r(path='.', &block)
-    list = []
-    stoplist = ['.', '..']
-    Dir.foreach(path) do |f|
-      next if stoplist.include?(f)
-      filename = path + '/' + f
-      list << filename
-      block.call(filename) if block
-      if FileTest.directory?(filename) and not FileTest.symlink?(filename)
-        list.concat( Dir.recurse(filename, &block) )
-      end
-    end
-    list
+  def self.parent?(parent_path, child_path)
+    %r|^#{Regexp.escape(parent_path)}| =~ child_path
   end
 
-  # Alias for Dir#ls_r
-  alias_method :recurse, :ls_r
-
   # Ascend a directory path.
-
-  def ascend(dir, inclusive=true, &blk)
+  #
+  #   Dir.ascend("/var/log") do |path|
+  #     p path
+  #   end
+  #
+  # _produces_
+  #
+  #   /var/log
+  #   /var
+  #   /
+  #
+  #   CREDIT: Daniel Berger
+  #   CREDIT: Jeffrey Schwab
+
+  def self.ascend(dir, inclusive=true, &blk)
     dir = dir.dup
     blk.call(dir) if inclusive
     ri = dir.rindex('/')
@@ -69,80 +49,50 @@ class Dir
   end
 
   # Descend a directory path.
-
-  def descend(path) #:yield:
+  #
+  #   Dir.descend("/var/log") do |path|
+  #     p path
+  #   end
+  #
+  # _produces_
+  #
+  #   /
+  #   /var
+  #   /var/log
+  #
+  #   CREDIT: Daniel Berger
+  #   CREDIT: Jeffrey Schwab
+
+  def self.descend(path) #:yield:
     paths = path.split('/')
     paths.size.times do |n|
-      yield File.join( *paths[0..n] )
+      yield File.join(*paths[0..n])
     end
   end
 
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin #no test
-
-  require 'test/unit'
-
-  # TODO Need to mockup dir for tests.
-
-  class TestDirNavigate < Test::Unit::TestCase
-
-    def test_ancestor
-      assert( Dir.ancestor?( "a/b/c", "a/b/c/d" ) )
-    end
-
-    def test_ls_r
-      td = Dir.pwd
-      Dir.chdir $TESTDIR
-        r = ["A", "A/B","A/B/C.txt", "A/B.txt", "A.txt"].collect{ |e|
-          File.join( 'ls_r', e )
-        }
-        fs = Dir.ls_r( 'ls_r' )
-        assert_equal( r, fs, Dir.pwd  )
-      Dir.chdir td
-    end
-
-    def test_recurse
-      td = Dir.pwd
-      Dir.chdir $TESTDIR
-        r = ["A", "A/B","A/B/C.txt", "A/B.txt", "A.txt"].collect{ |e|
-          File.join( 'ls_r', e )
-        }
-        fs = Dir.recurse( 'ls_r' )
-        assert_equal( r, fs, Dir.pwd )
-      Dir.chdir td
-    end
-
-    def test_parent
-      assert( Dir.ancestor?( "a/b/c", "a/b/c/d" ) )
-    end
-
-    def test_ascend_01
-      c = []
-      Dir.ascend( "this/path/up" ) do |path|
-        c << path
-      end
-      assert_equal( 'this/path/up', c[0] )
-      assert_equal( 'this/path', c[1] )
-      assert_equal( 'this', c[2] )
-    end
+  # Recursively scan a directory and pass each file
+  # to the given block.
+  #
+  #   CREDIT: George Moschovitis
 
-    def test_ascend_02
-      c = []
-      Dir.ascend( "this/path/up", false ) do |path|
-        c << path
+  def self.ls_r(path='.', &block)
+    list = []
+    stoplist = ['.', '..']
+    Dir.foreach(path) do |f|
+      next if stoplist.include?(f)
+      filename = path + '/' + f
+      list << filename
+      block.call(filename) if block
+      if FileTest.directory?(filename) and not FileTest.symlink?(filename)
+        list.concat( Dir.recurse(filename, &block) )
       end
-      assert_equal( 'this/path', c[0] )
-      assert_equal( 'this', c[1] )
     end
+    list
+  end
 
+  class << self
+    # Alias for Dir#ls_r
+    alias_method :recurse, :ls_r
   end
 
-=end
+end

data/lib/core/facets/enumerable.rb

@@ -1,7 +1,9 @@
 require 'facets/enumerable/cartesian.rb'
 require 'facets/enumerable/combination.rb'
-require 'facets/enumerable/collate.rb'
 require 'facets/enumerable/collect.rb'
-require 'facets/enumerable/permutation.rb'
 require 'facets/enumerable/count.rb'
+require 'facets/enumerable/each.rb'
+require 'facets/enumerable/mash.rb'
+require 'facets/enumerable/permutation.rb'
 require 'facets/enumerable/probability.rb'
+require 'facets/enumerable/split.rb'

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

@@ -1,47 +1,36 @@
-# TITLE:
-#
-#   Cartesian
-#
-# SUMMARY:
-#
-#   Cartesian product and similar methods.
-#
-# AUTHORS:
-#
-#   - Thomas Hafner
-
-#
 module Enumerable
 
-  class << self
-    # Provides the cross-product of two or more Enumerables.
-    # This is the class-level method. The instance method
-    # calls on this.
-    #
-    #   Enumerable.cart([1,2], [4], ["apple", "banana"])
-    #   #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-    #
-    #   Enumerable.cart([1,2], [3,4])
-    #   #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
-
-    def cartesian_product(*enums, &block)
-      result = [[]]
-      while [] != enums
-        t, result = result, []
-        b, *enums = enums
-        t.each do |a|
-          b.each do |n|
-            result << a + [n]
-          end
+  # Provides the cross-product of two or more Enumerables.
+  # This is the class-level method. The instance method
+  # calls on this.
+  #
+  #   Enumerable.cart([1,2], [4], ["apple", "banana"])
+  #   #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
+  #
+  #   Enumerable.cart([1,2], [3,4])
+  #   #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
+  #
+  #   CREDIT: Thomas Hafner
+
+  def self.cartesian_product(*enums, &block)
+    result = [[]]
+    while [] != enums
+      t, result = result, []
+      b, *enums = enums
+      t.each do |a|
+        b.each do |n|
+          result << a + [n]
         end
       end
-      if block_given?
-        result.each{ |e| block.call(e) }
-      else
-        result
-      end
     end
+    if block_given?
+      result.each{ |e| block.call(e) }
+    else
+      result
+    end
+  end
 
+  class << self
     alias_method :cart, :cartesian_product
   end
 
@@ -50,18 +39,22 @@ module Enumerable
   #   a = []
   #   [1,2].cart([4,5]){|elem| a << elem }
   #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+  #
+  #   CREDIT: Thomas Hafner
 
   def cartesian_product(*enums, &block)
     Enumerable.cartesian_product(self, *enums, &block)
   end
 
-  alias :cart :cartesian_product
+  alias_method :cart, :cartesian_product
 
   # Operator alias for cross-product.
   #
   #   a = [1,2] ** [4,5]
   #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
   #
+  #   CREDIT: Trans
+
   def **(enum)
     Enumerable.cartesian_product(self, enum)
   end
@@ -79,6 +72,8 @@ module Enumerable
   #   [1, 2]
   #   [1, 3]
   #
+  #   CREDIT: Trans
+
   def each_combo
     a = collect{ |x|
       x.respond_to?(:to_a) ? x.to_a : 0..x
@@ -101,6 +96,8 @@ module Enumerable
 
   # As with each_combo but returns combos collected in an array.
   #
+  #   CREDIT: Trans
+
   def combos
     a = []
     each_combo{ |c| a << c }
@@ -108,49 +105,3 @@ module Enumerable
   end
 
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestEnumerableClass < Test::Unit::TestCase
-
-    def test_cart_01
-      i = [[1,2], [3,4]]
-      o = [[1, 3], [1, 4], [2, 3], [2, 4]]
-      assert_equal( o, Enumerable.cart(*i) )
-    end
-
-    def test_cart_02
-      i = [[1,2], [4], ["apple", "banana"]]
-      o = [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-      assert_equal( o, Enumerable.cart(*i) )
-    end
-
-    def test_cart_03
-      a = [1,2,3].cart([4,5,6])
-      assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
-    end
-
-    def test_cart_04
-      a = []
-      [1,2,3].cart([4,5,6]) {|elem| a << elem }
-      assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
-    end
-
-    def test_op_pow
-      a = [1,2,3] ** [4,5,6]
-      assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
-    end
-
-  end
-
-=end

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

@@ -1,48 +1,12 @@
-# TITLE:
-#
-#   Collect
-#
-# DESCRIPTION:
-#
-#   Variations of Enumerable collection and partition methods.
-#
-# AUTHORS:
-#
-#   - Florian Gross
-#   - Thomas Sawyer
-#   - Gavin Sinclair
-#   - Thibaut Barrère
-#   - WhyTheLuckyStiff
-#   - Daniel Sheppard
-#   - Paul Battley
-#
-# NOTES:
-#
-#   - TODO Deprecate #group_by when released for Ruby 1.9.
-#   - TODO Suggest Enumerator's #each_slice use block arity if no parameter is given.
-
-require 'enumerator' # for each_slice
-
-#
 module Enumerable
 
-  # Partition an array into parts of given length.
-  #
-  # CREDIT WhyTheLuckyStiff
-
-  #   def / len
-  #     inject([]) do |ary, x|
-  #       ary << [] if [*ary.last].nitems % len == 0
-  #       ary.last << x
-  #       ary
-  #     end
-  #   end
-
   # 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|
@@ -51,6 +15,8 @@ module Enumerable
     r
   end
 
+  # Alias for collect_with_index.
+
   alias_method :map_with_index, :collect_with_index
 
   # Collects/Maps and filters items out in one single step.
@@ -64,6 +30,8 @@ module Enumerable
   #   end
   #
   # Also see Enumerable#collect, Enumerable#find_all.
+  #
+  #  CREDIT: Florian Gross
 
   def filter_collect #:yield:
     result = []
@@ -76,6 +44,8 @@ module Enumerable
     return result
   end
 
+  # Alias for #filter_collect.
+
   alias_method :filter_map, :filter_collect
 
   # Collects/Maps and compacts items in one single step.
@@ -86,6 +56,8 @@ module Enumerable
   #   persons.compact_collect { |person| person.telephone_no }
   #
   # Also see Enumerable#collect, Enumerable#map, Array#compact.
+  #
+  #  CREDIT: Florian Gross
 
   def compact_collect #:yield:
     filter_collect do |item|
@@ -95,146 +67,89 @@ module Enumerable
     end
   end
 
+  # Alias for #compact_collect.
+
   alias_method :compact_map, :compact_collect
 
-  # Say you want to count letters--
-  #
-  #    some_text.injecting(Hash.new(0)) {|h,l| h[l] += 1}
-  #
-  # vs
+  # Conditional collect.
   #
-  #    some_text.inject(Hash.new(0)) {|h,l| h[l] +=1; h}
+  #   [1,2,3].collect_if { |e| e > 1 }
   #
-  # CREDIT Louis J Scoras
+  #   CREDIT: ? Mauricio Fernandez
 
-  def injecting(s)
-    inject(s) do |k, i|
-      yield(k, i); k
-    end
+  def collect_if(&b)
+    a = map(&b)
+    # to get the same semantics as select{|e| e}
+    a.delete(false)
+    a.compact!
+    a
   end
 
-  # TODO Faster implementation? Verify equivalency.
-  #def injecting(res, &block)
-  #  ([res]*length).zip(to_a).each(&block)
-  #  res
-  #end
+  # Alias for #collect_if.
 
-  # The #group_by method is best explained by example.
-  #
-  #   (1..5).partition_by { |n| n % 3 }
-  #        #=> { 0 => [3], 1 => [1, 4], 2 => [2,5] }
-  #
-  #   ["I had", 1, "dollar and", 50, "cents"].partition_by { |e| e.class }
-  #        #=> { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
-  #
-  # #group_by is used to group items in a collection by something they
-  # have in common.  The common factor is the key in the resulting hash, the
-  # array of like elements is the value.
+  alias_method :map_if, :collect_if
+
+  # Send a message to each element and collect the result.
   #
-  # CREDIT Erik Veenstra
+  #   CREDIT: Sean O'Halpin
 
-  def group_by #:yield:
-    h = k = e = nil
-    r = Hash.new
-    each{ |e| (r[yield(e)] ||= []) << e }
-    r
+  def map_send(meth, *args) #:yield:
+    if block_given?
+      map{|e| yield(e.send(meth, *args))}
+    else
+      map{|e| e.send(meth, *args)}
+    end
   end
 
-  # This alias is the original Facets name for the method, but Ruby 1.9 has
-  # adopted #group_by as the name, so eventually #partition_by will be deprecated.
-  alias_method :partition_by, :group_by
-
-  # Similar to #group_by but returns an array of the groups.
-  # Returned elements are sorted by block.
+  #   # Cascade actions on each enumerated element.
+  #   #
+  #   #   [9, 19, 29].cascade :succ, :to_s, :reverse
+  #   #   => ["01", "02", "03"]
+  #   #
+  #   # See ruby-talk:199877.
   #
-  #    %w{this is a test}.cluster_by {|x| x[0]}
+  #   def cascade(*methods)
+  #     methods.inject(self){ |ary, method| ary.map{ |x| x.send(method)}}
+  #   end
+
+  # Say you want to count letters--
   #
-  # _produces_
+  #    some_text.inject!(Hash.new(0)) {|h,l| h[l] += 1}
   #
-  #    [ ['a'], ['is'], ['this', 'test'] ]
+  # vs
   #
-  # CREDIT Erik Veenstra
-
-  def cluster_by(&b)
-    group_by(&b).sort.transpose.pop || []   # group_by(&b).values ?
-  end
-
-  # Split on matching pattern.
+  #    some_text.inject(Hash.new(0)) {|h,l| h[l] +=1; h}
   #
-  # ['a1','b1','a2','b2'].divide(/^a/)
-  # => [['a1,'b1'],['a2','b2']]
+  #   CREDIT: David Black
 
-  def divide(pattern)
-    inject([]) do |memo,obj|
-      memo.push [] if pattern === obj
-      memo.last << obj
-      memo
-    end
+  def inject!(s)
+    k = s
+    each { |i| yield(k, i) }
+    k
   end
 
-  # Iterate through slices. If slicing +step+ is not
-  # given, the the arity if the block is used.
+  # Say you want to count letters--
   #
-  #   x = []
-  #   [1,2,3,4].each_by{ |a,b| x << [a,b] }
-  #   x  #=> [ [1,2], [3,4] ]
+  #    some_text.injecting(Hash.new(0)) {|h,l| h[l] += 1}
   #
-  #   x = []
-  #   [1,2,3,4,5,6].each_by(3){ |a| x << a }
-  #   x  #=> [ [1,2,3], [4,5,6] ]
-
-  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.
+  # vs
   #
-  #   [:a,:b,:c,:d].each_pair { |a,b|  puts "#{a} -> #{b}" }
+  #    some_text.inject(Hash.new(0)) {|h,l| h[l] +=1; h}
   #
-  # _produces_
+  # This may be deprecated in favor of inject!. We make both
+  # available for now to make sure (via the test of time) that
+  # they are 100% equivalent.
   #
-  #   a -> b
-  #   c -> d
+  #   CREDIT: Louis J Scoras
 
-  def each_pair #:yield:
-    e1 = nil
-    each_with_index do |e,i|
-      if i % 2 == 0
-        e1 = e
-        next
-      else
-        yield(e1,e)
-      end
+  def injecting(s)
+    inject(s) do |k, i|
+      yield(k, i); k
     end
   end
 
-  # Collect each n items.
-  #
-  # CREDIT Martin DeMello
-
-  def eachn(&block)
-    n = block.arity.abs
-    each_slice(n) {|i| block.call(*i)}
-  end
-
-  # Conditional collect.
-
-  def collect_if(&b)
-    a = map(&b)
-    # to get the same semantics as select{|e| e}
-    a.delete(false)
-    a.compact!
-    a
-  end
-
-  alias_method :map_if, :collect_if
 
-  # DEPRECATED
+  # DEPRECATED:
   #
   #   # Why the term counter? There may be a change in Ruby 2.0
   #   # to use this word instead of index. Index will
@@ -244,9 +159,6 @@ module Enumerable
   #   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
+  #   #instance_map and #instance_select --too invasive for convenience.
 
 end
-