facets 3.0.0 → 3.2.0

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_by.rb

@@ -1,30 +0,0 @@
-covers 'facets/enumerable/cluster_by'
-
-test_case Enumerable do
-
-  method :cluster_by do
-
-    test "on an array" do
-      a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-      e = [[0, 2, 4, 6, 8], [1, 3, 5, 7, 9]]
-      r = a.cluster_by{|x| x % 2} #.each{|a| a.sort!}
-      r.assert == e
-    end
-
-    test "on a hash" do
-      h = {0=>0, 1=>1, 2=>2, 3=>3, 4=>4, 5=>5, 6=>6, 7=>7, 8=>8, 9=>9}
-      e = [[[0, 0], [2, 2], [4, 4], [6, 6], [8, 8]], [[1, 1], [3, 3], [5, 5], [7, 7], [9, 9]]]
-      r = h.cluster_by{|k, v| v % 2}.each{|a| a.sort!}
-      r.assert == e
-    end
-
-    test "on an empty array" do
-      r = [].cluster_by{ |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_count.rb

@@ -1,32 +0,0 @@
-covers 'facets/enumerable/count'
-
-test_case Enumerable do
-
-  method :count do
-
-    test "strings" do
-      e = ['a','1','a']
-      r = e.count('1')
-      r.assert == 1
-
-      e = ['a','1','a']
-      r = e.count('a')
-      r.assert == 2
-    end
-
-    test "array of arrays" do
-      e = [['a',2],['a',2],['a',2],['b',1]]
-      r = e.count(['a',2])
-      r.assert == 3
-    end
-
-    test "hash" do
-      e = { :a=>2, 'b'=>1, :c=>2 }
-      r = e.count(2)
-      r.assert == 2
-    end
-
-  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_each_with_object.rb

@@ -1,18 +0,0 @@
-covers 'facets/enumerable/each_with_object'
-
-test_case Enumerable do
-
-  method :each_with_object do
-
-    test do
-      r = Hash.new(0)
-      a = [1,2,2,3]
-
-      a.each_with_object(r){ |c, h| h[c] += 1 }
-
-      r.assert == { 1=>1, 2=>2, 3=>1 }
-    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
-

data/test/core/enumerable/test_find_yield.rb

@@ -1,96 +0,0 @@
-covers 'facets/enumerable/find_yield'
-
-test_case Enumerable do
-  
-  method :find_yield do
-
-    test "a value" do
-      r = [true].find_yield { |value| value }
-      r.assert == true
-    end
-
-    test "detects correct value" do
-      r = [1].find_yield { |value| value }
-      r.assert == 1
-    end
-
-    test "returns value of block" do
-      r = [1].find_yield { |v| v + 3 }
-      r.assert == 4
-    end
-
-    test "detects first truthy value" do
-      r = [false, false, 1].find_yield { |value| value }
-      r.assert == 1
-    end
-
-    test "returns value when block is true" do
-      r = [false].find_yield { |value| true }
-      r.assert == true
-    end
-
-    test "returns early when block is true" do
-      v1 = lambda { :something }
-      v2 = lambda { raise "This shouldn't be called" }
-      r = [v1, v2].find_yield { |obj| obj.call }
-      r.assert == :something
-    end
-
-    test "returns nil when block returns false for all elements" do
-      r = [1,2,3,4].find_yield { |value| false }
-      r.assert == nil
-    end
-
-    test "returns nil when no elements in collection" do
-      r = [].find_yield { |v| }
-      r.assert == nil
-    end
-
-    test "can have return value specified when block isnt true" do
-      r = [1,2,3].find_yield(:a_value){ |value| false }
-      r.assert == :a_value
-    end
-
-    test "documentation correct" do
-      obj1, obj2 = Object.new, Object.new
-
-      class << obj1
-        def foo?
-          false
-        end
-
-        def foo
-          raise
-        end
-      end
-
-      class << obj2
-        def foo?
-          true
-        end
-
-        def foo
-          "a value"
-        end
-      end
-
-      obj1.foo?.assert == false
-      obj2.foo?.assert == true
-      obj2.foo.assert == "a value"
-
-      result = [obj1, obj2].find_yield { |obj| obj.foo if obj.foo? }
-      result.assert == "a value"
-    end
-
-  end
-
-  method :map_detect do
-
-    test "old alias for #find_yield" do
-      r = [true].map_detect{ |value| value }
-      r.assert == true
-    end
-
-  end
-
-end

data/test/core/enumerable/test_frequency.rb

@@ -1,15 +0,0 @@
-covers 'facets/enumerable/frequency'
-
-test_case Enumerable do
-
-  method :frequency do
-
-    test do
-      %w{a b}.frequency.assert == {'a'=>1,'b'=>1}
-      %w{a a b}.frequency.assert == {'a'=>2,'b'=>1}
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_graph.rb

@@ -1,42 +0,0 @@
-covers 'facets/enumerable/graph'
-
-test_case Enumerable do
-
-  method :graph do
-
-    test "returns hash" do
-      a = { :a => 1, :b => 2, :c => 3 }
-      e = { :a => 2, :b => 3, :c => 4 }
-      r = a.graph{ |k,v| {k => v+1} }
-      r.assert == e
-    end
-
-    test "hash of array" do
-      a = { :a => [1,2], :b => [2,3], :c => [3,4] }
-      e = { :a => 2, :b => 6, :c => 12 }
-      r = a.graph{ |k,v| [k, v[0]*v[1] ] }
-      r.assert == e
-    end
-
-    test "array of array" do
-      a = [ [1,2], [2,3], [3,4] ]
-      e = { [1,2] => 2, [2,3] => 6, [3,4] => 12 }
-      r = a.graph{ |a| [a, a[0]*a[1] ] }
-      r.assert == e
-    end
-
-    test "squares" do
-      numbers  = (1..3)
-      squares  = numbers.graph{ |n| [n, n*n] }
-      squares.assert == {1=>1, 2=>4, 3=>9}
-    end
-
-    test "roots" do
-      numbers  = (1..3)
-      sq_roots = numbers.graph{ |n| [n*n, n] }
-      sq_roots.assert == {1=>1, 4=>2, 9=>3}
-    end
-
-  end
-
-end

data/test/core/enumerable/test_group_by.rb

@@ -1,36 +0,0 @@
-covers 'facets/enumerable/group_by'
-
-test_case Enumerable do
-
-  method :group_by do
-
-    test "for array" do
-      a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-      e = {0=>[0, 2, 4, 6, 8], 1=>[1, 3, 5, 7, 9]}
-      r = a.group_by{ |x| x % 2 }  #.each{|k, v| v.sort!})
-      r.assert == e
-    end
-
-    test "for hash" do
-      h = {0=>0, 1=>1, 2=>2, 3=>3, 4=>4, 5=>5, 6=>6, 7=>7, 8=>8, 9=>9}
-      e = {0=>[[0, 0], [2, 2], [4, 4], [6, 6], [8, 8]], 1=>[[1, 1], [3, 3], [5, 5], [7, 7], [9, 9]]}
-      r = h.group_by{|k, v| v%2}.each{|k, v| v.sort!}
-      r.assert == e
-    end
-
-    test "for range" do
-      r = (1..5).group_by{ |n| n % 3 }
-      e = { 0 => [3], 1 => [1, 4], 2 => [2,5] }
-      r.assert == e
-    end
-
-    test "for array of string" do
-      r = ["I had", 1, "dollar and", 50, "cents"].group_by{ |e| e.class }
-      e = { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
-      r.assert == e
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_key_by.rb

@@ -1,22 +0,0 @@
-covers 'facets/enumerable/key_by'
-
-test_case Enumerable do
-
-  method :key_by do
-
-    test do
-      a = [:a,:b,:c]
-      r = a.key_by{ |v| v.to_s }
-      r.assert == {'a'=>:a, 'b'=>:b, 'c'=>:c}
-    end
-
-    # Is this how it should behave?
-    test "works with a hash" do
-      h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2}
-      r = h.key_by{ |k,v| k }
-      r.assert == {"A"=>["A",1], "B"=>["B",1], "C"=>["C",1], "D"=>["D",2], "E"=>["E",2]}
-    end
-
-  end
-
-end

data/test/core/enumerable/test_map_by.rb

@@ -1,27 +0,0 @@
-covers 'facets/enumerable/map_by'
-
-test_case Enumerable do
-
-  method :map_by do
-
-    test do
-      a = [1,2,3,4,5]
-      r = a.map_by{ |e| [e % 2, e + 1] }
-      r.assert == { 0=>[3,5], 1=>[2,4,6] }
-    end
-
-    test "works well with a hash" do
-      h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2}
-      r = h.map_by{ |k,v| [v, k.downcase] }
-      r.assert == {1=>["a", "b", "c"], 2=>["d", "e"]}
-    end
-
-    test "if only a scalar is returned, #map_by acts like #group_by" do
-      h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2}
-      r = h.map_by{ |k,v| v }
-      r.assert == {1=>[["A",1], ["B",1], ["C",1]], 2=>[["D",2], ["E",2]]}
-    end
-
-  end
-
-end

