hyperactive 0.2.2 → 0.2.3

data/lib/hyperactive/record.rb

@@ -61,7 +61,7 @@ module Hyperactive
         @attributes = attributes
       end
       #
-      # Get the Tree for the given +record+.
+      # Get the key for the given +record+.
       #
       def get_key_for(record)
         values = @attributes.collect do |att|
@@ -92,12 +92,12 @@ module Hyperactive
           old_key = get_key_for(old_record)
           new_key = get_key_for(record)
           if old_key != new_key
-            (CAPTAIN[old_key] ||= Hyperactive::Tree::Root.get_instance).delete(record.record_id)
-            (CAPTAIN[new_key] ||= Hyperactive::Tree::Root.get_instance)[record.record_id] = record
+            (CAPTAIN[old_key] ||= Hyperactive::Hash::Head.get_instance_with_transaction(record.transaction)).delete(record.record_id)
+            (CAPTAIN[new_key] ||= Hyperactive::Hash::Head.get_instance_with_transaction(record.transaction))[record.record_id] = record
           end
         else
           record = argument
-          (CAPTAIN[get_key_for(record)] ||= Hyperactive::Tree::Root.get_instance).delete(record.record_id)
+          (CAPTAIN[get_key_for(record)] ||= Hyperactive::Hash::Head.get_instance_with_transaction(record.transaction)).delete(record.record_id)
         end
       end
     end
@@ -130,23 +130,23 @@ module Hyperactive
         case @mode
         when :select
           if @matcher.call(record)
-            CAPTAIN[@key][record.record_id] = record
+            CAPTAIN[@key, record.transaction][record.record_id] = record
           else
-            CAPTAIN[@key].delete(record.record_id)
+            CAPTAIN[@key, record.transaction].delete(record.record_id)
           end
         when :reject
           if @matcher.call(record)
-            CAPTAIN[@key].delete(record.record_id)
+            CAPTAIN[@key, record.transaction].delete(record.record_id)
           else
-            CAPTAIN[@key][record.record_id] = record
+            CAPTAIN[@key, record.transaction][record.record_id] = record
           end
         when :delete_if_match
           if @matcher.call(record)
-            CAPTAIN[@key].delete(record.record_id)
+            CAPTAIN[@key, record.transaction].delete(record.record_id)
           end
         when :delete_unless_match
           unless @matcher.call(record)
-            CAPTAIN[@key].delete(record.record_id)
+            CAPTAIN[@key, record.transaction].delete(record.record_id)
           end
         end
       end
@@ -156,20 +156,19 @@ module Hyperactive
     # A convenient base class to inherit when you want the basic utility methods
     # provided by for example ActiveRecord::Base *hint hint*.
     #
-    # NB: After an instance is created, it will actually return a copy <b>within your local machine</b>
-    # which is not what is usually the case. Every other time you fetch it using a select or other
+    # NB: When an instance is created you will actually have a copy <b>within your local machine</b>
+    # which is not what you usually want. Every other time you fetch it using a select or other
     # method you will instead receive a proxy object to the database. This means that nothing you
     # do to it at that point will be persistent or even necessarily have a defined result. 
-    # Therefore: do not use <b>MyRecordSubclass.new</b> to <b>MyRecordSubclass#initialize</b> objects,
-    # instead use <b>MyRecordSubclass.get_instance</b>, since it will return a fresh proxy object
-    # instead of the devious original:
-    #  my_instance = MyRecordSubclass.get_instance(*the_same_arguments_as_to_initialize)
+    # Therefore: do not use the instantiated object, instead call <b>my_instance.save</b>
+    # to get a proxy to the object stored into the database.
     #
     class Bass
       
       @@create_hooks_by_class = {}
       @@destroy_hooks_by_class = {}
       @@save_hooks_by_class = {}
+      @@load_hooks_by_class = {}
 
       #
       # The host we are running on.
@@ -184,6 +183,50 @@ module Hyperactive
         CAPTAIN.setup(options[:pirate_options])
       end
 
