facets 2.9.3 → 3.0.0

data/test/core/hash/test_count.rb

@@ -5,7 +5,16 @@ test_case Hash do
   method :count do
 
     test do
-      {:A=>1, :B=>1}.count(1).assert == 2
+      {:A=>1, :B=>1, :C=>2}.count(1).assert == 2
+      {:A=>1, :B=>1, :C=>2}.count(2).assert == 1
+    end
+
+    test "no matches" do
+      {:A=>1, :B=>1, :C=>2}.count(3).assert == 0
+    end
+
+    test "still works with Enumerable#count" do
+      {:A=>1, :B=>1, :C=>2}.count.assert == 3
     end
 
   end

data/test/core/hash/test_deep_rekey.rb

@@ -0,0 +1,131 @@
+covers 'facets/hash/deep_rekey'
+
+test_case Hash do
+
+  method :deep_rekey do
+
+    test "default converts all keys to symbols" do
+      foo = { "c"=>{ "a"=>1, "b"=>2 } }
+      foo.deep_rekey.assert == { :c=>{ :a=>1, :b=>2 } }
+      foo.assert == { "c"=>{ "a"=>1, "b"=>2 } }
+    end
+
+    test "specific key" do
+      bar = { :d=>{ :a=>1, :b=>2 } }
+      foo = bar.deep_rekey(:a=>:c)
+      foo[:d][:c].assert == 1
+      foo[:d][:b].assert == 2
+      foo[:d][:a].assert == nil
+    end
+
+    test "multiple keys" do
+      bar = { :z=>{ :a=>1, :b=>2, :c=>3 } }
+      foo = bar.deep_rekey(:a=>:d,:b=>:e)
+      foo[:z][:d].assert == 1
+      foo[:z][:e].assert == 2
+      foo[:z][:c].assert == 3
+      foo[:z][:a].assert == nil
+      foo[:z][:b].assert == nil
+    end
+
+    test "multiple keys, some on same level as other hash" do
+      bar = { :z=>{ :a=>1, :b=>2, :c=>3 }, :y=>4 }
+      foo = bar.deep_rekey(:a=>:d,:b=>:e)
+      foo[:z][:d].assert == 1
+      foo[:z][:e].assert == 2
+      foo[:z][:c].assert == 3
+      foo[:y].assert == 4
+      foo[:z][:a].assert == nil
+      foo[:z][:b].assert == nil
+    end
+
+    # TODO: Is using Hash#deep_rekey to exhange keys possible?
+
+    #test "exchange keys via dummy key" do
+    #  bar = { :a=>1, :b=>2, :c=>3 }
+    #  foo = bar.deep_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 = { :c=>{ :a=>1, :b=>2 } }
+      foo = bar.deep_rekey{ |k| k.to_s }
+      foo['c']['a'].assert == 1
+      foo['c']['b'].assert == 2
+      foo['c'][:a].assert  == nil
+      foo['c'][:b].assert  == nil
+      foo.assert == { 'c'=>{ 'a'=>1, 'b'=>2 } }
+    end
+
+    test "with block of key, value" do
+      bar = { :c=>{ :a=>1, :b=>2 } }
+      foo = bar.deep_rekey{ |k, v| v.to_s }
+      k = foo.keys.first
+      foo[k]['1'].assert == 1
+      foo[k]['2'].assert == 2
+      foo[k][:a].assert  == nil
+      foo[k][:b].assert  == nil
+      foo[k]['a'].assert  == nil
+      foo[k]['b'].assert  == nil
+      foo.assert == { k=>{ '1'=>1, '2'=>2 } }
+    end
+
+    test "with keys and block" do
+      expect ArgumentError do
+        bar = { :c=>{ :a=>1, :b=>2 } }
+        bar.deep_rekey(:a=>:c){ |k| k.to_s }
+      end
+    end
+
+    test "symbol proc" do
+      foo = { :c=>{ :a=>1, :b=>2 } }
+      foo.deep_rekey(&:to_s).assert == { "c"=>{ "a"=>1, "b"=>2 } }
+      foo.assert == { :c=>{ :a =>1, :b=>2 } }
+    end
+
+  end
+
+  method :deep_rekey! do
+
+    test "default" do
+      foo = { "c"=>{ "a"=>1, "b"=>2 } }
+      foo.deep_rekey!.assert == { :c=>{ :a=>1, :b=>2 } }
+      foo.assert == { :c=>{ :a=>1, :b=>2 } }
+    end
+
+    test "specific key" do
+      foo = { :d=>{ :a=>1, :b=>2 } }
+      foo.deep_rekey!(:a=>:c)
+      foo[:d][:c].assert == 1
+      foo[:d][:b].assert == 2
+      foo[:d][:a].assert == nil
+    end
+
+    test "with block" do
+      foo = { :c=>{ :a=>1, :b=>2 } }
+      foo.deep_rekey!{ |k| k.to_s }
+      foo['c']['a'].assert == 1
+      foo['c']['b'].assert == 2
+      foo['c'][:a].assert  == nil
+      foo['c'][:b].assert  == nil
+      foo.assert == { 'c'=>{ 'a'=>1, 'b'=>2 } }
+    end
+
+    test "symbol proc" do
+      foo = { :c=>{ :a=>1, :b=>2 } }
+      foo.deep_rekey!(&:to_s).assert == { "c"=>{ "a"=>1, "b"=>2 } }
+      foo.assert == { "c"=>{ "a"=>1, "b"=>2 } }
+    end
+
+    test "no conflict between keys" do
+      r = { 0 => {1 => :a, 2 => :b} }.deep_rekey!{ |k| k + 1 }
+      r[1].refute = {3 => :a}
+      r[1].assert = {2 => :a, 3 => :b}
+    end
+
+  end
+
+end

