kissifer-hash-persistent 0.0.0 → 0.0.3

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 and collections to a moneta store}
+    gem.summary = %Q{Library of base classes to simplify persisting objects in a moneta store}
     gem.email = "tierneydrchris@gmail.com"
     gem.homepage = "http://github.com/kissifer/hash-persistent"
     gem.authors = ["kissifer"]

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.3

data/hash-persistent.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hash-persistent}
-  s.version = "0.0.0"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["kissifer"]
-  s.date = %q{2009-06-23}
+  s.date = %q{2009-05-22}
   s.email = %q{tierneydrchris@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -21,31 +21,22 @@ 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/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"
+     "spec/spec_helper.rb"
   ]
   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.4}
-  s.summary = %q{Library of base classes to simplify persisting objects and collections to a moneta store}
+  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/collection_spec.rb",
-     "spec/counter_spec.rb",
-     "spec/extended_store_spec.rb",
-     "spec/resource_spec.rb",
-     "spec/spec_helper.rb",
-     "spec/store_spec.rb"
+    "spec/basic_spec.rb",
+     "spec/counting_spec.rb",
+     "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/hash-persistent.rb

@@ -1,8 +1,5 @@
 $LOAD_PATH << File.dirname(__FILE__)
 
 require 'rubygems'
-require 'hash-persistent/store'
-require 'hash-persistent/extended_store'
-require 'hash-persistent/resource'
-require 'hash-persistent/collection'
-require 'hash-persistent/counter'
+require 'hash-persistent/basic'
+require 'hash-persistent/counting'

data/lib/hash-persistent/basic.rb

@@ -0,0 +1,36 @@
+module HashPersistent
+  class Basic
+    class << self
+      @@store = {}
+      @@prefix = ""
+      
+      def setup(store, prefix)
+        raise ArgumentError unless store.respond_to?(:has_key?) and prefix.respond_to?(:to_s)
+        @@store = store
+        @@prefix = prefix
+      end
+      
+      def find(key)
+        @@store[@@prefix + key]
+      end
+    end
+    
+    attr_reader :key
+    
+    def initialize(key)
+      raise RuntimeError if @@store.has_key?(key)
+      @key = key
+      @@store[@@prefix + @key] = self
+    end
+
+    def delete
+      raise RuntimeError unless @@store.has_key?(@@prefix + @key)
+      @@store.delete(@@prefix + @key)
+    end
+
+    def update
+      raise RuntimeError unless @@store.has_key?(@@prefix + @key)
+      @@store[@@prefix + @key] = self
+    end    
+  end
+end

data/lib/hash-persistent/counting.rb

@@ -0,0 +1,40 @@
+module HashPersistent
+  class Counting
+    class << self
+      @@store = {}
+      @@prefix = ""
+      @@next_key = 0
+      @@next_key_inc_lock = Mutex.new
+
+      def setup(store, prefix)
+        raise ArgumentError unless store.respond_to?(:has_key?) and prefix.respond_to?(:to_s)
+        @@store = store
+        @@prefix = prefix
+      end
+
+      def find(key)
+        @@store[@@prefix + key]
+      end
+    end
+
+    attr_reader :key
+
+    def initialize
+      @@next_key_inc_lock.synchronize do
+        @key = @@next_key.to_s
+        @@next_key += 1
+      end
+      @@store[@@prefix + @key] = self
+    end
+
+    def delete
+      raise RuntimeError unless @@store.has_key?(@@prefix + @key)
+      @@store.delete(@@prefix + @key)
+    end
+
+    def update
+      raise RuntimeError unless @@store.has_key?(@@prefix + @key)
+      @@store[@@prefix + @key] = self
+    end    
+  end
+end

data/spec/basic_spec.rb

