facets 3.0.0 → 3.2.0

data/test/core/array/test_after.rb

@@ -1,27 +0,0 @@
-covers 'facets/array/after'
-
-testcase Array do
-
-  method :after do
-
-    setup do
-      @sequence = ['a', 'b', 'c']
-    end
-
-    test "returns the following element" do
-      @sequence.after('a').assert == 'b'
-      @sequence.after('b').assert == 'c'
-    end
-
-    test "loops around from back to front" do
-      @sequence.after('c').assert == 'a'
-    end
-
-    test "non-member elements return nil" do
-      @sequence.after('d').assert == nil
-    end
-
-  end
-
-end
-

data/test/core/array/test_arrange.rb

@@ -1,37 +0,0 @@
-require 'facets/array/arrange'
-
-test_case Array do
-
-	method :rangify do
-		test 'Array of consecutive integers should return an array made up of a single range.' do
-			[1,2,3,4,5].rangify.assert == [1..5]
-		end
-		
-		test 'Array of non-consecutive integers should return the original array.' do
-			[1,3,5,7].rangify.assert == [1,3,5,7]
-		end
-
-		test 'Array of ranges should return the correct ranges.' do
-			arr = [40..45, 1..3, 4..10, 20..30, 24..28, 42..50, 1..6, 1..3, 1..1]
-			arr.rangify.assert == [1..10, 20..30, 40..50]
-		end
-		
-		test 'Array of ranges and integers should return the correct ranges.' do
-			arr = [99, 100, 1..3, 101, 4..5, 103, 10..19, 99, 20..20, 31, 32..33, 98, 97]
-			arr.rangify.assert == [1..5, 10..20, 31..33, 97..101, 103]
-		end	
-
-		test 'Array of non-consecutive integers should return the correct ranges.' do
-			[1,2,3,6,7,8,10,15].rangify.assert == [1..3, 6..8, 10, 15] 
-		end
-	
-		test 'Element order should not affect the result.' do
-			[8, 1, 15, 2, 6, 3, 7, 10].rangify.assert == [1..3, 6..8, 10, 15] 
-		end
-		
-		test 'Duplicate elements should not affect the result.' do
-			[8, 1, 15, 2, 6, 3, 7, 10, 8, 15, 2, 3, 1, 2].rangify.assert == [1..3, 6..8, 10, 15] 
-		end
-	end
-
-end

data/test/core/array/test_before.rb

@@ -1,27 +0,0 @@
-covers 'facets/array/before'
-
-test_case Array do
-
-  method :before do
-
-    setup do
-      @sequence = ['a', 'b', 'c']
-    end
-
-    test "returns the previous element" do
-      @sequence.before('b').assert == 'a'
-      @sequence.before('c').assert == 'b'
-    end
-
-    test "loops around from back to front" do
-      @sequence.before('a').assert == 'c'
-    end
-
-    test "non-member elements return nil" do
-      @sequence.before('d').assert == nil
-    end
-
-  end
-
-end
-

data/test/core/array/test_collapse.rb

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

data/test/core/array/test_combination.rb

