hyperactive 0.2.3 → 0.2.4

data/lib/hyperactive/record.rb

@@ -25,133 +25,17 @@ require 'archipelago'
 #
 module Hyperactive
 
+  #
+  # The default database connector.
+  #
+  CAPTAIN = Archipelago::Pirate::Captain.new
+  
   #
   # The package containing the base class Bass that simplifies
   # using archipelago for generic database stuff.
   #
   module Record
     
-    #
-    # The default database connector.
-    #
-    CAPTAIN = Archipelago::Pirate::Captain.new
-    
-    #
-    # A tiny <b>call</b>able class that saves stuff in
-    # indexes depending on certain attributes.
-    #
-    class IndexBuilder
-      #
-      # Get the first part of the key, that depends on the +attributes+.
-      #
-      def self.get_attribute_key_part(attributes)
-        "Hyperactive::IndexBuilder::#{attributes.join(",")}"
-      end
-      #
-      # Get the last part of the key, that depends on the +values+.
-      #
-      def self.get_value_key_part(values)
-        "#{values.join(",")}"
-      end
-      #
-      # Initialize an IndexBuilder giving it an array of +attributes+
-      # that will be indexed.
-      #
-      def initialize(attributes)
-        @attributes = attributes
-      end
-      #
-      # Get the key for the given +record+.
-      #
-      def get_key_for(record)
-        values = @attributes.collect do |att|
-          if record.respond_to?(att)
-            record.send(att)
-          else
-            nil
-          end
-        end
-        key = "#{self.class.get_attribute_key_part(@attributes)}::#{self.class.get_value_key_part(values)}"
-      end
-      #
-      # Call this IndexBuilder and pass it a +block+.
-      #
-      # If the +argument+ is an Array then we know we are a save hook, 
-      # otherwise we are a destroy hook.
-      #
-      def call(argument, &block)
-        yield
-
-        #
-        # If the argument is an Array (of old value, new value)
-        # then we are a save hook, otherwise a destroy hook.
-        #
-        if Array === argument
-          record = argument.last
-          old_record = argument.first
-          old_key = get_key_for(old_record)
-          new_key = get_key_for(record)
-          if old_key != new_key
-            (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::Hash::Head.get_instance_with_transaction(record.transaction)).delete(record.record_id)
-        end
-      end
-    end
-
-    #
-    # A tiny <b>call</b>able class that saves stuff inside containers
-    # if they match certain criteria.
-    #
-    class MatchSaver
-      #
-      # Initialize this MatchSaver with a +key+, a <b>call</b>able +matcher+
-      # and a +mode+ (:select, :reject, :delete_if_match or :delete_unless_match).
-      #
-      def initialize(key, matcher, mode)
-        @key = key
-        @matcher = matcher
-        @mode = mode
-      end
-      #
-      # Depending on <i>@mode</i> and return value of <i>@matcher</i>.call
-      # may save record in the Hash-like container named <i>@key</i> in
-      # the main database after having yielded to +block+.
-      #
-      def call(argument, &block)
-        yield
-
-        record = argument
-        record = argument.last if Array === argument
-
-        case @mode
-        when :select
-          if @matcher.call(record)
-            CAPTAIN[@key, record.transaction][record.record_id] = record
-          else
-            CAPTAIN[@key, record.transaction].delete(record.record_id)
-          end
-        when :reject
-          if @matcher.call(record)
-            CAPTAIN[@key, record.transaction].delete(record.record_id)
-          else
-            CAPTAIN[@key, record.transaction][record.record_id] = record
-          end
-        when :delete_if_match
-          if @matcher.call(record)
-            CAPTAIN[@key, record.transaction].delete(record.record_id)
-          end
-        when :delete_unless_match
-          unless @matcher.call(record)
-            CAPTAIN[@key, record.transaction].delete(record.record_id)
-          end
-        end
-      end
-    end
-
     #
     # A convenient base class to inherit when you want the basic utility methods
     # provided by for example ActiveRecord::Base *hint hint*.
@@ -164,201 +48,17 @@ module Hyperactive
     # 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 = {}
 
+      include Hyperactive::Index::Indexable
+      include Hyperactive::Transactions::Accessors
+      include Hyperactive::Transactions::Participant
+      include Hyperactive::Hooker::Pimp
+      
       #
       # The host we are running on.
       #
       HOST = "#{Socket::gethostbyname(Socket::gethostname)[0]}" rescue "localhost"
 
