kissifer-hash-persistent 0.0.0 → 0.0.3

data/spec/spec_helper.rb

@@ -1,6 +1,4 @@
-require 'rubygems'
 require 'spec'
-require 'ostruct'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kissifer-hash-persistent
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  version: 0.0.3
 platform: ruby
 authors: 
 - kissifer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-23 00:00:00 -07:00
+date: 2009-05-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,18 +31,12 @@ files:
 - VERSION
 - hash-persistent.gemspec
 - lib/hash-persistent.rb
-- lib/hash-persistent/collection.rb
-- lib/hash-persistent/counter.rb
-- lib/hash-persistent/extended_store.rb
-- lib/hash-persistent/resource.rb
-- lib/hash-persistent/store.rb
-- spec/collection_spec.rb
-- spec/counter_spec.rb
-- spec/extended_store_spec.rb
-- spec/resource_spec.rb
+- lib/hash-persistent/basic.rb
+- lib/hash-persistent/counting.rb
+- spec/basic_spec.rb
+- spec/counting_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
-- spec/store_spec.rb
 has_rdoc: false
 homepage: http://github.com/kissifer/hash-persistent
 post_install_message: 
@@ -68,11 +62,8 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3
-summary: Library of base classes to simplify persisting objects and collections to a moneta store
+summary: Library of base classes to simplify persisting objects in a moneta store
 test_files: 
-- spec/collection_spec.rb
-- spec/counter_spec.rb
-- spec/extended_store_spec.rb
-- spec/resource_spec.rb
+- spec/basic_spec.rb
+- spec/counting_spec.rb
 - spec/spec_helper.rb
-- spec/store_spec.rb

data/lib/hash-persistent/collection.rb

@@ -1,59 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/resource')
-
-module HashPersistent
-  module Collection
-    include HashPersistent::Resource
-
-    def self.included(base)
-      base.extend ClassMethods
-    end
-    
-    module ClassMethods
-      attr_accessor :basis
-      
-      def on_watched_store_save_event(store_for_collection, saved_object)
-        raise "Cannot collect objects without a basis for the collection. Set :basis class attribute" unless @basis
-        return unless saved_object.respond_to?(:basis) && saved_object.respond_to?(:key)
-        
-        collection_resource = store_for_collection.find(saved_object.send(:basis))
-        unless collection_resource
-          collection_resource = new
-          collection_resource.store = store_for_collection
-          collection_resource.key = saved_object.send(:basis)
-        end
-        
-        collection_resource.collected_keys << saved_object.send(:key)
-        collection_resource.collected_keys.uniq!
-        collection_resource.save
-      end
-
-      def on_watched_store_delete_event(store_for_collection, deleted_object)
-        raise "Cannot collect objects without a basis for the collection. Set :basis class attribute" unless @basis
-        return unless deleted_object.respond_to?(:basis) && deleted_object.respond_to?(:key)
-        
-        collection_resource = store_for_collection.find(deleted_object.send(:basis))
-        return unless collection_resource
-
-        collection_resource.collected_keys.delete(deleted_object.send(:key))
-        
-        if collection_resource.collected_keys == []
-          collection_resource.delete
-        else
-          collection_resource.save
-        end
-      end
-    end
-    
-    def collected_keys
-      @collected_keys ||= []
-    end
-
-    def collected_resources
-      @collected_keys.collect do |key|
-        resource = store.watching.find(key)
-        raise "Collected key not found in watched store" unless resource
-        resource
-      end
-    end
-  end
-end

data/lib/hash-persistent/counter.rb

@@ -1,26 +0,0 @@
-require 'ostruct'
-
-module HashPersistent  
-  class Counter
-    def initialize(store, key)
-      raise ArgumentError unless store.is_a?(HashPersistent::Store) and key.respond_to?(:to_s) and key.to_s.length != 0
-      @store = store
-      @key = key
-      
-      unless @store.find(@key)
-        counter = OpenStruct.new
-        counter.key = @key
-        counter.count = 0
-        @store.save(counter)
-      end
-    end
-    
-    def next
-      counter = @store.find(@key)
-      next_count = counter.count
-      counter.count += 1
-      @store.save(counter)
-      next_count
-    end
-  end
-end

