tenacity 0.4.1 → 0.5.0

data/lib/tenacity/errors.rb

@@ -6,4 +6,12 @@ module Tenacity
   # Raised on attempt to update an associate that is instantiated as read only.
   class ReadOnlyError < TenacityError
   end
+
+  # Raised when one of the objects specified in the relationship does not exist in the database
+  class ObjectDoesNotExistError < TenacityError
+  end
+
+  # Rasied when an attempt is made to delete an object whose id is in use by an association
+  class ObjectIdInUseError < TenacityError
+  end
 end

data/lib/tenacity/instance_methods.rb

@@ -6,26 +6,51 @@ module Tenacity
     end
 
     def _t_save_autosave_associations
-      self.class._tenacity_associations.each do |association|
-        if association.autosave == true
-          if association.type == :t_has_one || association.type == :t_belongs_to
-            associate = instance_variable_get(_t_ivar_name(association))
-            autosave_save_or_destroy(associate) unless associate.nil?
-          elsif association.type == :t_has_many
-            associates = instance_variable_get(_t_ivar_name(association))
-            unless associates.nil?
-              associates.each { |associate| autosave_save_or_destroy(associate) }
-              instance_variable_set(_t_ivar_name(association), associates.reject { |associate| associate.marked_for_destruction? })
-            end
+      associations = self.class._tenacity_associations
+      self.class._tenacity_associations.select { |a| a.autosave == true }.each do |association|
+        if association.type == :t_has_one || association.type == :t_belongs_to
+          associate = instance_variable_get(_t_ivar_name(association))
+          autosave_save_or_destroy(associate) unless associate.nil?
+        elsif association.type == :t_has_many
+          associates = instance_variable_get(_t_ivar_name(association))
+          unless associates.nil?
+            associates.each { |associate| autosave_save_or_destroy(associate) }
+            instance_variable_set(_t_ivar_name(association), associates.reject { |associate| associate.marked_for_destruction? })
           end
         end
       end
     end
 
+    def _t_verify_associates_exist
+      associations_requiring_associate_validation.each do |association|
+        associate_id = self.send(association.foreign_key)
+        unless associate_id.nil?
+          associate_class = association.associate_class(self)
+          associate = associate_class._t_find(_t_serialize(associate_id, association))
+          raise ObjectDoesNotExistError.new("#{associate_class} object with an id of #{associate_id} does not exist!") if associate.nil?
+        end
+      end
+    end
+
     private
 
     def autosave_save_or_destroy(associate)
-      associate.marked_for_destruction? ? associate.destroy : associate.save
+      associate.marked_for_destruction? ? autosave_destroy(associate) : associate.save
+    end
+
+    def autosave_destroy(associate)
+      nullify_has_one_associations(associate)
+      associate.destroy
+    end
+
+    def nullify_has_one_associations(associate)
+      associate.class._tenacity_associations.select { |a| a.type == :t_has_one }.each do |association|
+        has_one_associate = associate.has_one_associate(association)
+        if has_one_associate
+          has_one_associate.send "#{association.foreign_key(associate.class)}=", nil
+          has_one_associate.save
+        end
+      end
     end
 
     def get_associate(association, params)
@@ -67,5 +92,10 @@ module Tenacity
       self.class._t_serialize(object, association)
     end
 
+    def associations_requiring_associate_validation
+      associations = self.class._tenacity_associations
+      associations.select { |a| a.foreign_key_constraints_enabled? && a.type == :t_belongs_to }
+    end
+
   end
 end

data/lib/tenacity/orm_ext/activerecord.rb

@@ -1,8 +1,7 @@
 module Tenacity
   module OrmExt
     # Tenacity relationships on ActiveRecord objects require that certain columns
-    # exist on the associated table, and that join tables exist for one-to-many
-    # relationships.  Take the following class for example:
+    # exist on the associated table. Take the following class for example:
     #
     #   class Car < ActiveRecord::Base
     #     include Tenacity
@@ -31,15 +30,8 @@ module Tenacity
     #
     # == t_has_many
     #