data/test/core/enumerable/test_map_send.rb

@@ -1,26 +0,0 @@
-covers 'facets/enumerable/map_send'
-
-test_case Enumerable do
-
-  method :map_send do
-
-    test do
-      [1,2,3].map_send(:+, 3).assert == [4,5,6]
-    end
-
-  end
-
-  #method :map_send do
-  #  test do
-  #    r = [1,2,3].map_send(:+, 1)
-  #    assert_equal(r, [2,3,4])
-  #  end
-  #
-  #  test "with_block" do
-  #    r = [1,2,3].map_send(:+,1){ |x| x + 1 }
-  #    assert_equal(r, [3,4,5])
-  #  end
-  #end
-
-end
-

data/test/core/enumerable/test_map_with_index.rb

@@ -1,23 +0,0 @@
-covers 'facets/enumerable/map_with_index'
-
-test_case Enumerable do
-
-  method :map_with_index do
-
-    test do
-      a = [1,2,3].map_with_index{ |e,i| e*i }
-      a.assert == [0,2,6]
-    end
-
-  end
-
-  method :collect_with_index do
-
-    test do
-      a = [1,2,3].collect_with_index{ |e,i| e*i }
-      a.assert == [0,2,6]
-    end
-
-  end
-
-end

data/test/core/enumerable/test_mash.rb

@@ -1,17 +0,0 @@
-covers 'facets/enumerable/mash'
-
-test_case Enumerable do
-
-  method :mash do
-
-    test "is an alias for #graph" do
-      a = { :a => 1, :b => 2, :c => 3 }
-      e = { :a => 2, :b => 3, :c => 4 }
-      r = a.mash{ |k,v| {k => v+1} }
-      r.assert == e
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_modulate.rb

@@ -1,17 +0,0 @@
-covers 'facets/enumerable/modulate'
-
-test_case Enumerable do
-
-  method :modulate do
-
-    test do
-      a = [2,4,6,8]
-      r = a.modulate(2)
-      x = [[2,6],[4,8]]
-      r.assert == x
-    end
-
-  end
-
-end
-