hyperactive 0.2.4 → 0.2.5

data/README

@@ -9,6 +9,7 @@ Hyperactive::Hash:: A collection class that contains any number of Hyperactive::
 Hyperactive::List:: A collection class that contains any number of Hyperactive::Records in a list like structure.
 Hyperactive::Index:: A module included into Hyperactive::Record that adds simple indexing capabilities of the <b>find_by_...</b> type.
 Hyperactive::Transactions:: A module included into Hyperactive::Record that adds a few simplifications in handling transactions properly.
+Hyperactive::Hooker:: A module that provides around-hook functinality to Hyperactive::Record, so that you can implement save, destroy, create and load hooks that wrap the actual event.
 
 == Usage:
 
@@ -21,19 +22,16 @@ You can also use <b>new</b> of course, but beware that this will not store the o
 <b>or</b> give you a proxy. Both of these things are good for you, so use get_instance unless you know
 what you are doing. 
 
-By loading Hyperactive::Record you will automatically define Hyperactive::CAPTAIN which will
-be an Archipelago::Pirate::Captain that is your interface to the distributed database.
-
 == Examples:
 
 To define a Record subclass that has the properties @active and @city that are indexed in two ways:
 
- class MyClass < Hyperactive::Record
+ class MyClass < Hyperactive::Record:Bass
    attr_accessor :active, :city
-   select(:active_records, Proc.new do |record|
+   select :active_records do |record|
    			      record.active == true
-                           end)
-   index_by(:city)
+                           end
+   index_by :city
  end
 
 This will allow you to find all active MyClass instances by:

data/lib/hyperactive/cleaner.rb

@@ -0,0 +1,91 @@
+# 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 for classes being aware of their dirtyness.
+  #
+  module Cleaner
+
+    #
+    # Include this to get the new accessor methods that automatically check if you are dirty.
+    #
+    module Accessors
+
+      #
+      # The +base+ class including this will get a our ClassMethods as well.
+      #
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+      end
+
+      #
+      # Replies whether we are dirty.
+      #
+      def dirty?
+        @dirty ||= false
+      end
+
+      #
+      # Mark us as dirty.
+      #
+      def is_dirty!
+        @dirty = true
+      end
+
+      #
+      # Mark us as clean.
+      #
+      def is_clean!
+        @dirty = false
+      end
+      
+      #
+      # The class methods that help us set/get instance variables in a dirt-aware way.
+      #
+      module ClassMethods
+        #
+        # Works like normal attr_writer but sets us to dirty.
+        #
+        def attr_writer(*attributes)
+          super
+          attributes.each do |attribute|
+            alias_method "hyperactive_cleaner_accessors_#{attribute}=", "#{attribute}="
+            define_method("#{attribute}=") do |new_value|
+              self.send("hyperactive_cleaner_accessors_#{attribute}=", new_value)
+              self.is_dirty!
+            end
+          end
+        end
+        
+        #
+        # Works like normal attr_accessor but with with dirt-aware attr_writer.
+        #
+        def attr_accessor(*attributes)
+          attr_reader(*attributes)
+          attr_writer(*attributes)
+        end
+        
+      end
+      
+    end
+
+  end
+
+end

data/lib/hyperactive/hash.rb

@@ -35,7 +35,11 @@ module Hyperactive
     # A wrapper class that knows what key, value and list_element belong together.
     #
     class Element < Hyperactive::Record::Bass
+
+      include Hyperactive::Cleaner::Accessors
+
       attr_accessor :key, :value, :list_element
+
       #
       # Initialize a new Hash::Element with given +key+, +value+ and +list_element+.
       #
@@ -52,9 +56,10 @@ module Hyperactive
     #
     class Head < Hyperactive::Record::Bass
 
-      attr_accessor :list
-
       include Archipelago::Current::ThreadedCollection
+      include Hyperactive::Cleaner::Accessors
+
+      attr_accessor :list
 
       #
       # Initialize a Hash::Head.
@@ -84,7 +89,7 @@ module Hyperactive
       # Return the value for +key+.
       #
       def [](key)
