tenacity 0.3.0 → 0.4.0

data/lib/tenacity/associations/has_one.rb

@@ -1,24 +1,43 @@
 module Tenacity
-  module HasOne #:nodoc:
+  module Associations
+    module HasOne #:nodoc:
 
-    private
+      def _t_cleanup_has_one_association(association)
+        associate = has_one_associate(association)
+        unless associate.nil?
+          if association.dependent == :destroy
+            association.associate_class._t_delete([_t_serialize(associate.id)])
+          elsif association.dependent == :delete
+            association.associate_class._t_delete([_t_serialize(associate.id)], false)
+          elsif association.dependent == :nullify
+            associate.send "#{association.foreign_key(self.class)}=", nil
+            associate.save
+          end
+        end
+      end
 
-    def has_one_associate(association)
-      clazz = association.associate_class
-      clazz._t_find_first_by_associate(association.foreign_key(self.class), self.id.to_s)
-    end
+      private
 
-    def set_has_one_associate(association, associate)
-      associate.send "#{association.foreign_key(self.class)}=", self.id.to_s
-      associate.save
-    end
+      def has_one_associate(association)
+        clazz = association.associate_class
+        associate = clazz._t_find_first_by_associate(association.foreign_key(self.class), _t_serialize(self.id, association))
+        associate
+      end
 
-    module ClassMethods #:nodoc:
-      def initialize_has_one_association(association)
-        _t_initialize_has_one_association(association) if respond_to?(:_t_initialize_has_one_association)
+      def set_has_one_associate(association, associate)
+        associate.send "#{association.foreign_key(self.class)}=", _t_serialize(self.id, association)
+        associate.send "#{association.polymorphic_type}=", self.class.to_s if association.polymorphic?
+        associate.save unless association.autosave == false
+        associate
+      end
+
+      module ClassMethods #:nodoc:
+        def initialize_has_one_association(association)
+          _t_initialize_has_one_association(association) if respond_to?(:_t_initialize_has_one_association)
+        end
       end
-    end
 
+    end
   end
 end
 

data/lib/tenacity/class_methods.rb

@@ -86,6 +86,10 @@ module Tenacity
   # You can manipulate objects and associations before they are saved to the database, but there is some special behavior you should be
   # aware of, mostly involving the saving of associated objects.
   #
+  # Unless you set the :autosave option on a <tt>t_has_one</tt>, <tt>t_belongs_to</tt>, or
+  # <tt>t_has_many</tt> association. Setting it to +true+ will _always_ save the members,
+  # whereas setting it to +false+ will _never_ save the members.
+  #
   # === One-to-one associations
   #
   # * Assigning an object to a +t_has_one+ association automatically saves that object and the object being replaced (if there is one), in
@@ -99,6 +103,30 @@ module Tenacity
   #   (the owner of the collection) is not yet stored in the database.
   # * All unsaved members of the collection are automatically saved when the parent is saved.
   #
+  # === Polymorphic Associations
+  #
+  # Polymorphic associations on models are not restricted on what types of models they can be associated with.  Rather, they
+  # specify an interface that a +t_has_many+ association must adhere to.
+  #
+  #   class Asset < ActiveRecord::Base
+  #     include Tenacity
+  #     t_belongs_to :attachable, :polymorphic => true
+  #   end
+  #
+  #   class Post
+  #     include MongoMapper::Document
+  #     include Tenacity
+  #     t_has_many :assets, :as => :attachable         # The :as option specifies the polymorphic interface to use.
+  #   end
+  #
+  #   @asset.attachable = @post
+  #
+  # This works by using a type field/column in addition to a foreign key to specify the associated record.  In the Asset example, you'd need
+  # an +attachable_id+ field and an +attachable_type+ string field on your model.
+  #
+  # IDs for polymorphic associations are always stored as strings in the database, since we cannot determine the true type of the
+  # id when the association is defined.
+  #
   # == Caching
   #
   # All of the methods are built on a simple caching principle that will keep the result