@@ -0,0 +1,188 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "HashPersistent::Basic" do
+  context "(before use)" do
+    it "should accept a hash-like store, and a string-like prefix, as class initialisers" do
+      HashPersistent::Basic.setup({}, "_prefix")
+    end
+    
+    it "should reject a non-hash-like store" do
+      lambda {HashPersistent::Basic.setup(1, "_prefix")}.should raise_error(ArgumentError)
+    end
+
+    it "should reject a non-string-like prefix" do
+      lambda {HashPersistent::Basic.setup({}, Dummy_NoStringRep.new)}.should raise_error(ArgumentError)
+    end
+  end
+  
+  context "(creating objects)" do
+    it "should allow not objects to be created without a key" do
+      HashPersistent::Basic.setup({}, "")
+      lambda{HashPersistent::Basic.new}.should raise_error
+    end
+
+    it "should allow objects to be created with a key" do
+      HashPersistent::Basic.setup({}, "")
+      lambda{HashPersistent::Basic.new("a_key")}.should_not raise_error
+    end
+
+    it "should not allow objects to be created with a duplicate key" do
+      HashPersistent::Basic.setup({}, "")
+      HashPersistent::Basic.new("a_key")
+      lambda{HashPersistent::Basic.new("a_key")}.should raise_error
+    end
+
+    it "should return an object after creation" do
+      HashPersistent::Basic.setup({}, "")
+      new_object = HashPersistent::Basic.new("a_key")
+      new_object.class.should == HashPersistent::Basic
+      new_object.key.should == "a_key"
+    end
+  end
+  
+  context "(retrieving objects)" do
+    it "should not return an object when no objects have been created" do
+      HashPersistent::Basic.setup({}, "")
+      HashPersistent::Basic.find("a_key").should be_nil
+    end
+
+    it "should return created objects when given the correct key" do
+      HashPersistent::Basic.setup({}, "")
+      HashPersistent::Basic.new("a_key")
+      new_object = HashPersistent::Basic.find("a_key")
+      new_object.class.should == HashPersistent::Basic
+      new_object.key.should == "a_key"
+    end
+
+    it "should not return an object when given an incorrect key" do
+      HashPersistent::Basic.setup({}, "")
+      HashPersistent::Basic.new("a_key")
+      HashPersistent::Basic.find("another_key").should be_nil
+    end
+  end
+  
+  context "(deleting objects)" do
+    it "should delete an object when asked" do
+      HashPersistent::Basic.setup({}, "")
+      new_object = HashPersistent::Basic.new("a_key")
+      new_object.delete
+      HashPersistent::Basic.find("a_key").should be_nil
+    end
+
+    it "should not allow an object to be deleted twice" do
+      HashPersistent::Basic.setup({}, "")
+      new_object = HashPersistent::Basic.new("a_key")
+      new_object.delete
+      lambda{new_object.delete}.should raise_error
+    end
+  end
+  
+  context "(key namespacing)" do
+    it "should (transparently) prepend the supplied prefix to the key of the created object" do
+      store = {}
+      HashPersistent::Basic.setup(store, "a_namespace::")
+      new_object = HashPersistent::Basic.new("a_key")
+      new_object.class.should == HashPersistent::Basic
+      new_object.key.should == "a_key"
+      store.should_not have_key("a_key")
+      store.should     have_key("a_namespace::a_key")
+    end
+
+    it "should correctly find objects when given a namespace" do
+      HashPersistent::Basic.setup({}, "a_namespace::")
+      HashPersistent::Basic.new("a_key")
+      new_object = HashPersistent::Basic.find("a_key")
+      new_object.should_not be_nil
+      new_object.key.should == "a_key"
+    end
+
+    it "should not find objects when mistakenly given a namespaced key" do
+      HashPersistent::Basic.setup({}, "a_namespace::")
+      HashPersistent::Basic.new("a_key")
+      HashPersistent::Basic.find("a_namespace::a_key").should be_nil
+    end
+    
+    it "should correctly delete objects when given a namespace" do
+      store = {}
+      HashPersistent::Basic.setup(store, "a_namespace::")
+      new_object = HashPersistent::Basic.new("a_key")
+      new_object.delete
+      
+      HashPersistent::Basic.find("a_key").should be_nil
+      store.should_not have_key("a_namespace::a_key")
+    end
+  end
+  
+
+  class Dummy_BasicDerivedClass < HashPersistent::Basic
+    attr_accessor :dummy
+
+    def initialize(key, dummy)
+      super(key)
+      @dummy = dummy
+    end
+  end
+
+  context "(derived classes)" do
+    it "should correctly store the full member list of a derived class" do
+      Dummy_BasicDerivedClass.setup({}, "")
+      created_dummy = Dummy_BasicDerivedClass.new("a_key", 123)
+      created_dummy.key.should == "a_key"
+      created_dummy.dummy.should == 123
+
+      retrieved_dummy = Dummy_BasicDerivedClass.find("a_key")
+      retrieved_dummy.key.should == "a_key"
+      retrieved_dummy.dummy.should == 123
+    end
+  end  
+
+  context "(updating objects)" do
+    it "should correctly update members of a derived class" do
+      Dummy_BasicDerivedClass.setup({}, "prefix::")
+      created_dummy = Dummy_BasicDerivedClass.new("a_key", 123)
+      
+      duplicated_dummy = created_dummy.dup
+      duplicated_dummy.dummy = 456
+      duplicated_dummy.update
+
+      retrieved_dummy = Dummy_BasicDerivedClass.find("a_key")
+      retrieved_dummy.dummy.should_not == 123
+      retrieved_dummy.dummy.should     == 456
+    end
+
+    it "should not allow a deleted object to update" do
+      Dummy_BasicDerivedClass.setup({}, "prefix::")
+      created_dummy = Dummy_BasicDerivedClass.new("a_key", 123)
+      created_dummy.delete
+      created_dummy.dummy = 456
+      lambda{created_dummy.update}.should raise_error
+    end
+  end
+
+  context "(restricted hash api)" do
+    it "should use only the restricted hash api provided by moneta" do
+      lambda {
+        Dummy_BasicDerivedClass.setup(Dummy_RestrictedHash.new, "prefix::")
+        created_dummy = Dummy_BasicDerivedClass.new("a_key", 123)
+
+        duplicated_dummy = created_dummy.dup
+        duplicated_dummy.dummy = 456
+        duplicated_dummy.update
+
+        retrieved_dummy = Dummy_BasicDerivedClass.find("a_key")
+        retrieved_dummy.delete
+      }.should_not raise_error
+    end
+  end
+
+  context "(concurrent access)" do
+    it "should be careful doing various operations" do
+      # What to test here? Duplicate in the other similar classes
+      # Test: Update, update vs delete, delete vs find, update vs find
+      # Eugh, how best to do this? Options:
+      # Subclass Hash and slow the set/get methods down?
+      # Monkey patch the Mutex class to add lock/unlock callbacks?
+      pending
+    end
+  end
+end

