facets 3.1.0 → 3.2.0

data/test/core/array/test_duplicates.rb

@@ -1,29 +0,0 @@
-covers 'facets/array/duplicates'
-
-test_case Array do
-
-  method :duplicates do
-
-    test do
-      a = [1,1,2,2,3,4,5]
-      a.duplicates.sort.assert == [1,2]
-    end
-
-    test "with minimum" do
-      a = [0,1,2,3,4,5,
-           0,1,2,3,4,
-           0,1,2,3,
-           0,1,2,
-           0,1,
-           0]
-      (1..6).each do |m|
-        d = a.duplicates(m).sort
-        e = [*0..6-m]
-        d.assert == e
-      end
-    end
-
-  end
-
-end
-

data/test/core/array/test_each_overlap.rb

@@ -1,31 +0,0 @@
-covers 'facets/array/each_overlap'
-
-test_case Array do
-
-  method :each_overlap do
-
-    test do
-      a = [1,2,3,4,5]
-      r = []
-      a.each_overlap(2,1) { |x| r << x } 
-      r.assert == [[1,2],[2,3],[3,4],[4,5]]
-    end
-
-    test do
-      a = [1,2,3,4,5,6,7]
-      r = []
-      a.each_overlap(3,1) { |x| r << x } 
-      r.assert == [[1,2,3],[3,4,5],[5,6,7]]
-    end
-
-    test do
-      a = [1,2,3,4,5]
-      r = []
-      a.each_overlap(3,2) { |x| r << x } 
-      r.assert == [[1,2,3],[2,3,4],[3,4,5]]
-    end
-
-  end
-
-end
-

data/test/core/array/test_each_pair.rb

@@ -1,16 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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_entropy.rb

@@ -1,23 +0,0 @@
-covers 'facets/array/entropy'
-
-test_case Array do
-
-  method :entropy do
-
-    test do
-      %w{ a b }.entropy.assert == 1.0
-    end
-
-  end
-
-  method :ideal_entropy do
-
-    test do
-      %w{ a b }.ideal_entropy.assert == 1.0
-      %w{ a a b b }.ideal_entropy.assert == 2.0
-    end
-
-  end
-
-end
-

data/test/core/array/test_extract_options.rb

@@ -1,28 +0,0 @@
-covers 'facets/array/extract_options'
-
-test_case Array do
-
-  method :extract_options! do
-
-    test do
-      h = { :x=>1, :y=>1 }
-      a = [:a, :b, h]
-      a.extract_options!.assert == h
-    end
-
-  end
-
-end
-
-test_case Hash do
-
-  method :extractable_options? do
-
-    test do
-      h = { :x=>1, :y=>1 }
-      h.assert.extractable_options?
-    end
-
-  end
-
-end

data/test/core/array/test_first.rb

@@ -1,17 +0,0 @@
-covers 'facets/array/indexable'
-
-test_case Array do
-
-  method :first! do 
-
-    test "alias of shift" do
-      a = [1,2,3]
-      r = a.first!
-      r.assert == 1
-      a.assert == [2,3]
-    end
-
-  end
-
-end
-

data/test/core/array/test_from.rb

@@ -1,42 +0,0 @@
-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_intersection.rb

@@ -1,19 +0,0 @@
-require 'facets/array/intersection'
-
-test_case Array do
-
-	method :intersection do
-		test { [1, 2].intersection.assert == nil }
-		test { [1..10, 11..20].intersection.assert == nil }
-		test { [1..10, 5..15, 11..20].intersection.assert == nil }
-		test { [8..8, 1..10, 10 ].intersection.assert == nil }
-		test { [10, 1..10].intersection.assert == 10 }
-		test { [1..10, 1].intersection.assert == 1 }
-		test { [1, 1].intersection.assert == 1 }
-		test { [1..10, 5, 5..8, 5..10 ].intersection.assert == 5 }
-		test { [1..10, 5..8, 5..10 ].intersection.assert == (5..8) }
-		test { [5..10, 1..10, 4..8 ].intersection.assert == (5..8) }
-		test { [5..10, 1..10, 4..20, 8].intersection.assert == 8 }
-	end
-
-end

data/test/core/array/test_last.rb

@@ -1,17 +0,0 @@
-covers 'facets/array/indexable'
-
-test_case Array do
-
-  method :last! do
-
-    test "alias of pop" do
-      a = [1,2,3]
-      r = a.last!
-      r.assert == 3
-      a.assert == [1,2]
-    end
-
-  end
-
-end
-

data/test/core/array/test_median.rb

@@ -1,27 +0,0 @@
-covers 'facets/array/median'
-
-test_case Array do
-
-  method :median do
-    test "odd sized" do
-      r = %w{e a b c d}.median
-      r.assert == "c"
-    end
-
-    test "even sized" do
-      r = %w{f e a b c d}.median
-      r.assert == "d"
-    end
-
-    test "with positive offset" do
-      r = %w{e a b c d}.median(1)
-      r.assert == "d"
-    end
-
-    test "with negative offset" do
-      r = %w{e a b c d}.median(-1)
-      r.assert == "b"
-    end
-  end
-
-end