@@ -139,6 +167,7 @@ module Tenacity
   # can be used to override these defaults.
   #
   module ClassMethods
+    attr_reader :_tenacity_associations
 
     # Specifies a one-to-one association with another class. This method should only be used
     # if the other class contains the foreign key. If the current class contains the foreign key,
@@ -170,14 +199,29 @@ module Tenacity
     #   Specify the foreign key used for the association. By default this is guessed to be the name
     #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +t_has_one+ association
     #   will use "person_id" as the default <tt>:foreign_key</tt>.
+    # [:dependent]
+    #   If set to <tt>:destroy</tt>, the associated object is deleted when this object is, and all delete
+    #   callbacks are called.  If set to <tt>:delete</tt>, the associated object is deleted *without*
+    #   calling any of its delete callbacks.  If set to <tt>:nullify</tt>, the associated object's
+    #   foreign key is set to +NULL+.
+    # [:readonly]
+    #   If true, the associated object is readonly through the association.
+    # [:autosave]
+    #   If true, always save the associated object or destroy it if marked for destruction, when saving the parent object. Off by default.
+    # [:as]
+    #   Specifies a polymorphic interface (See <tt>t_belongs_to</tt>).
     #
     # Option examples:
+    #   t_has_one :credit_card, :dependent => :destroy  # destroys the associated credit card
+    #   t_has_one :credit_card, :dependent => :nullify  # updates the associated records foreign key value to NULL rather than destroying it
     #   t_has_one :project_manager, :class_name => "Person"
     #   t_has_one :project_manager, :foreign_key => "project_id"  # within class named SecretProject
+    #   t_has_one :boss, :readonly => :true
+    #   t_has_one :attachment, :as => :attachable
     #
     def t_has_one(name, options={})
-      extend(HasOne::ClassMethods)
-      association = Association.new(:t_has_one, name, self, options)
+      extend(Associations::HasOne::ClassMethods)
+      association = _t_create_association(:t_has_one, name, options)
       initialize_has_one_association(association)
 
       define_method(association.name) do |*params|
@@ -225,14 +269,29 @@ module Tenacity
     #   association will use "person_id" as the default <tt>:foreign_key</tt>. Similarly,
     #   <tt>t_belongs_to :favorite_person, :class_name => "Person"</tt> will use a foreign key
     #   of "favorite_person_id".
+    # [:dependent]
+    #   If set to <tt>:destroy</tt>, the associated object is deleted when this object is, calling all delete
+    #   callbacks.  If set to <tt>:delete</tt>, the associated object is deleted *without* calling any of
+    #   its delete callbacks.  This option should not be specified when <tt>t_belongs_to</tt> is used in
+    #   conjuction with a <tt>t_has_many</tt> relationship on another class because of the potential
+    #   to leave orphaned records behind.
+    # [:readonly]
+    #   If true, the associated object is readonly through the association.
+    # [:autosave]
+    #   If true, always save the associated object or destroy it if marked for destruction, when saving the parent object. Off by default.
+    # [:polymorphic]
+    #   Specify this association is a polymorphic association by passing +true+. (*Note*: IDs for polymorphic associations are always
+    #   stored as strings in the database.)
     #
     # Option examples:
     #   t_belongs_to :project_manager, :class_name => "Person"
     #   t_belongs_to :valid_coupon, :class_name => "Coupon", :foreign_key => "coupon_id"
+    #   t_belongs_to :project, :readonly => true
+    #   t_belongs_to :attachable, :polymorphic => true
     #
     def t_belongs_to(name, options={})
-      extend(BelongsTo::ClassMethods)
-      association = Association.new(:t_belongs_to, name, self, options)
+      extend(Associations::BelongsTo::ClassMethods)
+      association = _t_create_association(:t_belongs_to, name, options)
       initialize_belongs_to_association(association)
 
       define_method(association.name) do |*params|