+      #
+      # Works like normal attr_reader but with transactional awareness.
+      #
+      def self.attr_reader(*attributes)
+        attributes.each do |attribute|
+          define_method(attribute) do
+            value = instance_variable_get("@#{attribute}")
+            if Archipelago::Treasure::Dubloon === value
+              if @transaction ||= nil
+                return value.join(@transaction)
+              else
+                return value
+              end
+            else
+              return value
+            end
+          end
+        end
+      end
+
+      #
+      # Works like normal attr_writer but with transactional awareness.
+      #
+      def self.attr_writer(*attributes)
+        attributes.each do |attribute|
+          define_method("#{attribute}=") do |new_value|
+            if Archipelago::Treasure::Dubloon === new_value
+              new_value.assert_transaction(@transaction) if @transaction ||= nil
+              instance_variable_set("@#{attribute}", new_value)
+            else
+              instance_variable_set("@#{attribute}", new_value)
+            end
+          end
+        end
+      end
+
+      #
+      # Works like normal attr_accessor but with transactional awareness.
+      #
+      def self.attr_accessor(*attributes)
+        attr_reader(*attributes)
+        attr_writer(*attributes)
+      end
+
       #
       # Return our create_hooks, which can then be treated as any old Array.
       #
@@ -218,6 +261,23 @@ module Hyperactive
         self.get_hook_array_by_class(@@destroy_hooks_by_class)
       end
 
+      #
+      # Return our load_hooks, which can then be treated as any old Array.
+      #
+      # These must be <b>call</b>able objects with an arity of 1
+      # that will be sent the instance about to be loaded (insertion
+      # into the live hash of the database in question) that take a block argument.
+      # 
+      # The block argument will be a Proc that actually puts the
+      # instance into the live hash.
+      #
+      # Use this to preprocess, validate and/or postprocess your
+      # instances upon loading.
+      #
+      def self.load_hooks
+        self.get_hook_array_by_class(@@load_hooks_by_class)
+      end
+
       #
       # Return our save_hooks, which can then be treated as any old Array.
       #
@@ -263,7 +323,7 @@ END
       #
       def self.select(name, &block)
         key = self.collection_key(name)
-        CAPTAIN[key] ||= Hyperactive::Tree::Root.get_instance
+        CAPTAIN[key] ||= Hyperactive::Hash::Head.get_instance
         self.class_eval <<END
 def self.#{name}
     CAPTAIN["#{key}"]
@@ -283,9 +343,9 @@ END
       # does not return true. Will only return instances saved after this
       # rejector is defined.
       #
-    def self.reject(name, &block)
+      def self.reject(name, &block)
         key = self.collection_key(name)
-        CAPTAIN[key] ||= Hyperactive::Tree::Root.get_instance
+        CAPTAIN[key] ||= Hyperactive::Hash::Head.get_instance
         self.class_eval <<END
 def self.#{name}
     CAPTAIN["#{key}"]
@@ -300,44 +360,90 @@ END
       end
 
       #
-      # Return the record with +record_id+.
+      # Return the record with +record_id+, optionally within a +transaction+.
       #
-      def self.find(record_id)
-        CAPTAIN[record_id]
+      def self.find(record_id, transaction = nil)
+        CAPTAIN[record_id, transaction]
+      end
+
+      #
+      # Utility method to get a proxy to a newly saved instance of this class in one call.
+      #
+      def self.get_instance(*args)
+        instance = self.new(*args)
+        return instance.create
       end
     
       #
-      # Will execute +block+ within a transaction.
+      # Utility method to get a proxy to a within a transaction newly saved instance of this class in one call.
       #
-      def self.transaction(&block)
-        CAPTAIN.transaction(&block)
+      def self.get_instance_with_transaction(transaction, *args)
+        instance = self.new(*args)
+        return_value = nil
+        instance.with_transaction(transaction) do
+          return_value = instance.create
+        end
+        return return_value
       end
+    
+      #
+      # Our semi-unique id.
+      #
+      attr_reader :record_id, :transaction
 
       #
-      # Use this method to get new instances of this class, since it will actually 
-      # make sure it both resides in the database and return a proxy to the remote
-      # object.
+      # Utility compare method. Override as you please.
       #
