facets 3.1.0 → 3.2.0

data/test/core/denumerable_tc.rb

@@ -1,194 +0,0 @@
-covers 'facets/denumerable'
-covers 'facets/enumerable/defer'
-#require 'facets/enumerable/take'
-
-test_case Denumerable do
-
-  c = Class.new do
-    include Denumerable
-    def initialize(*a)
-      @a = a
-    end
-    def each(&blk)
-      @a.each(&blk)
-    end
-    def size; @a.size; end
-  end
-
-  method :map do
-    test do
-      o = c.new(1,2,3,4)
-      o.map.assert.is_a?(Denumerator)
-      o.map{ |x| x + 1 }.assert.is_a?(Denumerator)
-      o.map{ |x| x + 1 }.to_a.assert == [2,3,4,5]
-    end
-  end
-
-  method :collect do
-    test do
-      o = c.new(1,2,3,4)
-      o.collect.assert.is_a?(Denumerator)
-      o.collect{ |x| x + 1 }.assert.is_a?(Denumerator)
-      o.collect{ |x| x + 1 }.to_a.assert == [2,3,4,5]
-    end
-  end
-
-  method :select do
-    test do
-      o = c.new(1,2,3,4)
-      o.select.assert.is_a?(Denumerator)
-      o.select{ |x| x > 1 }.assert.is_a?(Denumerator)
-      o.select{ |x| x > 1 }.to_a.assert == [2,3,4]
-    end
-  end
-
-  method :find_all do
-    test do
-      o = c.new(1,2,3,4)
-      o.find_all.assert.is_a?(Denumerator)
-      o.find_all{ |x| x > 1 }.assert.is_a?(Denumerator)
-      o.find_all{ |x| x > 1 }.to_a.assert == [2,3,4]
-    end
-  end
-
-  method :reject do
-    test do
-      o = c.new(1,2,3,4)
-      o.reject.assert.is_a?(Denumerator)
-      o.reject{ |x| x > 1 }.assert.is_a?(Denumerator)
-      o.reject{ |x| x > 1 }.to_a.assert == [1]
-    end
-  end
-
-  method :skip do
-    test do
-      o = c.new(1,2,3,4)
-      o.skip(2).assert.is_a?(Denumerator)
-      o.skip(2).to_a.assert == [3,4]
-    end
-  end
-
-  method :take do
-    test do
-      o = c.new(1,2,3,4)
-      o.take(2).assert.is_a?(Denumerator)
-      o.take(2).to_a.assert == [1,2]
-    end
-  end
-
-end
-
-test_case Denumerator do
-
-  source = (1..1/0.0)   # infinite Enumerable object
-
-  method :each do
-    test do
-      res = []
-      (1..5).defer.each { |i| res << i }
-      res.assert == [1,2,3,4,5]
-    end
-  end
-
-  method :take do
-    test do
-      d = source.defer
-      d.take(5).to_a.assert == [1,2,3,4,5]
-    end
-  end
-
-  method :inject do
-    test do
-      d = (1..5).defer
-      d = d.inject({}) { |h,v| h[v] = v*2; h }
-      d.assert == {1=>2,2=>4,3=>6,4=>8,5=>10}
-    end
-
-    # TODO: problem with break in proc
-    #test do
-    #  d = (1..5).defer
-    #  d = d.inject({}){ |h,v| h[v] = v*2; break h if v>=3; h }
-    #  d.assert == {1=>2,2=>4,3=>6}
-    #end
-  end
-
-  method :max do
-    test do
-      d = source.defer
-      d.take(5).max.assert == 5
-    end
-  end
-
-  method :min do
-    test do
-      d = source.defer
-      d.take(5).min.assert == 1
-    end
-  end
-
-  method :sort_by do
-    test do
-      d = source.defer
-      d.take(5).sort_by{ |x| -x }.assert == [5,4,3,2,1]
-    end
-  end
-
-  method :map do
-    test do
-      d = source.defer
-      d.map{ |i| i*2 }.take(5).min.assert == 2
-    end
-  end
-
-  method :defer do
-    test do
-      d = source.defer.defer{ |out,i| out << i*2 }
-      d.take(5).to_a.assert == [2,4,6,8,10]
-    end
-
-    test "chain" do
-      d = source.defer { |out,i| out.yield(i) if i % 2 == 0 }.
-                 defer { |out,i| out.yield(i + 100) }
-      d.take(5).to_a.assert == [102,104,106,108,110]
-    end
-  end
-
-  method :select do
-    test do
-      d = source.defer
-      d = d.select{ |i| i % 2 == 0 }
-      d.take(5).to_a.assert == [2,4,6,8,10]
-    end
-  end
-
-  method :find_all do
-    test do
-      d = source.defer
-      d = d.find_all{ |i| i % 2 == 0 }
-      d.take(5).to_a.assert == [2,4,6,8,10]
-    end
-  end
-
-  method :reject do
-    test do
-      d = source.defer
-      d = d.reject { |i| i % 3 == 0 }
-      d.take(5).to_a.assert == [1,2,4,5,7]
-    end
-  end
-
-  method :skip do
-    test do
-      d = source.defer
-      d = d.skip(20)
-      d.take(5).to_a.assert == [21,22,23,24,25]
-    end
-  end
-
-  #method :each_cons
-  #  test do
-  #    a = source.defer
-  #    assert_equal [[1,2,3],[2,3,4],[3,4,5],[4,5,6]], a.each_cons(3).take(4)
-  #  end
-  #end
-end

