tenacity 0.3.0 → 0.4.0

data/EXTEND.rdoc

@@ -5,14 +5,6 @@ only, so as long as they have been implemented and are available on the model
 object, Tenacity will be able to manage the object's relationships.
 
 
-== A note about IDs
-
-An ID can be an integer, a string, or an object, depending on the database
-and database client you are using.  To be as compatible as possible, Tenacity
-treats all IDs as strings.  So, all database client extensions should accept
-strings for IDs as input parameters, and return strings for IDs.
-
-
 == The Association Class
 
 A few of the methods take an association as a parameter.  This association
@@ -56,21 +48,25 @@ delete callback meethods are not run.  Return nothing.
 
 Perform any database client specific initialization necessary to support a has
 many association.  This could include defining properties, or callback methods,
-on the object.  This method is optional, and does not need to be defined.
+on the object.  This method must also call
+_t_cleanup_has_many_association(association) to cleanup the association
+when the after the object has been deleted.
 
   _t_initialize_belongs_to_association(association)
 
 Perform any database client specific initialization necessary to support a
 belongs to association.  This could include defining properties, or callback
-methods, on the object.  This method is optional, and does not need to be
-defined.
+methods, on the object.  This method must also call
+_t_cleanup_belongs_to_association(association) to cleanup the association
+when the after the object has been deleted.
 
   _t_initialize_has_one_association(association)
 
 Perform any database client specific initialization necessary to support a has one
 association.  This could include defining properties, or callback methods,
-on the object.  This method is optional, and does not need to be defined.
-
+on the object.  This method must also call
+_t_cleanup_has_one_association(association) to cleanup the association
+when the after the object has been deleted.
 
 == Instance Methods
 

data/Rakefile

@@ -25,6 +25,12 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
+desc 'Run an abbreviated version of the test suite'
+task :quick_test do
+  ENV['QUICK'] = 'true'
+  Rake::Task["test"].invoke
+end
+
 Rcov::RcovTask.new do |test|
   test.libs << 'test' << 'test/fixtures'
   test.pattern = 'test/**/*_test.rb'

data/history.txt

@@ -1,3 +1,20 @@
+== 0.4.0
+
+* Major enhancements
+
+  * Tenacity will no longer convert foreign keys to strings before storing them
+    in the database.  Instead, the ID will be stored without any modification
+    (when possible).
+
+* Minor enhancements
+
+  * Added support for the :dependent option to all associations
+  * Added support for the :readonly option to all associations
+  * Added support for the :limit option to the t_has_many association
+  * Added support for the :offset option to the t_has_many association
+  * Added support for the :autosave option to all associations
+  * Added support for polymorphic associations to all associations
+
 == 0.3.0
 
 * Major enhancements

data/lib/tenacity.rb

@@ -1,12 +1,15 @@
 require File.join('active_support', 'inflector')
 
+require File.join(File.dirname(__FILE__), 'tenacity', 'associate_proxy')
 require File.join(File.dirname(__FILE__), 'tenacity', 'associates_proxy')
 require File.join(File.dirname(__FILE__), 'tenacity', 'association')
 require File.join(File.dirname(__FILE__), 'tenacity', 'class_methods')
+require File.join(File.dirname(__FILE__), 'tenacity', 'errors')
 require File.join(File.dirname(__FILE__), 'tenacity', 'instance_methods')
 require File.join(File.dirname(__FILE__), 'tenacity', 'associations', 'belongs_to')
 require File.join(File.dirname(__FILE__), 'tenacity', 'associations', 'has_many')
 require File.join(File.dirname(__FILE__), 'tenacity', 'associations', 'has_one')
+require File.join(File.dirname(__FILE__), 'tenacity', 'orm_ext', 'helpers')
 require File.join(File.dirname(__FILE__), 'tenacity', 'orm_ext', 'activerecord')
 require File.join(File.dirname(__FILE__), 'tenacity', 'orm_ext', 'couchrest')
 require File.join(File.dirname(__FILE__), 'tenacity', 'orm_ext', 'datamapper')
