kissifer-hash-persistent 0.2.2 → 0.3.1

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "hash-persistent"
-    gem.summary = %Q{Library of base classes to simplify persisting objects in a moneta store}
+    gem.summary = %Q{Library of base classes to simplify persisting objects and collections to a moneta store}
     gem.email = "tierneydrchris@gmail.com"
     gem.homepage = "http://github.com/kissifer/hash-persistent"
     gem.authors = ["kissifer"]

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.1

data/hash-persistent.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hash-persistent}
-  s.version = "0.2.2"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["kissifer"]
-  s.date = %q{2009-06-02}
+  s.date = %q{2009-06-04}
   s.email = %q{tierneydrchris@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -33,8 +33,8 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/kissifer/hash-persistent}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.3}
-  s.summary = %q{Library of base classes to simplify persisting objects in a moneta store}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Library of base classes to simplify persisting objects and collections to a moneta store}
   s.test_files = [
     "spec/collection_spec.rb",
      "spec/counter_spec.rb",

data/lib/hash-persistent/collection.rb

@@ -2,18 +2,21 @@ module HashPersistent
   module Collection
     
     def self.included(base)
-      base.extend ClassMethods
+      base.extend ClassMethods_Initial
       base.module_eval do
         include HashPersistent::Resource
       end
     end
     
-    module ClassMethods
-      attr_reader :resource_class
-      
+    module ClassMethods_Initial      
       def attach(resource_class, collection_basis)
-        raise ArgumentError unless resource_class.included_modules.include?(HashPersistent::Resource)
-        raise ArgumentError unless resource_class.instance_methods.include?(collection_basis.to_s)
+        raise "You must create a persistent subclass before attaching this collection class. Use HashPersistent::persist_to()" unless included_modules.include?(HashPersistent::Resource::InstanceMethods)
+        raise "You can attach this collection class only to a class that has been created with HashPersistent::Resource.persist_to()" unless resource_class.included_modules.include?(HashPersistent::Resource::InstanceMethods)
+        raise "Did not find the specified basis attribute (#{collection_basis}) in the given resource class" unless resource_class.instance_methods.include?(collection_basis.to_s)
+        
+        extend  ClassMethods
+        include InstanceMethods
+
         @collection_basis = collection_basis
         @resource_class = resource_class
         resource_class.on_save do |resource|
@@ -24,6 +27,10 @@ module HashPersistent
           collected_resource_deleted(resource)
         end
       end
+    end
+
+    module ClassMethods
+      attr_reader :resource_class
       
       def collected_resource_saved(resource)
         collection = find(resource.send(@collection_basis))
@@ -48,11 +55,13 @@ module HashPersistent
       end
     end
     
-    attr_accessor :collected_keys
+    module InstanceMethods
+      attr_accessor :collected_keys
     
-    def collected_resources
-      collected_keys.collect do |key|
-        self.class.resource_class.send(:find, key)
+      def collected_resources
+        collected_keys.collect do |key|
+          self.class.resource_class.send(:find, key)
+        end
       end
     end
   end

data/lib/hash-persistent/resource.rb

@@ -1,24 +1,29 @@
 module HashPersistent
   module Resource
     def self.included(base)
-      base.extend ClassMethods
-      base.module_eval do
-        @store = {}
-        @prefix = ""
-      end
+      base.extend ClassMethods_Initial
     end
-    
-    module ClassMethods
+
+    module ClassMethods_Initial
       def persist_to(store, prefix)
         raise ArgumentError unless store.respond_to?(:has_key?) and prefix.respond_to?(:to_s)
-        @store = store
-        @prefix = prefix
+        Class.new(self) do
+          extend  ClassMethods
+          include InstanceMethods
+
+          @store  = store
+          @prefix = prefix
+        end
       end
+    end
     
+    module ClassMethods
+      attr_reader :store, :prefix
+      
       def find(key)
         @store[@prefix + key]
       end
-      
+
       def on_save(&block)
         if block
           @on_save = block
@@ -33,30 +38,30 @@ module HashPersistent
         else
           @on_delete
         end
-      end
-    
-      attr_reader :store, :prefix
+      end          
     end
+    
+    module InstanceMethods
+      attr_accessor :key
 
-    attr_accessor :key
-
-    def prefix_key
-      self.class.prefix + key
-    end
+      def prefix_key
+        self.class.prefix + key
+      end
 
-    def save
-      raise RuntimeError unless key
-      self.class.store[prefix_key] = self
-      self.class.on_save.call(self) if self.class.on_save
-    end
+      def save
+        raise RuntimeError unless key
+        self.class.store[prefix_key] = self
+        self.class.on_save.call(self) if self.class.on_save
+      end
 
-    def delete
-      raise RuntimeError unless key
-      return unless self.class.store.has_key?(prefix_key)
-      # TODO concurrency here, the store's delete call should cope, but we don't want the callback if something else got in first?
-      # Alternative: ensure that callback handles this case, which is true of HashPersistent::Collection
-      self.class.store.delete(prefix_key)
-      self.class.on_delete.call(self) if self.class.on_delete
+      def delete
+        raise RuntimeError unless key
+        return unless self.class.store.has_key?(prefix_key)
+        # TODO concurrency here, the store's delete call should cope, but we don't want the callback if something else got in first?
+        # Alternative: ensure that callback handles this case, which is true of HashPersistent::Collection
+        self.class.store.delete(prefix_key)
+        self.class.on_delete.call(self) if self.class.on_delete
+      end
     end
   end
 end

data/spec/collection_spec.rb

@@ -13,130 +13,154 @@ class NotAResource
 end
 
 describe "A class that includes HashPersistent::Collection" do
-  it "should include the HashPersistent::Resource module" do
-    CollectionFoo.included_modules.should include (HashPersistent::Resource)
-  end
+  context "(before made persistent)" do
+    it "should include the HashPersistent::Resource module" do
+      CollectionFoo.included_modules.should include (HashPersistent::Resource)
+    end
 
-  it "should allow itself to be attached to another HashPersistent::Resource, specifying an attribute/method for the collection basis" do
-    lambda{CollectionFoo.attach(CollectedResource, :basis)}.should_not raise_error
+    it "should not allow itself to be attached to a persistent HashPersistent::Resource until it has been made persistent" do
+      lambda{CollectionFoo.attach(CollectedResource.persist_to({}, ""), :basis)}.should raise_error
+    end
   end
 
-  it "should not attach to the wrong class type" do
-    lambda{CollectionFoo.attach(NotAResource, :basis)}.should raise_error
-    lambda{CollectionFoo.attach(1, :basis)}.should raise_error
-  end
+  context "(once made persistent via the persist_to method)" do
+    it "should not add methods, except attach(), before attached to another persisted resource" do
+      # Grey-box here...
+      CollectionFoo.persist_to({}, "").respond_to?(:resource_class).should be_false
+      CollectionFoo.persist_to({}, "").respond_to?(:collected_resource_saved).should be_false
+      CollectionFoo.persist_to({}, "").respond_to?(:collected_resource_deleted).should be_false
+
+      CollectionFoo.persist_to({}, "").new.respond_to?(:collected_keys).should be_false
+      CollectionFoo.persist_to({}, "").new.respond_to?(:collected_resources).should be_false
+      CollectionFoo.persist_to({}, "").new.respond_to?(:collected_resources).should be_false
+    end
+    
+    it "should not attach to the wrong class type" do
+      lambda{CollectionFoo.attach(NotAResource, :basis)}.should raise_error
+      lambda{CollectionFoo.attach(1, :basis)}.should raise_error
+    end
+
+    it "should not allow itself to be attached to an un-persisted HashPersistent::Resource" do
+      lambda{CollectionFoo.attach(CollectedResource, :basis)}.should raise_error
+    end
+
 
-  it "should verify a valid collection basis" do
-    lambda{CollectionFoo.attach(CollectedResource)}.should raise_error
-    lambda{CollectionFoo.attach(CollectedResource, :not_a_valid_attr)}.should raise_error
+    it "should allow itself to be attached to a persisted HashPersistent::Resource, specifying an attribute/method for the collection basis" do
+      lambda{CollectionFoo.persist_to({}, "").attach(CollectedResource.persist_to({}, ""), :basis)}.should_not raise_error
+    end
+
+    it "should verify a valid collection basis" do
+      lambda{CollectionFoo.persist_to({}, "").attach(CollectedResource.persist_to({}, ""))}.should raise_error
+      lambda{CollectionFoo.persist_to({}, "").attach(CollectedResource.persist_to({}, ""), :not_a_valid_attr)}.should raise_error
+    end
   end
   
   context "(when attached resources are saved/deleted)" do
     it "should create a collection for a new basis" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
-      CollectionFoo.find("the_basis").should == nil
+      collection_class.attach(resource_class, :basis)
+      collection_class.find("the_basis").should == nil
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "fred"
       resource.save
 
-      CollectionFoo.find("the_basis").should_not == nil
+      collection_class.find("the_basis").should_not == nil
     end
 
     it "should report keys saved/added to the collection" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
+      collection_class.attach(resource_class, :basis)
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "fred"
       resource.save
 
-      CollectionFoo.find("the_basis").collected_keys.should == ["fred"]
+      collection_class.find("the_basis").collected_keys.should == ["fred"]
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "barney"
       resource.save
 
-      CollectionFoo.find("the_basis").collected_keys.should == ["fred", "barney"]
+      collection_class.find("the_basis").collected_keys.should == ["fred", "barney"]
     end
 
     it "should not duplicate keys when a resource is saved multiple times" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
+      collection_class.attach(resource_class, :basis)
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "fred"
       resource.save
       resource.save
 
-      CollectionFoo.find("the_basis").collected_keys.should == ["fred"]
+      collection_class.find("the_basis").collected_keys.should == ["fred"]
     end
 
     it "should not report keys with the wrong basis" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
+      collection_class.attach(resource_class, :basis)
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "one_basis"
       resource.key = "fred"
       resource.save
 
-      CollectionFoo.find("another_basis").should == nil
+      collection_class.find("another_basis").should == nil
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "another_basis"
       resource.key = "barney"
       resource.save
 
-      CollectionFoo.find("one_basis").collected_keys.should == ["fred"]
-      CollectionFoo.find("another_basis").collected_keys.should == ["barney"]
+      collection_class.find("one_basis").collected_keys.should == ["fred"]
+      collection_class.find("another_basis").collected_keys.should == ["barney"]
     end
 
     it "should remove the key when a resource is deleted" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
+      collection_class.attach(resource_class, :basis)
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "fred"
       resource.save
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "barney"
       resource.save
       resource.delete
 
-      CollectionFoo.find("the_basis").collected_keys.should == ["fred"]
+      collection_class.find("the_basis").collected_keys.should == ["fred"]
     end
 
     it "should not complain when a not-present key is removed (either not added, or deleted twice)" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
+      collection_class.attach(resource_class, :basis)
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "fred"
       resource.save
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "barney"
 
@@ -146,16 +170,16 @@ describe "A class that includes HashPersistent::Collection" do
       resource.delete
       lambda{resource.delete}.should_not raise_error
 
-      CollectionFoo.find("the_basis").collected_keys.should == ["fred"]
+      collection_class.find("the_basis").collected_keys.should == ["fred"]
     end
 
     it "should not complain when a resource with an unknown basis is removed" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
+      collection_class.attach(resource_class, :basis)
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "fred"
 
@@ -163,46 +187,46 @@ describe "A class that includes HashPersistent::Collection" do
     end
 
     it "should remove the collection when its final key is removed" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
+      collection_class.attach(resource_class, :basis)
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "fred"
       resource.save
 
-      resource = CollectedResource.new
+      resource = resource_class.new
       resource.basis = "the_basis"
       resource.key = "barney"
       resource.save
 
-      CollectedResource.find("fred").delete
-      CollectedResource.find("barney").delete
+      resource_class.find("fred").delete
+      resource_class.find("barney").delete
 
-      CollectionFoo.find("the_basis").should == nil
+      collection_class.find("the_basis").should == nil
     end
     
     it "should be helpful and derefence its keys when asked" do
-      CollectionFoo.persist_to({}, "")
-      CollectedResource.persist_to({}, "")
+      collection_class = CollectionFoo.persist_to({}, "")
+      resource_class = CollectedResource.persist_to({}, "")
       
-      CollectionFoo.attach(CollectedResource, :basis)
+      collection_class.attach(resource_class, :basis)
 
-      resource_1 = CollectedResource.new
+      resource_1 = resource_class.new
       resource_1.basis = "the_basis"
       resource_1.key = "fred"
       resource_1.save
 
-      CollectionFoo.find("the_basis").collected_resources.should == [resource_1]
+      collection_class.find("the_basis").collected_resources.should == [resource_1]
 
-      resource_2 = CollectedResource.new
+      resource_2 = resource_class.new
       resource_2.basis = "the_basis"
       resource_2.key = "barney"
       resource_2.save
 
-      CollectionFoo.find("the_basis").collected_resources.should == [resource_1, resource_2]
+      collection_class.find("the_basis").collected_resources.should == [resource_1, resource_2]
       
     end
   end

data/spec/resource_spec.rb

@@ -25,7 +25,20 @@ class ResourceFooOnlyUsedOnce
 end
 
 describe "A class that includes HashPersistent::Resource" do
-  context "(class methods)" do    
+  context "(not initially useful)" do
+    it "not gain much from the module" do
+      # Grey-box here...
+      lambda{ResourceFoo.store}.should raise_error
+      lambda{ResourceFoo.prefix}.should raise_error
+      lambda{ResourceFoo.on_save}.should raise_error
+      lambda{ResourceFoo.on_delete}.should raise_error
+      lambda{ResourceFoo.find}.should raise_error
+      
+      ResourceFoo.new.respond_to?(:key=).should be_false
+      ResourceFoo.new.respond_to?(:save).should be_false
+      ResourceFoo.new.respond_to?(:delete).should be_false
+    end
+
     it "should acquire a persist_to class method" do
       ResourceFoo.respond_to?(:persist_to).should be_true
     end
@@ -43,76 +56,127 @@ describe "A class that includes HashPersistent::Resource" do
     it "should reject a non-string-like prefix" do
       lambda {ResourceFoo.persist_to({}, Dummy_NoStringRep.new)}.should raise_error(ArgumentError)
     end
-  end
-  
+
+    it "should return a sub-class in response to persist_to" do
+      resource_class = ResourceFoo.persist_to({}, "")
+      resource_class.should_not == ResourceFoo
+      resource_class.superclass.should == ResourceFoo
+    end
+
+    it "should return a different sub-class each time" do
+      resource_class_1 = ResourceFoo.persist_to({}, "")
+      resource_class_2 = ResourceFoo.persist_to({}, "")
+      resource_class_1.should_not == resource_class_2
+    end
+
+    it "should return a sub-class that references the correct store and prefix" do
+      store = Hash.new
+      store["foo"] = "bar"
+      prefix = "baz"
+      resource_class = ResourceFoo.persist_to(store, prefix)
+      resource_class.store.should == store
+      resource_class.prefix.should == prefix
+    end
+
+    it "should return not cross-contaminate the store and prefix of subclasses" do
+      store_1 = Hash.new
+      store_1["foo"] = "bar"
+      prefix_1 = "baz"
+      resource_class_1 = ResourceFoo.persist_to(store_1, prefix_1)
+      resource_class_2 = ResourceFoo.persist_to(store_1, prefix_1)
+
+      store_3 = Hash.new
+      store_3["fred"] = "barney"
+      prefix_3 = "wilma"
+      resource_class_3 = ResourceFoo.persist_to(store_3, prefix_3)
+
+      resource_class_1.store.should == resource_class_2.store
+      resource_class_1.prefix.should == resource_class_2.prefix
+
+      resource_class_1.store.should_not == resource_class_3.store
+      resource_class_1.prefix.should_not == resource_class_3.prefix
+
+      resource_class_1.store.should == store_1
+      resource_class_2.store.should == store_1
+      resource_class_3.store.should == store_3
+
+      resource_class_1.prefix.should == prefix_1
+      resource_class_2.prefix.should == prefix_1
+      resource_class_3.prefix.should == prefix_3
+    end
+  end  
+
   context "(an instance that has not been saved)" do
+    before(:each) do
+      @resource_class = ResourceFoo.persist_to({}, "")
+    end
+    
     it "should maintain a key attribute" do
-      ResourceFoo.new.respond_to?(:key).should be_true
-      ResourceFoo.new.respond_to?(:key=).should be_true
+      @resource_class.new.respond_to?(:key).should be_true
+      @resource_class.new.respond_to?(:key=).should be_true
     end
     
     it "should respond to a save method" do
-      ResourceFoo.new.respond_to?(:save).should be_true
+      @resource_class.new.respond_to?(:save).should be_true
     end
 
     it "should respond to a delete method" do
-      ResourceFoo.new.respond_to?(:delete).should be_true
+      @resource_class.new.respond_to?(:delete).should be_true
     end
 
     it "should not save unless the key has been explictly set" do
-      lambda{ResourceFoo.new.save}.should raise_error
+      lambda{@resource_class.new.save}.should raise_error
     end
 
     it "should not delete unless the key has been explictly set" do
-      lambda{ResourceFoo.new.delete}.should raise_error
+      lambda{@resource_class.new.delete}.should raise_error
     end
 
     it "should not complain when deleted, even after a key is set" do
-      ResourceFoo.persist_to(Hash.new, "")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       lambda{resource.delete}.should_not raise_error
     end
     
     it "should not be findable via its key" do
-      ResourceFoo.persist_to(Hash.new, "")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
-      ResourceFoo.find("fred").should == nil
-      ResourceFoo.find("barney").should == nil
+      @resource_class.find("fred").should == nil
+      @resource_class.find("barney").should == nil
     end
   end
 
   context "(an instance that has been saved)" do
+    before(:each) do
+      @resource_class            = ResourceFoo.persist_to({}, "")
+      @resource_class_with_state = ResourceFooWithState.persist_to({}, "")
+    end
+
     it "should be findable via its key" do
-      ResourceFoo.persist_to(Hash.new, "")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       resource.save
-      ResourceFoo.find("fred").should_not be_nil
+      @resource_class.find("fred").should_not be_nil
     end
 
     it "should correctly recover all of its state" do
-      ResourceFooWithState.persist_to(Hash.new, "")
-      resource = ResourceFooWithState.new
+      resource = @resource_class_with_state.new
       resource.key = "fred"
       resource.dummy = ["something random", {}]
       resource.save
       resource_dup = resource.dup
-      ResourceFooWithState.find("fred").should == resource_dup
+      @resource_class_with_state.find("fred").should == resource_dup
     end
 
     it "should be deletable" do
-      ResourceFoo.persist_to(Hash.new, "")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       resource.save
       lambda{resource.delete}.should_not raise_error
     end
     
     it "should save a new state when asked" do
-      ResourceFooWithState.persist_to(Hash.new, "")
-      resource = ResourceFooWithState.new
+      resource = @resource_class_with_state.new
       resource.key = "fred"
 
       resource.dummy = ["something random", {}]
@@ -123,24 +187,26 @@ describe "A class that includes HashPersistent::Resource" do
       resource.save
       resource_dup_2 = resource.dup
       
-      ResourceFooWithState.find("fred").should_not == resource_dup_1
-      ResourceFooWithState.find("fred").should     == resource_dup_2
+      @resource_class_with_state.find("fred").should_not == resource_dup_1
+      @resource_class_with_state.find("fred").should     == resource_dup_2
     end
   end
 
   context "(an instance that has been saved and then deleted)" do
+    before(:each) do
+      @resource_class = ResourceFoo.persist_to({}, "")
+    end
+    
     it "should not be findable via its key" do
-      ResourceFoo.persist_to(Hash.new, "")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       resource.save
       resource.delete
-      ResourceFoo.find("fred").should == nil
+      @resource_class.find("fred").should == nil
     end
 
     it "should not complain when deleted" do
-      ResourceFoo.persist_to(Hash.new, "")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       resource.save
       resource.delete
@@ -149,157 +215,104 @@ describe "A class that includes HashPersistent::Resource" do
   end
   
   context "(use of prefix to namespace keys)" do
+    before(:each) do
+      @resource_class = ResourceFoo.persist_to({}, "a_random_namespace::")
+    end
+    
     it "should (transparently) prepend the supplied prefix to the key of the saved instance" do
-      store = Hash.new
-      ResourceFoo.persist_to(store, "a_random_namespace::")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       resource.save
-      store.should_not have_key("fred")
-      store.should     have_key("a_random_namespace::fred")
+      @resource_class.store.should_not have_key("fred")
+      @resource_class.store.should     have_key("a_random_namespace::fred")
     end
 
     it "should find instances when using a namespace, using only the key" do
-      store = Hash.new
-      ResourceFoo.persist_to(store, "a_random_namespace::")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       resource.save
-      ResourceFoo.find("fred").should_not == nil
+      @resource_class.find("fred").should_not == nil
     end
 
     it "should not find instances when mistakenly given a namespaced key" do
-      store = Hash.new
-      ResourceFoo.persist_to(store, "a_random_namespace::")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       resource.save
-      ResourceFoo.find("a_random_namespace::fred").should == nil
+      @resource_class.find("a_random_namespace::fred").should == nil
     end
 
     it "should correctly delete an instance from the store when using a prefix" do
-      store = Hash.new
-      ResourceFoo.persist_to(store, "a_random_namespace::")
-      resource = ResourceFoo.new
+      resource = @resource_class.new
       resource.key = "fred"
       resource.save
       resource.delete
-      ResourceFoo.find("fred").should == nil
+      @resource_class.find("fred").should == nil
+      @resource_class.store.should == {}
     end
   end
 
   context "(use of store)" do
     it "should correctly delete items from the store" do
-      store = Hash.new
-      ResourceFoo.persist_to(store, "")
-      resource_1 = ResourceFoo.new
+      @resource_class = ResourceFoo.persist_to({}, "")
+      resource_1 = @resource_class.new
       resource_1.key = "fred"
       resource_1.save
 
-      resource_2 = ResourceFoo.new
+      resource_2 = @resource_class.new
       resource_2.key = "barney"
       resource_2.save
-      store.should_not == Hash.new
+      @resource_class.store.should_not == {}
       
       resource_1.delete
+      @resource_class.store.should_not == {}
+
       resource_2.delete
-      store.should == Hash.new
+      @resource_class.store.should == {}
     end  
   end
-  
+    
   context "(use of restricted hash api)" do
     it "should use only the restricted hash api provided by moneta" do
       lambda {
-        ResourceFooWithState.persist_to(Dummy_RestrictedHash.new, "prefix::")
-        resource_1 = ResourceFooWithState.new
+        @resource_class = ResourceFooWithState.persist_to(Dummy_RestrictedHash.new, "prefix::")
+        resource_1 = @resource_class.new
         resource_1.key = "fred"
         resource_1.dummy = ["barney"]
         resource_1.save
-        ResourceFooWithState.find("fred").delete
+        @resource_class.find("fred").delete
       }.should_not raise_error
     end  
   end
-
-  context "(default store)" do
-    it "should function with a vdefault store/prefix if none is supplied" do
-      # This is implicitly tested elsewhere. Which makes this test documentation, I guess
-      resource_1 = ResourceFooOnlyUsedOnce.new
-      resource_1.key = "fred"
-      resource_1.dummy = ["barney"]
-      resource_1.save
-      ResourceFooOnlyUsedOnce.find("fred").should == resource_1.dup
-      lambda {ResourceFooOnlyUsedOnce.find("fred").delete}.should_not raise_error
-    end  
-  end
-
-  context "(multiple classes using module)" do
-    # TODO: should check the callbacks here? Seems over the top...
-    it "should not cross-contaminate classes that include the module" do
-      store_1 = Hash.new
-      ResourceFoo.persist_to(store_1, "")
-      store_2 = Hash.new
-      ResourceFooWithState.persist_to(store_2, "prefix::")
-
-      store_1.should == Hash.new
-      store_2.should == Hash.new
-      
-      resource_1 = ResourceFoo.new
-      resource_1.key = "1"
-      resource_1.save
-      
-      store_1.should_not == Hash.new
-      store_2.should == Hash.new
-      store_1.should have_key("1")
-      store_1.should_not have_key("prefix::1")
-
-      resource_1.delete
-      
-      store_1.should == Hash.new
-      store_2.should == Hash.new
-      
-      resource_2 = ResourceFooWithState.new
-      resource_2.key = "2"
-      resource_2.save
-
-      store_1.should == Hash.new
-      store_2.should_not == Hash.new
-      store_2.should have_key("prefix::2")
-      store_2.should_not have_key("2")
-
-      resource_2.delete
-      
-      store_1.should == Hash.new
-      store_2.should == Hash.new      
-    end
-  end
   
   context "(callbacks)" do
     it "should allow a class level callback to be set and retrieved for save events" do
-      ResourceFoo.on_save.should == nil
-      lambda{ResourceFoo.on_save do
+      @resource_class = ResourceFoo.persist_to({}, "")
+      @resource_class.on_save.should == nil
+
+      @resource_class.on_save do
         "thing"
-      end}.should_not raise_error
-      ResourceFoo.on_save.call.should == "thing"
-      lambda{ResourceFoo.on_save(1)}.should raise_error
+      end
+      @resource_class.on_save.call.should == "thing"
     end
 
     it "should allow a class level callback to be set and retrieved for delete events" do
-      ResourceFoo.on_delete.should == nil
-      lambda{ResourceFoo.on_delete do
+      @resource_class = ResourceFoo.persist_to({}, "")
+      @resource_class.on_delete.should == nil
+      @resource_class.on_delete do
         "thing"
-      end}.should_not raise_error
-      ResourceFoo.on_delete.call.should == "thing"
-      lambda{ResourceFoo.on_delete(1)}.should raise_error
+      end
+      @resource_class.on_delete.call.should == "thing"
     end
     
     it "should yield an instance to the save callback when the instance is saved" do
+      @resource_class = ResourceFoo.persist_to({}, "")
       yielded_instance = nil
-      ResourceFoo.on_save do |yielded|
+      @resource_class.on_save do |yielded|
         yielded_instance = yielded
       end
 
-      instance = ResourceFoo.new
-      instance.key = "1"
+      instance = @resource_class.new
+      instance.key = "fah"
       instance.save
       
       yielded_instance.should_not == nil
@@ -307,13 +320,14 @@ describe "A class that includes HashPersistent::Resource" do
     end
 
     it "should yield an instance to the delete callback when the instance is deleted" do
+      @resource_class = ResourceFoo.persist_to({}, "")
       yielded_instance = nil
-      ResourceFoo.on_delete do |yielded|
+      @resource_class.on_delete do |yielded|
         yielded_instance = yielded
       end
 
-      instance = ResourceFoo.new
-      instance.key = "1"
+      instance = @resource_class.new
+      instance.key = "bah"
       instance.save
       instance.delete
       
@@ -321,5 +335,21 @@ describe "A class that includes HashPersistent::Resource" do
       yielded_instance.should == instance
     end
     
+    it "should maintain separate callbacks for each created subclass" do
+      @resource_class_1 = ResourceFoo.persist_to({}, "")
+      @resource_class_2 = ResourceFoo.persist_to({}, "")
+      
+      @resource_class_1.on_save do "on_save_1" end
+      @resource_class_1.on_delete do "on_delete_1" end
+
+      @resource_class_2.on_save do "on_save_2" end
+      @resource_class_2.on_delete do "on_delete_2" end
+        
+      @resource_class_1.on_delete.call.should == "on_delete_1"
+      @resource_class_1.on_save.call.should   == "on_save_1"
+
+      @resource_class_2.on_delete.call.should == "on_delete_2"
+      @resource_class_2.on_save.call.should   == "on_save_2"        
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kissifer-hash-persistent
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.3.1
 platform: ruby
 authors: 
 - kissifer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-02 00:00:00 -07:00
+date: 2009-06-04 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -64,7 +64,7 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3
-summary: Library of base classes to simplify persisting objects in a moneta store
+summary: Library of base classes to simplify persisting objects and collections to a moneta store
 test_files: 
 - spec/collection_spec.rb
 - spec/counter_spec.rb