-    # The +t_has_many+ association requires that a join table exist to store the
-    # associations.  The name of the join table follows ActiveRecord conventions.
-    # The name of the join table in this example would be cars_wheels, since cars
-    # comes before wheels when shorted alphabetically.
-    #
-    #   create_table :cars_wheels do |t|
-    #     t.integer :car_id
-    #     t.string :wheel_id
-    #   end
+    # The +t_has_many+ association requires nothing special, as the associates
+    # are looked up using the associate class.
     #
     module ActiveRecord
 
@@ -77,17 +69,22 @@ module Tenacity
           find(:all, :conditions => ["#{property} = ?", _t_serialize(id)])
         end
 
+        def _t_find_all_ids_by_associate(property, id)
+          connection.select_values("SELECT id FROM #{table_name} WHERE #{property} = #{_t_serialize_id_for_sql(id)}")
+        end
+
         def _t_initialize_has_one_association(association)
-          after_destroy { |record| record._t_cleanup_has_one_association(association) }
+          before_destroy { |record| record._t_cleanup_has_one_association(association) }
         end
 
         def _t_initialize_tenacity
+          before_save { |record| record._t_verify_associates_exist }
           after_save { |record| record._t_save_autosave_associations }
         end
 
         def _t_initialize_has_many_association(association)
           after_save { |record| record.class._t_save_associates(record, association) }
-          after_destroy { |record| record._t_cleanup_has_many_association(association) }
+          before_destroy { |record| record._t_cleanup_has_many_association(association) }
         end
 
         def _t_initialize_belongs_to_association(association)
@@ -108,25 +105,7 @@ module Tenacity
 
         def _t_reload
           reload
-        end
-
-        def _t_clear_associates(association)
-          self.connection.execute("delete from #{association.join_table} where #{association.association_key} = #{_t_serialize_id_for_sql(self.id)}")
-        end
-
-        def _t_associate_many(association, associate_ids)
-          self.transaction do
-            _t_clear_associates(association)
-            associate_ids.each do |associate_id|
-              self.connection.execute("insert into #{association.join_table} (#{association.association_key}, #{association.association_foreign_key}) values (#{_t_serialize_id_for_sql(self.id)}, #{_t_serialize_id_for_sql(associate_id)})")
-            end
-          end
-        end
-
-        def _t_get_associate_ids(association)
-          return [] if self.id.nil?
-          rows = self.connection.execute("select #{association.association_foreign_key} from #{association.join_table} where #{association.association_key} = #{_t_serialize_id_for_sql(self.id)}")
-          ids = []; rows.each { |r| ids << r[0] }; ids
+          self
         end
       end
 

data/lib/tenacity/orm_ext/couchrest.rb

@@ -96,7 +96,13 @@ module Tenacity
           self.send("by_#{property}", :key => _t_serialize(id))
         end
 
+        def _t_find_all_ids_by_associate(property, id)
+          results = self.send("by_#{property}", :key => _t_serialize(id), :include_docs => false)
+          results['rows'].map { |r| r['id'] }
+        end
+
         def _t_initialize_tenacity
+          before_save { |record| record._t_verify_associates_exist }
           after_save { |record| record._t_save_autosave_associations }
         end
 
@@ -105,12 +111,8 @@ module Tenacity
         end
 
         def _t_initialize_has_many_association(association)
-          unless self.respond_to?(association.foreign_keys_property)
-            property association.foreign_keys_property, :type => [id_class_for(association)]
-            view_by association.foreign_keys_property
-            after_save { |record| record.class._t_save_associates(record, association) if record.class.respond_to?(:_t_save_associates) }
-            after_destroy { |record| record._t_cleanup_has_many_association(association) }
-          end
+          after_save { |record| record.class._t_save_associates(record, association) }
+          before_destroy { |record| record._t_cleanup_has_many_association(association) }
         end
 
         def _t_initialize_belongs_to_association(association)
