hashery 1.4.0 → 1.5.0

data/test/case_openobject.rb

@@ -1,130 +0,0 @@
-require 'hashery/openobject'
-
-TestCase OpenObject do
-
-  Unit :respond_to? do
-    o = OpenObject.new
-    assert{ o.respond_to?(:key?) }
-  end
-
-  Unit :is_a? do
-    assert OpenObject[{}].is_a?(Hash)
-    assert OpenObject[{}].is_a?(OpenObject)
-  end
-
-  Unit :[] => "subhash access" do
-    o = OpenObject[:a=>1,:b=>{:x=>9}]
-    assert{ o[:b][:x] == 9 }
-    assert{ o.b[:x] == 9 }
-  end
-
-  Unit :[] => "indifferent key access" do
-    o = OpenObject["a"=>1,"b"=>{:x=>9}]
-    assert{ o["a"] == 1 }
-    assert{ o[:a] == 1 }
-    assert{ o["b"] == {:x=>9} }
-    assert{ o[:b] == {:x=>9} }
-    assert{ o["b"][:x] == 9 }
-    assert{ o[:b]["x"] == nil }
-  end
-
-  Unit :[]= => "setting first entry" do
-    f0 = OpenObject.new
-    f0[:a] = 1
-    assert{ f0.to_h == {:a=>1} }
-  end
-
-  Unit :[]= => "setting an additional entry" do
-    f0 = OpenObject[:a=>1]
-    f0[:b] = 2
-    assert{ f0.to_h == {:a=>1,:b=>2} }
-  end
-
-  Unit :method_missing => "reading entries" do
-    f0 = OpenObject[:class=>1]
-    assert{ f0.class  == 1 }
-  end
-
-  Unit :method_missing => "setting entries" do
-    fo = OpenObject.new
-    9.times{ |i| fo.__send__("n#{i}=", 1) }
-    9.times{ |i|
-      assert( fo.__send__("n#{i}") == 1 )
-    }
-  end
-
-  Unit :method_missing => "using bang" do
-    o = OpenObject.new
-    o.a = 10
-    o.b = 20
-    h = {}
-    o.each!{ |k,v| h[k] = v + 10 }
-    assert( h == {:a=>20, :b=>30} )
-  end
-
-  #Unit :as_hash do
-  #  f0 = OpenObject[:f0=>"f0"]
-  #  h0 = { :h0=>"h0" }
-  #  assert{ OpenObject[:f0=>"f0", :h0=>"h0"] == f0.as_hash.merge(h0) }
-  #  assert{  {:f0=>"f0", :h0=>"h0"} == h0.merge(f0) }
-  #end
-
-  Unit :as_hash do
-    f1 = OpenObject[:f1=>"f1"]
-    h1 = { :h1=>"h1" }
-    f1.as_hash.update(h1)
-    h1.update(f1)
-    assert{ f1 == OpenObject[:f1=>"f1", :h1=>"h1"] }
-    assert{ h1 == {:f1=>"f1", :h1=>"h1"} }
-  end
-
-  Unit :<< => "passing a hash" do
-    fo = OpenObject.new
-    fo << {:a=>1,:b=>2}
-    assert{ fo.to_h == {:a=>1, :b=>2} }
-  end
-
-  Unit :<< => "passing a pair" do
-    fo = OpenObject.new
-    fo << [:a, 1]
-    fo << [:b, 2]
-    assert( fo.to_h == {:a=>1, :b=>2} )
-  end
-
-  Unit :to_h do
-    ho = {}
-    fo = OpenObject.new
-    5.times{ |i| ho["n#{i}".to_sym] = 1 }
-    5.times{ |i| fo.__send__("n#{i}=", 1) }
-    assert{ fo.to_h == ho  }
-  end
-
-  Unit :to_h => "OpenObject within OpenObject" do
-    o = OpenObject.new
-    o.a = 10
-    o.b = 20
-    o.x = OpenObject.new
-    o.x.a = 100
-    o.x.b = 200
-    o.x.c = 300
-    assert{ o.to_h == {:a=>10, :b=>20, :x=>{:a=>100, :b=>200, :c=>300}} }
-  end
-
-  Unit :to_proc do
-    p = lambda { |x| x.word = "Hello" }
-    o = OpenObject[:a=>1,:b=>2]
-    assert{ Proc === o.to_proc }
-  end
-
-end
-
-TestCase Proc do
-
-  Unit :to_openobject do
-    p = lambda { |x| x.word = "Hello" }
-    o = p.to_openobject
-    assert{ o.word == "Hello" }
-  end
-
-end
-