-      #
-      # Call this if you want to change the default database connector
-      # to something else.
-      #
-      def self.setup(options = {})
-        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.
-      #
-      # These must be <b>call</b>able objects with an arity of 1
-      # that will be sent the instance about to be created (initial
-      # insertion into the database system) that take a block argument.
-      # 
-      # The block argument will be a Proc that actually injects the
-      # instance into the database system.
-      #
-      # Use this to preprocess, validate and/or postprocess your
-      # instances upon creation.
-      #
-      def self.create_hooks
-        self.get_hook_array_by_class(@@create_hooks_by_class)
-      end
-
-      #
-      # Return our destroy_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 destroyed (removal
-      # from the database system) that take a block argument.
-      # 
-      # The block argument will be a Proc that actually removes the
-      # instance from the database system.
-      #
-      # Use this to preprocess, validate and/or postprocess your
-      # instances upon destruction.
-      #
-      def self.destroy_hooks
-        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.
-      #
-      # These must be <b>call</b>able objects with an arity of 1
-      # that will be sent [the old version, the new version] of the 
-      # instance about to be saved (storage into the database system) 
-      # along with a block argument.
-      # 
-      # The block argument will be a Proc that actually saves the
-      # instance into the database system.
-      #
-      # Use this to preprocess, validate and/or postprocess your
-      # instances upon saving.
-      #
-      def self.save_hooks
-        self.get_hook_array_by_class(@@save_hooks_by_class)
-      end
-
-      #
-      # Create an index for this class.
-      #
-      # Will create a method find_by_#{attributes.join("_and_")} for this
-      # class that will return what you expect.
-      #
-      def self.index_by(*attributes)
-        attribute_key_part = IndexBuilder.get_attribute_key_part(attributes)
-        self.class_eval <<END
-def self.find_by_#{attributes.join("_and_")}(*args)
-key = "#{attribute_key_part}::" + IndexBuilder.get_value_key_part(args)
-CAPTAIN[key]
-end
-END
-        index_builder = IndexBuilder.new(attributes)
-        self.save_hooks << index_builder
-        self.destroy_hooks << index_builder
-      end
-    
-      #
-      # Will define a method called +name+ that will include all
-      # existing instances of this class that when sent to +matcher+.call
-      # return true. Will only return instances saved after this selector
-      # is defined.
-      #
-      def self.select(name, &block)
-        key = self.collection_key(name)
-        CAPTAIN[key] ||= Hyperactive::Hash::Head.get_instance
-        self.class_eval <<END
-def self.#{name}
-    CAPTAIN["#{key}"]
-end
-END
-        self.save_hooks << MatchSaver.new(key, Proc.new do |arg|
-                                            yield(arg)
-                                          end, :select)
-        self.destroy_hooks << MatchSaver.new(key, Proc.new do |arg|
-                                               yield(arg)
-                                             end, :delete_if_match)
-      end
-
-      #
-      # Will define a method called +name+ that will include all
-      # existing instances of this class that when sent to +matcher+.call
-      # does not return true. Will only return instances saved after this
-      # rejector is defined.
-      #
-      def self.reject(name, &block)
-        key = self.collection_key(name)
-        CAPTAIN[key] ||= Hyperactive::Hash::Head.get_instance
-        self.class_eval <<END
-def self.#{name}
-    CAPTAIN["#{key}"]
-end
-END
-        self.save_hooks << MatchSaver.new(key, Proc.new do |arg|
-                                            yield(arg)
-                                          end, :reject)
-        self.destroy_hooks << MatchSaver.new(key, Proc.new do |arg|
-                                               yield(arg)
-                                             end, :delete_unless_match)
-      end
-
       #
       # Return the record with +record_id+, optionally within a +transaction+.
       #
@@ -374,22 +74,10 @@ END
         return instance.create
       end
     
-      #
-      # Utility method to get a proxy to a within a transaction newly saved instance of this class in one call.
-      #
-      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
+      attr_reader :record_id
 
       #
       # Utility compare method. Override as you please.
@@ -401,6 +89,11 @@ END
           0
         end
       end
+
+      def initialize
+        @record_id = nil
+        @transaction = nil
+      end
       
       #
       # Save this Record instance into the distributed database and return a proxy to the saved object.
@@ -410,8 +103,8 @@ END
       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(self, *self.class.create_hooks) do
+
+        self.class.with_hooks(:instance => self, :hooks => self.class.create_hooks) do
           CAPTAIN[self.record_id, @transaction] = self
         end
         
@@ -421,97 +114,17 @@ END
       end
 
       #
-      # Will execute +block+ within a transaction.
-      #
-      # 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
-      # supports it. See Archipelago::Hashish::BerkeleyHashish for an example
-      # of Hashish providers that do this.
-      #
-      def save_hook(old_value, &block)
-        Hyperactive::Hooker.call_with_hooks([old_value, self], *self.class.save_hooks) do
-          yield
-        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.
+      # Remove this instance from the database wrapped in our destroy_hooks.
       #
       # Freezes this instance after having deleted it.
       #
-      # Returns false without destroying anything if any of the @@pre_destroy_hooks
-      # returns false.
-      #
-      # Returns true otherwise.
-      #
       def destroy!
-        Hyperactive::Hooker.call_with_hooks(self, *self.class.destroy_hooks) do
+        self.class.with_hooks(:instance => self, :hooks => self.class.destroy_hooks) do
           CAPTAIN.delete(@record_id, @transaction)
           self.freeze
         end
       end
       