-        element = Hyperactive::CAPTAIN[my_key_for(key), @transaction]
+        element = Archipelago::Pirate::BLACKBEARD[my_key_for(key), @transaction]
         if element
           return element.value
         else
@@ -96,7 +101,7 @@ module Hyperactive
       # Returns whether +key+ is included in this Hash.
       #
       def include?(key)
-        Hyperactive::CAPTAIN.include?(my_key_for(key), @transaction)
+        Archipelago::Pirate::BLACKBEARD.include?(my_key_for(key), @transaction)
       end
 
       #
@@ -105,13 +110,13 @@ module Hyperactive
       def []=(key, value)
         self.list = Hyperactive::List::Head.get_instance_with_transaction(@transaction) unless self.list
 
-        if (element = Hyperactive::CAPTAIN[my_key_for(key), @transaction])
+        if (element = Archipelago::Pirate::BLACKBEARD[my_key_for(key), @transaction])
           element.value = value
         else          
           element = Element.get_instance_with_transaction(@transaction, key, value, nil)
           self.list << element
           element.list_element = self.list.last_element
-          Hyperactive::CAPTAIN[my_key_for(key), @transaction] = element
+          Archipelago::Pirate::BLACKBEARD[my_key_for(key), @transaction] = element
         end
       end
 
@@ -123,9 +128,9 @@ module Hyperactive
 
         return_value = nil
 
-        element = Hyperactive::CAPTAIN[my_key_for(key), @transaction]
+        element = Archipelago::Pirate::BLACKBEARD[my_key_for(key), @transaction]
         if element
-          Hyperactive::CAPTAIN.delete(my_key_for(key), @transaction)
+          Archipelago::Pirate::BLACKBEARD.delete(my_key_for(key), @transaction)
           self.list.unlink!(element.list_element)
           return_value = element.value
           element.destroy!

data/lib/hyperactive/index.rb

@@ -17,6 +17,10 @@
 
 module Hyperactive
 
+  #
+  # A package containing methods that will help you create automatically
+  # updated indexes of your Records.
+  #
   module Index
     
     #
@@ -70,12 +74,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::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
+            (Archipelago::Pirate::BLACKBEARD[old_key] ||= Hyperactive::Hash::Head.get_instance_with_transaction(record.transaction)).delete(record.record_id)
+            (Archipelago::Pirate::BLACKBEARD[new_key] ||= Hyperactive::Hash::Head.get_instance_with_transaction(record.transaction))[record.record_id] = record
           end
         else
           record = arguments.first
-          (CAPTAIN[get_key_for(record)] ||= Hyperactive::Hash::Head.get_instance_with_transaction(record.transaction)).delete(record.record_id)
+          (Archipelago::Pirate::BLACKBEARD[get_key_for(record)] ||= Hyperactive::Hash::Head.get_instance_with_transaction(record.transaction)).delete(record.record_id)
         end
       end
     end
@@ -107,32 +111,38 @@ module Hyperactive
         case @mode
         when :select
           if @matcher.call(record)
-            CAPTAIN[@key, record.transaction][record.record_id] = record
+            Archipelago::Pirate::BLACKBEARD[@key, record.transaction][record.record_id] = record
           else
-            CAPTAIN[@key, record.transaction].delete(record.record_id)
+            Archipelago::Pirate::BLACKBEARD[@key, record.transaction].delete(record.record_id)
           end
         when :reject
           if @matcher.call(record)
-            CAPTAIN[@key, record.transaction].delete(record.record_id)
+            Archipelago::Pirate::BLACKBEARD[@key, record.transaction].delete(record.record_id)
           else
-            CAPTAIN[@key, record.transaction][record.record_id] = record
+            Archipelago::Pirate::BLACKBEARD[@key, record.transaction][record.record_id] = record
           end
         when :delete_if_match
           if @matcher.call(record)
-            CAPTAIN[@key, record.transaction].delete(record.record_id)
+            Archipelago::Pirate::BLACKBEARD[@key, record.transaction].delete(record.record_id)
           end
         when :delete_unless_match
           unless @matcher.call(record)