@@ -135,22 +137,12 @@ module Tenacity
 
       module InstanceMethods #:nodoc:
         def _t_reload
-          return if self.id.nil?
-          new_doc = database.get(self.id)
-          self.clear
-          new_doc.each { |k,v| self[k] = new_doc[k] }
-        end
-
-        def _t_associate_many(association, associate_ids)
-          self.send(association.foreign_keys_property + '=', associate_ids)
-        end
-
-        def _t_get_associate_ids(association)
-          self.send(association.foreign_keys_property) || []
-        end
-
-        def _t_clear_associates(association)
-          self.send(association.foreign_keys_property + '=', [])
+          unless self.id.nil?
+            new_doc = database.get(self.id)
+            self.clear
+            new_doc.each { |k,v| self[k] = new_doc[k] }
+          end
+          self
         end
       end
 

data/lib/tenacity/orm_ext/datamapper.rb

@@ -1,8 +1,7 @@
 module Tenacity
   module OrmExt
     # Tenacity relationships on DataMapper objects require that certain columns
-    # exist on the associated table, and that join tables exist for one-to-many
-    # relationships.  Take the following class for example:
+    # exist on the associated table. Take the following class for example:
     #
     #   class Car
     #     include DataMapper::Resource
@@ -31,15 +30,8 @@ module Tenacity
     #
     # == t_has_many
     #
-    # The +t_has_many+ association requires that a join table exist to store the
-    # associations.  The name of the join table follows ActiveRecord conventions.
-    # The name of the join table in this example would be cars_wheels, since cars
-    # comes before wheels when shorted alphabetically.
-    #
-    #   create_table :car_wheels do
-    #     column :car_id, Integer
-    #     column :wheel_id, String
-    #   end
+    # The +t_has_many+ association requires nothing special, as the associates
+    # are looked up using the associate class.
     #
     module DataMapper
 
@@ -77,14 +69,22 @@ module Tenacity
           all(property => _t_serialize(id))
         end
 
+        def _t_find_all_ids_by_associate(property, id)
+          repository.adapter.select("SELECT id from #{storage_names[:default]} WHERE #{property} = #{_t_serialize_id_for_sql(id)}")
+        end
+
         def _t_initialize_tenacity
+          before :save do |record|
+            record._t_verify_associates_exist
+          end
+
           after :save do |record|
             record._t_save_autosave_associations
           end
         end
 
         def _t_initialize_has_one_association(association)
-          after :destroy do |record|
+          before :destroy do |record|
             record._t_cleanup_has_one_association(association)
           end
         end
@@ -94,7 +94,7 @@ module Tenacity
             record.class._t_save_associates(record, association)
           end
 
-          after :destroy do |record|
+          before :destroy do |record|
             record._t_cleanup_has_many_association(association)
           end
         end
@@ -131,24 +131,7 @@ module Tenacity
 
         def _t_reload
           reload
-        end
-
-        def _t_clear_associates(association)
-          self.repository.adapter.execute("delete from #{association.join_table} where #{association.association_key} = #{_t_serialize_id_for_sql(self.id)}")
-        end
-
-        def _t_associate_many(association, associate_ids)
-          self.transaction do
-            _t_clear_associates(association)
-            associate_ids.each do |associate_id|
-              self.repository.adapter.execute("insert into #{association.join_table} (#{association.association_key}, #{association.association_foreign_key}) values (#{_t_serialize_id_for_sql(self.id)}, #{_t_serialize_id_for_sql(associate_id)})")
-            end
-          end
-        end
-
-        def _t_get_associate_ids(association)
-          return [] if self.id.nil?
-          self.repository.adapter.select("select #{association.association_foreign_key} from #{association.join_table} where #{association.association_key} = #{_t_serialize_id_for_sql(self.id)}")
+          self.class._t_find(self.id)
         end
 
         private

data/lib/tenacity/orm_ext/helpers.rb

@@ -12,11 +12,11 @@ module Tenacity
         end
       end
 
-      def _t_serialize_ids(ids)
+      def _t_serialize_ids(ids, association=nil)
         if ids.respond_to?(:map)