data/test/core/array/test_merge.rb

@@ -1,27 +0,0 @@
-covers 'facets/array/merge'
-
-test_case Array do
-
-  method :merge do
-
-    test do
-      a = [1,2,3]
-      b = [3,4,5]
-      a.merge(b).assert == [1,2,3,4,5]
-    end
-
-  end
-
-  method :merge! do
-
-    test do
-      a = [1,2,3]
-      b = [3,4,5]
-      a.merge!(b)
-      a.assert == [1,2,3,4,5]
-    end
-
-  end
-
-end
-

data/test/core/array/test_missing.rb

@@ -1,12 +0,0 @@
-require 'facets/array/missing'
-
-test_case Array do
-
-	method :missing do
-		test { [1,3..3].missing.assert == [2] }
-		test { [1..5,10..12].missing.assert == [6..9] }
-		test { [100, 9..11, 14, 1..5, 16, 10..12, 17..17].missing.assert == [6..8, 13, 15, 18..99] }
-	end
-
-end
-

data/test/core/array/test_mode.rb

@@ -1,17 +0,0 @@
-covers 'facets/array/mode'
-
-test_case Array do
-
-  method :mode do
-
-    test do
-      [1, 1, 2, 3].mode.assert == [1]
-    end
-
-    test do
-      [1, 1, 2, 2, 3].mode.sort.assert == [1,2]
-    end
-
-  end
-
-end

data/test/core/array/test_nonuniq.rb

@@ -1,25 +0,0 @@
-covers 'facets/array/nonuniq'
-
-test_case Array do
-
-  method :nonuniq do
-
-    test do
-      a = [1,1,2,2,3,4,5]
-      a.nonuniq.sort.assert == [1,2]
-    end
-
-  end
-
-  method :nonuniq! do
-
-    test do
-      a = [1,1,2,2,3,4,5]
-      a.nonuniq!
-      a.sort.assert == [1,2]
-    end
-
-  end
-
-end
-

data/test/core/array/test_not_empty.rb

@@ -1,17 +0,0 @@
-covers 'facets/array/not_empty'
-
-test_case Array do
-
-  method :not_empty? do
-
-    test do
-      [].refute.not_empty?
-    end
-
-    test do
-      [1,2].assert.not_empty?
-    end
-
-  end
-
-end

data/test/core/array/test_occur.rb

@@ -1,52 +0,0 @@
-covers 'facets/array/occur'
-
-test_case Array do
-
-  method :occur do
-
-    test "set limit" do
-      a = [1,2,3,4,5,
-             2,3,4,5,
-               3,4,5,
-                 4,5,
-                   5]  
-      (1..5).each do |m|
-        d = a.occur(m)
-        d.assert == [m]
-      end
-    end
-
-    test "range" do
-      a = %w{a b c d e
-               b c d e
-                 c d e
-                   d e
-                     e}
-      a.occur(1..2).sort.assert == ['a','b']
-      a.occur(1..3).sort.assert == ['a','b','c']
-      a.occur(2..3).sort.assert == ['b','c']
-    end
-
-    test do
-      a = [:a,:b,:a]
-      a.occur(1).assert == [:b]
-    end
-
-    test do
-      a = [:a,:b,:a]
-      a.occur(2).assert == [:a]
-    end
-
-    test do
-      a = [:a,:b,:a]
-      a.occur(1..1).assert == [:b]
-    end
-
-    test do
-      a = [:a,:b,:a]
-      a.occur{ |n| n % 2 == 0 }.assert == [:a]
-    end
-
-  end
-
-end

data/test/core/array/test_occurrence.rb

@@ -1,20 +0,0 @@
-covers 'facets/array/occurrence'
-
-test_case Array do
-
-  method :occurrence do
-
-    test "no arguments" do
-      r = [:a,:a,:b,:c,:c,:c].occurrence
-      r.assert == { :a => 2, :b => 1, :c => 3 } 
-    end
-  
-    test "with block" do
-      r = [2,2,3,4,4,4].occurrence{|i| i % 2} 
-      r.assert == { 0 => 5, 1 => 1 }
-    end
-
-  end
-
-end
-

data/test/core/array/test_only.rb

@@ -1,17 +0,0 @@
-covers 'facets/array/only.rb'
-
-test_case Array do
-
-  method :only do
-
-    test do
-      [5].only.assert == 5
-      [nil].only.assert == nil
-      expect(IndexError){ [].only }
-      expect(IndexError){ [1,2,3].only }
-    end
-
-  end
-
-end
-

data/test/core/array/test_op_pow.rb

@@ -1,13 +0,0 @@
-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_pad.rb