@@ -1,25 +0,0 @@
-covers 'facets/array/combination'
-
-test_case Array do
-
-  method :combination do
-
-    test "finds pairs of combinations" do
-      e = [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
-      a = [1,2,3,4]
-      r = a.combination(2).to_a
-      r.assert == e
-    end
-
-    test "can also take a block" do
-      e = [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
-      r = []
-      a = [1,2,3,4]
-      a.combination(2){ |a,b| r << [a,b] }
-      r.assert == e
-    end
-
-  end
-
-end
-

data/test/core/array/test_commonality.rb

@@ -1,35 +0,0 @@
-covers 'facets/array/commonality'
-
-test_case Array do
-
-  method :commonality do
-
-    test do
-      a = [1,2,2,3,3,3]
-      e = { 2 => [2,2], 3 => [3,3,3] }
-      r = a.commonality
-      r.assert == e
-    end
-
-    test "with block" do
-      a = [1,2,2,3,3,3]
-      e = {false=>[1, 2, 2], true=>[3, 3, 3]}
-      r = a.commonality{ |x| x > 2 }
-      r.assert == e
-    end
-
-  end
-
-  method :collisions do
-
-    test "alias for commonality" do
-      a = [1,2,2,3,3,3]
-      e = { 2 => [2,2], 3 => [3,3,3] }
-      r = a.collisions
-      r.assert == e
-    end
-
-  end
-
-end
-

data/test/core/array/test_conjoin.rb

@@ -1,50 +0,0 @@
-covers 'facets/array/conjoin'
-
-test_case Array do
-
-  method :conjoin do
-
-    setup "any array" do
-      @a = [1,2,3,4]
-    end
-
-    test "like join but spaced" do
-      @a.conjoin.assert == "1 2 3 4"
-    end
-
-    test "comma+space and 'and' on tail" do
-      @a.conjoin(', ', ' and ').assert = "1, 2, 3 and 4"
-    end
-
-    test "comma+space and 'or' on tail using :last option" do
-      @a.conjoin(', ', :last => ' or ').assert == "1, 2, 3 or 4"
-    end
-
-    test "semicolon+space and ampersand on tail using index" do
-      @a.conjoin('; ', -1 => ' & ').assert == "1; 2; 3 & 4"
-    end
-
-    test "with block to determine separator" do
-      r = @a.conjoin{ |i, a, b| i % 2 == 0 ? '.' : '-' }
-      r.assert == "1.2-3.4"
-    end
-
-    test "very esoteric transformation" do
-      r = @a.conjoin{ |i, x, y| "<#{i} #{x} #{y}>" }
-      r.assert == "1<0 1 2>2<1 2 3>3<2 3 4>4"
-    end
-
-    test "with :space option" do
-      r = @a.conjoin(',', '&', :space=>2)
-      r.assert == "1  ,  2  ,  3  &  4"
-    end
-
-    test ":spacer option can set an alternate spacing string" do
-      r = @a.conjoin('|', '>', :space=>2, :spacer=>'-')
-      r.assert == "1--|--2--|--3-->--4"
-    end
-
-  end
-
-end
-

data/test/core/array/test_contains.rb

@@ -1,14 +0,0 @@
-covers 'facets/array/contains'
-
-test_case Array do
-
-  method :contains? do
-
-    test do
-      [1,2,3,4].assert.contains?(2)
-      [1,2,3,4].refute.contains?(9)
-    end
-
-  end
-
-end

data/test/core/array/test_delete.rb

@@ -1,42 +0,0 @@
-covers 'facets/array/delete'
-
-test_case Array do
-
-  method :delete_unless do
-
-    test do
-      a = [1,2,3]
-      a.delete_unless{ |e| e == 2 }
-      a.assert == [2]
-    end
-
-  end
-
-  method :delete_values do
-
-    test do
-      a = [1,2,3,4]
-      a.delete_values(1,2).assert == [1,2]
-      a.assert == [3,4]
-    end
-
-  end
-
-  method :delete_values_at do
-
-    test do
-      a = [1,2,3,4]
-      a.delete_values_at(1,2).assert == [2,3]
-      a.assert == [1,4]
-    end
-
-    test do
-      a = [1,2,3,4]
-      a.delete_values_at(0..2).assert == [1,2,3]
-      a.assert == [4]
-    end
-
-  end
-
-end
-

data/test/core/array/test_divide.rb

@@ -1,14 +0,0 @@
-covers 'facets/array/divide'
-
-test_case Array do
-
-  method :divide do
-
-    test do
-      r = ['a1','b1','a2','b2'].divide(/^a/)
-      r.assert == [['a1','b1'],['a2','b2']]
-    end
-
-  end
-
-end

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_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_index.rb

@@ -1,20 +0,0 @@
-covers 'facets/array/index'
-
-test_case Array do
-
-  method :index do
-
-    test "can handle a block" do
-      i = [1,2,3].index{ |e| e == 2 }
-      i.assert == 1
-    end
-
-    test "when no element is found" do
-      i = [1,2,3].index{ |e| e == 5 }
-      i.assert.nil?
-    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
-