-            CAPTAIN[@key, record.transaction].delete(record.record_id)
+            Archipelago::Pirate::BLACKBEARD[@key, record.transaction].delete(record.record_id)
           end
         end
       end
     end
 
     module Indexable
-      
+
       def self.append_features(base)
         super
+        base.class_eval do
+          #
+          # We depend on lots of hooks.
+          #
+          include(Hyperactive::Hooker::Pimp)
+        end
         base.extend(ClassMethods)
       end
       
@@ -147,7 +157,7 @@ module Hyperactive
           klass = self
           self.class.class_eval do
             define_method("find_by_#{attributes.join("_and_")}") do |*args|
-              CAPTAIN[IndexBuilder.get_key(klass, attributes, args)]
+              Archipelago::Pirate::BLACKBEARD[IndexBuilder.get_key(klass, attributes, args)]
             end
           end
           index_builder = IndexBuilder.new(self, attributes)
@@ -163,10 +173,10 @@ module Hyperactive
         #
         def select(name, &block) #:yields: instance
           key = collection_key(name)
-          CAPTAIN[key] ||= Hyperactive::Hash::Head.get_instance
+          Archipelago::Pirate::BLACKBEARD[key] ||= Hyperactive::Hash::Head.get_instance
           self.class.class_eval do
             define_method(name) do
-              CAPTAIN[key]
+              Archipelago::Pirate::BLACKBEARD[key]
             end
           end
           self.save_hooks << MatchSaver.new(key, block, :select)
@@ -181,10 +191,10 @@ module Hyperactive
         #
         def reject(name, &block) #:yields: instance
           key = collection_key(name)
-          CAPTAIN[key] ||= Hyperactive::Hash::Head.get_instance
+          Archipelago::Pirate::BLACKBEARD[key] ||= Hyperactive::Hash::Head.get_instance
           self.class.class_eval do
             define_method(name) do
-              CAPTAIN[key]
+              Archipelago::Pirate::BLACKBEARD[key]
             end
           end
           self.save_hooks << MatchSaver.new(key, block, :reject)

data/lib/hyperactive/list.rb

@@ -30,10 +30,11 @@ module Hyperactive
     # A wrapper class that knows its previous and next List::Elements as well as its value and the id of its list.
     #
     class Element < Hyperactive::Record::Bass
-      attr_accessor :previous, :next, :value, :list_id
 
       include Archipelago::Current::ThreadedCollection
 
+      attr_accessor :previous, :next, :value, :list_id
+
       #
       # Initialize this List::Element with given +previous_element+, +next_element+, +value+ and +list_id+.
       #
@@ -43,7 +44,6 @@ module Hyperactive
         self.value = value
         self.list_id = list_id
       end
-
       #
       # Yield to +block+ once for this and each following element.
       #
@@ -60,10 +60,11 @@ module Hyperactive
     # A List head.
     #
     class Head < Hyperactive::Record::Bass
-      attr_accessor :first_element, :last_element, :size
 
       include Archipelago::Current::ThreadedCollection
 
+      attr_accessor :first_element, :last_element, :size
+
       #
       # Create a List::Head. This is in essence the linked list.
       #

data/lib/hyperactive/record.rb

@@ -26,58 +26,65 @@ require 'archipelago'
 module Hyperactive
 
   #
-  # The default database connector.
+  # The host we are running on.
   #
-  CAPTAIN = Archipelago::Pirate::Captain.new
+  HOST = "#{Socket::gethostbyname(Socket::gethostname)[0]}" rescue "localhost"
   
   #
   # The package containing the base class Bass that simplifies
   # using archipelago for generic database stuff.
   #
   module Record
-    
-    #
-    # A convenient base class to inherit when you want the basic utility methods
-    # provided by for example ActiveRecord::Base *hint hint*.
+
     #
-    # 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 the instantiated object, instead call <b>my_instance.save</b>
-    # to get a proxy to the object stored into the database.
+    # The methods that make Hyperactive::Record::Bass persistent.
     #
-    class Bass
+    module Persistent
 
-      include Hyperactive::Index::Indexable
-      include Hyperactive::Transactions::Accessors
-      include Hyperactive::Transactions::Participant
-      include Hyperactive::Hooker::Pimp
-      
       #