data/spec/counting_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "HashPersistent::Counting" do
+  context "(before use)" do
+    it "should accept a hash-like store, and a string-like prefix, as class initialisers" do
+      HashPersistent::Counting.setup({}, "_prefix")
+    end
+
+    it "should reject a non-hash-like store" do
+      lambda {HashPersistent::Counting.setup(1, "_prefix")}.should raise_error(ArgumentError)
+    end
+
+    it "should reject a non-string-like prefix" do
+      lambda {HashPersistent::Counting.setup({}, Dummy_NoStringRep.new)}.should raise_error(ArgumentError)
+    end
+  end
+  
+  context "(creating objects)" do
+    it "should not allow objects to be created with a key" do
+      HashPersistent::Counting.setup({}, "")
+      lambda{HashPersistent::Counting.new("a_key")}.should raise_error
+    end
+
+    it "should allow objects to be created without a key" do
+      HashPersistent::Counting.setup({}, "")
+      lambda{HashPersistent::Counting.new}.should_not raise_error
+    end
+
+    it "should return an object after creation" do
+      HashPersistent::Counting.setup({}, "")
+      new_object = HashPersistent::Counting.new
+      new_object.class.should == HashPersistent::Counting
+    end
+
+    it "generate unique keys for each object creation" do
+      HashPersistent::Counting.setup({}, "")
+      keys = []
+      lots = 100 # How many is enough here? We just have to pick a number I guess...
+      lots.times do
+        keys << HashPersistent::Counting.new.key
+      end
+      keys.uniq.should == keys
+    end
+  end
+  
+  context "(retrieving objects)" do
+    it "should not return an object when no objects have been created" do
+      HashPersistent::Counting.setup({}, "")
+      HashPersistent::Counting.find("1").should be_nil
+    end
+
+    it "should return created objects when given the correct key" do
+      HashPersistent::Counting.setup({}, "")
+      key = HashPersistent::Counting.new.key
+      new_object = HashPersistent::Counting.find(key)
+      new_object.class.should == HashPersistent::Counting
+      new_object.key.should == key
+    end
+
+    it "should not return an object when given an incorrect key" do
+      HashPersistent::Counting.setup({}, "")
+      key = HashPersistent::Counting.new.key.to_s + "_not_a_valid_key"
+      HashPersistent::Counting.find(key).should be_nil
+    end
+  end
+  
+  context "(deleting objects)" do
+    it "should delete an object when asked" do
+      HashPersistent::Counting.setup({}, "")
+      new_object = HashPersistent::Counting.new
+      key = new_object.key
+      new_object.delete
+      HashPersistent::Counting.find(key).should be_nil
+    end
+    
+    it "should not allow an object to be deleted twice" do
+      HashPersistent::Counting.setup({}, "")
+      new_object = HashPersistent::Counting.new
+      new_object.delete
+      lambda{new_object.delete}.should raise_error
+    end
+  end
+  
+  context "(key namespacing)" do
+    it "should (transparently) prepend the supplied prefix to the key of the created object" do
+      store = {}
+      HashPersistent::Counting.setup(store, "a_namespace::")
+      new_object = HashPersistent::Counting.new
+      new_object.class.should == HashPersistent::Counting
+      store.should_not have_key("#{new_object.key}")
+      store.should_not have_key(new_object.key)
+      store.should     have_key("a_namespace::#{new_object.key}")
+    end
+
+    it "should correctly find objects when given a namespace" do
+      HashPersistent::Counting.setup({}, "a_namespace::")
+      key = HashPersistent::Counting.new.key
+      new_object = HashPersistent::Counting.find(key)
+      new_object.should_not be_nil
+      new_object.key.should == key
+    end
+
+    it "should not find objects when mistakenly given a namespaced key" do
+      HashPersistent::Counting.setup({}, "a_namespace::")
+      key = HashPersistent::Counting.new
+      HashPersistent::Counting.find("a_namespace::#{key}").should be_nil
+    end
+    
+    it "should correctly delete objects when given a namespace" do
+      store = {}
+      HashPersistent::Counting.setup(store, "a_namespace::")
+      new_object = HashPersistent::Counting.new
+      key = new_object.key
+      new_object.delete
+      
+      HashPersistent::Counting.find(key).should be_nil
+      store.should_not have_key("a_namespace::#{key}")
+    end
+  end
+  
+
+  class Dummy_CountingDerivedClass < HashPersistent::Counting
+    attr_accessor :dummy
+
+    def initialize(dummy)
+      super()
+      @dummy = dummy
+    end
+  end
+
+  context "(derived classes)" do
+    it "should correctly store the full member list of a derived class" do
+      Dummy_CountingDerivedClass.setup({}, "")
+      created_dummy = Dummy_CountingDerivedClass.new(123)
+      created_dummy.dummy.should == 123
+
+      retrieved_dummy = Dummy_CountingDerivedClass.find(created_dummy.key)
+      retrieved_dummy.key.should == created_dummy.key
+      retrieved_dummy.dummy.should == 123
+    end
+  end  
+
+  context "(updating objects)" do
+    it "should correctly update members of a derived class" do
+      Dummy_CountingDerivedClass.setup({}, "prefix::")
+      created_dummy = Dummy_CountingDerivedClass.new(123)
+      key = created_dummy.key
+      
+      duplicated_dummy = created_dummy.dup
+      duplicated_dummy.dummy = 456
+      duplicated_dummy.update
+      
+      retrieved_dummy = Dummy_CountingDerivedClass.find(key)
+      retrieved_dummy.dummy.should_not == 123
+      retrieved_dummy.dummy.should     == 456
+      
+      retrieved_dummy.key.should == key
+    end
+    
+    it "should not allow a deleted object to update" do
+      Dummy_CountingDerivedClass.setup({}, "prefix::")
+      created_dummy = Dummy_CountingDerivedClass.new(123)
+      created_dummy.delete
+      created_dummy.dummy = 456
+      lambda{created_dummy.update}.should raise_error
+    end
+  end
+
+  context "(restricted hash api)" do
+    it "should use only the restricted hash api provided by moneta" do
+      lambda {
+        Dummy_CountingDerivedClass.setup(Dummy_RestrictedHash.new, "prefix::")
+        created_dummy = Dummy_CountingDerivedClass.new(123)
+        key = created_dummy.key
+
+        duplicated_dummy = created_dummy.dup
+        duplicated_dummy.dummy = 456
+        duplicated_dummy.update
+
+        retrieved_dummy = Dummy_CountingDerivedClass.find(key)
+        retrieved_dummy.delete
+      }.should_not raise_error
+    end
+  end  
+
+  context "(concurrent access)" do
+    it "should be careful incrementing the auto-generated key" do
+      # TODO. Subclass Hash, adda delay into the []= method (or another one?)
+      # Kick off two threads and create a bunch of objects
+      # Collect keys into arrays, merge, sort and compare for equality with
+      # an array of sequential numbers the same size as the number of objects
+      # we created
+      pending
+    end
+  end  
+end