@@ -265,7 +324,9 @@ module Tenacity
     # [collection.concat(other_array)]
     #   Adds the objects in the other array to the collection by setting their foreign keys to the collection's primary key.
     # [collection.delete(object, ...)]
-    #   Removes one or more objects from the collection.
+    #   Removes one or more objects from the collection by setting their foreign keys to +NULL+.
+    #   Objects will be in addition deleted and callbacks called if they're associated with <tt>:dependent => :destroy</tt>,
+    #   and deleted and callbacks skipped if they're associated with <tt>:dependent => :delete_all</tt>.
     # [collection.destroy_all]
     #   Removes all objects from the collection, and deletes them from their respective
     #   database. If the deleted objects have any delete callbacks defined, they will be called.
@@ -279,7 +340,10 @@ module Tenacity
     # [collection_singular_ids=ids]
     #   Replace the collection with the objects identified by the primary keys in +ids+.
     # [collection.clear]
-    #   Removes every object from the collection.
+    #   Removes every object from the collection. This deletes the associated objects and issues callbacks
+    #   if they are associated with <tt>:dependent => :destroy</tt>, deletes them directly from the
+    #   database without calling any callbacks if <tt>:dependent => :delete_all</tt>, otherwise sets their
+    #   foreign keys to +NULL+.
     # [collection.empty?]
     #   Returns +true+ if there are no associated objects.
     # [collection.size]
@@ -319,6 +383,12 @@ module Tenacity
     #   for objects that store associated ids in an array instaed of a join table (CouchRest,
     #   MongoMapper, etc). <b>WARNING:</b> The name of the association with an "_ids" suffix should
     #   not be used as the property name, since tenacity adds a method with this name to the object.
+    # [:dependent]
+    #   If set to <tt>:destroy</tt> all the associated objects are deleted alongside this object
+    #   in addition to calling their delete callbacks.  If set to <tt>:delete_all</tt> all
+    #   associated objects are deleted *without* calling their delete callbacks.  If set to
+    #   <tt>:nullify</tt> all associated objects' foreign keys are set to +NULL+ *without* calling
+    #   their save backs.
     # [:join_table]
     #   Specify the name of the join table if the default based on lexical order isn't what you want.
     #   This option is only valid if one of the models in the association is backed by a relational
@@ -336,6 +406,18 @@ module Tenacity
     #   "_id" suffixed. So if a Person class makes a +t_has_many+ association to Project, the
     #   association will use "person_id" as the default <tt>:association_key</tt>.  This option is
     #   only valid if one of the associated objects is backed by a relational database.
+    # [:readonly]
+    #   If true, all the associated objects are readonly through the association.
+    # [:limit]
+    #   An integer determining the limit on the number of rows that should be returned. Results
+    #   are ordered by a string representation of the id.
+    # [:offset]
+    #   An integer determining the offset from where the rows should be fetched. So at 5, it would skip the first 4 rows.
+    #   Results are ordered by a string representation of the id.
+    # [:autosave]
+    #   If true, always save any loaded members and destroy members marked for destruction, when saving the parent object. Off by default.
+    # [:as]
+    #   Specifies a polymorphic interface (See <tt>t_belongs_to</tt>).
     #
     # Option examples:
     #   t_has_many :products, :class_name => "SpecialProduct"
@@ -344,10 +426,13 @@ module Tenacity
     #   t_has_many :managers, :join_table => "project_managers_and_projects"
     #   t_has_many :managers, :join_table => "project_managers_and_projects",
     #       :association_foreign_key => "mgr_id", :association_key => "proj_id"
+    #   t_has_many :tasks, :dependent => :destroy
+    #   t_has_many :reports, :readonly => true
+    #   t_has_many :tags, :as => :taggable
     #
     def t_has_many(name, options={})
-      extend(HasMany::ClassMethods)
-      association = Association.new(:t_has_many, name, self, options)
+      extend(Associations::HasMany::ClassMethods)
+      association = _t_create_association(:t_has_many, name, options)
       initialize_has_many_association(association)
 
       define_method(association.name) do |*params|