-      # The host we are running on.
+      # Give the class a @record_id getter/setter pair, @transaction getter/setter pair, 
+      # our instance methods and the class methods of ClassMethods.
       #
-      HOST = "#{Socket::gethostbyname(Socket::gethostname)[0]}" rescue "localhost"
+      def self.append_features(base)
+        super
 
-      #
-      # Return the record with +record_id+, optionally within a +transaction+.
-      #
-      def self.find(record_id, transaction = nil)
-        CAPTAIN[record_id, transaction]
+        base.class_eval do
+          #
+          # Our semi-unique id.
+          #
+          attr_reader :record_id
+          #
+          # The transaction we are currently in.
+          #
+          attr_reader :transaction
+        end
+
+        base.extend(ClassMethods)
       end
 
       #
-      # Utility method to get a proxy to a newly saved instance of this class in one call.
+      # Will execute +block+ within a transaction.
       #
-      def self.get_instance(*args)
-        instance = self.new(*args)
-        return instance.create
-      end
-    
+      # What it does is just set the @transaction instance variable
+      # before calling the block, and unsetting it after.
       #
-      # Our semi-unique id.
+      # This means that any classes that want to be transaction sensitive
+      # need to take heed regarding the @transaction instance variable.
       #
-      attr_reader :record_id
+      # 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
+          return yield
+        ensure
+          @transaction = nil
+        end
+      end
 
       #
       # Utility compare method. Override as you please.
@@ -90,11 +97,6 @@ module Hyperactive
         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.
       #
@@ -105,10 +107,10 @@ module Hyperactive
         @transaction ||= nil
 
         self.class.with_hooks(:instance => self, :hooks => self.class.create_hooks) do
-          CAPTAIN[self.record_id, @transaction] = self
+          Archipelago::Pirate::BLACKBEARD[self.record_id, @transaction] = self
         end
         
-        proxy = CAPTAIN[@record_id, @transaction]
+        proxy = Archipelago::Pirate::BLACKBEARD[@record_id, @transaction]
         
         return proxy
       end
@@ -120,11 +122,60 @@ module Hyperactive
       #
       def destroy!
         self.class.with_hooks(:instance => self, :hooks => self.class.destroy_hooks) do
-          CAPTAIN.delete(@record_id, @transaction)
+          Archipelago::Pirate::BLACKBEARD.delete(@record_id, @transaction)
           self.freeze
         end
       end
       
+      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
+        
+        #
+        # Return the record with +record_id+, optionally within a +transaction+.
+        #
+        def find(record_id, transaction = nil)
+          Archipelago::Pirate::BLACKBEARD[record_id, transaction]
+        end
+        
+        #
+        # Utility method to get a proxy to a newly saved instance of this class in one call.
+        #
+        def get_instance(*args)
+          instance = self.new(*args)
+          return instance.create
+        end
+    
+      end
+
+    end
+
+    #
+    # A convenient base class to inherit when you want the basic utility methods
+    # provided by for example ActiveRecord::Base *hint hint*.
+    #
+    # 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 the instantiated object, instead call <b>my_instance.save</b>
+    # to get a proxy to the object stored into the database.
+    #
+    class Bass
+
+      include Hyperactive::Record::Persistent
+      include Hyperactive::Index::Indexable
+      include Hyperactive::Transactions::Accessors
+
     end
   end
 end

data/lib/hyperactive/transactions.rb

@@ -22,68 +22,6 @@ module Hyperactive
   #
   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.
     #
@@ -105,9 +43,11 @@ module Hyperactive
         # Works like normal attr_reader but with transactional awareness.
         #
         def attr_reader(*attributes)
+          super
           attributes.each do |attribute|
+            alias_method "hyperactive_transactions_accessors_#{attribute}", attribute
             define_method(attribute) do
-              value = instance_variable_get("@#{attribute}")
+              value = self.send("hyperactive_transactions_accessors_#{attribute}")
               if Archipelago::Treasure::Dubloon === value
                 if @transaction ||= nil
                   return value.join(@transaction)
