facets 3.0.0 → 3.2.0

data/test/core/file/test_sanitize.rb

@@ -1,32 +0,0 @@
-covers 'facets/file/sanitize'
-
-test_case File do
-
-  # TODO: Write file identity tests.
-  class_method :sanitize do
-
-    test "spaces become underscores" do
-      File.sanitize('This is a test').assert == "This_is_a_test"
-    end
-
-    test "Windows-style path dividers" do
-      File.sanitize('This\is\test').assert == "test"
-    end
-
-    test "Unix-style path dividers" do
-      File.sanitize('This/is/test').assert == "test"
-    end
-
-    test "non-word characters" do
-      File.sanitize('This/te#$#@!st').assert == "te_____st"
-    end
-
-    test "initial dot" do
-      File.sanitize('.').assert == "_."
-      File.sanitize('....').assert == "_...."
-    end
-
-  end
-
-end
-

data/test/core/file/test_split_all.rb

@@ -1,14 +0,0 @@
-covers 'facets/file/split_all'
-
-test_case File do
-
-  class_method :split_all do
-
-    test do
-      fp = "test/core/file"
-      File.split_all(fp).assert == ['test', 'core', 'file']
-    end
-
-  end
-
-end

data/test/core/file/test_write.rb

@@ -1,22 +0,0 @@
-covers 'facets/file/write'
-
-test_case File do
-
-  class_method :write do
-
-    test_file = 'tmp/write.txt'
-
-    test do
-      data = "Test data\n"
-
-      nbytes = File.write(test_file, data)
-
-      out = File.read(test_file)
-      out.assert == data
-      out.size.assert == nbytes
-    end
-
-  end
-
-end
-

data/test/core/file/test_writelines.rb

@@ -1,21 +0,0 @@
-covers 'facets/file/writelines'
-
-#require File.dirname(__FILE__) + '/helpers/mockfile'
-test_case File do
-
-  class_method :writelines do
-
-    test_file = 'tmp/writelines.txt'
-    test_data = %w[one two three four five]
-
-    test do
-      File.writelines(test_file, test_data)
-
-      out = File.readlines(test_file)
-      out.map{ |l| l.chomp }.assert == test_data
-    end
-
-  end
-
-end
-

data/test/core/filetest/test_root.rb

@@ -1,14 +0,0 @@
-covers 'facets/filetest/root'
-
-test_case FileTest do
-
-  class_method :root? do
-
-    test do
-      assert FileTest.root?('/')
-    end
-
-  end
-
-end
-

data/test/core/functor_tc.rb

@@ -1,41 +0,0 @@
-covers 'facets/functor'
-
-test_case Functor do
-
-  class_method :new do
-
-    test do
-      fc = Functor.new do |op, *a, &b|
-        [op, a, b]
-      end
-      (fc + 1).assert == [:+, [1], nil]
-    end
-
-  end
-
-  method :__class__ do
-
-    test do
-      fc = Functor.new do |op, *a, &b|
-        [op, a, b]
-      end
-      fc.__class__.assert == Functor
-    end
-
-  end
-
-  method :to_proc do
-
-    test do
-      f = Functor.new do |op, *a|
-        [op, *a]
-      end
-      p = f.to_proc
-      p.assert.is_a? Proc
-      p.call(:+,1,2,3).assert == [:+,1,2,3]
-    end
-
-  end
-
-end
-

data/test/core/hash/test_alias.rb

@@ -1,25 +0,0 @@
-covers 'facets/hash/alias'
-
-test_case Hash do
-
-  method :alias! do
-
-    test do
-      foo = { 'a'=>1, 'b'=>2 }
-      foo.alias!('c','b').assert == { 'a'=>1, 'b'=>2, 'c'=>2 }
-    end
-
-    test do
-      foo = { 'a'=>1, 'b'=>2 }
-      foo.alias!(:a,'a').assert == { :a=>1, 'a'=>1, 'b'=>2 }
-    end
-
-    test do
-      foo = { :a=>1, :b=>2 }
-      foo.alias!('bar','foo').assert == { :a=>1, :b=>2 }
-    end
-
-  end
-
-end
-

