facets 3.0.0 → 3.2.0

data/test/core/hash/test_fetch_nested.rb

@@ -1,24 +0,0 @@
-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_graph.rb

@@ -1,40 +0,0 @@
-covers 'facets/hash/graph'
-
-test_case Hash do
-
-  method :graph! do
-
-    test "using a hash" do
-      a = { :a => 1, :b => 2, :c => 3 }
-      e = { :a => 2, :b => 3, :c => 4 }
-      a.graph!{ |k,v| { k => v+1 } }
-      a.assert == e
-    end
-
-    test "using an associative array" do
-      h  = {:a=>1,:b=>2,:c=>3}
-      h.graph!{ |k,v| [v, v*v] }
-      h.assert == {1=>1, 2=>4, 3=>9}
-    end
-
-  end
-
-  method :mash! do
-
-    test "using a hash" do
-      a = { :a => 1, :b => 2, :c => 3 }
-      e = { :a => 2, :b => 3, :c => 4 }
-      a.mash!{ |k,v| { k => v+1 } }
-      a.assert == e
-    end
-
-    test "using an associative array" do
-      h  = {:a=>1,:b=>2,:c=>3}
-      h.mash!{ |k,v| [v, v*v] }
-      h.assert == {1=>1, 2=>4, 3=>9}
-    end
-
-  end
-
-end
-

data/test/core/hash/test_insert.rb

@@ -1,20 +0,0 @@
-covers 'facets/hash/insert'
-
-test_case Hash do
-
-  method :insert do
-
-    test do
-      h = {:a=>1, :b=>2}
-
-      h.assert.insert(:c,3)
-      h.assert == {:a=>1, :b=>2, :c=>3}
-
-      h.refute.insert(:a,0)
-      h.assert == {:a=>1, :b=>2, :c=>3}
-    end
-
-  end
-
-end
-

data/test/core/hash/test_inverse.rb

@@ -1,20 +0,0 @@
-covers 'facets/hash/inverse'
-
-test_case Hash do
-
-  method :inverse do
-
-    test do
-      h1 = { :a=>1, :b=>2, :c=>2 }
-      h2 = h1.inverse
-
-      h2[1].assert == :a
-
-      h2[2].assert.include?(:b)
-      h2[2].assert.include?(:c)
-    end
-
-  end
-
-end
-

data/test/core/hash/test_join.rb

@@ -1,32 +0,0 @@
-covers 'facets/hash/join'
-
-test_case Hash do
-
-  method :join do
-
-    setup do
-      @h = {:a=>1, :b=>2}
-    end
-
-    test do
-      s = @h.join
-      s.assert.include?('b2')
-      s.assert.include?('a1')
-    end
-
-    test do
-      s = @h.join(',')
-      s.assert.include?('a,1')
-      s.assert.include?('b,2')
-    end
-
-    test do
-      s = @h.join(',', ':')
-      s.assert.include?('a,1')
-      s.assert.include?('b,2')
-      s.assert.include?(':')
-    end
-
-  end
-
-end

data/test/core/hash/test_keys.rb

@@ -1,41 +0,0 @@
-covers 'facets/hash/keys'
-
-test_case Hash do
-
-  method :keys? do
-
-    test do
-      {:a=>1,:b=>2,:c=>3}.assert.keys?(:a,:b)
-      {:a=>1,:b=>2,:c=>3 }.refute.keys?(:a,:b,:d)
-    end
-
-  end
-
-  method :only_keys? do
-
-    test do
-      {:a=>1,:b=>2,:c=>3}.assert.only_keys?(:a,:b,:c)
-      {:a=>1,:b=>2,:c=>3}.refute.only_keys?(:a,:b)
-    end
-
-  end
-
-  method :has_keys? do
-
-    test do
-      {:a=>1,:b=>2,:c=>3}.assert.has_keys?(:a,:b)
-      {:a=>1,:b=>2,:c=>3 }.refute.has_keys?(:a,:b,:d)
-    end
-
-  end
-
-  method :has_only_keys? do
-
-    test do
-      {:a=>1,:b=>2,:c=>3}.assert.has_only_keys?(:a,:b,:c)
-      {:a=>1,:b=>2,:c=>3}.refute.has_only_keys?(:a,:b)
-    end
-
-  end
-
-end

data/test/core/hash/test_new_with.rb

@@ -1,17 +0,0 @@
-covers 'facets/hash/new_with'
-
-test_case Hash do
-
-  class_method :new_with do
-
-    test do
-      h = Hash.new_with{0}
-
-      h[:ab].assert == 0
-      h[100].assert == 0
-      h["a"].assert == 0
-    end
-
-  end
-
-end

data/test/core/hash/test_op_add.rb

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

data/test/core/hash/test_op_and.rb

@@ -1,31 +0,0 @@
-covers 'facets/hash/op_and'
-
-test_case Hash do
-
-  method :& do
-
-    test "hash and hash" do
-      a = { :a => 1, :b => 2 }
-      b = { :a => 1 }
-      x = { :a => 1 }
-      (a & b).assert == x 
-    end
-
-    test "hashes with sub-array" do
-      a = { :a => [1], :b => [2] }
-      b = { :a => [1] }
-      x = { :a => [1] }
-      (a & b).assert == x
-    end
-
-    test "hash and array" do
-      a = { :a => 1, :b => 2 }
-      b = [ :a ]
-      x = { :a => 1 }
-      (a & b).assert == x
-    end
-
-  end
-
-end
-

data/test/core/hash/test_op_mul.rb

@@ -1,17 +0,0 @@
-covers 'facets/hash/op_mul'
-
-test_case Hash do
-
-  method :* do
-
-    test do
-      a = { :a => 1, :b => 2 }
-      b = { :b => 3 }
-      x = { :a => 1, :b => 2 }
-      (a * b).assert == x 
-    end
-
-  end
-
-end
-

data/test/core/hash/test_op_or.rb

@@ -1,17 +0,0 @@
-covers 'facets/hash/op_or'
-
-test_case Hash do
-
-  method :| do
-
-    test do
-      a = { :a => 1, :b => 2 }
-      b = { :b => 3 }
-      x = { :a => 1, :b => 2 }
-      (a | b).assert == x
-    end
-
-  end
-
-end
-

data/test/core/hash/test_op_push.rb

@@ -1,34 +0,0 @@
-covers 'facets/hash/op_push'
-
-test_case Hash do
-
-  method :<< do
-
-    test "two element array" do
-      h = {}
-      a = [:b, 2]
-      x = {:b => 2}
-      (h << a).assert == h
-      h.assert == x
-    end
-
-    test "update new entries" do
-      a = {:a => 1}
-      b = {:b => 2, :c => 3 }
-      x = {:a => 1, :b => 2, :c => 3}
-      (a << b).assert == x
-      a.assert == x
-    end
-
-    test "update overwrite" do
-      a = {:a => 1, :b => 2, :c => 3}
-      b = {:a => 0, :d => 4}
-      x = {:a => 0, :b => 2, :c => 3, :d => 4}
-      (a << b).assert == x 
-      a.assert == x
-    end
-
-  end
-
-end
-

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