facets 3.1.0 → 3.2.0

data/test/core/hash/test_data.rb

@@ -1,35 +0,0 @@
-covers 'facets/hash/data'
-
-test_case Hash do
-
-  method :data do
-
-    test do
-      h = {:a=>1, :b=>2}
-
-      h.data.a.assert == 1
-      h.data.b.assert == 2
-      h.data.c.assert == nil
-    end
-
-    test do
-      h = {:a=>1, :b=>2}
-
-      h.data.c = 3
-      h.data.c.assert == 3
-    end
-
-    test do
-      h = {:a=>1, :b=>2}
-
-      # Note, we can't apply a functor to a functor.
-      #h.data.assert.a?
-      #h.data.refute.d?
-
-      h.data.a?.assert == true
-      h.data.d?.assert == false
-    end
-
-  end
-
-end

data/test/core/hash/test_dearray_values.rb

@@ -1,26 +0,0 @@
-covers 'facets/hash/dearray_values'
-
-test_case Hash do
-
-  method :dearray_values do
-
-    test do
-      h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
-      x = { :a=>1, :b=>1, :c=>3, :d=>nil }
-      h.dearray_values.assert == x
-    end
-
-  end
-
-  method :dearray_singular_values do
-
-    test do
-      h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
-      x = { :a=>1, :b=>[1,2], :c=>3, :d=>nil }
-      h.dearray_singular_values.assert == x
-    end
-
-  end
-
-end
-

data/test/core/hash/test_deep_merge.rb

@@ -1,31 +0,0 @@
-covers 'facets/hash/deep_merge'
-
-test_case Hash do
-
-  method :deep_merge do
-
-    test do
-      h1 = { :a=>1, :c=>{:x=>10} }
-      h2 = { :b=>2, :c=>{:y=>11} }
-
-      h = h1.deep_merge(h2)
-
-      h.assert == {:a=>1, :b=>2, :c=>{:x=>10, :y=>11}}
-    end
-
-  end
-
-  method :deep_merge! do
-
-    test do
-      h1 = { :a=>1, :c=>{:x=>10} }
-      h2 = { :b=>2, :c=>{:y=>11} }
-
-      h1.deep_merge!(h2)
-
-      h1.assert == {:a=>1, :b=>2, :c=>{:x=>10, :y=>11}}
-    end
-
-  end
-
-end

data/test/core/hash/test_deep_rekey.rb

@@ -1,131 +0,0 @@
-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_delete_at.rb

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

data/test/core/hash/test_delete_unless.rb

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

data/test/core/hash/test_delete_values.rb

@@ -1,30 +0,0 @@
-covers 'facets/hash/delete_values'
-
-test_case Hash do
-
-  method :delete_values do
-
-    test do
-      a = { :a => 1, :b => 2, :c => 3 }
-      x = { :b => 2, :c => 3 }
-      r = a.delete_values(1)
-      #r.assert == x
-      a.assert == x
-    end
-
-  end
-
-  method :delete_values_at do
-
-    test do
-      a = { :a => 1, :b => 2, :c => 3 }
-      x = { :b => 2, :c => 3 }
-      r = a.delete_values_at(:a)
-      r.assert == [1]
-      a.assert == x
-    end
-
-  end
-
-end
-

data/test/core/hash/test_diff.rb

@@ -1,16 +0,0 @@
-covers "facets/hash/diff"
-
-test_case Hash do
-
-  method :diff do
-
-    test do
-      h1 = {:a=>1,:b=>2}
-      h2 = {:a=>1,:b=>3}
-      h1.diff(h2).assert == {:b=>2}
-      h2.diff(h1).assert == {:b=>3}
-    end
-
-  end
-
-end

data/test/core/hash/test_each_with_key.rb

@@ -1,16 +0,0 @@
-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_expect.rb

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

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
-