data/lib/hash-persistent/extended_store.rb

@@ -1,49 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/store')
-
-module HashPersistent
-  class ExtendedStore
-    attr_reader :store
-    
-    def initialize(store)
-      @store = store
-      yield self if block_given?
-    end
-    
-    def find(key)
-      a_singleton = singleton_keys.find do |singleton|
-       key.match(singleton[0])
-     end
-
-      if a_singleton
-        find_or_create(key, a_singleton[1], *a_singleton[2], &a_singleton[3])
-      else
-        @store.find(key)
-      end
-    end
-
-    def save(object)
-      @store.save(object)
-    end
-
-    def delete(object)
-      @store.delete(object)
-    end
-
-    def create(key, class_to_create, *args, &block)
-      @store.create(key, class_to_create, *args, &block)
-    end
-
-    def find_or_create(key, class_to_create, *args, &block)
-      @store.find_or_create(key, class_to_create, *args, &block)
-    end
-    
-    def singleton_key(pattern, class_to_create, *args, &block)
-      "1".match(pattern) # a test to check the duck typing early
-      singleton_keys << [pattern, class_to_create, args, block]
-    end
-
-    def singleton_keys
-      @singleton_keys ||= []
-    end
-  end
-end

data/lib/hash-persistent/resource.rb

@@ -1,20 +0,0 @@
-module HashPersistent
-  module Resource
-    attr_accessor :store, :key
-    
-    def save
-      @store.save(self) if @store
-    end
-
-    def delete
-      @store.delete(self) if @store
-    end
-
-    def move(new_store)
-      delete
-      @store = new_store
-      save
-    end
-  end
-end
-

data/lib/hash-persistent/store.rb

@@ -1,67 +0,0 @@
-module HashPersistent
-  class Store
-    attr_reader :key_value_store, :key_prefix, :cached_to
-    
-    def initialize(key_value_store, key_prefix)
-      raise ArgumentError unless key_value_store.respond_to?(:has_key?) and key_prefix.respond_to?(:to_s)
-      @key_value_store = key_value_store
-      @key_prefix = key_prefix
-      yield self if block_given?
-    end
-    
-    def cached_to=(cache)
-      raise ArgumentError unless cache.is_a?(HashPersistent::Store) if cache
-      @cached_to = cache
-    end
-    
-    def save(object)
-      store_this = object.dup
-      store_this.store = nil if store_this.respond_to?(:store)
-      @key_value_store[@key_prefix + store_this.key] = store_this
-
-      @cached_to.save(object) if @cached_to
-
-      object.store = self if object.respond_to?(:store)
-      self
-    end
-
-    def delete(object)
-      @key_value_store.delete(@key_prefix + object.key)
-      @cached_to.delete(object) if @cached_to
-
-      object.store = self if object.respond_to?(:store)
-      self
-    end
-
-    def find(key)
-      if @cached_to
-        found = @cached_to.find(key)
-        unless found
-          found = @key_value_store[@key_prefix + key]
-          @cached_to.save(found) if found
-        end
-      else
-        found = @key_value_store[@key_prefix + key]
-      end
-      return nil unless found
-
-      object = found.dup
-      object.store = self if object.respond_to?(:store)
-
-      object
-    end
-
-    def create(key, class_to_create, *args, &block)
-      object = class_to_create.new(*args, &block)
-      object.key = key
-      object.store = self if object.respond_to?(:store)
-      object
-    end
-    
-    def find_or_create(key, class_to_create, *args, &block)
-      #TODO: Lock?
-      save(create(key, class_to_create, *args, &block)) unless find(key)
-      find(key)
-    end
-  end
-end

data/spec/collection_spec.rb