-          ids.map { |id| _t_serialize(id) }
+          ids.map { |id| _t_serialize(id, association) }
         else
-          _t_serialize(ids)
+          _t_serialize(ids, association)
         end
       end
 

data/lib/tenacity/orm_ext/mongo_mapper.rb

@@ -4,7 +4,7 @@ module Tenacity
     # defined on the object.  Tenacity will define the keys that it needs
     # to support the relationships.  Take the following class for example:
     #
-    #   class Car < ActiveRecord::Base
+    #   class Car
     #     include MongoMapper::Document
     #     include Tenacity
     #
@@ -65,20 +65,23 @@ module Tenacity
           all(property => _t_serialize(id))
         end
 
+        def _t_find_all_ids_by_associate(property, id)
+          results = collection.find({property => _t_serialize(id)}, {:fields => 'id'}).to_a
+          results.map { |r| r['_id'] }
+        end
+
         def _t_initialize_tenacity
+          before_save { |record| record._t_verify_associates_exist }
           after_save { |record| record._t_save_autosave_associations }
         end
 
         def _t_initialize_has_one_association(association)
-          after_destroy { |record| record._t_cleanup_has_one_association(association) }
+          before_destroy { |record| record._t_cleanup_has_one_association(association) }
         end
 
         def _t_initialize_has_many_association(association)
-          unless self.respond_to?(association.foreign_keys_property)
-            key association.foreign_keys_property, Array
-            after_save { |record| record.class._t_save_associates(record, association) }
-            after_destroy { |record| record._t_cleanup_has_many_association(association) }
-          end
+          after_save { |record| record.class._t_save_associates(record, association) }
+          before_destroy { |record| record._t_cleanup_has_many_association(association) }
         end
 
         def _t_initialize_belongs_to_association(association)
@@ -100,21 +103,12 @@ module Tenacity
 
       module InstanceMethods #:nodoc:
         def _t_reload
-          reload
-        rescue ::MongoMapper::DocumentNotFound
-          nil
-        end
-
-        def _t_associate_many(association, associate_ids)
-          self.send(association.foreign_keys_property + '=', associate_ids)
-        end
-
-        def _t_get_associate_ids(association)
-          self.send(association.foreign_keys_property)
-        end
-
-        def _t_clear_associates(association)
-          self.send(association.foreign_keys_property + '=', [])
+          begin
+            reload
+          rescue ::MongoMapper::DocumentNotFound
+            # Ignore
+          end
+          self
         end
       end
 

data/lib/tenacity/orm_ext/mongoid.rb

@@ -70,20 +70,23 @@ module Tenacity
           find(:all, :conditions => { property => _t_serialize(id) })
         end
 
+        def _t_find_all_ids_by_associate(property, id)
+          results = collection.find({property => _t_serialize(id)}, {:fields => 'id'}).to_a
+          results.map { |r| r['_id'] }
+        end
+
         def _t_initialize_tenacity
+          before_save { |record| record._t_verify_associates_exist }
           after_save { |record| record._t_save_autosave_associations }
         end
 
         def _t_initialize_has_one_association(association)
-          after_destroy { |record| record._t_cleanup_has_one_association(association) }
+          before_destroy { |record| record._t_cleanup_has_one_association(association) }
         end
 
         def _t_initialize_has_many_association(association)
-          unless self.respond_to?(association.foreign_keys_property)
-            field association.foreign_keys_property, :type => Array
-            after_save { |record| self.class._t_save_associates(record, association) }
-            after_destroy { |record| record._t_cleanup_has_many_association(association) }
-          end
+          after_save { |record| self.class._t_save_associates(record, association) }
+          before_destroy { |record| record._t_cleanup_has_many_association(association) }
         end
 
         def _t_initialize_belongs_to_association(association)
@@ -107,18 +110,7 @@ module Tenacity
       module InstanceMethods #:nodoc:
         def _t_reload
           reload
