facets 1.8.54 → 2.0.0

data/lib/core/facets/dir.rb

@@ -0,0 +1,2 @@
+require 'facets/dir/multiglob.rb'
+require 'facets/dir/traverse.rb'

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

@@ -0,0 +1,143 @@
+# TITLE:
+#
+#   Multiglob
+#
+# SUMMARY:
+#
+#    Dir extensions for globbing multiple locations at once.
+#
+# CREDITS:
+#
+#   - Thomas Sawyer
+
+#
+class Dir
+
+  # Like +glob+ but can take multiple patterns.
+  #
+  #   Dir.multiglob( '*.rb', '*.py' )
+  #
+  # Rather then constants for options multiglob accepts a trailing options
+  # hash of symbol keys.
+  #
+  #   :noescape    File::FNM_NOESCAPE
+  #   :casefold    File::FNM_CASEFOLD
+  #   :pathname    File::FNM_PATHNAME
+  #   :dotmatch    File::FNM_DOTMATCH
+  #   :strict      File::FNM_PATHNAME && File::FNM_DOTMATCH
+  #
+  # It also has an option for recurse.
+  #
+  #   :recurse     Recurively include contents of directories.
+  #
+  # For example
+  #
+  #   Dir.multiglob( '*', :recurse => true )
+  #
+  # would have the same result as
+  #
+  #   Dir.multiglob('**/*')
+  #
+  # Multiglob also accepts '+' and '-' prefixes. Any entry that begins with a '-'
+  # is treated as an exclusion glob and will be removed from the final result.
+  # For example, to collect all files in the current directory, less ruby scripts:
+  #
+  #   Dir.multiglob( '*', '-*.rb' )
+  #
+  # This is very useful in collecting files as specificed by a configuration
+  # parameter.
+
+  def self.multiglob( *patterns )
+    options  = (Hash === patterns.last ? patterns.pop : {})
+
+    bitflags = 0
+    bitflags |= File::FNM_NOESCAPE if options[:noescape]
+    bitflags |= File::FNM_CASEFOLD if options[:casefold]
+    bitflags |= File::FNM_PATHNAME if options[:pathname] or options[:strict]
+    bitflags |= File::FNM_DOTMATCH if options[:dotmatch] or options[:strict]
+
+    patterns = [patterns].flatten.compact
+
+    patterns_include = patterns.select{ |f| f !~ /^[-]/ }
+    patterns_exclude = patterns.select{ |f| f =~ /^[-]/ }
+
+    patterns_include.collect!{ |f| f =~ /^[+]/ ? f[1..-1] : f }
+    patterns_exclude.collect!{ |f| f =~ /^[-]/ ? f[1..-1] : f }
+
+    if options[:recurse]
+      patterns_include += patterns_include.collect{ |f| File.join(f, '**', '*') }
+      patterns_exclude += patterns_exclude.collect{ |f| File.join(f, '**', '*') }
+    end
+
+    files = []
+    files += patterns_include.collect{ |pattern| Dir.glob(pattern, bitflags) }.flatten.uniq
+    files -= patterns_exclude.collect{ |pattern| Dir.glob(pattern, bitflags) }.flatten.uniq
+
+    return files
+  end
+
+  # The same as +multiglob+, but recusively includes directories.
+  #
+  #   Dir.multiglob_r( 'folder' )
+  #
+  # is equivalent to
+  #
+  #   Dir.multiglob( 'folder', :recurse=>true )
+  #
+  # The effect of which is
+  #
+  #   Dir.multiglob( 'folder', 'folder/**/*' )
+
+  def self.multiglob_r( *patterns )
+    options = (Hash === patterns.last ? patterns.pop : {})
+    options[:recurse] = true
+    patterns << options
+    multiglob(*patterns)
+  end
+
+  # This is just like multiglob but handles a base pattern such that
+  # if the +patterns+ list starts with a '+' or '-' entry, then the base
+  # will be included in the result, otherwise it will be omitted.
+  #
+  #   Dir.multiglob_with_default('*.yaml', '-*.rb')  #=> [ 'foo.yaml' ]
+  #   Dir.multiglob_with_default('*.yaml', '+*.rb')  #=> [ 'foo.yaml', 'foo.rb' ]
+  #   Dir.multiglob_with_default('*.yaml', '*.rb')   #=> [ 'foo.rb' ]
+  #
+  # This is useful when a configuration option needs to supply a file list
+  # that may include files, exclude files or append files to a default list.
+
+  def self.multiglob_with_default(default, *patterns)
+    default = [default].flatten.compact
+    patterns = patterns.flatten.compact
+
+    if patterns.empty?
+      patterns = default
+    elsif patterns.first =~ /^[+-]/
+      patterns = default + patterns
+    end
+
+    multiglob(*patterns)
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO Need to mock file system.
+
+=begin #no test yet
+
+  require 'test/unit'
+
+  class TestDir < Test::Unit::TestCase
+
+  end
+
+=end

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