@@ -1,269 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'ostruct'
-
-__END__
-
-class CollectionFoo
-  include HashPersistent::Collection
-end
-
-class CollectionDoNotSetABasis
-  include HashPersistent::Collection
-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 acquire on_watched_store_save_event() and on_watched_store_delete_event() methods" do
-    CollectionFoo.respond_to?(:on_watched_store_save_event).should be_true
-    CollectionFoo.respond_to?(:on_watched_store_delete_event).should be_true
-  end
-  
-  it "should acquire a basis attribute" do
-    CollectionFoo.basis = "foo"
-    CollectionFoo.basis.should == "foo"
-  end
-  
-  context "(when not given a basis)" do
-    it "should complain when given a save event" do
-      lambda{CollectionDoNotSetABasis.on_watched_store_save_event("store", "saved_object")}.should raise_error
-    end
-
-    it "should complain when given a delete event" do
-      lambda{CollectionDoNotSetABasis.on_watched_store_delete_event("store", "deleted_object")}.should raise_error
-    end
-  end
-  
-  context "(when a save event happens)" do
-    before(:each) do
-      CollectionFoo.basis = :basis
-      @store = HashPersistent::Store.new({}, "")
-    end
-    
-    it "should create a resource for the basis if one does not exist" do
-      object = OpenStruct.new
-      object.key = "key"
-      object.basis = "basis"
-
-      CollectionFoo.on_watched_store_save_event(@store, object)
-      @store.find("basis").should_not be_nil
-    end
-
-    it "should collect the saved keys for a basis, in the resource for that basis" do
-      object = OpenStruct.new
-      object.basis = "basis"
-
-      object.key = "key_1"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-
-      object.key = "key_2"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-
-      collection_resource = @store.find("basis")
-      collection_resource.collected_keys.should include("key_1")
-      collection_resource.collected_keys.should include("key_2")
-    end
-
-    it "should not duplicate keys in the resource for the basis" do
-      object = OpenStruct.new
-      object.basis = "basis"
-
-      object.key = "key_1"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-      CollectionFoo.on_watched_store_save_event(@store, object)
-
-      object.key = "key_2"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-
-      collection_resource = @store.find("basis")
-      collection_resource.collected_keys.size.should == 2
-    end
-
-    it "should not cross-contaminate keys between bases" do
-      object = OpenStruct.new
-
-      object.basis = "basis_1"
-      object.key = "key_1A"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-      object.key = "key_1B"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-
-      object.basis = "basis_2"
-      object.key = "key_2"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-
-      collection_resource_1 = @store.find("basis_1")
-      collection_resource_2 = @store.find("basis_2")
-      
-      collection_resource_1.collected_keys.should     include("key_1A")
-      collection_resource_1.collected_keys.should     include("key_1B")
-      collection_resource_1.collected_keys.should_not include("key_2")
-
-      collection_resource_2.collected_keys.should_not include("key_1A")
-      collection_resource_2.collected_keys.should_not include("key_1B")
-      collection_resource_2.collected_keys.should     include("key_2")
-    end
-  end
-
-  context "(when a delete event happens)" do
-    before(:each) do
-      CollectionFoo.basis = :basis
-      @store = HashPersistent::Store.new({}, "")
-    end
-    
-    it "should not complain when asked to remove a key from an unknown basis" do
-      object = OpenStruct.new
-
-      object.basis = "basis"
-      object.key = "key"
-      lambda{CollectionFoo.on_watched_store_delete_event(@store, object)}.should_not raise_error
-    end
-    
-    it "should delete the key from the resource for a basis" do
-      object = OpenStruct.new
-
-      object.basis = "basis"
-      object.key = "key_1"
-      CollectionFoo.on_watched_store_save_event(@store, object) # save
-      object.key = "key_2"
-      CollectionFoo.on_watched_store_save_event(@store, object) # save
-
-      object.key = "key_1"
-      CollectionFoo.on_watched_store_delete_event(@store, object) # delete
-
-      collection_resource = @store.find("basis")
-      
-      collection_resource.collected_keys.should     include("key_2")
-      collection_resource.collected_keys.should_not include("key_1")
-    end
-
-    it "should not complain when asked to remove a non-existent key from the basis" do
-      object = OpenStruct.new
-
-      object.basis = "basis"
-      object.key = "key_1"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-
-      object.key = "key_2"
-      lambda{CollectionFoo.on_watched_store_delete_event(@store, object)}.should_not raise_error
-    end
-
-    it "should remove the resource for a basis when the last key is removed" do
-      object = OpenStruct.new
-
-      object.basis = "basis"
-      object.key = "key"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-      CollectionFoo.on_watched_store_delete_event(@store, object)
-      
-      @store.find("basis").should be_nil
-    end
-    
-    it "should not complain when asked to remove a key from a deleted basis" do
-      object = OpenStruct.new
-
-      object.basis = "basis"
-      object.key = "key"
-      CollectionFoo.on_watched_store_save_event(@store, object)
-      CollectionFoo.on_watched_store_delete_event(@store, object)
-      lambda{CollectionFoo.on_watched_store_delete_event(@store, object)}.should_not raise_error
-    end
-  end
-  
-  it "should do nothing when told about save or delete events for objects with no key attribute" do
-    store = HashPersistent::Store.new({}, "")
-    object = OpenStruct.new
-    object.basis = "fred"
-
-    CollectionFoo.on_watched_store_save_event(store, object)
-    store.key_value_store.should == {}
-    CollectionFoo.on_watched_store_delete_event(store, object)
-    store.key_value_store.should == {}    
-  end
-
-  it "should do nothing when told about save or delete events for objects with no basis attribute" do
-    store = HashPersistent::Store.new({}, "")
-    object = OpenStruct.new
-    object.key = "fred"
-
-    CollectionFoo.on_watched_store_save_event(store, object)
-    store.key_value_store.should == {}
-    CollectionFoo.on_watched_store_delete_event(store, object)
-    store.key_value_store.should == {}    
-  end
-  
-  context "(dereferencing collected keys)" do
-    it "should provide a convenient means to retrieve/dereference collected resources" do
-      watched_store = HashPersistent::Store.new({}, "")
-      watching_store = HashPersistent::Store.new({}, "")
-      watching_store.watch(watched_store)
-      watching_store.managed_class = CollectionFoo
-      CollectionFoo.basis = :basis
-      
-      object = OpenStruct.new
-
-      object.basis = "fred"
-      object.key = "1"
-      watched_store.save(object)
-
-      object.basis = "fred"
-      object.key = "2"
-      watched_store.save(object)
-
-      object.basis = "barney"
-      object.key = "3"
-      watched_store.save(object)
-      
-      fred = watching_store.find("fred")
-      fred.collected_resources.should include(watched_store.find("1"))
-      fred.collected_resources.should include(watched_store.find("2"))
-    end
-
-    it "should complain if asked to dereference a resource that does not exist in the watched store" do
-      watched_store = HashPersistent::Store.new({}, "")
-      watching_store = HashPersistent::Store.new({}, "")
-      watching_store.managed_class = CollectionFoo
-      watching_store.watch(watched_store)
-      CollectionFoo.basis = :basis
-      
-      object = OpenStruct.new
-      object.basis = "fred"
-      object.key = "1"
-      watched_store.save(object)
-
-      object.basis = "fred"
-      object.key = "2"
-      watched_store.save(object)
-
-      watched_store.watched_by = nil
-      watched_store.delete(object)
-      watched_store.watched_by = watching_store
-
-      fred = watching_store.find("fred")
-      lambda{fred.collected_resources}.should raise_error
-    end
-
-    it "should complain if asked to dereference a resource but does not know what store it's watching" do
-      watched_store = HashPersistent::Store.new({}, "")
-      watching_store = HashPersistent::Store.new({}, "")
-      watching_store.managed_class = CollectionFoo
-      watched_store.watched_by = watching_store # Note, only on-way relationship here
-      CollectionFoo.basis = :basis
-      
-      object = OpenStruct.new
-      object.basis = "fred"
-      object.key = "1"
-      watched_store.save(object)
-
-      object.basis = "fred"
-      object.key = "2"
-      watched_store.save(object)
-
-      fred = watching_store.find("fred")
-      lambda{fred.collected_resources}.should raise_error
-    end
-  end
-end
-