data/test/case_sparsearray.rb

@@ -1,316 +0,0 @@
-require 'hashery/sparsearray'
-require 'ae/legacy'
-
-# This is a mostly complete testcase for SparseArray.
-# SparseArray is tested by comparison to standard Array.
-
-Case SparseArray do
-
-  def aha(a)
-    return a, SparseArray[*a]
-  end
-
-  Unit :to_ary do
-    a, ha = aha [1,3,'a',8,nil,[1]]
-    assert_equal(ha, ha.to_ary)  # these need to be opposite
-  end
-
-  Unit :to_a do
-    a, ha = aha [1,3,'a',8,nil,[1]]
-    assert_equal(a, ha.to_a)     #
-    assert_equal(a.to_s, ha.to_s)
-  end
-
-  Unit :to_s do
-    a, ha = aha [1,3,'a',8,nil,[1]]
-    assert_equal(a.to_s, ha.to_s)
-  end
-
-  Unit :|, :&, :+, :- do
-    a, ha = aha [1,3,5,8,9]
-    b, hb = aha [2,3,6,8,9]
-    assert_equal(a | b, (ha | hb).to_a)
-    assert_equal(a & b, (ha & hb).to_a)
-    assert_equal(a + b, (ha + hb).to_a)
-    assert_equal(a - b, (ha - hb).to_a)
-  end
-
-  Unit :* do
-    a, ha = aha [1,3]
-    assert_equal(a*3,(ha*3).to_a)
-  end
-
-  Unit :[]= do
-    a, ha = aha [1,2,3,4]
-    a[1..2] = [8,9]
-    ha[1..2] = [8,9]
-    assert_equal(a, ha.to_a)
-  end
-
-  Unit :assoc do
-    a, ha = aha [[1,2],[3,4],[3,6]]
-    assert_equal(a.assoc(3), ha.assoc(3).to_a)
-  end
-
-  Unit :at do
-    a, ha = aha [4,5,6,6]
-    assert_equal(a.at(0), ha.at(0))
-    assert_equal(a.at(2), ha.at(2))
-    assert_equal(a.at(4), ha.at(4))
-    assert_equal(a.at(9), ha.at(9))
-    assert_equal(a.at(-1), ha.at(-1))
-    assert_equal(a.at(-3), ha.at(-3))
-    assert_equal(a.at(-4), ha.at(-4))
-    assert_equal(a.at(-5), ha.at(-5))
-  end
-
-  Unit :collect do
-    a, ha = aha [4,5,6,6]
-    assert_equal(a.collect{|e|e}, ha.collect{|e|e}.to_a)
-    assert_equal(a.collect!{|e|e}, ha.collect!{|e|e}.to_a)
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :compact do
-    a, ha = aha [4,nil,5,nil,6]
-    assert_equal(a.compact, ha.compact.to_a)
-  end
-
-  Unit :concat do
-    a, ha = aha [1,3,5,8,9]
-    b, hb = aha [2,3,6,8,9]
-    assert_equal(a.concat(b),ha.concat(hb).to_a)
-  end
-
-  Unit :count do
-    ha = SparseArray[9,3,9,5,nil,nil,9,3]
-    assert_equal(2,ha.count)
-    assert_equal(2,ha.count(3))
-    assert_equal(3,ha.count{|e|e==9})
-  end
-
-  Unit :delete do
-    a, ha = aha [1,3,5,8,9,'a','b','c','c','d']
-    # test delete
-    assert_equal(a.delete(1),ha.delete(1))
-    assert_equal(a,ha.to_a)
-    assert_equal(a.delete('a'),ha.delete('a'))
-    assert_equal(a,ha.to_a)
-    # test delete_at
-    assert_equal(a.delete_at(0),ha.delete_at(0))
-    assert_equal(a,ha.to_a)
-    # test delete_if
-    assert_equal(a.delete_if{|v|v=='c'},ha.delete_if{|v|v=='c'}.to_a)
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :each do
-    a, ha = aha [4,'a',nil,'b']
-    # test each
-    ca, cha = '', ''
-    a.each{|e| ca += e.to_s}
-    ha.each{|e| cha += e.to_s}
-    assert_equal(ca,cha)
-    assert_equal(a,ha.to_a)
-    # test each_index
-    ca, cha = '', ''
-    a.each_index{|i| ca += i.to_s}
-    ha.each_index{|i| cha += i.to_s}
-    assert_equal(ca,cha)
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :eql? do
-    a, ha = aha [4,'a',nil,'b']
-    b, hb = aha [4,'a',nil,'b']
-    assert_equal(a,b)
-    assert_equal(ha,hb)
-    assert_equal(a.eql?(b),ha.eql?(hb))
-    assert_equal(b.eql?(a),hb.eql?(ha))
-    assert(ha.eql?(hb))
-    assert(hb.eql?(ha))
-  end
-
-  Unit :empty? do
-    a, ha = aha []
-    assert_equal(a.empty?,ha.empty?)
-    a, ha = aha [1,2,3]
-    assert_equal(a.empty?,ha.empty?)
-  end
-
-  Unit :fill do
-    a, ha = aha ['a','b','c','d']
-    assert_equal(a.fill('x'),ha.fill('x').to_a)
-    assert_equal(a,ha.to_a)
-    assert_equal(a.fill('y',2,2),ha.fill('y',2,2).to_a)
-    assert_equal(a,ha.to_a)
-    assert_equal(a.fill('z',0..1),ha.fill('z',0..1).to_a)
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :first do
-    a, ha = aha [2,3,4]
-    assert_equal(a.first,ha.first)
-  end
-
-  Unit :flatten do
-    a, ha = aha [2,[3],'a',[[1,2],4],nil,5]
-    assert_equal(a.flatten,ha.flatten.to_a)
-    a, ha = aha [2,[3],'a',[[1,2],4],nil,5]
-    assert_equal(a.flatten!,ha.flatten!.to_a)
-    assert_equal(a,ha.to_a)
-    a, ha = aha [2,3,'a',nil,5]
-    assert_equal(a.flatten!,ha.flatten!)
-  end
-
-  Unit :include? do
-    a, ha = aha ['a','b','c','d']
-    assert_equal(a.include?('b'),ha.include?('b'))
-    assert_equal(a.include?('x'),ha.include?('x'))
-  end
-
-  Unit :index do
-    a, ha = aha ['a','b','b','c','d']
-    assert_equal(a.index('b'),ha.index('b'))
-    assert_equal(a.index('x'),ha.index('x'))
-  end
-
-  Unit :join do
-    a, ha = aha [2,3,4]
-    assert_equal(a.join,ha.join)
-    assert_equal(a.join(','),ha.join(','))
-  end
-
-  Unit :last do
-    a, ha = aha [2,3,4]
-    assert_equal(a.last,ha.last)
-  end
-
-  Unit :length do
-    a, ha = aha [2,3,4]
-    assert_equal(a.length,ha.length)
-  end
-
-  Unit :map! do
-    a, ha = aha [4,5,6,6]
-    assert_equal(a.map!{|e|e}, ha.map!{|e|e}.to_a)
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :nitems do
-    a, ha = aha [4,5,nil,6,nil]
-    assert_equal(a.nitems, ha.nitems)
-  end
-
-  Unit :pop do
-    a, ha = aha [4,5,nil,6,nil]
-    assert_equal(a.pop, ha.pop)
-    assert_equal(a, ha.to_a)
-    assert_equal(a.pop, ha.pop)
-    assert_equal(a, ha.to_a)
-  end
-
-  Unit :push do
-    a, ha = aha [4,5,nil,6,nil]
-    args = [1,2,3]
-    assert_equal(a.push(*args), ha.push(*args).to_a)
-    assert_equal(a, ha.to_a)
-  end
-
-  Unit :rassoc do
-    a, ha = aha [[1,2],[1,3],[1,3]]
-    assert_equal(a.rassoc(3), ha.rassoc(3).to_a)
-  end
-
-  Unit :reject! do
-    a, ha = aha ['a','b','c','c','d']
-    assert_equal(a.reject!{|v|v=='c'},ha.reject!{|v|v=='c'}.to_a)
-    assert_equal(a,ha.to_a)
-    assert_equal(a.reject!{|v|v=='x'},ha.reject!{|v|v=='x'})
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :reverse do
-    a, ha = aha ['a','b','c','c','d']
-    assert_equal(a.reverse,ha.reverse.to_a)
-    assert_equal(a.reverse!,ha.reverse!.to_a)
-    assert_equal(a,ha.to_a)
-    a, ha = aha [1,2,3,'a','b','c']
-    assert_equal(a.reverse!,ha.reverse!.to_a)
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :reverse_each do
-    a, ha = aha [4,'a',nil,'b']
-    # test each
-    ca, cha = '', ''
-    a.reverse_each{|e| ca += e.to_s}
-    ha.reverse_each{|e| cha += e.to_s}
-    assert_equal(ca,cha)
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :rindex do
-    a, ha = aha ['a','b','c','c','d']
-    assert_equal(a.rindex('c'),ha.rindex('c'))
-    assert_equal(a.rindex('x'),ha.rindex('x'))
-  end
-
-  Unit :shift do
-    a, ha = aha ['a','b','c','c','d']
-    assert_equal(a.shift,ha.shift)
-    assert_equal(a,ha.to_a)
-  end
-
-  Unit :slice do
-    a, ha = aha [1,2,3,4]
-    # test []
-    assert_equal(a[1], ha[1])
-    assert_equal(a[1..2], ha[1..2].to_a)
-    assert_equal(a[1...2], ha[1...2].to_a)
-    assert_equal(a[1..7], ha[1..7].to_a)
-    assert_equal(a[1,2], ha[1,2].to_a)
-    # test slice
-    assert_equal(a.slice(1), ha.slice(1))
-    assert_equal(a.slice(1..2), ha.slice(1..2).to_a)
-    assert_equal(a.slice(1...2), ha.slice(1...2).to_a)
-    assert_equal(a.slice(1...2), ha.slice(1...2).to_a)
-    assert_equal(a.slice(1,2), ha.slice(1,2).to_a)
-    # test slice!
-    assert_equal(a.slice!(1..2), ha.slice!(1..2).to_a)
-    assert_equal(a, ha.to_a)
-  end
-
-  Unit :sort do
-    a, ha = aha [1,2,3,4]
-    # test sort
-    assert_equal(a.sort, ha.sort.to_a)
-    #assert_equal(a.sort{|x,y| y<=>x}, ha.sort{|x,y| y<=>x}.to_a)
-    # test sort!
-    assert_equal(a.sort!, ha.sort!.to_a)
-    assert_equal(a, ha.to_a)
-  end
-
-  Unit :uniq do
-    a, ha = aha [1,1,2,3,3,4,5,6,6]
-    assert_equal(a.uniq, ha.uniq.to_a)
-  end
-
-  Unit :uniq! do
-    a, ha = aha [1,1,2,3,3,4,5,6,6]
-    a.uniq!; ha.uniq!
-    assert_equal(a, ha.to_a)
-  end
-
-  Unit :values_at do
-    a, ha = aha ['a','b','c','d']
-    assert_equal(a.values_at(1,3),ha.values_at(1,3).to_a)
-  end
-
-  Unit :unshift do
-    a, ha = aha ['a','b','c','c','d']
-    assert_equal(a.unshift('x'),ha.unshift('x').to_a)
-    assert_equal(a,ha.to_a)
-  end
-end
-