@@ -17,20 +20,21 @@ require File.join(File.dirname(__FILE__), 'tenacity', 'orm_ext', 'sequel')
 module Tenacity #:nodoc:
   include InstanceMethods
 
-  include BelongsTo
-  include HasMany
-  include HasOne
+  include Associations::BelongsTo
+  include Associations::HasMany
+  include Associations::HasOne
 
   def self.included(model)
-    ActiveRecord.setup(model)
-    CouchRest.setup(model)
-    DataMapper.setup(model)
-    MongoMapper.setup(model)
-    Mongoid.setup(model)
-    Sequel.setup(model)
+    OrmExt::ActiveRecord.setup(model)
+    OrmExt::CouchRest.setup(model)
+    OrmExt::DataMapper.setup(model)
+    OrmExt::MongoMapper.setup(model)
+    OrmExt::Mongoid.setup(model)
+    OrmExt::Sequel.setup(model)
 
     raise "Tenacity does not support the database client used by #{model}" unless model.respond_to?(:_t_find)
     model.extend(ClassMethods)
+    model._t_initialize_tenacity
   end
 end
 

data/lib/tenacity/associate_proxy.rb

@@ -0,0 +1,56 @@
+module Tenacity
+  class AssociateProxy #:nodoc:
+    alias_method :proxy_respond_to?, :respond_to?
+    instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+    def initialize(target, association)
+      raise "Cannot create a Tenacity::AssociateProxy with a nil target" if target.nil?
+      @target = target
+      @association = association
+      @marked_for_destruction = false
+    end
+
+    def respond_to?(*args)
+      proxy_respond_to?(*args) || @target.respond_to?(*args)
+    end
+
+    # Explicitly proxy === because the instance method removal above doesn't catch it.
+    def ===(other)
+      other === @target
+    end
+
+    def inspect
+      @target.inspect
+    end
+
+    def save
+      if @association.readonly?
+        raise ReadOnlyError
+      else
+        @target.save
+      end
+    end
+
+    def association_target
+      @target
+    end
+
+    def mark_for_destruction
+      @marked_for_destruction = true
+    end
+
+    def marked_for_destruction?
+      @marked_for_destruction
+    end
+
+    private
+
+    def method_missing(method, *args)
+      if block_given?
+        @target.send(method, *args) { |*block_args| yield(*block_args) }
+      else
+        @target.send(method, *args)
+      end
+    end
+  end
+end

data/lib/tenacity/associates_proxy.rb

@@ -20,17 +20,19 @@ module Tenacity
 
     def <<(object)
       object.save unless @parent.id.nil?
-      @target << object
+      @target << AssociateProxy.new(object, @association)
     end
 
     def push(*objects)
       objects.each { |object| object.save } unless @parent.id.nil?
-      @target.push(*objects)
+      proxies = objects.map { |object| AssociateProxy.new(object, @association) }
+      @target.push(*proxies)
     end
 
     def concat(objects)
       objects.each { |object| object.save } unless @parent.id.nil?
-      @target.concat(objects)
+      proxies = objects.map { |object| AssociateProxy.new(object, @association) }
+      @target.concat(proxies)
     end
 
     def destroy_all

data/lib/tenacity/association.rb

@@ -8,15 +8,33 @@ module Tenacity
     # Type type of the association (<tt>:t_has_one</tt>, <tt>:t_has_many</tt>, or <tt>:t_belongs_to</tt>)
     attr_reader :type
 
-    # The name of the association
-    attr_reader :name
-
     # The class defining the association
     attr_reader :source
 
     # The name of the associated class
     attr_reader :class_name
 
+    # What happens to the associated object when the object is deleted
+    attr_reader :dependent
+
+    # Are the associated objects read only?
+    attr_reader :readonly
+
+    # The limit on the number of results to be returned.
+    attr_reader :limit
+
+    # The offset from where the results should be fetched.
+    attr_reader :offset
+
+    # Should the associated object be saved when the parent object is saved?
+    attr_reader :autosave
+
+    # The interface this association is reffered to as
+    attr_reader :as
+
+    # Is this association a polymorphic association?
+    attr_reader :polymorphic
+
     def initialize(type, name, source, options={})
       @type = type
       @name = name