data/test/core/hash/test_argumentize.rb

@@ -1,23 +0,0 @@
-covers 'facets/hash/argumentize'
-
-test_case Hash do
-
-  method :argumentize do
-
-    setup do
-      @h = { :list => [1,2], :base => "HI" }
-    end
-
-    test "without an argument field" do
-      @h.argumentize.assert == [ { :list => [1,2], :base => "HI" } ]
-    end
-
-    test "with an argument field" do
-      @h.argumentize(:list).assert == [ 1, 2, { :base => "HI" } ]
-      @h.argumentize(:base).assert == [ "HI", { :list => [1,2] } ]
-    end
-
-  end
-
-end
-

data/test/core/hash/test_at.rb

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

data/test/core/hash/test_autonew.rb

@@ -1,22 +0,0 @@
-covers 'facets/hash/autonew'
-
-test_case Hash do
-
-  class_method :autonew do
-
-    test do
-      h = Hash.autonew
-      h['s1']['p1'] = 4
-      h['s1']['p2'] = 5
-      h['s1']['p3'] = 2
-      h['s1']['p4'] = 3
-    
-      h.assert == {"s1"=>{"p1"=>4, "p4"=>3, "p3"=>2, "p2"=>5}}
-    
-      h['s1'].keys.sort.assert == ["p1", "p2", "p3", "p4"]
-    end
-
-  end
-
-end
-

data/test/core/hash/test_collate.rb

@@ -1,61 +0,0 @@
-covers 'facets/hash/collate'
-
-test_case Hash do
-
-  setup do
-    @a = { :a=>1, :b=>2, :z=>26, :all=>%w|a b z|, :stuff1=>%w|foo bar|, :whee=>%w|a b| }
-    @b = { :a=>1, :b=>4, :c=>9,  :all=>%w|a b c|, :stuff2=>%w|jim jam|, :whee=>%w|a b| }
-    @c = { :a=>1, :b=>8, :c=>27 }
-  end
-
-  method :collate do
-
-    test do
-      collated = @a.collate(@b)
-
-      collated.keys.length.assert == 8
-
-      collated[:a].assert == [1,1]
-      collated[:b].assert == [2,4]
-      collated[:c].assert == [9]
-      collated[:z].assert == [26]
-
-      collated[:all].assert == %w|a b z a b c|
-      collated[:stuff1].assert == %w|foo bar|
-      collated[:stuff2].assert == %w|jim jam|
-      collated[:whee].assert == %w|a b a b|
-    end
-
-    test "multiple times" do
-      collated = @a.collate(@b).collate(@c)
-
-      collated[:a].assert == [1,1,1]
-      collated[:b].assert == [2,4,8]
-      collated[:c].assert == [9,27]
-    end
-
-  end
-
-  method :collate! do
-
-    test "in place variant of #collate" do
-      collated = @a.dup
-      collated.collate!(@b)
-
-      collated.keys.length.assert == 8
-
-      collated[:a].assert == [1,1]
-      collated[:b].assert == [2,4]
-      collated[:c].assert == [9]
-      collated[:z].assert == [26]
-
-      collated[:all].assert == %w|a b z a b c|
-      collated[:stuff1].assert == %w|foo bar|
-      collated[:stuff2].assert == %w|jim jam|
-      collated[:whee].assert == %w|a b a b|
-    end
-
-  end
-
-end
-

data/test/core/hash/test_count.rb

@@ -1,23 +0,0 @@
-covers 'facets/hash/count'
-
-test_case Hash do
-
-  method :count do
-
-    test do
-      {: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
-
-end
-

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,24 +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 == {:a=>1}
-      h.assert == {:b=>2,:c=>3}
-    end
-
-  end
-
-end