facets 0.9.0 → 1.0.0

data/lib/facet/enumerable/probability.rb

@@ -1 +1,59 @@
-require 'nano/enumerable/probability.rb'
+#--
+# Credit goes to Brian Schröder for current code
+# and Derek for original.
+#++
+module Enumerable
+
+  # Generates a hash mapping each unique symbol in the array
+  # to the relative frequency, i.e. the probablity, of
+  # it appearence.
+  def probability
+    probs = Hash.new(0.0)
+    size = 0.0
+    each do | e |
+      probs[e] += 1.0
+      size += 1.0
+    end
+    probs.keys.each { |e| probs[e] /= size }
+    probs
+  end
+
+# old def
+#
+#   def probability
+#     arr = self.to_a
+#     probHash = Hash.new
+#     size = arr.size.to_f
+#     arr.uniq.each do |i|
+#       ct = arr.inject(0) do |mem,obj|
+#         obj.eql?(i) ? (mem+1) : mem
+#       end
+#       probHash[i] = ct.to_f/size
+#     end
+#     probHash
+#   end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCEnumerable < Test::Unit::TestCase
+
+    def test_probability
+      assert_equal( {'a'=>0.5,'b'=>0.5}, %w{a b}.probability )
+      assert_equal( {'tom'=>0.5,'boy'=>0.5}, %w{tom boy}.probability )
+    end
+
+  end
+
+=end

data/lib/facet/enumerable/project.rb

@@ -1 +1,11 @@
-require 'nano/enumerable/project.rb'
+#--
+# :credit: Sean O'Halpin
+#++
+
+module Enumerable
+
+  def project(&block)
+    self.map{|x| x.instance_eval(&block) }
+  end
+
+end

data/lib/facet/enumerable/self/combinations.rb

@@ -1 +1,68 @@
-require 'nano/enumerable/self/combinations.rb'
+
+module Enumerable
+
+  # Produces an array of arrays of all possible combinations
+  # of the given arrays in the position given. (Explain me better?)
+  #
+  #   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
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCEnumerable < Test::Unit::TestCase
+
+    def test_combinations
+      a = [1,2]
+      b = [3,4]
+      r = Enumerable.combinations(a,b)
+      assert_equal( [[1,3],[1,4],[2,3],[2,4]], r )
+
+      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"] ]
+      a = %w|a b|
+      b = %w|a x|
+      c = %w|x y|
+      z = Enumerable.combinations(a, b, c)
+      assert_equal( r, z )
+    end
+
+  end
+
+=end

data/lib/facet/enumerable/self/cross.rb