data/test/core/dir/test_ascend.rb

@@ -1,40 +0,0 @@
-covers 'facets/dir/ascend'
-
-test_case Dir do
-
-   test_directory = 'test/core/dir'
-
-   class_method :ascend do
-
-     test do
-       c = []
-       Dir.ascend(test_directory) do |path|
-         c << path
-       end
-       rdir = test_directory
-       c.each do |d|
-         d.assert == rdir
-         rdir = File.dirname(rdir)
-       end
-     end
-
-   end
-
-   class_method :ascend do
-
-     test "exclude current" do
-       c = []
-       Dir.ascend(test_directory, false) do |path|
-         c << path
-       end
-       rdir = File.dirname(test_directory)
-       c.each do |d|
-         d.assert == rdir
-         rdir = File.dirname(rdir)
-       end
-     end
-
-   end
-
-end
-

data/test/core/dir/test_descend.rb

@@ -1,24 +0,0 @@
-covers 'facets/dir/ascend'
-
-test_case Dir do
-
-   test_directory = 'test/core/dir'
-
-   class_method :descend do
-
-     test do
-       c = []
-       Dir.descend(test_directory) do |path|
-         c << path
-       end
-       rdir = test_directory
-       c.reverse_each do |d|
-         d.assert == rdir
-         rdir = File.dirname(rdir)
-       end
-     end
-
-   end
-
-end
-

data/test/core/dir/test_each_child.rb

@@ -1,22 +0,0 @@
-covers 'facets/dir/each_child'
-
-test_case Dir do
-
-  test_directory = 'test'
-
-  method :each_child do
-
-    test do
-      c = []
-      d = Dir.new(test_directory)
-      d.each_child do |path|
-        c << path
-      end
-      d.close
-      (['core', 'standard'] - c).assert.empty?
-    end
-
-  end
-
-end
-

data/test/core/dir/test_multiglob.rb

@@ -1,25 +0,0 @@
-covers 'facets/dir/multiglob'
-
-test_case Dir do
-
-  class_method :multiglob do
-
-    test do
-      r = Dir.multiglob('test/c*').sort
-      r.assert.include?('test/core')
-    end
-
-  end
-
-  class_method :multiglob_r do
-
-    test do
-      r = Dir.multiglob_r('test').sort
-      r.assert.include?('test/core/dir')
-      r.assert.include?('test/core/dir/test_multiglob.rb')
-    end
-
-  end
-
-end
-

data/test/core/dir/test_parent.rb

@@ -1,14 +0,0 @@
-covers 'facets/dir/parent'
-
-test_case Dir do
-
-  class_method :parent? do
-
-    test do
-      Dir.assert.parent?("a/b/c", "a/b/c/d")
-    end
-
-  end
-
-end
-

data/test/core/dir/test_recurse.rb

