facets 3.0.0 → 3.1.0

data/test/core/array/test_divide.rb

@@ -9,6 +9,16 @@ test_case Array do
       r.assert == [['a1','b1'],['a2','b2']]
     end
 
+    test do
+      r = ['a1','b1','a2','b2'].divide(/^b/)
+      r.assert == [['a1'],['b1', 'a2'],['b2']]
+    end
+
+    test do
+      r = ['a1','b1','a2','b2'].divide(/c/)
+      r.assert = [['a1','b1','a2','b2']]
+    end
+
   end
 
 end

data/test/core/array/test_each_pair.rb

@@ -0,0 +1,16 @@
+covers 'facets/array/each_pair'
+
+test_case Array do
+
+  method :each_pair do
+
+    test do
+      result = {}
+      a = [:a,:b,:c,:d]
+      a.each_pair{|i,e| result[e] = i + 1}
+      result.assert == {a: 1, b: 2, c: 3, d: 4}
+    end
+
+  end
+
+end

data/test/core/array/test_each_value.rb

@@ -0,0 +1,16 @@
+covers 'facets/array/each_value'
+
+test_case Array do
+
+  method :each_value do
+
+    test do
+      a = [ "a", "b", "c" ]
+      out = ''
+      a.each_value {|x| out +=  "#{x} -- " }
+      out.assert == 'a -- b -- c -- '
+    end
+
+  end
+
+end

data/test/core/array/test_from.rb

@@ -0,0 +1,42 @@
+covers 'facets/array/from'
+
+test_case Array do
+
+  method :from do
+
+    test do
+      %w{W o r l d}.from(3).assert == ['l', 'd']
+      %w{W o r l d}.from(8).assert == []
+    end
+  end
+
+  method :thru do
+
+    test do
+
+      [1, 2, 3, 4, 5].thru(2).assert == [1, 2, 3]
+      [1, 2, 3, 4, 5].thru(7).assert == [1, 2, 3, 4, 5]
+
+    end
+
+    test do
+
+      [1, 2, 3, 4, 5].thru(0, 2).assert == [1, 2, 3]
+      [1, 2, 3, 4, 5].thru(2, 4).assert == [3, 4, 5]
+
+    end
+
+    test do
+
+      [1, 2, 3, 4, 5].thru(3, 7).assert == [4, 5]
+
+    end
+
+    test do
+
+      [1, 2, 3, 4, 5].thru(6, 7).assert = []
+
+    end
+
+  end
+end

data/test/core/array/test_op_pow.rb

@@ -0,0 +1,13 @@
+covers 'facets/array/op_pow'
+
+test_case Array do
+
+  method :** do
+
+    test do
+      ([1,2] ** [3,4]).assert == [[1, 3], [1, 4], [2, 3], [2, 4]]
+    end
+
+  end
+
+end

data/test/core/array/test_standard_deviation.rb

@@ -0,0 +1,18 @@
+require 'facets/array/standard_deviation'
+
+test_case Array do
+  method :standard_deviation do
+    test 'Empty array returns nil' do
+      [].standard_deviation.assert == nil
+    end
+
+    test 'Calculate standard_deviation of array of numerical values' do
+      [1, 2, 3].standard_deviation.assert == 0.816496580927726
+      [96, 35, 72, 30, 75, 33, 68, 13, 49, 71].standard_deviation.assert == 24.69331893448104
+      [36, -67, -17, 85, -46, -64, -23, -13, 89, -47].standard_deviation.assert == 54.67183918618432
+      [60.7829, 31.2622, 20.626, 78.8907, 61.5328].standard_deviation.assert == 21.428815505053002
+    end
+  end
+end
+
+

data/test/core/array/test_to_h.rb

@@ -0,0 +1,14 @@
+covers 'facets/array/to_h'
+
+test_case Array do
+
+  method :to_h do
+
+    test do
+      arr = [[:a, 1], [:b, 2]]
+      arr.to_h.assert == {:a => 1, :b => 2}
+    end
+
+  end
+
+end