@@ -1 +1,79 @@
-require 'nano/enumerable/self/cross.rb'
+#--
+# Cross product adapted from code by Michael Neuman.
+#++
+require 'generator'
+
+module Enumerable
+
+  #  Provides the cross-product of two or more Enumerables.
+  #  This is the class-level method. The instance method
+  #  calls on this.
+  #
+  #    Enumerable.cross([1,2], [4], ["apple", "banana"])
+  #    #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
+  #
+  #    Enumerable.cross([1,2], [3,4])
+  #    #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
+  #
+  def self.cross(*enums, &block)
+    raise if enums.empty?
+    gens = enums.map{|e| Generator.new(e)}
+    return [] if gens.any? {|g| g.end?}
+    sz = gens.size
+    res = []
+    tuple = Array.new(sz)
+
+    loop do
+      # fill tuple
+      (0 ... sz).each { |i| 
+        tuple[i] = gens[i].current 
+      }
+      if block.nil?
+        res << tuple.dup
+      else
+        block.call(tuple.dup)
+      end
+
+      # step forward
+      gens[-1].next
+      (sz-1).downto(0) { |i|
+        if gens[i].end?
+          if i > 0
+            gens[i].rewind
+            gens[i-1].next
+          else
+            return res
+          end
+        end
+      }
+    end
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCEnumerable < Test::Unit::TestCase
+
+    def test_cross
+      i = [[1,2], [3,4]]
+      o = [[1, 3], [1, 4], [2, 3], [2, 4]]
+      assert_equal( o, Enumerable.cross(*i) )
+      i = [[1,2], [4], ["apple", "banana"]]
+      o = [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
+      assert_equal( o, Enumerable.cross(*i) )
+    end
+
+  end
+
+=end

data/lib/facet/enumerable/to_h.rb

@@ -1 +1,50 @@
-require 'nano/enumerable/to_h.rb'
+
+module Enumerable
+
+  # Produces a hash from an Enumerable with index for keys.
+  #
+  #   enu = 'a'..'b'
+  #   enu.to_h  #=> { 0=>'a', 1=>'b' }
+  #
+  # If a block is passed, the hash values will be set by 
+  # calling the block with the enumerated element and it's
+  # counter.
+  #
+  #   enu = 'a'..'b'
+  #   enu.to_h{ |e,i| e }  #=> { 0=>'a', 1=>'b' }
+  #
+  # See also #graph.
+  #
+  def to_h( &blk )
+    h = {}
+    if block_given?
+      each_with_index{ |e,i| h[i] = blk.call(e,i) }
+    else
+      each_with_index{ |e,i| h[i] = e }
+    end
+    h
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCEnumerable < Test::Unit::TestCase
+
+    def test_to_h
+      a = [:a,:b,:c]
+      assert_equal( { 0=>:a, 1=>:b, 2=>:c }, a.to_h )
+    end
+
+  end
+
+=end

data/lib/facet/enumerable/uniq_by.rb

@@ -1 +1,39 @@
-require 'nano/enumerable/uniq_by.rb'
+
+module Enumerable
+
+  # 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
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCEnumerable < Test::Unit::TestCase
+
+    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
+
+  end
+
+=end

data/lib/facet/enumerable/where.rb

@@ -1 +1,12 @@
-require 'nano/enumerable/where.rb'
+#--
+# :credit: Sean O'Halpin
+#++
+
+module Enumerable
+
+  def where(&block)
+    self.select{|x| x.instance_eval(&block) }
+  end
+
+end
+

data/lib/facet/file.rb

@@ -1 +1,5 @@
-require 'nano/file.rb'
+require 'nano/file/self/create'
+require 'nano/file/self/open_as_string'
+require 'nano/file/self/read_list'
+require 'nano/file/self/sanitize'
+require 'nano/file/self/split_all'

data/lib/facet/file/self/create.rb

@@ -1 +1,52 @@
-require 'nano/file/self/create.rb'
+#--
+# Copyright (c) 2005 George Moschovitis <gm@navel.gr>
+#++
+
+# Creates a new file, or overwrites an existing file,
+# and writes a string into it. Can also take a block
+# just like File#open, which is yielded _after_ the
+# string is writ.
+#
+#   str = 'The content for the file'
+#   File.create('myfile.txt', str)
+#
+def File.create(path, str='', &blk)
+  File.open(path, 'w') { |f|
+    f << str
+    blk.call(f) if blk
+  }
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  # FIND TEST DIRECTORY
+  paths = File.expand_path(File.dirname(__FILE__)).split('/')
+  paths.size.downto(1) do |i|
+    f = (paths.slice(0..i)+['test']).join('/')
+    $TESTDIR = File.join(f,'FIXTURE') if File.directory?(f)
+  end
+  raise unless $TESTDIR
+
+  class TC_CREATE < Test::Unit::TestCase
+
+    def test_create
+      f = File.join( $TESTDIR, 'create_file' )
+      t = 'This is a test'
+      File.create( f, t )
+      assert( File.exists?( f ) )
+      s = File.read( f )
+      assert_equal( t, s )
+    end
+
+  end
+
+=end

data/lib/facet/file/self/open_as_string.rb

@@ -1 +1,81 @@
-require 'nano/file/self/open_as_string.rb'
+
+# Opens a file as a string and writes back the string to the file at
+# the end of the block.
+#
+# Returns the number of written bytes or +nil+ if the file wasn't
+# modified.
+#
+# Note that the file will even be written back in case the block
+# raises an exception.
+#
+# Mode can either be "b" or "+" and specifies to open the file in
+# binary mode (no mapping of the plattform's newlines to "\n" is
+# done) or to append to it.
+#
+# Usage:
+#   # Reverse contents of "message"
+#   File.open_as_string("message") { |str| str.reverse! }
+#
+#   # Replace "foo" by "bar" in "binary"
+#   File.open_as_string("binary", "b") { |str| str.gsub!("foo", "bar") }
+#
+def File.open_as_string(name, mode = "")
+  unless block_given?
+    raise(ArgumentError, "Need to supply block to File.open_as_string")
+  end
+
+  if mode.is_a?(Numeric) then
+    flag, mode = mode, ""
+    mode += "b" if flag & File::Constants::BINARY != 0
+    mode += "+" if flag & File::Constants::APPEND != 0
+  else
+    mode.delete!("^b+")
+  end
+
+  str = File.open(name, "r#{mode}") { |file| file.read } rescue ""
+  old_str = str.clone
+
+  begin
+    yield str
+  ensure
+    if str != old_str then
+      File.open(name, "w#{mode}") { |file| file.write(str) }
+    end
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  # FIND TEST DIRECTORY
+  paths = File.expand_path(File.dirname(__FILE__)).split('/')
+  paths.size.downto(1) do |i|
+    f = (paths.slice(0..i)+['test']).join('/')
+    $TESTDIR = File.join(f,'FIXTURE') if File.directory?(f)
+  end
+  raise unless $TESTDIR
+
+  class TC_OPEN_AS_STRING < Test::Unit::TestCase
+
+    def test_open_as_string
+      f = File.join( $TESTDIR, 'open_as_string_file' )
+      t = 'This is a test'
+      File.open( f, 'w' ) { |s| s << t }
+      assert( File.exists?( f ) )
+      File.open_as_string(f) { |s| s.reverse! }
+      s = File.read( f )
+      assert_equal( t.reverse, s )
+    end
+
+  end
+
+=end