facets 1.0.0 → 1.0.1

data/lib/facet/dir/self/recurse.rb

@@ -1,2 +0,0 @@
-# stub
-require 'facet/dir/self/ls_r'

data/lib/facet/enumerable.rb

@@ -1,38 +0,0 @@
-require 'nano/enumerable/collect_with_counter'
-require 'nano/enumerable/collect_with_index'
-require 'nano/enumerable/commonality'
-require 'nano/enumerable/compact_collect'
-require 'nano/enumerable/compact_map'
-require 'nano/enumerable/cross'
-require 'nano/enumerable/each_by'
-require 'nano/enumerable/each_combination'
-require 'nano/enumerable/each_pair'
-require 'nano/enumerable/each_permutation'
-require 'nano/enumerable/each_slice'
-require 'nano/enumerable/each_unique_pair'
-require 'nano/enumerable/each_with_counter'
-require 'nano/enumerable/elementwise'
-require 'nano/enumerable/entropy'
-require 'nano/enumerable/every'
-require 'nano/enumerable/ew'
-require 'nano/enumerable/filter_collect'
-require 'nano/enumerable/filter_map'
-require 'nano/enumerable/find_collisions'
-require 'nano/enumerable/frequency'
-require 'nano/enumerable/graph'
-require 'nano/enumerable/ideal_entropy'
-require 'nano/enumerable/map_with_counter'
-require 'nano/enumerable/map_with_index'
-require 'nano/enumerable/none'
-require 'nano/enumerable/nonuniq'
-require 'nano/enumerable/occur'
-require 'nano/enumerable/one'
-require 'nano/enumerable/op_pow'
-require 'nano/enumerable/partition_by'
-require 'nano/enumerable/probability'
-require 'nano/enumerable/project'
-require 'nano/enumerable/self/combinations'
-require 'nano/enumerable/self/cross'
-require 'nano/enumerable/to_h'
-require 'nano/enumerable/uniq_by'
-require 'nano/enumerable/where'

data/lib/facet/enumerable/collect_with_counter.rb

@@ -1,2 +0,0 @@
-# stub
-require 'facet/enumerable/collect_with_index'

data/lib/facet/enumerable/collect_with_index.rb

@@ -1,51 +0,0 @@
-
-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]
-  #
-  def collect_with_index
-    r = []
-    each_index do |i|
-      r << yield(self[i], i)
-    end
-    r
-  end
-
-  alias_method( :map_with_index, :collect_with_index )
-
-  #--
-  # Why the term counter? There may be a change in Ruby 2.0
-  # to use this word instead of index. Index will
-  # still be used for Array, since that is the proper meaning
-  # in that context. In the mean time, aliases are provided.
-  #++
-  alias_method( :collect_with_counter, :collect_with_index )
-  alias_method( :map_with_counter, :collect_with_index )
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_collect_with_index
-      a = [1,2,3].collect_with_index{ |e,i| e*i }
-      assert_equal( [0,2,6], a )
-    end
-
-  end
-
-=end

data/lib/facet/enumerable/commonality.rb

@@ -1,63 +0,0 @@
-
-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.
-  # No guarantee about the order of the elements in the resulting array is made.
-  #
-  # Note: The result will be an array if you supply no block and a hash otherwise.
-  #
-  #   [1, 2, 2, 3, 4, 4].commonality # => { 2 => [2], 4 => [4] }
-  #
-  #   ["foo", "bar", "a"].commonality { |str| str.length }
-  #   # => { 2 => ["foo, "bar"] }
-  #
-  #   # Returns all persons that share their last name with another person.
-  #   persons.collisions { |person| person.last_name }
-  #
-  #--
-  # Credit goes to 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
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_commonality
-      a = [1,2,2,3,3,3]
-      r = { 2 => [2,2], 3 => [3,3,3] }
-      assert_equal( r, a.commonality )
-      a = [1,2,2,3,3,3]
-      r = {false=>[1, 2, 2], true=>[3, 3, 3]}
-      assert_equal( r, a.commonality { |x| x > 2 } )
-    end
-
-  end
-
-=end