data/test/core/array/test_uniq_by.rb

@@ -11,6 +11,13 @@ test_case Array do
       r.assert == e
     end
 
+    test do
+      e = [5, 4, 3, 2, 1, 0]
+      r = (-5..5).to_a.reverse
+      r.uniq_by!{ |i| i*i }
+      r.assert == e
+    end
+
   end
 
 end

data/test/core/array/test_variance.rb

@@ -0,0 +1,17 @@
+require 'facets/array/variance'
+
+test_case Array do
+  method :variance do
+    test 'Empty array returns nil' do
+      [].variance.assert == nil
+    end
+
+    test 'Calculate variance of array of numerical values' do
+      [1, 2, 3].variance.assert == 0.6666666666666666
+      [96, 35, 72, 30, 75, 33, 68, 13, 49, 71].variance.assert == 609.76
+      [36, -67, -17, 85, -46, -64, -23, -13, 89, -47].variance.assert == 2989.0099999999993
+      [60.7829, 31.2622, 20.626, 78.8907, 61.5328].variance.assert == 459.1941339495999
+    end
+  end
+end
+

data/test/core/array/test_zip.rb

@@ -0,0 +1,13 @@
+covers 'facets/array/zip'
+
+test_case Array do
+
+  method :zip do
+
+    test 'example' do
+      Array.zip([1,2], [3,4]).assert == [[1,3],[2,4]]
+    end
+
+  end
+
+end

data/test/core/dir/test_each_child.rb

@@ -13,7 +13,7 @@ test_case Dir do
         c << path
       end
       d.close
-      c.sort.assert == ['core', 'standard']
+      (['core', 'standard'] - c).assert.empty?
     end
 
   end

data/test/core/dir/test_multiglob.rb

@@ -6,7 +6,7 @@ test_case Dir do
 
     test do
       r = Dir.multiglob('test/c*').sort
-      r.assert == ['test/core']
+      r.assert.include?('test/core')
     end
 
   end

data/test/core/enumerable/test_cluster.rb

@@ -0,0 +1,36 @@
+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_hashify.rb

@@ -0,0 +1,113 @@
+covers 'facets/enumerable/hashify'
+
+test_case Enumerable do
+  method :hashify do
+    test do
+      a = [ [:a,1], [:b,2] ]
+      a.hashify.class.assert == Enumerable::Hashifier
+    end
+  end
+end
+
+test_case Enumerable::Hashifier do
+  method :splat do
+    test do
+      a = [1,2,3,4]
+      h = Enumerable::Hashifier.new(a)
+      h.splat.assert == {1 => 2, 3 => 4}
+    end
+
+    test do
+      a = [1,2,3,4,5]
+      h = Enumerable::Hashifier.new(a)
+      h.splat.assert == {1 => 2, 3 => 4, 5=> nil}
+    end
+
+    test do
+      a = 1..5
+      h = Enumerable::Hashifier.new(a)
+      h.splat.assert == {1 => 2, 3 => 4, 5=> nil}
+    end
+  end
+
+  method :flat do
+    test do
+      a = [:a,1,[:b,2,:c],4]
+      h = Enumerable::Hashifier.new(a)
+      h.flat.assert == {a: 1, b: 2, c: 4}
+    end
+
+    test do
+      a = [:a,1,[:b,2,:c]]
+      h = Enumerable::Hashifier.new(a)
+      h.flat.assert == {a: 1, b: 2, c: nil}
+    end
+
+    test do
+      require 'set'
+      a = Set.new([:a, 1, [:b, 2, :c]])
+      h = Enumerable::Hashifier.new(a)
+      h.flat.assert == {a: 1, b: 2, c: nil}
+    end
+  end
+
+  method :associate do
+    test do
+      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+      a.hashify.associate.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    end
+
+    test do
+      a = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
+      a.hashify.associate.assert == { :x=>[4] }
+    end
+  end
+
+  method :merge do
+    test do
+      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+      a.hashify.merge.assert == { :a=>1, :b=>2, :c=>nil, :d=>nil }
+    end
+
+    test do
+      a = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
+      a.hashify.merge.assert == { :x=>4 }
+    end
+  end
+
+  method :concat do
+    test do
+      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+      a.hashify.concat.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    end
+
+    test do
+      a = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
+      a.hashify.concat.assert == { :a=>[1,2,3,4] }
+    end
+  end
+
+  method :by_index do
+    test do
+      [:a,:b,:c].hashify.by_index.assert == {0=>:a, 1=>:b, 2=>:c}
+    end
+  end
+
+  method :auto do
+    test do
+      a = [ [:a,1], [:b,2] ]
+      a.hashify.auto.assert == { :a=>1, :b=>2 }
+    end
+
+    test do
+      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+      a.hashify.auto.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    end
+
+    test do
+      a = [ [:a,1,2], 2, :b, [:c,3], 9 ]
+      a.hashify.auto.assert =={ [:a,1,2]=>2, :b=>[:c,3], 9=>nil }
+    end
+
+  end
+end

