facets 0.6.3

data/lib/facet/enumerable/every.rb

@@ -0,0 +1,45 @@
+#--
+# Special thanks to Martin DeMello for helping to develop this.
+#++
+begin
+  require 'carat/functor'
+rescue
+  class Functor
+    def initialize(&func) ; @func = func ; end
+    def method_missing(op, *args) ; @func.call(op, *args) ; end
+  end
+end
+module Enumerable
+  # Uses a Functor to provide R-like per element 
+  # method application.
+  #
+  #   require 'facet/enumerable/every'
+  #
+  #   a = [1,2,3]
+  #   b = [4,5]
+  #
+  #   p a.every + 3       => [4,5,6]
+  #   p a.every + b       => [5,7]
+  #   p a.every.+(b,2)    => [[5,7],[3,4,5]]
+  #
+  # Note that this method is still undergoing some fine tuning.
+  # It is questionable as to whether different sized arrays should 
+  # be padded with nil (or a parameter) and whether multiple parameters
+  # are a good idea (e.g. <tt>a.%.+(b,2,...)</tt>).
+  def every
+    #Functor.new(self) do |op,*args|
+    Functor.new do |op,*args|
+      a = args.collect do |arg|
+        if arg.kind_of?(Enumerable)
+          ln = ( arg.length > self.length ? self.length : arg.length )
+          self[0...ln].zip(arg[0...ln]).collect{ |a,b| a.send(op,b) }
+          #self[0...l].zip(arg[0...1]).collect{ |a,b| b ? a.send(op,b) : nil }
+        else
+          self.collect{ |a| a.send(op,arg) }
+        end
+      end
+      a.flatten! if args.length == 1
+      a
+    end
+  end
+end

data/lib/facet/enumerable/graph.rb

@@ -0,0 +1,48 @@
+#--
+# Credits for original work goes to Zallus Kanite and Gavin Sinclair.
+#++
+module Enumerable
+  #
+  # Like <tt>#map</tt>/<tt>#collect</tt>, but it generates a Hash.  The block
+  # is expected to return two values: the key and the value for the new hash.
+  #
+  #   require 'facet/enumberable/graph'
+  #
+  #   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 graph(&yld)
+    if yld
+      inject({}) do |h,kv|
+        nk, nv = yld[*kv]
+        h[nk] = nv
+        h
+      end
+    else
+      Hash[*self.to_a.flatten]
+    end
+  end
+  alias_method( :build_hash, :graph )
+    
+#old version
+#    result = {}
+#    if block_given?
+#      self.each do |elt|
+#        key, value = yield(elt)
+#        result[key] = value
+#      end
+#    else
+#      Hash[*self.to_a.flatten]
+#    end
+#    result
+#  end
+
+
+  # As with map_hash but acts in place.
+  def graph!( &blk )
+    self.replace( map_hash( &blk ) )
+  end
+  alias_method( :build_hash!, :graph! )
+
+end

data/lib/facet/enumerable/none?.rb

@@ -0,0 +1,28 @@
+#--
+# Credit goes to Gavin Sinclair.
+#++
+module Enumerable
+  #
+  # 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+).
+  #
+  #   require 'facet/enumerable/none?'
+  #
+  #   [].none?                      # true
+  #   [nil].none?                   # true
+  #   [5,8,9].none?                 # false
+  #   (1...10).none? { |n| n < 0 }  # true
+  #   (1...10).none? { |n| n > 0 }  # false
+  #
+  def none?  # :yield: e
+    if block_given?
+      not self.any? { |e| yield e }
+    else
+      not self.any?
+    end
+  end
+end 

data/lib/facet/enumerable/one?.rb

@@ -0,0 +1,35 @@
+#--
+# Credit goes to Gavin Sinclair.
+#++
+module Enumerable
+  #
+  # 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+).
+  #
+  #   require 'facet/enumerable/one?'
+  #
+  #   [].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
+  #
+  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
+end

data/lib/facet/enumerable/partition_by.rb