data/lib/facet/enumerable/compact_collect.rb

@@ -1,50 +0,0 @@
-#--
-# Credit goes to Florian Gross.
-#++
-require 'facet/enumerable/filter_collect'
-
-module Enumerable
-
-  # Collects/Maps and compacts items in one single step.
-  # The items for which the supplied block returns +nil+ will not
-  # end up in the resulting array.
-  #
-  #   # Return telephone numbers of all persons that have a telephone number.
-  #   persons.compact_collect { |person| person.telephone_no }
-  #
-  # Also see Enumerable#collect, Enumerable#map, Array#compact.
-  #
-  def compact_collect #:yield:
-    filter_collect do |item|
-      new_item = yield(item)
-      throw(:skip) if new_item.nil?
-      new_item
-    end
-  end
-
-  alias_method :compact_map, :compact_collect
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_compact_collect
-      a = [1,2,nil,4].compact_collect { |e| e }
-      assert_equal( [1,2,4], a )
-    end
-
-  end
-
-=end

data/lib/facet/enumerable/compact_map.rb

@@ -1,2 +0,0 @@
-# stub
-require 'facet/enumerable/compact_collect'

data/lib/facet/enumerable/cross.rb

@@ -1,44 +0,0 @@
-#--
-# Cross product adapted from code by Michael Neuman.
-#++
-require 'facet/enumerable/self/cross'
-
-module Enumerable
-
-  # The instance level cross-product method.
-  #
-  #   a = []
-  #   [1,2].cross([4,5]){|elem| a << elem }
-  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
-  #
-  def cross(*enums, &block)
-    Enumerable.cross(self, *enums, &block)
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_cross
-      a = [1,2,3].cross([4,5,6])
-      assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
-      a = []
-      [1,2,3].cross([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
-
-  end
-
-=end

data/lib/facet/enumerable/each_by.rb

@@ -1,2 +0,0 @@
-# stub
-require 'facet/enumerable/each_slice'

data/lib/facet/enumerable/each_combination.rb

@@ -1,59 +0,0 @@
-
-class Array
-
-  # Yields the block to each unique combination of _n_ elements.
-  #
-  #   a = %w|a b c d|
-  #   a.each_combination(3) do |c|
-  #     p c
-  #   end
-  #
-  # produces
-  #
-  #   ["a", "b", "c"]
-  #   ["a", "b", "d"]
-  #   ["a", "c", "d"]
-  #   ["b", "c", "d"]
-  #
-  def each_combination(k=2)
-    s = self.to_a
-    n = s.size
-    return unless (1..n) === k
-    idx = (0...k).to_a
-    loop do
-      yield s.values_at(*idx)
-      i = k - 1
-      i -= 1 while idx[i] == n - k + i
-      break if i < 0
-      idx[i] += 1
-      (i + 1 ... k).each {|j| idx[j] = idx[i] + j - i}
-    end
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_each_combination
-      r = []
-      a = [1,2,3,4]
-      a.each_combination(2){ |a,b| r << [a,b] }
-      assert_equal( [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], r )
-    end
-
-  end
-
-=end
-

data/lib/facet/enumerable/each_pair.rb

@@ -1,50 +0,0 @@
-
-module Enumerable
-
-  # Iterators ovr each element pairing.
-  #
-  #   [:a,:b,:c,:d].each_pair { |a,b|  puts "#{a} -> #{b}" }
-  #
-  # _produces_
-  #
-  #   a -> b
-  #   c -> d
-  #
-  def each_pair #:yield:
-    e1 = nil
-    each_with_index do |e,i|
-      if i % 2 == 0
-        e1 = e
-        next
-      else
-        yield(e1,e)
-      end
-    end
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_each_pair
-      r = []
-      a = [1,2,3,4]
-      a.each_pair{ |a,b| r << [a,b] }
-      assert_equal( [[1,2],[3,4]], r )
-    end
-
-  end
-
-=end

data/lib/facet/enumerable/each_permutation.rb

@@ -1,2 +0,0 @@
-# stub
-require 'facet/enumerable/permute.rb'

data/lib/facet/enumerable/each_slice.rb

@@ -1,131 +0,0 @@
-
-module Enumerable
-
-  # Iterate through slices. If slicing _step_ is not
-  # given, the the arity if the block is used.
-  #
-  #   x = []
-  #   [1,2,3,4].each_slice(2){ |a,b| x << [a,b] }
-  #   x  #=> [ [1,2], [3,4] ]
-  #
-  #   x = []
-  #   [1,2,3,4,5,6].each_slice(3){ |a| x << a }
-  #   x  #=> [ [1,2,3], [4,5,6] ]
-  #
-  def each_slice(step=nil, &yld)
-    if step
-      cnt = step
-      n = length / cnt
-      n += 1 if length % cnt > 0
-      n.times { |i|
-        yld.call(*self.slice(i*cnt,cnt))
-      }
-      return cnt
-    else
-      cnt = yld.arity.abs
-      n = length / cnt
-      n += 1 if length % cnt > 0
-      n.times { |i|
-        yld.call(*self.slice(i*cnt,cnt))
-      }
-      return cnt
-    end
-  end
-
-  alias_method( :each_by, :each_slice )
-
-end
-
-
-class Array
-
-  # Iterates over +n+ elements at a time. If +n+ is
-  # not given then the arity of the block determines the 
-  # slicing quantity.
-  #
-  #   [1, 2, 3, 4].each_slice(2){ |a,b| ... }
-  #
-  # This is a specialized version Enumerable#each_slice
-  # but optimized specifically for Array.
-  def each_slice(n=nil, &yld)
-    n = yld.arity.abs unless n
-    i=0
-    while i < self.length
-      yld.call(*self.slice(i,n))
-      i+=n
-    end
-  end
-
-  alias_method( :each_by, :each_slice )
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_each_slice
-      x = []
-      [1,2,3,4].each_slice{ |a,b| x << [a,b] }
-      o = [[1,2],[3,4]]
-      assert_equal( o, x )
-
-      x = []
-      [1,2,3,4,5].each_by{ |a,b,c| x << [a,b,c] }
-      o = [[1,2,3],[4,5,nil]]
-      assert_equal( o, x )
-
-      x = []
-      [1,2,3,4].each_slice(2){ |a,b| x << [a,b] }
-      o = [[1,2],[3,4]]
-      assert_equal( o, x )
-
-      x = []
-      [1,2,3,4,5,6,7,8].each_slice(4){ |*a| x << a }
-      o = [[1,2,3,4],[5,6,7,8]]
-      assert_equal( o, x )
-
-      x = []
-      [1,2,3,4,5,6].each_slice(3){ |*a| x << a }
-      o = [[1,2,3],[4,5,6]]
-      assert_equal( o, x )
-
-      a = [1,2,3,4,5,6]
-      r = []
-      a.each_slice(2){ |x,y| r << [x,y] }
-      assert_equal( [[1,2],[3,4],[5,6]], r )
-
-      r = []
-      a.each_slice(3){ |*e| r << e }
-      assert_equal( [[1,2,3],[4,5,6]], r )
-    end
-
-  end
-
-  class TC02 < Test::Unit::TestCase
-
-    def test_each_by
-      x = []
-      [1,2,3,4].each_by(2){ |a,b| x << [a,b] }
-      o = [[1,2],[3,4]]
-      assert_equal( o, x )
-
-      x = []
-      [1,2,3,4,5].each_by(3){ |*a| x << a }
-      o = [[1,2,3],[4,5]]
-      assert_equal( o, x )
-    end
-
-  end
-
-=end