@@ -125,13 +65,15 @@ module Hyperactive
         # Works like normal attr_writer but with transactional awareness.
         #
         def attr_writer(*attributes)
+          super
           attributes.each do |attribute|
+            alias_method "hyperactive_transactions_accessors_#{attribute}=", "#{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)
+                self.send("hyperactive_transactions_accessors_#{attribute}=", new_value)
               else
-                instance_variable_set("@#{attribute}", new_value)
+                self.send("hyperactive_transactions_accessors_#{attribute}=", new_value)
               end
             end
           end

data/lib/hyperactive.rb

@@ -20,6 +20,7 @@ $: << File.dirname(__FILE__)
 require 'hyperactive/hooker'
 require 'hyperactive/index'
 require 'hyperactive/transactions'
+require 'hyperactive/cleaner'
 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::CAPTAIN.setup(:chest_description => {:class => 'TestChest'},
+    Archipelago::Pirate::BLACKBEARD.setup(:chest_description => {:class => 'TestChest'},
                                :tranny_description => {:class => 'TestManager'})
     assert_within(20) do
-      Set.new(Hyperactive::CAPTAIN.chests.keys) == Set.new([@c.service_id, @c2.service_id])
+      Set.new(Archipelago::Pirate::BLACKBEARD.chests.keys) == Set.new([@c.service_id, @c2.service_id])
     end
     assert_within(20) do
-      Hyperactive::CAPTAIN.trannies.keys == [@tm.service_id]
+      Archipelago::Pirate::BLACKBEARD.trannies.keys == [@tm.service_id]
     end
   end
 
@@ -36,8 +36,8 @@ class HashBenchmark < Test::Unit::TestCase
   end
 
   def test_regular_hash_set_get
-    Hyperactive::CAPTAIN["h"] = {}
-    h = Hyperactive::CAPTAIN["h"]
+    Archipelago::Pirate::BLACKBEARD["h"] = {}
+    h = Archipelago::Pirate::BLACKBEARD["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::CAPTAIN.setup(:chest_description => {:class => 'TestChest'},
+    Archipelago::Pirate::BLACKBEARD.setup(:chest_description => {:class => 'TestChest'},
                                :tranny_description => {:class => 'TestManager'})
-    Hyperactive::CAPTAIN.update_services!
+    Archipelago::Pirate::BLACKBEARD.update_services!
     assert_within(10) do
-      Hyperactive::CAPTAIN.chests.keys.sort == [@c.service_id, @c2.service_id].sort
+      Archipelago::Pirate::BLACKBEARD.chests.keys.sort == [@c.service_id, @c2.service_id].sort
     end
     assert_within(10) do
-      Hyperactive::CAPTAIN.trannies.keys == [@tm.service_id]
+      Archipelago::Pirate::BLACKBEARD.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::CAPTAIN[h.record_id][k])
+      assert_equal(v, Archipelago::Pirate::BLACKBEARD[h.record_id][k])
     end
   end
 

data/tests/list_benchmark.rb

@@ -10,13 +10,13 @@ class ListBenchmark < Test::Unit::TestCase
     @c2.publish!
     @tm = TestManager.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("tranny1.db")))
     @tm.publish!
-    Hyperactive::CAPTAIN.setup(:chest_description => {:class => 'TestChest'},
+    Archipelago::Pirate::BLACKBEARD.setup(:chest_description => {:class => 'TestChest'},
                                :tranny_description => {:class => 'TestManager'})
     assert_within(20) do
-      Set.new(Hyperactive::CAPTAIN.chests.keys) == Set.new([@c.service_id, @c2.service_id])
+      Set.new(Archipelago::Pirate::BLACKBEARD.chests.keys) == Set.new([@c.service_id, @c2.service_id])
     end
     assert_within(20) do
-      Hyperactive::CAPTAIN.trannies.keys == [@tm.service_id]
+      Archipelago::Pirate::BLACKBEARD.trannies.keys == [@tm.service_id]
     end
   end
 

data/tests/list_test.rb

@@ -18,14 +18,14 @@ class ListTest < Test::Unit::TestCase
     @c2.publish!
     @tm = TestManager.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("tranny1.db")))
     @tm.publish!
