kissifer-hash-persistent 0.1.1 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/hash-persistent.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hash-persistent}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["kissifer"]
-  s.date = %q{2009-05-27}
+  s.date = %q{2009-05-28}
   s.email = %q{tierneydrchris@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -21,8 +21,10 @@ Gem::Specification.new do |s|
      "VERSION",
      "hash-persistent.gemspec",
      "lib/hash-persistent.rb",
+     "lib/hash-persistent/collection.rb",
      "lib/hash-persistent/counter.rb",
      "lib/hash-persistent/resource.rb",
+     "spec/collection_spec.rb",
      "spec/counter_spec.rb",
      "spec/resource_spec.rb",
      "spec/spec.opts",
@@ -34,7 +36,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.3}
   s.summary = %q{Library of base classes to simplify persisting objects in a moneta store}
   s.test_files = [
-    "spec/counter_spec.rb",
+    "spec/collection_spec.rb",
+     "spec/counter_spec.rb",
      "spec/resource_spec.rb",
      "spec/spec_helper.rb"
   ]

data/lib/hash-persistent.rb

@@ -3,3 +3,4 @@ $LOAD_PATH << File.dirname(__FILE__)
 require 'rubygems'
 require 'hash-persistent/counter'
 require 'hash-persistent/resource'
+require 'hash-persistent/collection'

data/lib/hash-persistent/collection.rb

@@ -0,0 +1,50 @@
+module HashPersistent
+  module Collection
+    
+    def self.included(base)
+      base.extend ClassMethods
+      base.module_eval do
+        include HashPersistent::Resource
+      end
+    end
+    
+    module ClassMethods
+      def attach(resource_class, collection_basis)
+        raise ArgumentError unless resource_class.included_modules.include?(HashPersistent::Resource)
+        raise ArgumentError unless resource_class.new.respond_to?(collection_basis)
+        @collection_basis = collection_basis
+        resource_class.on_save do |resource|
+          collected_resource_saved(resource)
+        end
+        
+        resource_class.on_delete do |resource|
+          collected_resource_deleted(resource)
+        end
+      end
+      
+      def collected_resource_saved(resource)
+        collection = find(resource.send(@collection_basis))
+        unless collection
+          collection = new
+          collection.collected_keys = []
+          collection.key = resource.send(@collection_basis)
+        end
+        collection.collected_keys << resource.key
+        collection.collected_keys.uniq!
+        collection.save
+      end
+
+      def collected_resource_deleted(resource)
+        collection = find(resource.send(@collection_basis))
+        collection.collected_keys.delete(resource.key)
+        if collection.collected_keys.empty?
+          collection.delete
+        else
+          collection.save
+        end
+      end
+    end
+    
+    attr_accessor :collected_keys
+  end
+end

data/lib/hash-persistent/resource.rb

@@ -18,6 +18,22 @@ module HashPersistent
       def find(key)
         @store[@prefix + key]
       end
+      
+      def on_save(&block)
+        if block
+          @on_save = block
+        else
+          @on_save
+        end
+      end
+
+      def on_delete(&block)
+        if block
+          @on_delete = block
+        else
+          @on_delete
+        end
+      end
     
       attr_reader :store, :prefix
     end
@@ -31,13 +47,17 @@ module HashPersistent
     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 self.class.store.has_key?(prefix_key)
+      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
 

data/spec/collection_spec.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class CollectionFoo
+  include HashPersistent::Collection
+end
+
+class CollectedResource
+  include HashPersistent::Resource
+  attr_accessor :basis
+end
+
+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
+
+  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
+  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 verify a valid collection basis" do
+    lambda{CollectionFoo.attach(CollectedResource)}.should raise_error
+    lambda{CollectionFoo.attach(CollectedResource, :not_a_valid_attr)}.should raise_error
+  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({}, "")
+      
+      CollectionFoo.attach(CollectedResource, :basis)
+      CollectionFoo.find("the_basis").should == nil
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "fred"
+      resource.save
+
+      CollectionFoo.find("the_basis").should_not == nil
+    end
+
+    it "should report keys saved/added to the collection" do
+      CollectionFoo.persist_to({}, "")
+      CollectedResource.persist_to({}, "")
+      
+      CollectionFoo.attach(CollectedResource, :basis)
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "fred"
+      resource.save
+
+      CollectionFoo.find("the_basis").collected_keys.should == ["fred"]
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "barney"
+      resource.save
+
+      CollectionFoo.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({}, "")
+      
+      CollectionFoo.attach(CollectedResource, :basis)
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "fred"
+      resource.save
+      resource.save
+
+      CollectionFoo.find("the_basis").collected_keys.should == ["fred"]
+    end
+
+    it "should not report keys with the wrong basis" do
+      CollectionFoo.persist_to({}, "")
+      CollectedResource.persist_to({}, "")
+      
+      CollectionFoo.attach(CollectedResource, :basis)
+
+      resource = CollectedResource.new
+      resource.basis = "one_basis"
+      resource.key = "fred"
+      resource.save
+
+      CollectionFoo.find("another_basis").should == nil
+
+      resource = CollectedResource.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"]
+    end
+
+    it "should remove the key when a resource is deleted" do
+      CollectionFoo.persist_to({}, "")
+      CollectedResource.persist_to({}, "")
+      
+      CollectionFoo.attach(CollectedResource, :basis)
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "fred"
+      resource.save
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "barney"
+      resource.save
+      resource.delete
+
+      CollectionFoo.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({}, "")
+      
+      CollectionFoo.attach(CollectedResource, :basis)
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "fred"
+      resource.save
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "barney"
+
+      lambda{resource.delete}.should_not raise_error
+
+      resource.save
+      resource.delete
+      lambda{resource.delete}.should_not raise_error
+
+      CollectionFoo.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({}, "")
+      
+      CollectionFoo.attach(CollectedResource, :basis)
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "fred"
+
+      lambda{resource.delete}.should_not raise_error
+    end
+
+    it "should remove the collection when its final key is removed" do
+      CollectionFoo.persist_to({}, "")
+      CollectedResource.persist_to({}, "")
+      
+      CollectionFoo.attach(CollectedResource, :basis)
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "fred"
+      resource.save
+
+      resource = CollectedResource.new
+      resource.basis = "the_basis"
+      resource.key = "barney"
+      resource.save
+
+      CollectedResource.find("fred").delete
+      CollectedResource.find("barney").delete
+
+      CollectionFoo.find("the_basis").should == nil
+    end
+
+  end
+  
+  context "(concurrent access)" do
+    it "should be careful when creating and updating the collection resources"
+    # Cases to cover here...
+    # - delete last basis and add basis race condition
+    # - add basis and add basis race condition
+  end
+end

