hashery 1.5.0 → 2.0.0

data/test/{case_keyhash.rb → case_key_hash.rb}

@@ -1,15 +1,17 @@
-require 'lemon'
-require 'ae'
-require 'ae/pry'
-
-require 'hashery/key_hash'
+require 'helper'
 
 testcase KeyHash do
 
   class_method :[] do
-    test 'class level fetch' do
+    test 'creates new KeyHash' do
+      s = KeyHash[]
+      KeyHash.assert === s
+    end
+
+    test 'pre-assigns values' do
       s = KeyHash[:a=>1, :b=>2]
-      assert(s)
+      s[:a].assert == 1
+      s[:b].assert == 2
     end
   end
 
@@ -18,6 +20,10 @@ testcase KeyHash do
       s = KeyHash[:a=>1, :b=>2]
       s[:a].assert == 1
       s[:b].assert == 2
+    end
+
+    test 'by default keys are converted to strings' do
+      s = KeyHash[:a=>1, :b=>2]
       s['a'].assert == 1
       s['b'].assert == 2
     end
@@ -97,7 +103,7 @@ testcase KeyHash do
       s1.to_h.assert == {'a'=>1,'b'=>2,'c'=>3,'d'=>4}
     end
   end
-require 'ae'
+
   method :rekey do
     test do
       s = KeyHash[:a=>1,:b=>2,:c=>3]
@@ -164,12 +170,12 @@ require 'ae'
     end
   end
 
-  method :convert_key do
-    test do
-      s = KeyHash.new
-      s.pry.convert_key(:a).assert == 'a'
-    end
-  end
+  #method :cast_key do
+  #  test do
+  #    s = KeyHash.new
+  #    s.send(:cast_key, :a).assert == 'a'
+  #  end
+  #end
 
 end
 

data/test/case_lru_hash.rb

@@ -0,0 +1,162 @@
+require 'helper'
+
+test_case LRUHash do
+
+  class_method :new do
+    h = LRUHash.new(10)
+    LRUHash.assert === h
+  end
+
+  method :max_size= do
+    test do
+      h = LRUHash.new(10)
+      h.max_size = 100
+    end
+  end
+
+  method :store do
+    test do
+      h = LRUHash.new(10)
+      h.store(:a, 1)
+      h[:a].assert == 1     
+    end
+  end
+
+  method :[] do
+    test do
+      h = LRUHash.new(10)
+      h.store(:a, 1)
+      h[:a].assert == 1
+    end
+
+    test do
+      h = LRUHash.new(10){ |h,k| h[k] = 0 }
+      h[:a].assert == 0
+    end
+  end
+
+  method :empty? do
+    test do
+      h = LRUHash.new(10)
+      h.assert.empty?
+    end
+  end
+
+  method :key do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h.key(1).assert == :a
+    end
+  end
+
+  method :keys do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h.keys.assert == [:a]
+    end
+  end
+
+  method :values do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h.values.assert == [1]
+    end
+  end
+
+  method :values_at do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h[:b] = 2
+      h.values_at(:a).assert == [1]
+    end
+  end
+
+  method :has_key? do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h.assert.has_key?(:a)
+    end
+  end
+
+  method :has_value? do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h.assert.has_value?(1)
+    end
+  end
+
+  method :assoc do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h[:b] = 2
+      h.assoc(:a).assert == [:a,1]
+    end
+  end
+
+  method :rassoc do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h[:b] = 2
+      h.rassoc(1).assert == [:a,1]
+    end
+  end
+
+  method :each_key do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h[:b] = 2
+      h.each_key do |k|
+        [:a,:b].assert.include?(k)
+      end
+    end
+  end
+
+  method :each_value do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h[:b] = 2
+      h.each_value do |v|
+        [1,2].assert.include?(v)
+      end
+    end
+  end
+
+  method :clear do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h[:b] = 2
+      h.clear
+      h.assert.empty?
+    end
+  end
+
+  method :delete do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h.delete(:a)
+      h.assert.empty?     
+    end
+  end
+
+  method :delete_if do
+    test do
+      h = LRUHash.new(10)
+      h[:a] = 1
+      h.delete_if{ |k,v| k == :a }
+      h.assert.empty?     
+    end
+  end
+
+end

data/test/{case_opencascade.rb → case_open_cascade.rb}

@@ -1,14 +1,10 @@
-require 'lemon'
-require 'ae'
-require 'ae/legacy' # bacause imitation BasicObject sucks
-
-require 'hashery/open_cascade'
+require 'helper'
 
 testcase OpenCascade do
   include AE::Legacy::Assertions
 
   class_method :new do