@@ -357,7 +442,9 @@ module Tenacity
       end
 
       define_method("#{association.name}=") do |associates|
-        set_associate(association, associates)
+        set_associate(association, associates) do
+          set_has_many_associates(association, associates)
+        end
       end
 
       define_method("#{ActiveSupport::Inflector.singularize(association.name)}_ids") do
@@ -375,6 +462,27 @@ module Tenacity
       end
     end
 
+    def _t_serialize(object_id, association=nil) #:nodoc:
+      if association && association.polymorphic?
+        object_id.to_s
+      elsif object_id.nil?
+        nil
+      elsif [Fixnum].include?(object_id.class)
+        object_id
+      else
+        object_id.to_s
+      end
+    end
+
+    private
+
+    def _t_create_association(type, name, options) #:nococ:
+      association = Association.new(type, name, self, options)
+      @_tenacity_associations ||= []
+      @_tenacity_associations << association
+      association
+    end
+
   end
 end
 

data/lib/tenacity/errors.rb

@@ -0,0 +1,9 @@
+module Tenacity
+  # Generic Tenacity exception class.
+  class TenacityError < StandardError
+  end
+
+  # Raised on attempt to update an associate that is instantiated as read only.
+  class ReadOnlyError < TenacityError
+  end
+end

data/lib/tenacity/instance_methods.rb

@@ -5,8 +5,26 @@ module Tenacity
       "@_t_" + association.name.to_s
     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))
+            associates.each { |associate| autosave_save_or_destroy(associate) } unless associates.nil?
+          end
+        end
+      end
+    end
+
     private
 
+    def autosave_save_or_destroy(associate)
+      associate.marked_for_destruction? ? associate.destroy : associate.save
+    end
+
     def get_associate(association, params)
       _t_reload unless id.nil?
       force_reload = params.first unless params.empty?
@@ -19,12 +37,31 @@ module Tenacity
     end
 
     def set_associate(association, associate)
-      yield if block_given?
-      instance_variable_set _t_ivar_name(association), associate
+      associate = yield if block_given?
+      instance_variable_set _t_ivar_name(association), create_proxy(associate, association)
     end
 
     def create_proxy(value, association)
-      value.respond_to?(:each) ? AssociatesProxy.new(self, value, association) : value
+      return value if value.respond_to?(:proxy_respond_to?)
+
+      if multiple_associates?(association, value)
+        value.map! { |v| create_associate_proxy_for(v, association) }
+        AssociatesProxy.new(self, value, association)
+      else
+        create_associate_proxy_for(value, association)
+      end
+    end
+
+    def create_associate_proxy_for(value, association)
+      value.nil? ? nil : AssociateProxy.new(value, association)
+    end
+
+    def multiple_associates?(association, value)
+      association.type == :t_has_many && value.is_a?(Enumerable)
+    end
+
+    def _t_serialize(object, association=nil)
+      self.class._t_serialize(object, association)
     end
 
   end

data/lib/tenacity/orm_ext/activerecord.rb

@@ -1,116 +1,135 @@
 module Tenacity