-      private
-      
-      #
-      # The key used to store the collection with the given +sym+ as name.
-      #
-      def self.collection_key(sym)
-        "Hyperactive::Record::Bass::collection_key::#{sym}"
-      end
-      
-      #
-      # Get an Array from +hash+ using <i>self</i> as
-      # key. If <i>self</i> doesnt exist in the +hash+
-      # it will recurse by calling the same method in the
-      # superclass until it has been called in Hyperactive::Record::Base.
-      #
-      def self.get_hook_array_by_class(hash)
-        return hash[self] if hash.include?(self)
-        
-        if self == Bass
-          hash[self] = []
-          return self.get_hook_array_by_class(hash)
-        else
-          hash[self] = self.superclass.get_hook_array_by_class(hash).clone
-          return self.get_hook_array_by_class(hash)
-        end
-      end
-      
     end
   end
 end

data/lib/hyperactive/transactions.rb

@@ -0,0 +1,154 @@
+# Archipelago - a distributed computing toolkit for ruby
+# Copyright (C) 2006  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+module Hyperactive
+
+  #
+  # A utility package of transaction handling methods.
+  #
+  module Transactions
+
+    #
+    # Include this to get methods to do with participating in a transaction.
+    #
+    module Participant
+
+      #
+      # The transaction we are currently in.
+      #
+      attr_reader :transaction
+
+      #
+      # Will execute +block+ within a transaction.
+      #
+      # 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
+
+      #
+      # Add our ClassMethods to anyone that includes us.
+      #
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+      end
+
+      #
+      # Class methods for transaction participants.
+      #
+      module ClassMethods
+        #
+        # Utility method to get a proxy to a within a transaction newly saved instance of this class in one call.
+        #
+        def 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
+        
+      end
+
+    end
+    
+    #
+    # Include this to get the default attr_reader at al redefined to be transactionally aware.
+    #
+    module Accessors
+
+      #
+      # The +base+ class including this will get a our ClassMethods as well.
+      #
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+      end
+      
+      #
+      # The class methods that help us set/get instance variables in a transactionally aware way.
+      #
+      module ClassMethods
+        #
+        # Works like normal attr_reader but with transactional awareness.
+        #
+        def 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 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 attr_accessor(*attributes)
+          attr_reader(*attributes)
+          attr_writer(*attributes)
+        end
+        
+      end
+      
+    end
+
+  end
+
+end

data/lib/hyperactive.rb

@@ -18,6 +18,8 @@
 $: << File.dirname(__FILE__)
 
 require 'hyperactive/hooker'
+require 'hyperactive/index'
+require 'hyperactive/transactions'
 require 'hyperactive/record'
 require 'hyperactive/hash'
 require 'hyperactive/list'

data/tests/hash_benchmark.rb

@@ -10,13 +10,13 @@ class HashBenchmark < Test::Unit::TestCase
     @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'},
+    Hyperactive::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])
+      Set.new(Hyperactive::CAPTAIN.chests.keys) == Set.new([@c.service_id, @c2.service_id])
     end
     assert_within(20) do
-      Hyperactive::Record::CAPTAIN.trannies.keys == [@tm.service_id]
+      Hyperactive::CAPTAIN.trannies.keys == [@tm.service_id]
     end
   end
 
@@ -36,8 +36,8 @@ class HashBenchmark < Test::Unit::TestCase
   end
 
   def test_regular_hash_set_get
-    Hyperactive::Record::CAPTAIN["h"] = {}
-    h = Hyperactive::Record::CAPTAIN["h"]
+    Hyperactive::CAPTAIN["h"] = {}
+    h = Hyperactive::CAPTAIN["h"]
     r = Hyperactive::Record::Bass.get_instance
     hash_test("Hash", h, r, 100)
   end

data/tests/hash_test.rb

@@ -19,14 +19,14 @@ class HashTest < Test::Unit::TestCase
     @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'},
+    Hyperactive::CAPTAIN.setup(:chest_description => {:class => 'TestChest'},
                                :tranny_description => {:class => 'TestManager'})
-    Hyperactive::Record::CAPTAIN.update_services!
+    Hyperactive::CAPTAIN.update_services!
     assert_within(10) do
-      Hyperactive::Record::CAPTAIN.chests.keys.sort == [@c.service_id, @c2.service_id].sort
+      Hyperactive::CAPTAIN.chests.keys.sort == [@c.service_id, @c2.service_id].sort
     end
     assert_within(10) do
-      Hyperactive::Record::CAPTAIN.trannies.keys == [@tm.service_id]
+      Hyperactive::CAPTAIN.trannies.keys == [@tm.service_id]
     end
   end
 
@@ -69,7 +69,7 @@ class HashTest < Test::Unit::TestCase
 
     h2.each do |k,v|
       assert_equal(v, h[k])
-      assert_equal(v, Hyperactive::Record::CAPTAIN[h.record_id][k])
+      assert_equal(v, Hyperactive::CAPTAIN[h.record_id][k])
     end
   end