data/spec/counter_spec.rb

@@ -16,9 +16,7 @@ describe "HashPersistent::Counter" do
       CounterFoo.next_key.should_not == CounterFoo.next_key
     end
     
-    it "should be careful when incrementing the key in multi-threaded/process environment" do
-      pending
-    end
+    it "should be careful when incrementing the key in multi-threaded/process environment"
   end
   
   context "when mixed-in to more than one class" do

data/spec/resource_spec.rb

@@ -63,12 +63,15 @@ describe "A class that includes HashPersistent::Resource" do
       lambda{ResourceFoo.new.save}.should raise_error
     end
 
-    it "should not be deletable, even after a key is set" do
+    it "should not delete unless the key has been explictly set" do
+      lambda{ResourceFoo.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
-      lambda{resource.delete}.should raise_error
       resource.key = "fred"
-      lambda{resource.delete}.should raise_error
+      lambda{resource.delete}.should_not raise_error
     end
     
     it "should not be findable via its key" do
@@ -135,13 +138,13 @@ describe "A class that includes HashPersistent::Resource" do
       ResourceFoo.find("fred").should == nil
     end
 
-    it "should not be deletable" do
+    it "should not complain when deleted" do
       ResourceFoo.persist_to(Hash.new, "")
       resource = ResourceFoo.new
       resource.key = "fred"
       resource.save
       resource.delete
-      lambda{resource.delete}.should raise_error
+      lambda{resource.delete}.should_not raise_error
     end
   end
   
@@ -230,6 +233,7 @@ describe "A class that includes HashPersistent::Resource" do
   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, "")
@@ -268,4 +272,54 @@ describe "A class that includes HashPersistent::Resource" do
       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
+        "thing"
+      end}.should_not raise_error
+      ResourceFoo.on_save.call.should == "thing"
+      lambda{ResourceFoo.on_save(1)}.should raise_error
+    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
+        "thing"
+      end}.should_not raise_error
+      ResourceFoo.on_delete.call.should == "thing"
+      lambda{ResourceFoo.on_delete(1)}.should raise_error
+    end
+    
+    it "should yield an instance to the save callback when the instance is saved" do
+      yielded_instance = nil
+      ResourceFoo.on_save do |yielded|
+        yielded_instance = yielded
+      end
+
+      instance = ResourceFoo.new
+      instance.key = "1"
+      instance.save
+      
+      yielded_instance.should_not == nil
+      yielded_instance.should == instance
+    end
+
+    it "should yield an instance to the delete callback when the instance is deleted" do
+      yielded_instance = nil
+      ResourceFoo.on_delete do |yielded|
+        yielded_instance = yielded
+      end
+
+      instance = ResourceFoo.new
+      instance.key = "1"
+      instance.save
+      instance.delete
+      
+      yielded_instance.should_not == nil
+      yielded_instance.should == instance
+    end
+    
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kissifer-hash-persistent
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - kissifer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-27 00:00:00 -07:00
+date: 2009-05-28 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,8 +31,10 @@ files:
 - VERSION
 - hash-persistent.gemspec
 - lib/hash-persistent.rb
+- lib/hash-persistent/collection.rb
 - lib/hash-persistent/counter.rb
 - lib/hash-persistent/resource.rb
+- spec/collection_spec.rb
 - spec/counter_spec.rb
 - spec/resource_spec.rb
 - spec/spec.opts
@@ -64,6 +66,7 @@ signing_key:
 specification_version: 3
 summary: Library of base classes to simplify persisting objects in a moneta store
 test_files: 
+- spec/collection_spec.rb
 - spec/counter_spec.rb
 - spec/resource_spec.rb
 - spec/spec_helper.rb