data/test/case_stash.rb

@@ -1,131 +0,0 @@
-require 'hashery/stash'
-
-TestCase Stash do
-
-  Unit :[] => 'class level fetch' do
-    s = Stash[:a=>1, :b=>2]
-    assert(s)
-  end
-
-  Unit :[] => 'instance level fetch' do
-    s = Stash[:a=>1, :b=>2]
-    s[:a].assert == 1
-    s[:b].assert == 2
-    s['a'].assert == 1
-    s['b'].assert == 2
-  end
-
-  Unit :[]= => '' do
-    s = Stash.new
-    s[:a] = 1
-    s[:b] = 2
-    s[:a].assert == 1
-    s[:b].assert == 2
-    s['a'].assert == 1
-    s['b'].assert == 2
-  end
-
-  Unit :initialize do
-    s = Stash.new
-    assert(s)
-  end
-
-  Unit :to_hash do
-    s = Stash[:a=>1, :b=>2]
-    s.to_hash.assert == {'a'=>1, 'b'=>2}
-  end
-
-  Unit :to_h do
-    s = Stash[:a=>1, :b=>2]
-    s.to_h.assert == {'a'=>1, 'b'=>2}
-  end
-
-  Unit :replace do
-    s = Stash.new
-    s.replace(:a=>1, :b=>2)
-    s.to_h.assert == {'a'=>1, 'b'=>2}
-  end
-
-  Unit :delete do
-    s = Stash[:a=>1, :b=>2]
-    s.delete(:a)
-    s.to_h.assert == {'b'=>2}
-  end
-
-  Unit :each do
-    s = Stash[:a=>1, :b=>2]
-    s.each do |k,v|
-      String.assert === k
-    end
-  end
-
-  Unit :store => '' do
-    s = Stash.new
-    s.store(:a, 1)
-    s.to_h.assert == {'a'=>1}
-  end
-
-  Unit :update => '' do
-    s1 = Stash[:a=>1,:b=>2]
-    s2 = Stash[:c=>3,:d=>4]
-    s1.update(s2)
-    s1.to_h.assert == {'a'=>1,'b'=>2,'c'=>3,'d'=>4}
-  end
-
-  Unit :rekey => '' do
-    s = Stash[:a=>1,:b=>2,:c=>3]
-    x = s.rekey{ |k| k.upcase }
-    x.to_h.assert == {'A'=>1,'B'=>2,'C'=>3}
-  end
-
-  Unit :rekey! => '' do
-    s = Stash[:a=>1,:b=>2,:c=>3]
-    s.rekey!{ |k| k.upcase }
-    s.to_h.assert == {'A'=>1,'B'=>2,'C'=>3}
-  end
-
-  Unit :key? => '' do
-    s = Stash[:a=>1]
-    s.assert.key?(:a)
-    s.assert.key?('a')
-  end
-
-  Unit :has_key? => '' do
-    s = Stash[:a=>1]
-    s.assert.has_key?(:a)
-    s.assert.has_key?('a')
-  end
-
-  Unit :<< => '' do
-    s = Stash.new
-    s << [:a, 1]
-    s << [:b, 2]
-    s.to_h.assert == {'a'=>1, 'b'=>2}
-  end
-
-  Unit :merge! => '' do
-    s1 = Stash[:a=>1,:b=>2]
-    s2 = Stash[:c=>3,:d=>4]
-    s1.merge!(s2)
-    s1.to_h.assert == {'a'=>1,'b'=>2,'c'=>3,'d'=>4}
-  end
-
-  Unit :values_at => '' do
-    s = Stash[:a=>1,:b=>2,:c=>3]
-    s.values_at(:a, :b).assert == [1,2]
-    s.values_at('a','b').assert == [1,2]
-  end
-
-  Unit :fetch => '' do
-    s = Stash[:a=>1,:b=>2,:c=>3]
-    s.fetch(:a).assert == 1
-    s.fetch('a').assert == 1
-  end
-
-  Unit :convert_key => '' do
-    s = Stash.new
-    s.pry.convert_key(:a).assert == 'a'
-  end
-
-end
-