@@ -1,40 +0,0 @@
-covers 'facets/array/pad'
-
-test_case Array do
-
-  method :pad do
-
-    test do
-      r = [0,1,2,3].pad(7,"x")
-      x = [0,1,2,3,"x","x","x"]
-      r.assert == x
-    end
-
-    test "negative index" do
-      r = [0,1,2,3].pad(-7,"n")
-      x = ["n","n","n",0,1,2,3]
-      r.assert == x
-    end
-
-  end
-
-  method :pad! do
-
-    test do
-      a = [0,1,2,3]
-      r = a.pad!(6,"y")
-      x = [0,1,2,3,"y","y"]
-      r.assert == x
-    end
-
-    test "negative index" do
-      a = [0,1,2,3]
-      r = a.pad!(-6,"q")
-      x = ["q","q",0,1,2,3]
-      r.assert == x
-    end
-
-  end
-
-end
-

data/test/core/array/test_peek.rb

@@ -1,28 +0,0 @@
-covers 'facets/array/pull'
-
-test_case Array do
-
-  method :peek do
-
-    test do
-      a = [1,2,3]
-      a.peek.assert == 3
-      a.assert == [1,2,3]
-    end
-
-    test do
-      a = [1,2,3]
-      a.peek(1).assert == 2
-      a.assert == [1,2,3]
-    end
-
-    test do
-      a = [1,2,3]
-      a.peek(-1).assert == 1
-      a.assert == [1,2,3]
-    end
-
-  end
-
-end
-

data/test/core/array/test_poke.rb

@@ -1,21 +0,0 @@
-covers 'facets/array/pull'
-
-test_case Array do
-
-  method :poke do
-
-    test do
-      a = [1,2,3]
-      a.poke(9)
-      a.assert == [9,1,2,3]
-    end
-
-    test do
-      a = [2,3]
-      a.poke(1).assert == [1,2,3]
-      a.poke(4).assert == [4,1,2,3]
-    end
-
-  end
-
-end

data/test/core/array/test_probability.rb

@@ -1,18 +0,0 @@
-covers 'facets/array/probability'
-
-test_case Array do
-
-  method :probability do
-
-    test do
-      %w{a b}.probability.assert == {'a'=>0.5, 'b'=>0.5}
-    end
-
-    test do
-      %w{a a a b}.probability.assert == {'a'=>0.75, 'b'=>0.25}
-    end
-
-  end
-
-end
-

data/test/core/array/test_pull.rb

@@ -1,15 +0,0 @@
-covers 'facets/array/pull'
-
-test_case Array do
-
-  method :pull do
-
-    test do
-      a = [1,2,3]
-      a.pull.assert == 1
-      a.assert == [2,3]
-    end
-
-  end
-
-end

data/test/core/array/test_recurse.rb

@@ -1,40 +0,0 @@
-covers 'facets/array/recurse'
-
-test_case Array do
-
-  method :recurse do
-
-    test do
-      a = ["a", ["b", "c", nil], nil]
-      r = a.recurse{|a| a.compact! }
-      r.assert ["a", ["b", "c"]]
-    end
-
-    test "with Hashes" do
-      require 'facets/hash/recurse'
-      objects = []
-      struct = [1, 2, {:a => 3, :b => [4, 5, {:c=>6}]}, [7, 8]]
-      struct.recurse(Array, Hash){|o| objects << o; o } 
-
-      objects.assert.include?( [7, 8]                           )
-      objects.assert.include?( {:c=>6}                          )
-      objects.assert.include?( [4, 5, {:c=>6}]                  )
-      objects.assert.include?( {:a => 3, :b => [4, 5, {:c=>6}]} )
-      objects.assert.include?( struct                           )
-
-      objects.length.assert == 5
-    end
-
-  end
-
-  method :recurse! do
-
-    test do
-      a = ["a", ["b", "c", nil], nil]
-      a.recurse!{|a| a.compact! }
-      a.assert ["a", ["b", "c"]]
-    end
-
-  end
-
-end

data/test/core/array/test_recursively.rb

@@ -1,33 +0,0 @@
-covers 'facets/array/recursively'
-
-test_case Array do
-
-  method :recursively do
-
-    test "each" do
-      r = []
-      [1,2,['a','b']].recursively{ |v| v }.each{ |v| r << v }
-      r.assert == [1,2,'a','b']
-    end
-
-    test "map" do
-      a = [1,2,['a','b']]
-      r = a.recursively{ |v| v.reverse }.map{ |v| v.succ }
-      r.assert == [2,3,['c','b']]
-    end
-
-    test "map!" do
-      a = [1,2,['a','b']]
-      a.recursively{ |v| v }.map!{ |v| v.succ }
-      a.assert == [2,3,['b','c']]
-    end
-
-    test "with block" do
-      a = [1,2,['a','b', nil], nil]
-      r = a.recursively{ |v| v.compact }.map{ |v| v }.compact
-      r.assert == [1,2,['a','b']]
-    end
-
-  end
-
-end