@@ -0,0 +1,148 @@
+# TITLE:
+#
+#  Dir Travserse Extensions
+#
+# SUMMARY:
+#
+#   Travsersal extensions for Dir class.
+#
+# CREDITS:
+#
+#   - Thomas Sawyer
+#   - Daniel Berger
+#   - Jeffrey Schwab
+#   - George Moschovitis
+
+#
+class Dir
+
+  # Is a path parental to another?
+  #--
+  # TODO Needs work
+  #++
+  def 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
+
+  # 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
+  end
+
+  # Alias for Dir#ls_r
+  alias_method :recurse, :ls_r
+
+  # Ascend a directory path.
+
+  def ascend(dir, inclusive=true, &blk)
+    dir = dir.dup
+    blk.call(dir) if inclusive
+    ri = dir.rindex('/')
+    while ri
+      dir = dir.slice(0...ri)
+      if dir == ""
+        blk.call('/') ; break
+      end
+      blk.call( dir )
+      ri = dir.rindex('/')
+    end
+  end
+
+  # Descend a directory path.
+
+  def descend(path) #:yield:
+    paths = path.split('/')
+    paths.size.times do |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
+
+    def test_ascend_02
+      c = []
+      Dir.ascend( "this/path/up", false ) do |path|
+        c << path
+      end
+      assert_equal( 'this/path', c[0] )
+      assert_equal( 'this', c[1] )
+    end
+
+  end
+
+=end

data/lib/core/facets/enumerable.rb

@@ -0,0 +1,9 @@
+require 'facets/enumerable/instance_map.rb'
+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/partition.rb'
+require 'facets/enumerable/probability.rb'

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

@@ -0,0 +1,156 @@
+# 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
+        end
+      end
+      if block_given?
+        result.each{ |e| block.call(e) }
+      else
+        result
+      end
+    end
+
+    alias_method :cart, :cartesian_product
+  end
+
+  # The instance level version of <tt>Enumerable::cartesian_product</tt>.
+  #
+  #   a = []
+  #   [1,2].cart([4,5]){|elem| a << elem }
+  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+
+  def cartesian_product(*enums, &block)
+    Enumerable.cartesian_product(self, *enums, &block)
+  end
+
+  alias :cart :cartesian_product
+
+  # Operator alias for cross-product.
+  #
+  #   a = [1,2] ** [4,5]
+  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+  #
+  def **(enum)
+    Enumerable.cartesian_product(self, enum)
+  end
+
+  # Expected to be an enumeration of arrays. This method
+  # iterates through combinations of each in position.
+  #
+  #   a = [ [0,1], [2,3] ]
+  #   a.each_combo { |c| p c }
+  #
+  # produces
+  #
+  #   [0, 2]
+  #   [0, 3]
+  #   [1, 2]
+  #   [1, 3]
+  #
+  def each_combo
+    a = collect{ |x|
+      x.respond_to?(:to_a) ? x.to_a : 0..x
+    }
+
+    if a.size == 1
+      r = a.shift
+      r.each{ |n|
+        yield n
+      }
+    else
+      r = a.shift
+      r.each{ |n|
+        a.each_combo{ |s|
+          yield [n, *s]
+        }
+      }
+    end
+  end
+
+  # As with each_combo but returns combos collected in an array.
+  #
+  def combos
+    a = []
+    each_combo{ |c| a << c }
+    a
+  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