-      def self.get_instance(*arguments)
-        instance = self.new(*arguments)
-        instance.instance_eval do
-          @record_id = Digest::SHA1.hexdigest("#{HOST}:#{Time.new.to_f}:#{self.object_id}:#{rand(1 << 32)}")
+      def <=>(o)
+        if Record === o
+          @record_id <=> o.record_id 
+        else
+          0
         end
+      end
+      
+      #
+      # Save this Record instance into the distributed database and return a proxy to the saved object.
+      #
+      # This will also wrap the actual insertion within the create_hooks you have defined for this class.
+      #
+      def create
+        @record_id ||= Digest::SHA1.hexdigest("#{HOST}:#{Time.new.to_f}:#{self.object_id}:#{rand(1 << 32)}").to_s
+        @transaction ||= nil
         
-        Hyperactive::Hooker.call_with_hooks(instance, *self.create_hooks) do
-          CAPTAIN[instance.record_id] = instance
+        Hyperactive::Hooker.call_with_hooks(self, *self.class.create_hooks) do
+          CAPTAIN[self.record_id, @transaction] = self
         end
         
-        proxy = CAPTAIN[instance.record_id]
+        proxy = CAPTAIN[@record_id, @transaction]
         
         return proxy
       end
-      
+
       #
-      # Our semi-unique id.
+      # Will execute +block+ within a transaction.
       #
-      attr_reader :record_id
-      
+      # What it does is just set the @transaction instance variable
+      # before calling the block, and unsetting it after.
+      #
+      # This means that any classes that want to be transaction sensitive
+      # need to take heed regarding the @transaction instance variable.
+      #
+      # For example, when creating new Record instances you may want to use
+      # get_instance_with_transaction(@transaction, *args) to ensure that the
+      # new instance exists within the same transaction as yourself.
+      #
+      # See Hyperactive::List::Head and Hyperactive::Hash::Head for examples of this behaviour.
+      #
+      def with_transaction(transaction, &block)
+        @transaction = transaction
+        begin
+          yield
+        ensure
+          @transaction = nil
+        end
+      end
+
       #
       # This will allow us to wrap any write of us to persistent storage
       # in the @@save_hooks as long as the Archipelago::Hashish provider
@@ -350,6 +456,18 @@ END
         end
       end
       
+      #
+      # This will allow us to wrap any load of us from persistent storage
+      # in the @@load_hooks as long as the Archipelago::Hashish provider
+      # supports it. See Archipelago::Hashish::BerkeleyHashish for an example
+      # of Hashish providers that do this.
+      #
+      def load_hook(&block)
+        Hyperactive::Hooker.call_with_hooks(self, *self.class.load_hooks) do
+          yield
+        end
+      end
+      
       #
       # Remove this instance from the database calling all the right hooks.
       #
@@ -360,9 +478,9 @@ END
       #
       # Returns true otherwise.
       #
-      def destroy
+      def destroy!
         Hyperactive::Hooker.call_with_hooks(self, *self.class.destroy_hooks) do
-          CAPTAIN.delete(@record_id)
+          CAPTAIN.delete(@record_id, @transaction)
           self.freeze
         end
       end

data/tests/{tree_benchmark.rb → hash_benchmark.rb}

@@ -1,7 +1,7 @@
 
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class TreeBenchmark < Test::Unit::TestCase
+class HashBenchmark < Test::Unit::TestCase
 
   def setup
     @c = TestChest.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("chest.db")))
@@ -22,17 +22,17 @@ class TreeBenchmark < Test::Unit::TestCase
 
   def teardown
     @c.stop!
-    @c.persistence_provider.unlink
+    @c.persistence_provider.unlink!
     @c2.stop!
-    @c2.persistence_provider.unlink
+    @c2.persistence_provider.unlink!
     @tm.stop!
-    @tm.persistence_provider.unlink
+    @tm.persistence_provider.unlink!
   end
   
   def test_set_get
-    h = Hyperactive::Tree::Root.get_instance
+    h = Hyperactive::Hash::Head.get_instance
     r = Hyperactive::Record::Bass.get_instance