data/test/core/hash/test_each_with_key.rb

@@ -0,0 +1,16 @@
+covers 'facets/hash/each_with_key'
+
+test_case Hash do
+
+  method :each_with_key do
+
+    test do
+      h1 = {:a=>1, :b=>2}
+      h2 = {}
+      h1.each_with_key { |v,k| h2[v] = k }
+      h2.assert == {1=>:a, 2=>:b}
+    end
+
+  end
+
+end

data/test/core/hash/test_fetch_nested.rb

@@ -0,0 +1,24 @@
+covers 'facets/hash/fetch_nested'
+
+test_case Hash do
+
+  setup do
+    @a = {'hello'=>{'world'=>42}}
+    @b = {}
+  end
+
+  method :fetch_nested do
+
+    test 'safe case' do
+      @a['hello']['world'].assert == 42
+      @a.fetch_nested(*['hello','world']).assert == 42
+    end
+
+    test 'dangerous case' do
+      expect(NoMethodError){@b['hello']['world']}
+      @b.fetch_nested(*['hello','world']).assert == nil
+    end
+
+  end
+
+end

data/test/core/hash/test_keys.rb

@@ -2,17 +2,6 @@ covers 'facets/hash/keys'
 
 test_case Hash do
 
-  method :each_with_key do
-
-    test do
-      h1 = {:a=>1, :b=>2}
-      h2 = {}
-      h1.each_with_key { |v,k| h2[v] = k }
-      h2.assert == {1=>:a, 2=>:b}
-    end
-
-  end
-
   method :keys? do
 
     test do

data/test/core/hash/test_rekey.rb

@@ -4,7 +4,7 @@ test_case Hash do
 
   method :rekey do
 
-    test "default" 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 }
@@ -18,6 +18,27 @@ test_case Hash do
       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 }
@@ -28,6 +49,25 @@ test_case Hash do
       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 }

data/test/core/hash/test_revalue.rb

@@ -0,0 +1,98 @@
+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_slice.rb

@@ -4,11 +4,16 @@ test_case Hash do
 
   method :slice do
 
-    test 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
@@ -19,6 +24,12 @@ test_case Hash do
       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/kernel/test_deep_clone.rb

@@ -0,0 +1,31 @@
+covers 'facets/kernel/deep_clone'
+
+test_case Kernel do
+
+  method :deep_clone do
+
+    setup "a class with reference to another class" do
+      xC = Class.new do
+        attr_reader :x
+        def initialize
+          @x = 1
+        end
+      end
+
+      @c = Class.new do
+        attr_reader :y
+        define_method(:initialize) do
+          @y = xC.new
+        end
+      end
+    end
+
+    test do
+      o = @c.new
+      d = o.deep_clone
+      d.y.x.assert == 1
+    end
+
+  end
+
+end

data/test/core/kernel/test_deep_copy.rb

@@ -5,35 +5,9 @@ test_case Kernel do
   method :deep_copy do
 
     test do
-      o = "This is a week test."
+      o = "This is a weak test."
       d = o.deep_copy
-      d.assert == "This is a week test."
-    end
-
-  end
-
-  method :deep_clone do
-
-    setup "a class with reference to another class" do
-      xC = Class.new do
-        attr_reader :x
-        def initialize
-          @x = 1
-        end
-      end
-
-      @c = Class.new do
-        attr_reader :y
-        define_method(:initialize) do
-          @y = xC.new
-        end
-      end
-    end
-
-    test do
-      o = @c.new
-      d = o.deep_clone
-      d.y.x.assert == 1
+      d.assert == "This is a weak test."
     end
 
   end