mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/comparable/comparable.rb

@@ -0,0 +1,42 @@
+# It would nice if we could the following. Then the middle portion of the #Comparable
+# method would not be needed. But I fear it might break others code.
+#
+#   module Comparable
+#
+#    def <=>(other)
+#      comparability.each do |field|
+#        cmp = send(field) <=> other.send(field); return cmp unless cmp == 0
+#      end
+#    end
+#
+#  end
+
+class Module
+
+  # Automatically generate sorting defintions base on attribute fields.
+  #
+  #   include SortOn(:a, :b)
+  #
+  # is equivalent to including a module containing:
+  #
+  #   def <=>(other)
+  #     cmp = self.a <=> other.a; return cmp unless cmp == 0
+  #     cmp = self.b <=> other.b; return cmp unless cmp == 0
+  #     0
+  #   end
+
+  def Comparable(*accessors)
+    define_method(:comparability){ accessors }
+    code = %{
+      def <=>(other)
+        comparability.each do |a|
+          cmp = (send(a) <=> other.send(a)); return cmp unless cmp == 0
+        end
+      end
+    }
+    module_eval code
+    return Comparable
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/dir.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/dir/ascend.rb

@@ -0,0 +1,59 @@
+class Dir
+
+  # TODO: Make instance method versions ?
+
+  # Ascend a directory path.
+  #
+  #   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('/')
+    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.
+  #
+  #   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|
+      pth = File.join(*paths[0..n])
+      pth = "/" if pth == ""
+      yield(pth)
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/dir/descend.rb

@@ -0,0 +1 @@
+require 'facets/dir/ascend'

data/lib/gems/facets-2.4.5/lib/core/facets/dir/multiglob.rb

@@ -0,0 +1,92 @@
+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('**/*')
+  #
+  #--
+  # DEPRECATED
+  #
+  # 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 : {})
+
+    if options.delete(:recurse)
+      #patterns += patterns.collect{ |f| File.join(f, '**', '**') }
+      multiglob_r(*patterns)
+    end
+
+    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
+
+    if options[:recurse]
+      patterns += patterns.collect{ |f| File.join(f, '**', '**') }
+    end
+
+    files = []
+    files += patterns.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 : {})
+    matches = multiglob(*patterns)
+    directories = matches.select{ |m| File.directory?(m) }
+    matches += directories.collect{ |d| multiglob_r(File.join(d, '**'), options) }.flatten
+    matches.uniq
+    #options = (Hash === patterns.last ? patterns.pop : {})
+    #options[:recurse] = true
+    #patterns << options
+    #multiglob(*patterns)
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/dir/parent.rb

@@ -0,0 +1,13 @@
+class Dir
+
+  # Is a path parental to another?
+  #
+  # TODO: Needs improvement.
+  # TODO: Instance version?
+
+  def self.parent?(parent_path, child_path)
+    %r|^#{Regexp.escape(parent_path)}| =~ child_path
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/dir/recurse.rb

@@ -0,0 +1,29 @@
+class Dir
+
+  # Recursively scan a directory and pass each file
+  # to the given block.
+  #
+  #   CREDIT: George Moschovitis
+
+  def self.recurse(path='.', &block)
+    list = []
+    stoplist = ['.', '..']
+    Dir.foreach(path) do |f|
+      next if stoplist.include?(f)
+      filename = (path == '.' ? f : 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
+
+  # Same as Dir#recurse.
+  def self.ls_r(path='.', &block)
+    recurse(path, &block)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/accumulate.rb

@@ -0,0 +1,21 @@
+require 'facets/functor'
+
+module Enumerable
+
+  # Accumulate a set of a set.
+  #
+  # For example, in an ORM design if Group
+  # has_many User then
+  #
+  #   groups.accumulate.users
+  #
+  # will return a list of users from all groups.
+
+  def accumulate
+    @_accumulate ||= Functor.new do |op, *args|
+      inject([]) { |a, x| a << x.send(op, *args) }.flatten
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/cluster_by.rb

@@ -0,0 +1,21 @@
+require 'facets/enumerable/group_by'
+
+module Enumerable
+
+  # Similar to #group_by but returns an array of the groups.
+  # Returned elements are sorted by block.
+  #
+  #    %w{this is a test}.cluster_by {|x| x[0]}
+  #
+  # _produces_
+  #
+  #    [ ['a'], ['is'], ['this', 'test'] ]
+  #
+  #  CREDIT Erik Veenstra
+
+  def cluster_by(&b)
+    group_by(&b).sort.transpose.pop || []   # group_by(&b).values ?
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/collect.rb

@@ -0,0 +1,54 @@
+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
+

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/commonality.rb

@@ -0,0 +1,33 @@
+module Enumerable
+
+  # Returns all items that are equal in terms of the supplied block.
+  # If no block is given objects are considered to be equal if they
+  # return the same value for Object#hash and if obj1 == obj2.
+  #
+  #   [1, 2, 2, 3, 4, 4].commonality # => { 2 => [2], 4 => [4] }
+  #
+  #   ["foo", "bar", "a"].commonality { |str| str.length }
+  #   # => { 3 => ["foo, "bar"] }
+  #
+  #   # Returns all persons that share their last name with another person.
+  #   persons.collisions { |person| person.last_name }
+  #
+  #   CREDIT: Florian Gross
+
+  def commonality( &block )
+    had_no_block = !block
+    block ||= lambda { |item| item }
+    result = Hash.new { |hash, key| hash[key] = Array.new }
+    self.each do |item|
+      key = block.call(item)
+      result[key] << item
+    end
+    result.reject! do |key, values|
+      values.size <= 1
+    end
+    #return had_no_block ? result.values.flatten : result
+    return result
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/count.rb

@@ -0,0 +1,26 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  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
+    #
+    #   CREDIT: Trans
+
+    def count(*c)
+      self.select{ |*i| i == c }.length
+    end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/divide.rb

@@ -0,0 +1,33 @@
+module Enumerable
+
+  # Divide on matching pattern.
+  #
+  #   ['a1','b1','a2','b2'].divide(/^a/)
+  #   => [['a1,'b1'],['a2','b2']]
+  #
+  #  CREDIT: Trans
+
+  def divide(pattern)
+    memo = []
+    each do |obj|
+      memo.push [] if pattern === obj
+      memo.last << obj
+    end
+    memo
+  end
+
+  # DEPRECATED -- Use 'each_slice(n).to_a' as of 1.9.
+  # 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
+
+end
+