facets 3.0.0 → 3.2.0

data/test/core/hash/test_reverse_merge.rb

@@ -1,39 +0,0 @@
-covers 'facets/hash/reverse_merge'
-
-test_case Hash do
-
-  method :reverse_merge do
-
-    test do
-      h1 = { :a=>1, :b=>2, :c=>2 }
-      h2 = { :c=>3 }
-      h3 = h1.reverse_merge(h2)
-      h3[:c].assert == 2
-    end
-
-  end
-
-  method :reverse_merge! do
-
-    test do
-      h1 = { :a=>1, :b=>2, :c=>2 }
-      h2 = { :c=>3 }
-      h1.reverse_merge!(h2)
-      h1[:c].assert == 2
-    end
-
-  end
-
-  method :reverse_update do
-
-    test do
-      h1 = { :a=>1, :b=>2, :c=>2 }
-      h2 = { :c=>3 }
-      h1.reverse_update(h2)
-      h1[:c].assert == 2
-    end
-
-  end
-
-end
-

data/test/core/hash/test_select.rb

@@ -1,44 +0,0 @@
-covers 'facets/hash/select'
-
-test_case Hash do
-
-  method :select! do
-
-    test "empty hash" do
-      a = {}
-      a.select!{false}.assert == nil
-      a.assert == {}
-
-      a = {}
-      a.select!{true}.assert == nil
-      a.assert == {}
-    end
-
-    test "select none" do
-      a = {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
-      a.select!{false}.assert == {}
-      a.assert == {}
-    end
-
-    test "select one" do
-      a = {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
-      a.select! {|x,y| y == 'b'}.assert == {1 => 'b'}
-      a.assert == {1 => 'b'}
-    end
-
-    test "select some" do
-      a = {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
-      a.select! {|x,y| x % 2 == 0}.assert == {0 => 'a', 2 => 'c'}
-      a.assert == {0 => 'a', 2 => 'c'}
-    end
-
-    test "select all" do
-      a = {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
-      a.select!{true}.assert == nil
-      a.assert == {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
-    end
-
-  end
-
-end
-

data/test/core/hash/test_slice.rb

@@ -1,36 +0,0 @@
-covers 'facets/hash/slice'
-
-test_case Hash do
-
-  method :slice do
-
-    test 'only existing keys' do
-      h = {:a=>1,:b=>2,:c=>3}
-      h.slice(:a, :b).assert == {:b=>2, :a=>1}
-    end
-
-    test 'with non-existent keys' do
-      h = {:a=>1,:b=>2,:c=>3}
-      h.slice(:a, :d).assert == {:a=>1}
-    end
-
-  end
-
-  method :slice! do
-
-    test do
-      h = {:a=>1,:b=>2,:c=>3}
-      h.slice!(:a, :b).assert == {:c=>3}
-      h.assert == {:a=>1,:b=>2}
-    end
-
-    test do
-      h = {:a=>1,:b=>2,:c=>3}
-      h.slice!(:a, :d).assert == {:c=>3, :b=>2}
-      h.assert == {:a=>1}
-    end
-
-  end
-
-end
-

data/test/core/hash/test_stringify_keys.rb

@@ -1,26 +0,0 @@
-covers 'facets/hash/stringify_keys'
-
-test_case Hash do
-
-  method :stringify_keys do
-
-    test do
-      foo = { :a=>1, :b=>2 }
-      foo.stringify_keys.assert == { "a"=>1, "b"=>2 }
-      foo.assert == { :a =>1, :b=>2 }
-    end
-
-  end
-
-  method :stringify_keys! do
-
-    test do
-      foo = { :a=>1, :b=>2 }
-      foo.stringify_keys!.assert == { "a"=>1, "b"=>2 }
-      foo.assert == { "a"=>1, "b"=>2 }
-    end
-
-  end
-
-end
-

data/test/core/hash/test_swap.rb

@@ -1,15 +0,0 @@
-covers 'facets/hash/swap'
-
-test_case Hash do
-
-  method :swap! do
-
-    test do
-      h = { :a=>1, :b=>2 }
-      h.swap!(:a, :b).assert == { :a=>2, :b=>1 }
-    end
-
-  end
-
-end
-

data/test/core/hash/test_symbolize_keys.rb

@@ -1,26 +0,0 @@
-covers 'facets/hash/symbolize_keys'
-
-test_case Hash do
-
-  method :symbolize_keys do
-
-    test do
-      foo = { 'a'=>1, 'b'=>2 }
-      foo.symbolize_keys == { :a=>1, :b=>2 }
-      foo.assert == { "a" =>1, "b"=>2 }
-    end
-
-  end
-
-  method :symbolize_keys! do
-
-    test do
-      foo = { 'a'=>1, 'b'=>2 }
-      foo.symbolize_keys!.assert == { :a=>1, :b=>2 }
-      foo.assert == { :a=>1, :b=>2 }
-    end
-
-  end
-
-end
-

data/test/core/hash/test_to_mod.rb

@@ -1,24 +0,0 @@
-covers 'facets/hash/to_mod'
-
-test_case Hash do
-
-  method :to_mod do
-
-    test do
-      h = { :a=>1, :b=>2 }
-      m = h.to_mod
-      Module.assert === m
-    end
-
-    test "check methods" do
-      h = { :a=>1, :b=>2 }
-      m = h.to_mod
-      x = Class.new{ include m }.new
-      x.a.assert == 1
-      x.b.assert == 2
-    end
-
-  end
-
-end
-

data/test/core/hash/test_to_proc.rb

@@ -1,23 +0,0 @@
-covers 'facets/hash/to_proc'
-
-test_case Hash do
-
-  method :to_proc do
-
-    test do
-      c = Class.new do
-        attr_accessor :a
-      end
-
-      h = {:a => 1}
-      o = c.new
-
-      h.to_proc.call(o)
-
-      o.a.assert == 1
-    end
-
-  end
-  
-end
-

data/test/core/hash/test_to_struct.rb

@@ -1,22 +0,0 @@
-covers 'facets/hash/to_struct'
-
-test_case Hash do
-
-  method :to_struct do
-
-    test do
-      h = {:name=>"Dan","age"=>33,"rank"=>"SrA","grade"=>"E4"}
-      s = h.to_struct("Foo")
-
-      s.name.assert  = "Dan"
-      s.age.assert   = 33
-      s.rank.assert  = "SrA"
-      s.grade.assert = "E4"
-
-      #Foo.assert.is_a?(Struct) ?
-    end
-
-  end
-  
-end
-

data/test/core/hash/test_traverse.rb

@@ -1,29 +0,0 @@
-covers 'facets/hash/traverse'
-
-test_case Hash do
-
-  method :traverse do
-
-    test do
-      h = { "A" => "x", "B" => "y" }
-      j = h.traverse{ |k,v| [k.downcase, v.upcase] }
-      x = { "a" => "X", "b" => "Y" }
-      j.refute == h
-      j.assert == x
-    end
-
-  end
-
-  method :traverse! do
-
-    test do
-      h = { "A" => "x", "B" => "y" }
-      h.traverse!{ |k,v| [k.downcase, v.upcase] }
-      x = { "a" => "X", "b" => "Y" }
-      h.assert == x
-    end
-
-  end
-
-end
-

data/test/core/hash/test_update_each.rb

@@ -1,16 +0,0 @@
-covers 'facets/hash/update_each'
-
-test_case Hash do
-
-  method :update_each do
-
-    test do
-      a = { :a => 1, :b => 2, :c => 3 }
-      x = { :a => 2, :b => 3, :c => 4 }
-      a.update_each{ |k,v| { k => v+1 } }
-      a.assert == x
-    end
-
-  end
-
-end

data/test/core/hash/test_update_keys.rb

@@ -1,21 +0,0 @@
-covers 'facets/hash/update_keys'
-
-test_case Hash do
-
-  method :update_keys do
-
-    test do
-      h = { 'A' => 1, 'B' => 2 }
-      h.update_keys{ |k| k.downcase }
-      h.assert == {'a' => 1, 'b' => 2}
-    end
-
-    test do
-      h = { :a => 1, :b => 2 }
-      h.update_keys{ |k| "#{k}!" }
-      h.assert == {'a!' => 1, 'b!' => 2}
-    end
-
-  end
-
-end

data/test/core/hash/test_update_values.rb

@@ -1,15 +0,0 @@
-covers 'facets/hash/update_values'
-
-test_case Hash do
-
-  method :update_values do
-
-    test do
-      h = {1 => 'A', 2 => 'B'}
-      h.update_values{ |v| v.downcase }
-      h.assert == {1 => 'a', 2 => 'b'}
-    end
-
-  end
-
-end

data/test/core/hash/test_url_params.rb

@@ -1,26 +0,0 @@
-covers 'facets/hash/url_params'
-
-testcase Hash do
-
-  method :url_params do
-
-    test 'simple hash' do
-      hash1 = {:foo => "bar"}
-      hash1.url_params.assert == "foo=bar"
-    end
-
-    test 'hash with array value' do
-      hash2 = {"foo" => ["bar", "fab", 1]}
-      hash2.url_params.assert == "foo=bar,fab,1"
-    end
-
-    test 'hash with multiple elements' do
-      hash3 = {:foo => [:bar, :asdf,1], :fee => 1}
-      params = hash3.url_params
-      params.assert.include? "foo=bar,asdf,1"
-      params.assert.include? "fee=1"
-    end
-
-  end
-
-end

data/test/core/hash/test_weave.rb

@@ -1,18 +0,0 @@
-covers 'facets/hash/weave'
-
-test_case Hash do
-
-  method :weave do
-
-    test do
-      b = { :a=>1, :b=>[1,2,3], :c=>{ :x=>'X' } }
-      c = { :a=>2, :b=>[4,5,6], :c=>{ :x=>'A', :y => 'B' } }
-      x = { :a=>2, :b=>[1,2,3,4,5,6], :c=>{ :x => 'A', :y => 'B' } }
-      b.weave(c).assert == x
-    end
-
-  end
-
-end
-
-

data/test/core/hash/test_zip.rb

@@ -1,16 +0,0 @@
-covers 'facets/hash/zip'
-
-test_case Hash do
-
-  class_method :zip do
-
-    test do
-      a = [1,2,3]
-      b = [4,5,6]
-      Hash.zip(a,b).assert == {1=>4,2=>5,3=>6}
-    end
-
-  end
-
-end
-

data/test/core/indexable_tc.rb

@@ -1,226 +0,0 @@
-covers 'facets/indexable'
-covers 'facets/array/indexable'
-
-test_case Indexable do
-
-  method :head do
-    test do
-      [1,2,3].head.assert == [1]
-    end
-  end
-
-  method :tail do
-    test do
-      [1,2,3].tail.assert == [2,3]
-    end
-  end
-
-  method :foot do
-    test do
-      [1,2,3].foot.assert == [3]
-    end
-  end
-
-  method :body do
-    test do
-      [1,2,3].body.assert == [1,2]
-    end
-  end
-
-  method :mid do
-    test do
-      %w{W o r l d}.mid.assert == 'r'
-      %w{W o r l d}.mid(1).assert == 'l'
-      %w{W o r l d}.mid(-1).assert == 'o'
-    end
-  end
-
-  method :mid do
-    test do
-      a = [1,2,3,4,5]
-      b = [1,2,3,4,5,6]
-      a.mid.assert == 3
-      b.mid.assert == 4
-      a.mid(1).assert == 4
-      b.mid(1).assert == 5
-      b.mid(2).assert == 6
-      b.mid(-1).assert == 3
-    end
-  end
-
-  method :middle do
-    test do
-      [1,2,3,4,5].middle.assert == [3]
-      [1,2,3,4,5,6].middle.assert == [3,4]
-    end
-  end
-
-  method :middle do
-    test do
-      %w{W o r l d}.middle.assert == ['r']
-      %w{W o r l d y}.middle.assert == ['r', 'l']
-    end
-  end
-
-  method :middle do
-    test do
-      [1,2,3,4,5].middle(1).assert == [2,3,4]
-      [1,2,3,4,5,6].middle(1).assert == [2,3,4,5]
-    end
-  end
-
-  method :from do
-    test do
-      %w{W o r l d}.from(3).assert == %w{l d}
-    end
-  end
-
-  method :thru  do
-    test "single parameter" do
-      a = [1,2,3,4,5]
-      r = a.thru(3)
-      r.assert == [1,2,3,4]
-    end
-
-    test "dual parameter" do
-      a = [1,2,3,4,5]
-      r = a.thru(3,4)
-      r.assert == [4,5]
-    end
-
-    test do
-      [0,1,2,3,4,5].thru(2,4).assert == [2,3,4]
-      [0,1,2,3,4,5].thru(0,1).assert == [0,1]
-    end
-  end
-
-  # to be deprecated
-  method :index_of do
-    test do
-      [1,2,3,4].index_of{ |e| e == 3 }.assert == 2
-      [1,2,3,4].index_of{ |e| e > 3 }.assert == 3
-    end
-  end
-
-  method :first= do
-    test do
-      a = [1,2,3]
-      a.first = 9
-      a.assert == [9,2,3]
-    end
-  end
-
-  method :last= do
-    test do
-      a = [1,2,3]
-      a.last = 9
-      a.assert == [1,2,9]
-    end
-  end
-
-  method :ends do
-    test do
-      [1,2,3,4,5].ends.assert == 4
-    end
-  end
-
-  method :pos do
-    test do
-      [1,2,3,4,5].pos(1).assert == 0
-      [1,2,3,4,5].pos(-1).assert == 4
-    end
-  end
-
-  method :range do
-    test do
-      ['a','b','c','d'].range.assert == (0..3)
-      ['a','b','c','d'].range('b','d').assert == (1..3)
-    end
-  end
-
-  method :range do
-    test do
-      a = [1,2,3,4,5]
-      b = [1,2,3,4,5,6]
-      a.range.assert == (0..4)
-      b.range.assert == (0..5)
-      a.range(2,4).assert == (1..3)
-      b.range(2,3).assert == (1..2)
-      b.range(4,2).assert == (3..1)
-    end
-  end
-
-  # We can't use an Array to test the following methods b/c
-  # Array handles them specially, either for efficency reasons,
-  # or becuase the have been added to Ruby as of 1.8.7+.
-
-  setup "special Indexable object" do
-    @c = Class.new do
-      include Indexable
-      def initialize(*a); @a = a; end
-      def slice(*a)  ; @a.slice(*a)  ; end
-      def splice(*a) ; @a.splice(*a) ; end
-      def size       ; @a.size       ; end
-      def to_a       ; @a            ; end
-    end
-  end
-
-  method :first do
-    test do
-      a = @c.new(1,2,3,4,5)
-      r = a.first(3)
-      r.assert == [1,2,3]
-    end
-  end
-
-  method :last do
-    test do
-      a = @c.new(1,2,3,4,5)
-      r = a.last(3)
-      r.assert == [3,4,5]
-    end
-  end
-
-  method :first! do
-    test do
-      a = @c.new(1,2,3,4,5)
-      e = a.first!
-      e.assert == 1
-      a.to_a.assert == [2,3,4,5]
-    end
-  end
-
-  method :last! do
-    test do
-      a = @c.new(1,2,3,4,5)
-      e = a.last!
-      e.assert == 5
-      a.to_a.assert == [1,2,3,4]
-    end
-  end
-
-  method :index do
-    test do
-      @c.new(1,2,3,4).index{ |e| e == 3 }.assert == 2
-      @c.new(1,2,3,4).index{ |e| e > 3 }.assert == 3
-    end
-  end
-
-  #method :[] do
-  #  test do
-  #    a = ['a','b','c','d','e','f']
-  #    assert_equal( ['b','f'], a[[1,-1]] )
-  #  end
-  #end
-
-  #method :[]= do
-  #  test do
-  #    a = ['a','o','z']
-  #    a[[0,2]] = ['A','Z']
-  #    assert_equal( ['A','o','Z'], a )
-  #    a[[0,-1]] = ['W','Y']
-  #    assert_equal( ['W','o','Y'], a )
-  #  end
-  #end
-
-end

data/test/core/integer/test_bitmask.rb

@@ -1,73 +0,0 @@
-covers 'facets/integer/bitmask'
-
-test_case Integer do
-
-  method :bit do
-    test do
-      0.bit(0).assert == 1
-      0.bit(1).assert == 2
-      0.bit(2).assert == 4
-      0.bit(3).assert == 8
-    end
-  end
-
-  method :bit do
-    test "negate" do
-      1.bit(~0).assert == 0
-      2.bit(~1).assert == 0
-      4.bit(~2).assert == 0
-      8.bit(~3).assert == 0
-    end
-  end
-
-  method :bit_clear do
-    test do
-      1.bit_clear(0).assert == 0
-      2.bit_clear(1).assert == 0
-      4.bit_clear(2).assert == 0
-      8.bit_clear(3).assert == 0
-    end
-  end
-
-  method :bit? do
-    test do
-      a = 8
-      assert(! a.bit?(0))
-      assert(! a.bit?(1))
-      assert(! a.bit?(2))
-      assert(  a.bit?(3))
-      assert(! a.bit?(4))
-      assert(! a.bit?(5))
-    end
-  end
-
-  method :bitmask do
-    test do
-      a =  1
-      m = Bit(4)
-      a = a.bitmask(m)
-      a.assert == 17
-      assert( a.bitmask?(m) )
-    end
-  end
-
-  method :bitmask? do
-    test do
-      7.assert.bitmask?(7)
-      7.assert.bitmask?(5)
-      8.refute.bitmask?(3)
-    end
-  end
-
-end
-
-test_case Kernel do
-
-  method :Bit do
-    test do
-      n = Bit(4)
-      n.assert == 16
-    end
-  end
-
-end