-  # 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:
-  #
-  #   class Car < ActiveRecord::Base
-  #     include Tenacity
-  #
-  #     t_has_many    :wheels
-  #     t_has_one     :dashboard
-  #     t_belongs_to  :driver
-  #   end
-  #
-  #
-  # == t_belongs_to
-  #
-  # The +t_belongs_to+ association requires that a property exist in the table
-  # to hold the id of the assoicated object.
-  #
-  #   create_table :cars do |t|
-  #     t.string :driver_id
-  #   end
-  #
-  #
-  # == t_has_one
-  #
-  # The +t_has_one+ association requires no special column in the table, since
-  # the associated object holds the foreign key.
-  #
-  #
-  # == 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
-  #
-  module ActiveRecord
-
-    def self.setup(model)
-      require 'active_record'
-      if model.ancestors.include?(::ActiveRecord::Base)
-        model.send :include, ActiveRecord::InstanceMethods
-        model.extend ActiveRecord::ClassMethods
-      end
-    rescue LoadError
-      # ActiveRecord not available
-    end
+  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:
+    #
+    #   class Car < ActiveRecord::Base
+    #     include Tenacity
+    #
+    #     t_has_many    :wheels
+    #     t_has_one     :dashboard
+    #     t_belongs_to  :driver
+    #   end
+    #
+    #
+    # == t_belongs_to
+    #
+    # The +t_belongs_to+ association requires that a property exist in the table
+    # to hold the id of the assoicated object.
+    #
+    #   create_table :cars do |t|
+    #     t.string :driver_id
+    #   end
+    #
+    #
+    # == t_has_one
+    #
+    # The +t_has_one+ association requires no special column in the table, since
+    # the associated object holds the foreign key.
+    #
+    #
+    # == 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
+    #
+    module ActiveRecord
 
-    module ClassMethods #:nodoc:
-      def _t_find(id)
-        find_by_id(id)
+      def self.setup(model)
+        require 'active_record'
+        if model.ancestors.include?(::ActiveRecord::Base)
+          model.send :include, ActiveRecord::InstanceMethods
+          model.extend ActiveRecord::ClassMethods
+        end
+      rescue LoadError
+        # ActiveRecord not available
       end
 
-      def _t_find_bulk(ids)
-        return [] if ids.nil? || ids.empty?
-        find(:all, :conditions => ["id in (?)", ids])
-      end
+      module ClassMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
 
-      def _t_find_first_by_associate(property, id)
-        find(:first, :conditions => ["#{property} = ?", id.to_s])
-      end
+        def _t_id_type
+          Integer
+        end
 
-      def _t_find_all_by_associate(property, id)
-        find(:all, :conditions => ["#{property} = ?", id.to_s])
-      end
+        def _t_find(id)
+          find_by_id(_t_serialize(id))
+        end
 
-      def _t_initialize_has_many_association(association)
-        after_save { |record| record.class._t_save_associates(record, association) }
-      end
+        def _t_find_bulk(ids)
+          return [] if ids.nil? || ids.empty?
+          find(:all, :conditions => ["id in (?)", _t_serialize_ids(ids)])
+        end
 
-      def _t_initialize_belongs_to_association(association)
-        before_save { |record| record.class._t_stringify_belongs_to_value(record, association) }
-      end
+        def _t_find_first_by_associate(property, id)
+          find(:first, :conditions => ["#{property} = ?", _t_serialize(id)])
+        end
 
-      def _t_delete(ids, run_callbacks=true)
-        if run_callbacks
-          destroy_all(["id in (?)", ids])
-        else
-          delete_all(["id in (?)", ids])
+        def _t_find_all_by_associate(property, id)
+          find(:all, :conditions => ["#{property} = ?", _t_serialize(id)])
         end
-      end
-    end
 
-    module InstanceMethods #:nodoc:
-      def _t_reload
-        reload
-      end
+        def _t_initialize_has_one_association(association)
+          after_destroy { |record| record._t_cleanup_has_one_association(association) }
+        end
 
-      def _t_clear_associates(association)
-        self.connection.execute("delete from #{association.join_table} where #{association.association_key} = #{self.id}")
-      end
+        def _t_initialize_tenacity
+          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) }
+        end
+
+        def _t_initialize_belongs_to_association(association)
+          after_destroy { |record| record._t_cleanup_belongs_to_association(association) }
+        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 (#{self.id}, '#{associate_id}')")
+        def _t_delete(ids, run_callbacks=true)
+          if run_callbacks
+            destroy_all(["id in (?)", _t_serialize_ids(ids)])
+          else
+            delete_all(["id in (?)", _t_serialize_ids(ids)])
           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} = #{self.id}")
-        ids = []; rows.each { |r| ids << r[0] }; ids
+      module InstanceMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
+
+        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
+        end
       end
-    end
 
+    end
   end
 end