-    OpenCascade.new(:a=>1)
+    OpenCascade[:a=>1]
   end
 
   class_method :[] do
@@ -32,7 +28,7 @@ testcase OpenCascade do
     test "basic assignment" do
       o = OpenCascade.new
       o[:a] = 1
-      assert_equal(1, o.a)
+      assert_equal(1, o[:a])
     end
   end
 
@@ -64,8 +60,8 @@ testcase OpenCascade do
   method :merge! do
     test do
       o = OpenCascade[:f0=>"f0"]
-      h = { :h0=>"h0" }
       r = OpenCascade[:f0=>"f0", :h0=>"h0"]
+      h = { :h0=>"h0" }
       assert_equal(r, o.merge!(h))
       assert_equal({:f0=>"f0", :h0=>"h0"}, h.merge(o))
     end

data/test/case_open_hash.rb

@@ -0,0 +1,87 @@
+require 'helper'
+
+testcase OpenHash do
+
+  class_method :[] do
+    test do
+      o = OpenHash[:a=>1, :b=>2]
+      o.a.assert == 1
+      o.b.assert == 2
+    end
+
+    test do
+      o = OpenHash[:a=>1, :b=>2]
+      o.a.assert == 1
+      o.b.assert == 2
+    end
+  end
+
+  method :open? do
+    test do
+      o = OpenHash[:a=>1, :b=>2]
+      o.assert.open?(:foo)
+      o.refute.open?(:each)
+    end
+  end
+
+  method :open! do
+    test do
+      o = OpenHash[:a=>1, :b=>2]
+      o.open!(:each)
+      o.assert.open?(:each)
+      o.each = 10
+      o.each.assert == 10
+    end
+  end
+
+  method :close! do
+    test do
+      o = OpenHash[:a=>1, :b=>2]
+      o.open!(:each)
+      o.assert.open?(:each)
+      o.each = 10
+      o.each.assert == 10
+      o.close!(:each)
+      o.each.refute == 10
+    end
+  end
+
+  method :method_missing do
+    test 'bang method' do
+      o = OpenHash[]
+      o.open!(:each)
+      o.each = 10
+      o.each.assert == 10
+
+      a = []
+      o.each! do |k,v|
+        a << [k,v]
+      end
+      a.assert == [[:each,10]]
+    end
+
+    test 'query method' do
+      o = OpenHash[]
+      o.a = 1
+      o.assert.a?
+      o.refute.b?
+    end
+  end
+
+  method :send do
+    test do
+      o = OpenHash[]
+      o.open!(:each)
+      o.each = 10
+      o.each.assert == 10
+
+      a = []
+      o.send(:each) do |k,v|
+        a << [k,v]
+      end
+      a.assert == [[:each,10]]
+    end
+  end
+
+end
+

data/test/case_query_hash.rb