-    Hyperactive::CAPTAIN.setup(:chest_description => {:class => 'TestChest'},
+    Archipelago::Pirate::BLACKBEARD.setup(:chest_description => {:class => 'TestChest'},
                                :tranny_description => {:class => 'TestManager'})
-    Hyperactive::CAPTAIN.update_services!
+    Archipelago::Pirate::BLACKBEARD.update_services!
     assert_within(10) do
-      Hyperactive::CAPTAIN.chests.keys.sort == [@c.service_id, @c2.service_id].sort
+      Archipelago::Pirate::BLACKBEARD.chests.keys.sort == [@c.service_id, @c2.service_id].sort
     end
     assert_within(10) do
-      Hyperactive::CAPTAIN.trannies.keys == [@tm.service_id]
+      Archipelago::Pirate::BLACKBEARD.trannies.keys == [@tm.service_id]
     end
   end
 
@@ -56,8 +56,8 @@ class ListTest < Test::Unit::TestCase
     r1 = l.first_element.record_id
     r2 = l.record_id
     l.destroy!
-    assert(!Hyperactive::CAPTAIN.include?(r1))
-    assert(!Hyperactive::CAPTAIN.include?(r2))
+    assert(!Archipelago::Pirate::BLACKBEARD.include?(r1))
+    assert(!Archipelago::Pirate::BLACKBEARD.include?(r2))
   end
 
   def test_each

data/tests/record_test.rb

@@ -37,14 +37,14 @@ class RecordTest < Test::Unit::TestCase
     @c2.publish!
     @tm = TestManager.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("tranny1.db")))
     @tm.publish!
-    Hyperactive::CAPTAIN.setup(:chest_description => {:class => 'TestChest'},
+    Archipelago::Pirate::BLACKBEARD.setup(:chest_description => {:class => 'TestChest'},
                                :tranny_description => {:class => 'TestManager'})
-    Hyperactive::CAPTAIN.update_services!
+    Archipelago::Pirate::BLACKBEARD.update_services!
     assert_within(10) do
-      Hyperactive::CAPTAIN.chests.keys.sort == [@c.service_id, @c2.service_id].sort
+      Archipelago::Pirate::BLACKBEARD.chests.keys.sort == [@c.service_id, @c2.service_id].sort
     end
     assert_within(10) do
-      Hyperactive::CAPTAIN.trannies.keys == [@tm.service_id]
+      Archipelago::Pirate::BLACKBEARD.trannies.keys == [@tm.service_id]
     end
     $BEFORE_SAVE = 0
     $AFTER_SAVE = 0
@@ -140,13 +140,13 @@ class RecordTest < Test::Unit::TestCase
     assert_equal(2, $BEFORE_SAVE)
     assert_equal(2, $AFTER_SAVE)
     assert_equal("brunt", r.bajs)
-    assert_equal("brunt", Hyperactive::CAPTAIN[r.record_id].bajs)
+    assert_equal("brunt", Archipelago::Pirate::BLACKBEARD[r.record_id].bajs)
     i = r.record_id
-    assert_equal(r, Hyperactive::CAPTAIN[i])
+    assert_equal(r, Archipelago::Pirate::BLACKBEARD[i])
     r.destroy!
     assert_equal(1, $BEFORE_DESTROY)
     assert_equal(1, $AFTER_DESTROY)
-    assert_equal(nil, Hyperactive::CAPTAIN[i])
+    assert_equal(nil, Archipelago::Pirate::BLACKBEARD[i])
   end
 
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: hyperactive
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
-date: 2006-12-02 00:00:00 +01:00
+  version: 0.2.5
+date: 2006-12-20 00:00:00 +01:00
 summary: A base class for persistent objects that uses archipelago for persistence. Useful for Ruby on Rails models for example.
 require_paths: 
 - lib
@@ -29,6 +29,7 @@ authors:
 - Martin Kihlgren
 files: 
 - lib/hyperactive.rb
+- lib/hyperactive/cleaner.rb
 - lib/hyperactive/hash.rb
 - lib/hyperactive/hooker.rb
 - lib/hyperactive/index.rb