@@ -0,0 +1,27 @@
+#--
+# Credit goes to Gavin Sinclair.
+#++
+module Enumerable
+  # See Enumerable#partition for the background.  #partition_by is best
+  # explained by example.
+  #
+  #   require 'facet/enumerable/partition_by'
+  #
+  #   (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] } 
+  #
+  # #partition_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.
+  def partition_by
+    result = {}
+    self.each do |e|
+      value = yield e
+      (result[value] ||= []) << e
+    end
+    result
+  end
+end 

data/lib/facet/enumerable/per.rb

@@ -0,0 +1,18 @@
+require 'facet/enumerable/every'
+module Enumerable
+  # Alias for #every.
+  alias_method( :per, :every )
+  
+  # Very nice, concise alias shorthand for #every.
+  #
+  #   require 'facet/enumerable/every'
+  #
+  #   a = [1,2,3]
+  #   b = [4,5]
+  #
+  #   p a.% + 3       => [4,5,6]
+  #   p a.% + b       => [5,7]
+  #   p a.%.+(b,2)    => [[5,7],[3,4,5]]
+  #
+  alias_method( :%, :every )
+end 

data/lib/facet/enumerable/to_hash.rb

@@ -0,0 +1,17 @@
+module Enumerable
+
+  # Produces a hash from an Array with index for keys.
+  #
+  #   require 'facet/array/to_hash'
+  #
+  #   a1 = [ :a, :b ]
+  #   a1.to_hash  #=> { 0=>:a, 1=>:b }
+  #
+  def to_hash
+    h = {}
+    each_with_index{|e,i| h[i] = e }
+    h
+  end
+
+end
+

data/lib/facet/enumerable/uniq_by.rb

@@ -0,0 +1,35 @@
+module Enumerable
+  
+  # Like #uniq, but determines uniqueness based
+  # on a given block.
+  #
+  #   require 'facet/enumerable/uniq_by'
+  #
+  #   (-5..5).to_a.uniq_by {|i| i*i }
+  #
+  # produces
+  #
+  #   [-5, -4, -3, -2, -1, 0]
+  #
+  def uniq_by
+    h = {}; inject([]) {|a,x| h[yield(x)] ||= a << x} 
+  end
+
+  # # alternate definition
+  # #
+  # #  [[1, 2], [3, 4], [5, 6], [7, 2]].uniq_by(:at, 1)
+  # #
+  # def uniq_by(*args, &blk)
+  #   blk = lambda {|i| i.send(*args)} unless args.empty?
+  #   raise "needs args or block" unless blk
+  #   h = {}
+  #   a = []
+  #   each {|i|
+  #     k = blk.call(i)
+  #     a << i unless h[k]
+  #     h[k] = true
+  #   }
+  #   a
+  # end
+
+end

data/lib/facet/file.rb

@@ -0,0 +1,7 @@
+
+# base
+
+# common
+require 'facet/file/split_all'
+
+# uncommon (not required)

data/lib/facet/file/split_all.rb

@@ -0,0 +1,17 @@
+class File
+  # Splits a file path into an array of individual path components.
+  # This differs from <tt>File.split</tt>, which divides the path into
+  # only two parts, directory path and basename.
+  #
+  #   require 'facet/file/split_all'
+  #
+  #   split_all("a/b/c") =>  ['a', 'b', 'c']
+  #
+  def self.split_all(path)
+    head, tail = File.split(path)
+    return [tail] if head == '.' || tail == '/'
+    return [head, tail] if head == '/'
+    return split_all(head) + [tail]
+  end
+end
+

data/lib/facet/fileutils.rb

@@ -0,0 +1,11 @@
+
+# base
+
+# common
+require 'facet/fileutils/head&tail'
+require 'facet/fileutils/wc'
+
+# uncommon (not required)
+# require 'facet/fileutils/safe_ln'
+# require 'facet/fileutils/whereis'
+# require 'facet/fileutils/which'

data/lib/facet/fileutils/head&tail.rb