@@ -0,0 +1,226 @@
+require 'helper'
+
+testcase QueryHash do
+
+  class_method :new do
+    test 'new QueryHash with default proc' do
+      q = QueryHash.new{ |h,k| h[k] = 1 }
+      q[:a].assert == 1
+    end
+  end
+
+  class_method :[] do
+    test 'creates new QueryHash' do
+      s = QueryHash[]
+      QueryHash.assert === s
+    end
+
+    test 'pre-assigns values' do
+      s = QueryHash[:a=>1, :b=>2]
+      s[:a].assert == 1
+      s[:b].assert == 2
+    end
+  end
+
+  method :[] do
+    test 'instance level fetch' do
+      s = QueryHash[:a=>1, :b=>2]
+      s[:a].assert == 1
+      s[:b].assert == 2
+      #s['a'].assert == 1
+      #s['b'].assert == 2
+    end
+  end
+
+  method :[]= do
+    test do
+      s = QueryHash.new
+      s[:a] = 1
+      s[:b] = 2
+      s[:a].assert == 1
+      s[:b].assert == 2
+      #s['a'].assert == 1
+      #s['b'].assert == 2
+    end
+  end
+
+  method :respond_to? do
+    test 'responds to all query methods' do
+      q = QueryHash.new
+      q.assert.respond_to?(:anything?)
+    end
+
+    test 'responds to all bang methods' do
+      q = QueryHash.new
+      q.assert.respond_to?(:anything!)
+    end
+
+    test 'responds to all setter methods' do
+      q = QueryHash.new
+      q.assert.respond_to?(:anything=)
+    end
+
+    test 'responds to usual methods' do
+      q = QueryHash.new
+      q.assert.respond_to?(:each)
+    end
+  end
+
+  method :to_hash do
+    test do
+      s = QueryHash[:a=>1, :b=>2]
+      s.to_hash.assert == {'a'=>1, 'b'=>2}
+    end
+  end
+
+  method :to_h do
+   test do
+      s = QueryHash[:a=>1, :b=>2]
+      s.to_h.assert == {'a'=>1, 'b'=>2}
+    end
+  end
+
+  method :replace do
+    test do
+      s = QueryHash.new
+      s.replace(:a=>1, :b=>2)
+      s.to_h.assert == {'a'=>1, 'b'=>2}
+    end
+  end
+
+  method :delete do
+    test do
+      s = QueryHash[:a=>1, :b=>2]
+      s.delete(:a)
+      s.to_h.assert == {'b'=>2}
+    end
+  end
+
+  method :each do
+    test do
+      s = QueryHash[:a=>1, :b=>2]
+      s.each do |k,v|
+        String.assert === k
+      end
+    end
+  end
+
+  method :store do
+    test do
+      s = QueryHash.new
+      s.store(:a, 1)
+      s.to_h.assert == {'a'=>1}
+    end
+  end
+
+  method :update do
+    test do
+      s1 = QueryHash[:a=>1,:b=>2]
+      s2 = QueryHash[:c=>3,:d=>4]
+      s1.update(s2)
+      s1.to_h.assert == {'a'=>1,'b'=>2,'c'=>3,'d'=>4}
+    end
+  end
+
+  method :rekey do
+    test do
+      s = QueryHash[:a=>1,:b=>2,:c=>3]
+      x = s.rekey{ |k| k.upcase }
+      x.to_h.assert == {'A'=>1,'B'=>2,'C'=>3}
+    end
+  end
+
+  method :rekey! do
+    test do
+      s = QueryHash[:a=>1,:b=>2,:c=>3]
+      s.rekey!{ |k| k.upcase }
+      s.to_h.assert == {'A'=>1,'B'=>2,'C'=>3}
+    end
+  end
+
+  method :key? do
+    test do
+      s = QueryHash[:a=>1]
+      s.assert.key?(:a)
+      s.assert.key?('a')
+    end
+  end
+
+  method :has_key? do
+    test do
+      s = QueryHash[:a=>1]
+      s.assert.has_key?(:a)
+      s.assert.has_key?('a')
+    end
+  end
+
+  method :<< do
+    test do
+      s = QueryHash.new
+      s << [:a, 1]
+      s << [:b, 2]
+      s.to_h.assert == {'a'=>1, 'b'=>2}
+    end
+  end
+
+  method :merge! do
+    test do
+      s1 = QueryHash[:a=>1,:b=>2]
+      s2 = QueryHash[:c=>3,:d=>4]
+      s1.merge!(s2)
+      s1.to_h.assert == {'a'=>1,'b'=>2,'c'=>3,'d'=>4}
+    end
+  end
+
+  method :values_at do
+    test do
+      s = QueryHash[:a=>1,:b=>2,:c=>3]
+      s.values_at(:a, :b).assert == [1,2]
+      s.values_at('a','b').assert == [1,2]
+    end
+  end
+
+  method :fetch do
+    test do
+      s = QueryHash[:a=>1,:b=>2,:c=>3]
+      s.fetch(:a).assert == 1
+      s.fetch('a').assert == 1
+    end
+  end
+
+  method :cast_key do
+    test do
+      s = QueryHash.new
+      s.pry.cast_key(:a).assert == 'a'
+    end
+  end
+
+  method :method_missing do
+    test 'dynamic query methods can look-up values' do
+      q = QueryHash[:a=>1,:b=>2,:c=>3]
+      q.a?.assert == 1
+      q.b?.assert == 2
+      q.c?.assert == 3
+    end
+
+    test 'dynamic bang methods can looks up values too' do
+      q = QueryHash[:a=>1,:b=>2,:c=>3]
+      q.a!.assert == 1
+      q.b!.assert == 2
+      q.c!.assert == 3
+    end
+
+    test 'dynamic bang methods will auto-instantiate' do
+      q = QueryHash.new
+      q.default_proc{ |h,k| h[k] = 'default' }
+      q.foo!.assert == 'default'
+    end
+
+    test 'dynamic query methods will NOT auto-instantiate' do
+      q = QueryHash.new
+      q.default_proc{ |h,k| h[k] = 'default' }
+      q.foo?.assert == nil
+    end
+  end
+
+end