@@ -1,26 +0,0 @@
-covers 'facets/dir/recurse'
-
-test_case Dir do
-
-  class_method :recurse do
-
-    test do
-      r = Dir.recurse('test')
-      r.assert.include?('test/core/dir')
-      r.assert.include?('test/core/dir/test_recurse.rb')
-    end
-
-  end
-
-  class_method :ls_r do
-
-    test do
-      r = Dir.ls_r('test')
-      r.assert.include?('test/core/dir')
-      r.assert.include?('test/core/dir/test_recurse.rb')
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_accumulate.rb

@@ -1,44 +0,0 @@
-covers 'facets/enumerable/accumulate'
-
-test_case Enumerable do
-
-  method :accumulate do
-
-    test do
-      a = [1,2,3]
-      a.accumulate.succ.assert == [2,3,4]
-    end
-
-    test do
-      a = [{:ab=>1},{22=>:c}]
-      a.accumulate.values_at(:ab,22).assert == [1,nil,:c]
-    end
-
-    test "chained twice" do
-      a = [1,2,3]
-      a.accumulate(2).succ.to_s.assert == ['2','3','4']
-    end
-
-    test "chained three times" do
-      a = [{:ab=>1},{22=>:c}]
-      a.accumulate(3).keys.to_s.split(//).assert == ['a', 'b', '2']
-    end
-
-    test "empty receiver" do
-      a = []
-      a.accumulate.succ.assert == []
-    end
-
-  end
-
-  method :accumulate_all do
-
-    test "not uniq entries" do
-      a = [{:ab=>1},{22=>:c}]
-      a.accumulate_all(3).keys.to_s.split(//).assert == ['a', 'b', '2', '2']
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_cluster.rb

@@ -1,36 +0,0 @@
-covers 'facets/enumerable/cluster'
-
-test_case Enumerable do
-
-  method :cluster do
-
-    test "on an array" do
-      a = [0, 2, 3, 5, 6, 6, 7, 13]
-      e = [[0, 2], [3, 5], [6, 6], [7, 13]]
-      r = a.cluster{ |x| x % 2 }
-      r.assert == e
-    end
-
-    test "on an array of strings" do
-      a = ["dog", "duck", "cat", "dude"]
-      e = [["dog", "duck"], ["cat"], ["dude"]]
-      r = a.cluster{ |x| x[0] }
-      r.assert == e
-    end
-
-    test "on a hash" do
-      h = {0=>0, 1=>2, 2=>4, 3=>6, 4=>8, 5=>1, 6=>3, 7=>5, 8=>7, 9=>9}
-      e = [[[0, 0], [1, 2], [2, 4], [3, 6], [4, 8]], [[5, 1], [6, 3], [7, 5], [8, 7], [9, 9]]]
-      r = h.cluster{ |k, v| v % 2 }.each{|a| a.sort!}
-      r.assert == e
-    end
-
-    test "on an empty array" do
-      r = [].cluster{ |a| a }
-      r.assert == []
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_compact_map.rb

@@ -1,32 +0,0 @@
-covers 'facets/enumerable/compact_map'
-
-test_case Enumerable do
-
-  method :compact_map do
-
-    test do
-      r = [1,2,nil,4].compact_map { |e| e }
-      r.assert == [1,2,4]
-    end
-
-  end
-
-  method :compact_collect do
-
-    test do
-      r = [1,2,nil,4].compact_collect { |e| e }
-      r.assert == [1,2,4]
-    end
-
-  end
-
-  #method :filter_collect do
-  #  e = [3,4]
-  #  a = [1,2,3,4].filter_collect { |n|
-  #    throw(:skip) if n < 3
-  #    n
-  #  }
-  #  assert_equal( e, a )
-  #end
-
-end

data/test/core/enumerable/test_defer.rb

@@ -1,27 +0,0 @@
-covers 'facets/enumerable/defer'
-
-test_case Enumerable do
-
-  method :defer do
-
-    source = (1...1/0.0)
-
-    test do
-      Denumerator.assert === [1,2,3,4].defer
-    end
-
-    test "without block" do
-      a = source.defer
-      a.class.assert == Denumerator
-      a.take(5).to_a.assert == [1,2,3,4,5]
-    end
-
-    test "with block" do
-      a = source.defer { |out,i| out << i*2 }
-      a.class.assert == Denumerator
-      a.take(5).to_a.assert == [2,4,6,8,10]
-    end
-
-  end
-
-end

data/test/core/enumerable/test_each_by.rb

@@ -1,49 +0,0 @@
-covers 'facets/enumerable/each_by'
-
-test_case Enumerable do
-
-  method :each_by do
-
-    test "infer groups of two" do
-      e = [[1,2], [3,4], [5,6]]
-      a = [1,2,3,4,5,6]
-      r = []
-      a.each_by{ |a,b| r << [a,b] }
-      r.assert == e
-    end
-
-    test "infer groups of three" do
-      e = [[1,2,3],[4,5,nil]]
-      a = [1,2,3,4,5]
-      r = []
-      a.each_by{ |a,b,c| r << [a,b,c] }
-      r.assert == e
-    end
-
-    test "specify groups of two" do
-      e = [[1,2],[3,4]]
-      a = [1,2,3,4]
-      r = []
-      a.each_by(2){ |a,b| r << [a,b] }
-      r.assert == e
-    end
-
-    test "specify groups of three with splat argument" do
-      e = [ [[1,2,3]], [[4,5,6]] ]
-      a = [1,2,3,4,5,6]
-      r = []
-      a.each_by(3){ |*a| r << a }
-      r.assert == e
-    end
-
-    test "specify groups of four with splat argument" do
-      e = [ [[1,2,3,4]], [[5,6,7,8]] ]
-      a = [1,2,3,4,5,6,7,8]
-      r = []
-      a.each_by(4){ |*a| r << a }
-      r.assert == e
-    end
-
-  end
-
-end

data/test/core/enumerable/test_every.rb

@@ -1,33 +0,0 @@
-covers 'facets/enumerable/every'
-
-test_case Enumerable do
-
-  method :every do
-
-    test do
-      a = [1,2,3]
-      (a.every + 3 ).assert == [4,5,6]
-      (a.every - 1).assert == [0,1,2]
-      (a.every.to_s).assert == ['1','2','3']
-    end
-
-    test "on Enumerator" do
-      e = [1,2,3].to_enum(:map)
-      r = e.every + 3
-      r.assert == [4,5,6]
-    end
-
-  end
-
-  method :every! do
-
-    test do
-      a = [1,2,3]
-      a.every! + 3
-      a.assert == [4,5,6]
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_ewise.rb

@@ -1,30 +0,0 @@
-covers 'facets/enumerable/ewise'
-
-test_case Enumerable do
-
-  method :ewise do
-
-    test do
-      a = [1,2,3]
-      (a.ewise + 3).assert == [4,5,6]
-      (a.ewise + [4,5]).assert == [5,7]
-      (a.ewise.+([4,5],2)).assert == [[5,7],[3,4,5]]
-      (a.ewise.+([4,5],3)).assert == [[5,7],[4,5,6]]
-    end
-
-  end
-
-  method :elementwise do
-
-    test do
-      a = [1,2,3]
-      (a.elementwise + 3).assert == [4,5,6]
-      (a.elementwise + [4,5]).assert == [5,7]
-      (a.elementwise.+([4,5],2)).assert == [[5,7],[3,4,5]]
-      (a.elementwise.+([4,5],3)).assert == [[5,7],[4,5,6]]
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_exclude.rb

@@ -1,15 +0,0 @@
-covers 'facets/enumerable/exclude'
-
-test_case Enumerable do
-
-  method :exclude? do
-
-    test do
-      a = [1,2,2,3]
-      a.refute.exclude?(2)
-      a.assert.exclude?(4)
-    end
-
-  end
-
-end

data/test/core/enumerable/test_expand.rb

@@ -1,15 +0,0 @@
-covers 'facets/enumerable/expand'
-
-test_case Enumerable do
-
-  method :expand do
-
-    test do
-      a = [1,2,2,[1,2]]
-      r = a.expand
-      r == [1,2,2,1,2]
-    end
-
-  end
-
-end

data/test/core/enumerable/test_filter.rb

@@ -1,19 +0,0 @@
-covers 'facets/enumerable/filter'
-
-test_case Enumerable do
-
-  method :filter do
-
-    test do
-      x = (1..10000)
-      x = x.filter{ |out,i| out << i if i % 2 == 0 }   # like select
-      x = x.filter{ |out,i| out << i + 100 }           # like map
-      x = x.take(3)
-
-      x.assert == [102, 104, 106]
-    end
-
-  end
-
-end
-