-        end
-
-        def _t_associate_many(association, associate_ids)
-          self.send(association.foreign_keys_property + '=', associate_ids)
-        end
-
-        def _t_get_associate_ids(association)
-          self.send(association.foreign_keys_property)
-        end
-
-        def _t_clear_associates(association)
-          self.send(association.foreign_keys_property + '=', [])
+          self
         end
       end
 

data/lib/tenacity/orm_ext/ripple.rb

@@ -0,0 +1,270 @@
+module Tenacity
+  module OrmExt
+    # Tenacity relationships on Ripple objects require no special properties
+    # defined on the object.  Tenacity will define the properties that it needs
+    # to support the relationships.  Take the following class for example:
+    #
+    #   class Car
+    #     include Ripple::Document
+    #     include Tenacity
+    #
+    #     t_has_many    :wheels
+    #     t_has_one     :dashboard
+    #     t_belongs_to  :driver
+    #   end
+    #
+    # == t_belongs_to
+    #
+    # The +t_belongs_to+ association will define a property named after the association.
+    # The example above will create a property named <tt>:driver_id</tt>  The +t_belongs_to+
+    # relationship will also create a bucket in Riak that acts as an index to find
+    # objects by their foreign key.  The bucket will be named after the Ripple class
+    # and the name of the property used to store the foreign key.  In the above example,
+    # the bucket will be named tenacity_car_driver_id.
+    #
+    #
+    # == t_has_one
+    #
+    # The +t_has_one+ association will not define any new properties on the object, since
+    # the associated object holds the foreign key.
+    #
+    #
+    # == t_has_many
+    #
+    # The +t_has_many+ association will define a property named after the association.
+    # The example above will create a property named <tt>:wheels_ids</tt>
+    #
+    module Ripple
+
+      def self.setup(model) #:nodoc:
+        require 'ripple'
+        if model.included_modules.include?(::Ripple::Document)
+          model.send :include, Ripple::InstanceMethods
+          model.extend Ripple::ClassMethods
+        end
+      rescue LoadError
+        # Ripple not available
+      end
+
+      module ClassMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
+
+        attr_accessor :_t_has_one_associations
+        attr_accessor :_t_has_many_associations
+        attr_accessor :_t_belongs_to_associations
+
+        def _t_id_type
+          String
+        end
+
+        def _t_find(id)
+          find(_t_serialize(id))
+        end
+
+        def _t_find_bulk(ids)
+          objects = find(_t_serialize_ids(ids)) || []
+          objects = [objects] unless objects.respond_to?(:each)
+          objects.reject(&:nil?)
+        end
+
+        def _t_find_first_by_associate(property, id)
+          bucket = ::Ripple.client.bucket(_t_bucket_name(property))
+          if bucket.exist?(id)
+            object = bucket.get(id)
+            find(object.data.first)
+          else
+            nil
+          end
+        end
+
+        def _t_find_all_by_associate(property, id)
+          find(_t_find_all_ids_by_associate(property, id)) || []
+        end
+
+        def _t_find_all_ids_by_associate(property, id)
+          bucket = ::Ripple.client.bucket(_t_bucket_name(property))
+          if bucket.exist?(id)
+            object = bucket.get(id)
+            object.data || []
+          else
+            []
+          end
+        end
+
+        def _t_initialize_tenacity
+        end
+
+        def _t_initialize_has_one_association(association)
+          @_t_has_one_associations ||= []
+          @_t_has_one_associations << association
+        end
+
+        def _t_initialize_has_many_association(association)
+          @_t_has_many_associations ||= []
+          @_t_has_many_associations << association
+        end
+
+        def _t_initialize_belongs_to_association(association)
+          @_t_belongs_to_associations ||= []
+          @_t_belongs_to_associations << association
+
+          property association.foreign_key, id_class_for(association)
+          property association.polymorphic_type, String if association.polymorphic?
+        end
+
+        def _t_delete(ids, run_callbacks=true)
+          docs = _t_find_bulk(ids)
+          if run_callbacks
+            docs.each { |doc| doc.destroy }
+          else
+            docs.each { |doc| doc.delete }
+          end
+        end
+
+        private
+
+        def _t_bucket_name(property_name)
+          prefix = ENV['TENACITY_TEST'] == 'true' ? 'tenacity_test' : 'tenacity'
+          "#{prefix}_#{ActiveSupport::Inflector.underscore(self.name)}_#{property_name.to_s}"
+        end
+      end
+
+      module InstanceMethods #:nodoc:
+        def id
+          key
+        end
+
+        def _t_reload
+          reload
+          self
+        end
+
+        def save
+          before_save
+          super
+          after_save
+        end
+
+        def destroy(run_callbacks=true)
+          before_destroy if run_callbacks
+          super()
+          after_destroy if run_callbacks
+        end
+
+        def delete
+          destroy(false)
+        end
+
+        private
+
+        def before_save
+          _t_verify_associates_exist
+          remember_old_associate_ids
+        end
+
+        def after_save
+          update_associate_indexes
+          _t_save_autosave_associations
+
+          associations = self.class._t_has_many_associations || []
+          associations.each { |association| self.class._t_save_associates(self, association) }
+        end
+
+        def before_destroy
+          associations = self.class._t_has_one_associations || []
+          associations.each { |association| self._t_cleanup_has_one_association(association) }
+
+          associations = self.class._t_has_many_associations || []
+          associations.each { |association| self._t_cleanup_has_many_association(association) }
+        end
+
+        def after_destroy
+          delete_associate_indexes
+
+          associations = self.class._t_belongs_to_associations || []
+          associations.each { |association| self._t_cleanup_belongs_to_association(association) }
+        end
+
+        def remember_old_associate_ids
+          @old_associate_ids = {}
+
+          unless self.id.nil?
+            old_instance = self.class._t_find(self.id)
+            associations = self.class._t_belongs_to_associations || []
+            associations.each do |association|
+              @old_associate_ids[association.name] = old_instance.send(association.foreign_key)
+            end
+          end
+        end
+
+        def update_associate_indexes
+          manage_associate_indexes(:update)
+        end
+
+        def delete_associate_indexes
+          manage_associate_indexes(:delete)
+        end
+
+        def manage_associate_indexes(operation)
+          associations = self.class._t_belongs_to_associations || []
+          associations.each do |association|
+            associate_id = self.send(association.foreign_key)
+            if operation == :update
+              update_associate_index(association, associate_id)
+            else
+              delete_associate_index(association, associate_id)
+            end
+          end
+        end
+
+        def update_associate_index(association, associate_id)
+          bucket = get_bucket_for_association(association)
+          if !@old_associate_ids[association.name].nil? && associate_id.nil?
+            clear_associate_index_of_nilified_id(association, bucket)
+          else
+            store_id_in_associate_index(associate_id, bucket)
+          end
+        end
+
+        def store_id_in_associate_index(associate_id, bucket)
+          unless associate_id.nil?
+            if bucket.exist?(associate_id)
+              object = bucket.get(associate_id)
+              object.data << self.id unless object.data.include?(self.id)
+            else
+              object = bucket.new(associate_id)
+              object.data = [self.id]
+            end
+            object.store
+          end
+        end
+
+        def clear_associate_index_of_nilified_id(association, bucket)
+          if bucket.exist?(@old_associate_ids[association.name])
+            object = bucket.get(@old_associate_ids[association.name])
+            object.data.delete(self.id)
+            object.store
+          end
+        end
+
+        def delete_associate_index(association, associate_id)
+          unless associate_id.nil?
+            bucket = get_bucket_for_association(association)
+            if bucket.exist?(associate_id)
+              object = bucket.get(associate_id)
+              object.data.delete(self.id)
+              object.store
+            end
+          end
+        end
+
+        def get_bucket_for_association(association)
+          ::Ripple.client.bucket(self.class.send(:_t_bucket_name, association.foreign_key))
+        end
+      end
+
+    end
+  end
+end
+
+