@@ -33,6 +51,13 @@ module Tenacity
       @join_table = options[:join_table]
       @association_key = options[:association_key]
       @association_foreign_key = options[:association_foreign_key]
+      @dependent = options[:dependent]
+      @readonly = options[:readonly]
+      @limit = options[:limit]
+      @offset = options[:offset]
+      @autosave = options[:autosave]
+      @polymorphic = options[:polymorphic]
+      @as = options[:as]
 
       if @foreign_keys_property
         if @foreign_keys_property.to_s == ActiveSupport::Inflector.singularize(name) + "_ids"
@@ -41,9 +66,18 @@ module Tenacity
       end
     end
 
+    # The name of the association
+    def name
+      @as.nil? ? @name : @as
+    end
+
     # Get the associated class
-    def associate_class
-      @clazz ||= Kernel.const_get(@class_name)
+    def associate_class(object=nil)
+      if @type == :t_belongs_to && polymorphic?
+        Kernel.const_get(object.send(polymorphic_type))
+      else
+        @clazz ||= Kernel.const_get(@class_name)
+      end
     end
 
     # Get the foreign key used by this association. <tt>t_has_one</tt> and
@@ -52,10 +86,9 @@ module Tenacity
     def foreign_key(clazz=nil)
       @foreign_key || begin
         if @type == :t_belongs_to
-          @class_name.underscore + "_id"
+          belongs_to_foreign_key
         elsif @type == :t_has_one || @type == :t_has_many
-          raise "The class of the associate must be provided in order to determine the name of the foreign key" if clazz.nil?
-          "#{ActiveSupport::Inflector.underscore(clazz)}_id"
+          has_x_foreign_key(clazz)
         end
       end
     end
@@ -68,7 +101,14 @@ module Tenacity
     # Get the name of the join table used by this association
     def join_table
       table_name = fetch_table_name
-      @join_table || (name.to_s < table_name ? "#{name}_#{table_name}" : "#{table_name}_#{name}")
+
+      if @type == :t_has_many && polymorphic?
+        association_name_for_join_table = name.to_s.pluralize
+      else
+        association_name_for_join_table = name
+      end
+
+      @join_table || (name.to_s < table_name ? "#{association_name_for_join_table}_#{table_name}" : "#{table_name}_#{association_name_for_join_table}")
     end
 
     # Get the name of the column in the join table that represents this object
@@ -82,6 +122,21 @@ module Tenacity
       @association_foreign_key || name.to_s.singularize + '_id'
     end
 
+    # Are the associated objects read only?
+    def readonly?
+      @readonly == true
+    end
+
+    # Is this association a polymorphic association?
+    def polymorphic?
+      @polymorphic == true || !@as.nil?
+    end
+
+    # The name of the property that stores the polymorphic type (for polymorphic associations)
+    def polymorphic_type
+      (name.to_s + "_type").to_sym
+    end
+
     private
 
     def fetch_table_name
@@ -91,5 +146,22 @@ module Tenacity
         "#{ActiveSupport::Inflector.underscore(@source)}s"
       end
     end
+
+    def belongs_to_foreign_key
+      if polymorphic?
+        (name.to_s + "_id").to_sym
+      else
+        @class_name.underscore + "_id"
+      end
+    end
+
+    def has_x_foreign_key(clazz)
+      raise "The class of the associate must be provided in order to determine the name of the foreign key" if clazz.nil?
+      if polymorphic?
+        (@as.to_s + "_id").to_sym
+      else
+        "#{ActiveSupport::Inflector.underscore(clazz)}_id"
+      end
+    end
   end
 end

data/lib/tenacity/associations/belongs_to.rb

@@ -1,28 +1,40 @@
 module Tenacity
-  module BelongsTo #:nodoc:
+  module Associations
+    module BelongsTo #:nodoc:
 
-    private
+      def _t_cleanup_belongs_to_association(association)
+        associate_id = self.send(association.foreign_key)
+        if associate_id != nil && associate_id.to_s.strip != ''
+          if association.dependent == :destroy
+            association.associate_class._t_delete(associate_id)
+          elsif association.dependent == :delete
+            association.associate_class._t_delete(associate_id, false)
+          end
+        end
+      end
 