data/test/core/hash/test_expect.rb

@@ -15,7 +15,17 @@ test_case Hash do
 
     test do
       h = {:a=>1, :b=>2, :c=>3}
-      h.except!(:a).assert == {:a=>1}
+      h.except!(:a).assert == {:b=>2,:c=>3}
+      h.assert == {:b=>2,:c=>3}
+    end
+
+  end
+
+  method :remove! do
+
+    test do
+      h = {:a=>1, :b=>2, :c=>3}
+      h.remove!(:a).assert == {:a=>1}
       h.assert == {:b=>2,:c=>3}
     end
 

data/test/core/kernel/test_ergo.rb

@@ -7,11 +7,12 @@ test_case Kernel do
     test do
       "a".ergo.upcase.assert == "A"
       nil.ergo.foobar.assert == nil
+
     end
- 
+
     test do
-      "a".ergo{ |o| o.upcase }.assert == "A"
-      nil.ergo{ |o| o.foobar }.assert == nil
+      "a".ergo { |o| o.upcase }.assert == "A"
+      nil.ergo { |o| o.foobar }.assert == nil
     end
 
   end
@@ -23,8 +24,9 @@ test_case NilClass do
   method :ergo do
 
     test do
-      "a".ergo{ |o| o.upcase }.assert == "A"
-      nil.ergo{ |o| o.bar }.assert == nil
+      "a".ergo { |o| o.upcase }.assert   == "A"
+      nil.ergo { |o| o.bar }.assert      == nil
+      nil.ergo.ergo { |o| o.bar }.assert == nil
     end
 
   end

data/test/core/{object/test_replace.rb → kernel/test_instance_replace.rb}

@@ -1,8 +1,7 @@
-covers 'facets/object/replace'
+covers 'facets/kernel/instance_replace'
+test_case Kernel do
 
-test_case Object do
-
-  method :replace do
+  method :instance_replace do
 
     test "must be the same type" do
       c = Class.new do
@@ -18,7 +17,7 @@ test_case Object do
 
       # TODO: TypeError ?
       expect ArgumentError do
-        o.replace(:a=>3, :b=>4)
+        o.instance_replace(:a=>3, :b=>4)
       end
     end
 
@@ -30,14 +29,14 @@ test_case Object do
           @name, @age = name, age
         end
       end
-   
+
       a = c.new('bob', 60)
       a.name.assert == 'bob'
       a.age.assert == 60
 
       b = c.new('tom', 40)
 
-      a.replace(b)
+      a.instance_replace(b)
 
       a.name.assert == 'tom'
       a.age.assert == 40
@@ -46,24 +45,3 @@ test_case Object do
   end
 
 end
-
-test_case Struct do
-
-  method :replace do
-
-    test do
-      s = Struct.new(:name, :age)
-   
-      o = s.new('bob', 60)
-      o.name.assert == 'bob'
-      o.age.assert == 60
-
-      o.replace(:name=>'tom', :age=>40)
-
-      o.name.assert == 'tom'
-      o.age.assert == 40
-    end
-
-  end
-
-end