-    hash_test("Tree", h, r, 100)
+    hash_test("Hyperactive::Hash", h, r, 100)
   end
 
   def test_regular_hash_set_get

data/tests/{tree_test.rb → hash_test.rb}

@@ -10,7 +10,7 @@ class RecordMatcher
   end
 end
 
-class TreeTest < Test::Unit::TestCase
+class HashTest < Test::Unit::TestCase
   
   def setup
     @c = TestChest.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("chest.db")))
@@ -32,33 +32,34 @@ class TreeTest < Test::Unit::TestCase
 
   def teardown
     @c.stop!
-    @c.persistence_provider.unlink
+    @c.persistence_provider.unlink!
     @c2.stop!
-    @c2.persistence_provider.unlink
+    @c2.persistence_provider.unlink!
     @tm.stop!
-    @tm.persistence_provider.unlink
-    Archipelago::Disco::MC.clear!
-    Hyperactive::Record::CAPTAIN.update_services!
-    assert_within(10) do
-      Hyperactive::Record::CAPTAIN.chests.empty?
-    end
-    assert_within(10) do
-      Hyperactive::Record::CAPTAIN.trannies.empty?
-    end
+    @tm.persistence_provider.unlink!
   end
 
   def test_select_reject
-    h = Hyperactive::Tree::Root.get_instance
+    h = Hyperactive::Hash::Head.get_instance
     r1 = Hyperactive::Record::Bass.get_instance
     r2 = Hyperactive::Record::Bass.get_instance
     h[r1.record_id] = r1
     h[r2.record_id] = r2
-    assert_equal(r1.record_id, h.select(RecordMatcher.new(r1.record_id)).first.first)
-    assert_equal(r1.record_id, h.reject(RecordMatcher.new(r2.record_id)).keys.first)
+    assert_equal(r1.record_id, h.t_select(RecordMatcher.new(r1.record_id)).first.first)
+    assert_equal(r1.record_id, h.t_reject(RecordMatcher.new(r2.record_id)).first.first)
   end
   
+  def test_delete
+    h = Hyperactive::Hash::Head.get_instance
+    r = Hyperactive::Record::Bass.get_instance
+    h[r.record_id] = r
+    assert(h.include?(r.record_id))
+    h.delete(r.record_id)
+    assert(!h.include?(r.record_id))
+  end
+
   def test_set_get
-    h = Hyperactive::Tree::Root.get_instance
+    h = Hyperactive::Hash::Head.get_instance
     h2 = {}
     10.times do
       r = Hyperactive::Record::Bass.get_instance

data/tests/list_benchmark.rb

@@ -0,0 +1,48 @@
+
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ListBenchmark < Test::Unit::TestCase
+
+  def setup
+    @c = TestChest.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("chest.db")))
+    @c.publish!
+    @c2 = TestChest.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("chest2.db")))
+    @c2.publish!
+    @tm = TestManager.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("tranny1.db")))
+    @tm.publish!
+    Hyperactive::Record::CAPTAIN.setup(:chest_description => {:class => 'TestChest'},
+                               :tranny_description => {:class => 'TestManager'})
+    assert_within(20) do
+      Set.new(Hyperactive::Record::CAPTAIN.chests.keys) == Set.new([@c.service_id, @c2.service_id])
+    end
+    assert_within(20) do
+      Hyperactive::Record::CAPTAIN.trannies.keys == [@tm.service_id]
+    end
+  end
+
+  def teardown
+    @c.stop!
+    @c.persistence_provider.unlink!
+    @c2.stop!
+    @c2.persistence_provider.unlink!
+    @tm.stop!
+    @tm.persistence_provider.unlink!
+  end
+  
+  def test_set_get
+    l = Hyperactive::List::Head.get_instance
+    r = Hyperactive::Record::Bass.get_instance
+    bm("List::Head#push/pop", :n => 1000) do
+      l << r
+      l.pop
+    end
+    bm("List::Head#push", :n => 1000) do
+      l << r
+    end
+    bm("List::Head#push/pop (big)", :n => 1000) do
+      l << r
+      l.pop
+    end
+  end
+
+end