facets 3.1.0 → 3.2.0

data/test/core/hash/test_op_sub.rb

@@ -1,28 +0,0 @@
-covers 'facets/hash/op_sub'
-
-test_case Hash do
-
-  method :- do
-
-    test "hash minus array" do
-      a = { :a => 1, :b => 2, :c => 3 }
-      b = [ :a ]
-      x = { :b => 2, :c => 3 }
-      (a - b).assert == x
-    end
-
-  end
-
-  method :- do
-
-    test "hash minus hash" do
-      a = { :a => 1, :b => 2, :c => 3 }
-      b = { :a => 1, :d => 4 }
-      x = { :b => 2, :c => 3 }
-      (a - b).assert == x
-    end
-
-  end
-
-end
-

data/test/core/hash/test_recurse.rb

@@ -1,39 +0,0 @@
-covers 'facets/hash/recurse'
-
-test_case Hash do
-
-  method :recurse do
-
-    test do
-      h = {:a=>1, :b=>{:b1=>1, :b2=>2}}
-      g = h.recurse{|h| h.inject({}){|h,(k,v)| h[k.to_s] = v; h} }
-      g.assert == {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
-    end
-
-    test "with Arrays" do
-      require 'facets/array/recurse'
-      objects = []
-      struct = {:a => 3, :b => [4, 5, {:c=>6}]} 
-      struct.recurse(Array, Hash){|o| objects << o; o }
-
-      objects.assert.include?( {:c=>6}                          )
-      objects.assert.include?( [4, 5, {:c=>6}]                  )
-      objects.assert.include?( struct                           )
-
-      objects.length.assert == 3
-    end
-
-  end
-
-  method :recurse! do
-
-    test do
-      h = {:a=>1, :b=>{:b1=>1, :b2=>2}}
-      h.recurse!{|h| h.inject({}){|h,(k,v)| h[k.to_s] = v; h} }
-      h.assert == {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
-    end
-
-  end
-
-end
-

data/test/core/hash/test_recursively.rb

@@ -1,71 +0,0 @@
-covers 'facets/hash/recursively'
-covers 'facets/hash/graph'
-
-test_case Hash do
-
-  method :recursively do
-
-    test "each" do
-      h = {:a=>1,:b=>{:c=>3}}
-      r = []
-      h.recursively.each{ |k,v| r << [k,v] }
-      r.assert.include? [:a,1]
-      r.assert.include? [:b,{:c=>3}]
-      r.assert.include? [:c,3]
-    end
-
-    test "map" do
-      h = {:a=>1,:b=>{:c=>3}}
-      r = h.recursively{ |k,v| [k,v] }.map{ |k,v| [k, v.succ] }
-      r.assert.include? [:a,2]
-      r.assert.include? [:b,[[:c,4]]]
-    end
-
-    test "map (moot)" do
-      h = {:a=>1,:b=>{:c=>3}}
-      a = h.recursively.map{ |k,v| [k, v] }
-      a.assert.include? [:a,1]
-      a.assert.include? [:b,[[:c,3]]]
-    end
-
-    test 'graph' do
-      h = {:a=>1,:b=>{:c=>3}}
-      r = h.recursively{ |k,v| [k.to_s, v] }.graph{ |k,v| [k.to_s, v.to_s] }
-      r.assert == {'a'=>'1','b'=>{'c'=>'3'}}
-    end
-
-    test 'graph!' do
-      h = {:a=>1,:b=>{:c=>3}}
-      h.recursively{ |k,v| [k.to_s, v] }.graph!{ |k,v| [k.to_s, v.to_s] }
-      h.assert == {'a'=>'1','b'=>{'c'=>'3'}}
-    end
-
-    test 'mash' do
-      h = {:a=>1,:b=>{:c=>3}}
-      r = h.recursively{ |k,v| [k.to_s, v] }.mash{ |k,v| [k.to_s, v.to_s] }
-      r.assert == {'a'=>'1','b'=>{'c'=>'3'}}
-    end
-
-    test 'mash!' do
-      h = {:a=>1,:b=>{:c=>3}}
-      h.recursively{ |k,v| [k.to_s, v] }.mash!{ |k,v| [k.to_s, v.to_s] }
-      h.assert == {'a'=>'1','b'=>{'c'=>'3'}}
-    end
-
-    #test 'merge' do
-    #  h1 = {:a=>1,:b=>{:c=>3}}
-    #  h2 = {:b=>{:d=>4}}
-    #  r = h1.recursively.merge(h2)
-    #  r.assert == {:a=>1,:b=>{:c=>3, :d=>4}}
-    #end
-
-    #test 'merge!' do
-    #  h1 = {:a=>1,:b=>{:c=>3}}
-    #  h2 = {:b=>{:d=>4}}
-    # h1.recursively.merge!(h2)
-    #  h1.assert == {:a=>1,:b=>{:c=>3, :d=>4}}
-    #end
-
-  end
-
-end

data/test/core/hash/test_rekey.rb

@@ -1,119 +0,0 @@
-covers 'facets/hash/rekey'
-
-test_case Hash do
-
-  method :rekey do
-
-    test "default converts all keys to symbols" do
-      foo = { "a"=>1, "b"=>2 }
-      foo.rekey.assert == { :a=>1, :b=>2 }
-      foo.assert == { "a"=>1, "b"=>2 }
-    end
-
-    test "specific key" do
-      bar = { :a=>1, :b=>2 }
-      foo = bar.rekey(:a=>:c)
-      foo[:c].assert == 1
-      foo[:b].assert == 2
-      foo[:a].assert == nil
-    end
-
-    test "multiple keys" do
-      bar = { :a=>1, :b=>2, :c=>3 }
-      foo = bar.rekey(:a=>:d,:b=>:e)
-      foo[:d].assert == 1
-      foo[:e].assert == 2
-      foo[:c].assert == 3
-      foo[:a].assert == nil
-      foo[:b].assert == nil
-    end
-
-    # TODO: Is using Hash#rekey to exhange keys possible?
-
-    #test "exchange keys via dummy key" do
-    #  bar = { :a=>1, :b=>2, :c=>3 }
-    #  foo = bar.rekey(:a=>:d,:c=>:a,:d=>:c)
-    #  foo[:a].assert == 3
-    #  foo[:b].assert == 2
-    #  foo[:c].assert == 1
-    #  foo[:d].assert == nil
-    #end
-
-    test "with block" do
-      bar = { :a=>1, :b=>2 }
-      foo = bar.rekey{ |k| k.to_s }
-      foo['a'].assert == 1
-      foo['b'].assert == 2
-      foo[:a].assert  == nil
-      foo[:b].assert  == nil
-      foo.assert == { 'a'=>1, 'b'=>2 }
-    end
-
-    test "with block of key, value" do
-      bar = { :a=>1, :b=>2 }
-      foo = bar.rekey{ |k, v| v.to_s }
-      foo['1'].assert == 1
-      foo['2'].assert == 2
-      foo[:a].assert  == nil
-      foo[:b].assert  == nil
-      foo['a'].assert  == nil
-      foo['b'].assert  == nil
-      foo.assert == { '1'=>1, '2'=>2 }
-    end
-
-    test "with keys and block" do
-      expect ArgumentError do
-        bar = { :a=>1, :b=>2 }
-        bar.rekey(:a=>:c){ |k| k.to_s }
-      end
-    end
-
-    test "symbol proc" do
-      foo = { :a=>1, :b=>2 }
-      foo.rekey(&:to_s).assert == { "a"=>1, "b"=>2 }
-      foo.assert == { :a =>1, :b=>2 }
-    end
-
-  end
-
-  method :rekey! do
-
-    test "default" do
-      foo = { "a"=>1, "b"=>2 }
-      foo.rekey!.assert == { :a=>1, :b=>2 }
-      foo.assert == { :a=>1, :b=>2 }
-    end
-
-    test "specific key" do
-      foo = { :a=>1, :b=>2 }
-      foo.rekey!(:a=>:c)
-      foo[:c].assert == 1
-      foo[:b].assert == 2
-      foo[:a].assert == nil
-    end
-
-    test "with block" do
-      foo = { :a=>1, :b=>2 }
-      foo.rekey!{ |k| k.to_s }
-      foo['a'].assert == 1
-      foo['b'].assert == 2
-      foo[:a].assert == nil
-      foo[:b].assert == nil
-      foo.assert == { 'a'=>1, 'b'=>2 }
-    end
-
-    test "symbol proc" do
-      foo = { :a=>1, :b=>2 }
-      foo.rekey!(&:to_s).assert == { "a"=>1, "b"=>2 }
-      foo.assert == { "a"=>1, "b"=>2 }
-    end
-
-    test "no conflict between keys" do
-      r = {1 => :a, 2 => :b}.rekey!{ |k| k + 1 }
-      r.refute = {3 => :a}
-      r.assert = {2 => :a, 3 => :b}  
-    end
-
-  end
-
-end

data/test/core/hash/test_replace_each.rb

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

data/test/core/hash/test_revalue.rb

@@ -1,98 +0,0 @@
-covers 'facets/hash/revalue'
-
-test_case Hash do
-
-  method :revalue do
-
-    #test "default converts all keys to symbols" do
-    #  foo = { "a"=>1, "b"=>2 }
-    #  foo.rekey.assert == { :a=>1, :b=>2 }
-    #  foo.assert == { "a"=>1, "b"=>2 }
-    #end
-
-    test "specific value" do
-      bar = { :a=>1, :b=>2 }
-      foo = bar.revalue(2=>3)
-      foo[:a].assert == 1
-      foo[:b].assert == 3
-      foo.size.assert == 2
-    end
-
-    test "multiple values" do
-      bar = { :a=>1, :b=>2, :c=>3 }
-      foo = bar.revalue(1=>4,3=>5)
-      foo[:a].assert == 4
-      foo[:b].assert == 2
-      foo[:c].assert == 5
-      foo.size.assert == 3
-    end
-
-    test "with block" do
-      bar = { :a=>1, :b=>2 }
-      foo = bar.revalue{ |v| v.to_s }
-      foo[:a].assert == "1"
-      foo[:b].assert == "2"
-      foo.assert == { :a=>"1", :b=>"2" }
-    end
-
-    test "with block of key, value" do
-      bar = { :a=>1, :b=>2 }
-      foo = bar.revalue{ |k, v| [k,v] }
-      foo[:a].assert == [:a,1]
-      foo[:b].assert == [:b,2]
-      foo.assert == { :a=>[:a,1], :b=>[:b,2] }
-    end
-
-    test "with values and block" do
-      expect ArgumentError do
-        bar = { :a=>1, :b=>2 }
-        bar.revalue(1=>3){ |v| v.to_s }
-      end
-    end
-
-    test "symbol proc" do
-      foo = { :a=>1, :b=>2 }
-      foo.revalue(&:to_s).assert == { :a=>"1", :b=>"2" }
-      foo.assert == { :a =>1, :b=>2 }
-    end
-
-  end
-
-  method :revalue! do
-
-    #test "default" do
-    #  foo = { "a"=>1, "b"=>2 }
-    #  foo.revalue!.assert == { :a=>1, :b=>2 }
-    #  foo.assert == { :a=>1, :b=>2 }
-    #end
-
-    test "specific value" do
-      foo = { :a=>1, :b=>2 }
-      foo.revalue!(1=>3)
-      foo[:a].assert == 3
-      foo[:b].assert == 2
-    end
-
-    test "with block" do
-      foo = { :a=>1, :b=>2 }
-      foo.revalue!{ |v| v.to_s }
-      foo[:a].assert == "1"
-      foo[:b].assert == "2"
-      foo.assert == { :a=>"1", :b=>"2" }
-    end
-
-    test "symbol proc" do
-      foo = { :a=>1, :b=>2 }
-      foo.revalue!(&:to_s).assert == { :a=>"1", :b=>"2" }
-      foo.assert == { :a=>"1", :b=>"2" }
-    end
-
-    test "no conflict between keys" do
-      r = {:a => 1, :b => 2}.revalue!{ |v| v + 1 }
-      r.refute = {:a => 3}
-      r.assert = {:a => 2, :b => 3}  
-    end
-
-  end
-
-end

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_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_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
-
-