-    def belongs_to_associate(association)
-      associate_id = self.send(association.foreign_key)
-      clazz = association.associate_class
-      clazz._t_find(associate_id)
-    end
+      private
 
-    def set_belongs_to_associate(association, associate)
-      self.send "#{association.foreign_key}=", associate.id.to_s
-    end
+      def belongs_to_associate(association)
+        associate_id = self.send(association.foreign_key)
+        clazz = association.associate_class(self)
+        associate = clazz._t_find(associate_id)
+        associate
+      end
 
-    module ClassMethods #:nodoc:
-      def initialize_belongs_to_association(association)
-        _t_initialize_belongs_to_association(association) if self.respond_to?(:_t_initialize_belongs_to_association)
+      def set_belongs_to_associate(association, associate)
+        self.send "#{association.foreign_key}=", _t_serialize(associate.id)
+        self.send "#{association.polymorphic_type}=", associate.class.to_s if association.polymorphic?
+        associate
       end
 
-      def _t_stringify_belongs_to_value(record, association)
-        record.send "#{association.foreign_key}=", record.send(association.foreign_key).to_s
+      module ClassMethods #:nodoc:
+        def initialize_belongs_to_association(association)
+          _t_initialize_belongs_to_association(association) if self.respond_to?(:_t_initialize_belongs_to_association)
+        end
       end
-    end
 
+    end
   end
 end
 

data/lib/tenacity/associations/has_many.rb

@@ -1,80 +1,140 @@
 module Tenacity
-  module HasMany #:nodoc:
+  module Associations
+    module HasMany #:nodoc:
 
-    def _t_remove_associates(association)
-      instance_variable_set _t_ivar_name(association), []
-      _t_clear_associates(association)
-    end
+      def _t_remove_associates(association)
+        instance_variable_set _t_ivar_name(association), []
+        _t_clear_associates(association)
+      end
 
-    private
+      def _t_cleanup_has_many_association(association)
+        associates = has_many_associates(association)
+        unless associates.nil? || associates.empty?
+          if association.dependent == :destroy
+            associates.each { |associate| association.associate_class._t_delete([_t_serialize(associate.id)]) }
+          elsif association.dependent == :delete_all
+            associates.each { |associate| association.associate_class._t_delete([_t_serialize(associate.id)], false) }
+          elsif association.dependent == :nullify
+            associates.each do |associate|
+              associate.send "#{association.foreign_key(self.class)}=", nil
+              associate.save
+            end
+          end
+        end
+      end
 
-    def has_many_associates(association)
-      ids = _t_get_associate_ids(association)
-      clazz = association.associate_class
-      clazz._t_find_bulk(ids)
-    end
+      private
 
-    def has_many_associate_ids(association)
-      _t_get_associate_ids(association)
-    end
+      def has_many_associates(association)
+        ids = _t_get_associate_ids(association)
+        pruned_ids = prune_associate_ids(association, ids)
+        clazz = association.associate_class
+        clazz._t_find_bulk(pruned_ids)
+      end
 
-    def set_has_many_associate_ids(association, associate_ids)
-      clazz = association.associate_class
-      instance_variable_set _t_ivar_name(association), clazz._t_find_bulk(associate_ids)
-    end
+      def set_has_many_associates(association, associates)
+        associates.map { |associate| AssociateProxy.new(associate, association) }
+      end
 
-    def save_without_callback
-      @perform_save_associates_callback = false
-      save
-    ensure
-      @perform_save_associates_callback = true
-    end
+      def has_many_associate_ids(association)
+        ids = _t_get_associate_ids(association)
+        prune_associate_ids(association, ids)
+      end
+
+      def set_has_many_associate_ids(association, associate_ids)
+        clazz = association.associate_class
+        instance_variable_set _t_ivar_name(association), clazz._t_find_bulk(associate_ids)
+      end
+
+      def save_without_callback
+        @perform_save_associates_callback = false
+        save
+      ensure
+        @perform_save_associates_callback = true
+      end
 