@@ -0,0 +1,65 @@
+#--
+# The body() method was provided by Shashank Date, via Daniel Berger.
+#++
+require 'fileutils'
+
+module FileUtils
+
+  module_function
+
+  # In block form, yields the first number of ((*lines*)) of file ((*filename*)).
+  # In non-block form, it returns an array of the first number of ((*lines*)).
+  #
+  #   require 'facet/fileutils/head&tail'
+  #
+  #   # Returns first 10 lines of 'myfile'
+  #   FileUtils.head("myfile")
+  #  
+  def head(filename,lines=10) #:yield:
+    a = []
+    IO.foreach(filename){|line|
+        break if lines <= 0
+        lines -= 1
+        if block_given?
+          yield line
+        else
+          a << line
+        end
+    }
+    return a.empty? ? nil : a
+  end
+  #alias first head
+
+  # In block form, yields lines ((*from*))-((*to*)).  In non-block form,
+  # returns an array of lines ((*from*))-((*to*)).
+  #
+  #   require 'facet/fileutils/head&tail'
+  #
+  #   # Returns lines 8-12 of 'myfile'
+  #   FileUtils.body("myfile",8,12)
+  #
+  def body(filename,from=10,to=20) #:yield:
+    IO.readlines(filename)[from-1..to-1]
+  end
+  #alias middle body
+  #alias mid body
+    
+  # In block form, yields the last number of ((*lines*)) of file ((*filename*)).
+  # In non-block form, it returns the lines as an array.
+  #
+  # Note that this method slurps the entire file, so I don't recommend it
+  # for very large files.  If you want an advanced form of ((*tail*)), I
+  # suggest using file-tail, by Florian Frank (available on the RAA).
+  # And no tail -f.
+  #
+  #   require 'facet/fileutils/head&tail'
+  #
+  #   # Returns last 3 lines of 'myfile'
+  #   FileUtils.tail("myfile",3)
+  #
+  def tail(filename,lines=10) #:yield
+    IO.readlines(filename).reverse[0..lines-1].reverse
+  end 
+  #alias last tail
+  
+end

data/lib/facet/fileutils/safe_ln.rb

@@ -0,0 +1,18 @@
+require 'fileutils'
+module FileUtils
+  module_function
+  # Attempt to do a normal file link, but fall back
+  # to a copy if the link fails.
+  def safe_ln(*args)
+    if @link_not_supported
+      FileUtils.cp(*args)
+    else
+      begin
+        FileUtils.ln(*args)
+      rescue Errno::EOPNOTSUPP
+        @link_not_supported = true
+        FileUtils.cp(*args)
+      end
+    end
+  end
+end

data/lib/facet/fileutils/wc.rb

@@ -0,0 +1,62 @@
+#--
+# Credit goes to Daniel J. Berger.
+#++
+require 'fileutils'
+
+module FileUtils
+  # With no arguments, returns a four element array consisting of the number
+  # of bytes, characters, words and lines in _filename_, respectively.
+  # 
+  # Valid options are <tt>bytes</tt>, <tt>characters</tt> (or just 'chars'),
+  # <tt>words</tt> and <tt>lines</tt>.
+  #
+  #   require 'facet/fileutils/wc'
+  #
+  #   # Return the number of words in 'myfile'
+  #   FileUtils.wc("myfile",'words')  
+  #
+  def self.wc(filename,option='all')
+    option.downcase!
+    valid = %w/all bytes characters chars lines words/
+
+    unless valid.include?(option)
+        raise "Invalid option: '#{option}'"
+    end
+
+    n = 0
+    if option == 'lines'
+        IO.foreach(filename){ n += 1 }
+        return n
+    elsif option == 'bytes'
+        File.open(filename){ |f|
+          f.each_byte{ n += 1 }
+        }
+        return n
+    elsif option == 'characters' || option == 'chars'
+        File.open(filename){ |f|
+          while f.getc
+              n += 1
+          end
+        }
+        return n
+    elsif option == 'words'
+        IO.foreach(filename){ |line|
+          n += line.split.length
+        }
+        return n
+    else
+        bytes,chars,lines,words = 0,0,0,0
+        IO.foreach(filename){ |line|
+          lines += 1
+          words += line.split.length
+          chars += line.split('').length
+        }
+        File.open(filename){ |f|
+          while f.getc
+              bytes += 1
+          end
+        }
+        return [bytes,chars,words,lines]
+    end
+  end
+end