-    module ClassMethods #:nodoc:
-      def initialize_has_many_association(association)
-        _t_initialize_has_many_association(association) if self.respond_to?(:_t_initialize_has_many_association)
+      def prune_associate_ids(association, associate_ids)
+        if association.limit || association.offset
+          sorted_ids = associate_ids.sort { |a,b| a <=> b }
 
-        attr_accessor :perform_save_associates_callback
+          limit = association.limit || associate_ids.size
+          offset = association.offset || 0
+          sorted_ids[offset...(offset + limit)]
+        else
+          associate_ids
+        end
       end
 
-      def _t_save_associates(record, association)
-        return if record.perform_save_associates_callback == false
+      module ClassMethods #:nodoc:
+        def initialize_has_many_association(association)
+          _t_initialize_has_many_association(association) if self.respond_to?(:_t_initialize_has_many_association)
+
+          attr_accessor :perform_save_associates_callback
+        end
+
+        def _t_save_associates(record, association)
+          return if record.perform_save_associates_callback == false
+
+          old_associates = get_current_associates(record, association)
+
+          # Some ORM libraries (CouchRest, ActiveRecord, etc) return a proxy in
+          # place of the associated objects.  The actual associated objects
+          # will be fetched the first time they are needed.  So, force them to
+          # be fetched here, before we clear them out in the database.
+          old_associates.inspect
+
+          _t_clear_old_associations(record, association)
 
-        _t_clear_old_associations(record, association)
+          associates = (record.instance_variable_get record._t_ivar_name(association)) || []
+          associates.each do |associate|
+            associate._t_reload
+            associate.send("#{association.foreign_key(record.class)}=", _t_serialize(record.id, association))
+            associate.send "#{association.polymorphic_type}=", self.to_s if association.polymorphic?
+            save_associate(associate)
+          end
 
-        associates = (record.instance_variable_get record._t_ivar_name(association)) || []
-        associates.each do |associate|
-          associate._t_reload
-          associate.send("#{association.foreign_key(record.class)}=", record.id.to_s)
-          save_associate(associate)
+          unless associates.blank?
+            associate_ids = associates.map { |associate| _t_serialize(associate.id) }
+            record._t_associate_many(association, associate_ids)
+            save_associate(record)
+          end
+
+          destroy_orphaned_associates(association, old_associates, associates)
         end
 
-        unless associates.blank?
-          associate_ids = associates.map { |associate| associate.id.to_s }
-          record._t_associate_many(association, associate_ids)
+        def _t_clear_old_associations(record, association)
+          property_name = association.foreign_key(record.class)
+          old_associates = get_current_associates(record, association)
+          old_associates.each do |old_associate|
+            old_associate.send("#{property_name}=", nil)
+            save_associate(old_associate)
+          end
+
+          record._t_clear_associates(association)
           save_associate(record)
         end
-      end
 
-      def _t_clear_old_associations(record, association)
-        clazz = association.associate_class
-        property_name = association.foreign_key(record.class)
+        def save_associate(associate)
+          associate.respond_to?(:_t_save_without_callback) ? associate._t_save_without_callback : associate.save
+        end
 
-        old_associates = clazz._t_find_all_by_associate(property_name, record.id.to_s)
-        old_associates.each do |old_associate|
-          old_associate.send("#{property_name}=", nil)
-          save_associate(old_associate)
+        def get_current_associates(record, association)
+          clazz = association.associate_class
+          property_name = association.foreign_key(record.class)
+          clazz._t_find_all_by_associate(property_name, _t_serialize(record.id, association))
         end
 
-        record._t_clear_associates(association)
-        save_associate(record)
+        def destroy_orphaned_associates(association, old_associates, associates)
+          if association.dependent == :destroy || association.dependent == :delete_all
+            issue_callbacks = (association.dependent == :destroy)
+            (old_associates.map{|a| a.id} - associates.map{|a| a.id}).each do |associate_id|
+              association.associate_class._t_delete([_t_serialize(associate_id)], issue_callbacks)
+            end
+          end
+        end
       end
 
-      def save_associate(associate)
-        associate.respond_to?(:_t_save_without_callback) ? associate._t_save_without_callback : associate.save
-      end
     end
-
   end
 end