has_many_polymorphs 2.2

data/lib/has_many_polymorphs/association.rb

@@ -0,0 +1,160 @@
+module ActiveRecord #:nodoc:
+  module Associations #:nodoc:
+    
+    class PolymorphicError < ActiveRecordError #:nodoc:
+    end 
+    
+    class PolymorphicMethodNotSupportedError < ActiveRecordError #:nodoc:
+    end
+    
+    # The association class for a <tt>has_many_polymorphs</tt> association.
+    class PolymorphicAssociation < HasManyThroughAssociation
+
+      # Push a record onto the association. Triggers a database load for a uniqueness check only if <tt>:skip_duplicates</tt> is <tt>true</tt>. Return value is undefined.
+      def <<(*records)
+        return if records.empty?
+
+        if @reflection.options[:skip_duplicates]
+          _logger_debug "Loading instances for polymorphic duplicate push check; use :skip_duplicates => false and perhaps a database constraint to avoid this possible performance issue"
+          load_target
+        end
+        
+        @reflection.klass.transaction do
+          flatten_deeper(records).each do |record|
+            if @owner.new_record? or not record.respond_to?(:new_record?) or record.new_record?
+              raise PolymorphicError, "You can't associate unsaved records."            
+            end
+            next if @reflection.options[:skip_duplicates] and @target.include? record
+            @owner.send(@reflection.through_reflection.name).proxy_target << @reflection.klass.create!(construct_join_attributes(record))
+            @target << record if loaded?
+          end
+        end
+        
+        self
+      end
+      
+      alias :push :<<
+      alias :concat :<<      
+     
+      # Runs a <tt>find</tt> against the association contents, returning the matched records. All regular <tt>find</tt> options except <tt>:include</tt> are supported.
+      def find(*args)
+        opts = args._extract_options!
+        opts.delete :include
+        super(*(args + [opts]))
+      end      
+      
+      def construct_scope
+        _logger_warn "Warning; not all usage scenarios for polymorphic scopes are supported yet."
+        super
+      end
+     
+     # Deletes a record from the association. Return value is undefined.
+      def delete(*records)
+        records = flatten_deeper(records)
+        records.reject! {|record| @target.delete(record) if record.new_record?}
+        return if records.empty?
+        
+        @reflection.klass.transaction do
+          records.each do |record|
+            joins = @reflection.through_reflection.name
+            @owner.send(joins).delete(@owner.send(joins).select do |join|
+              join.send(@reflection.options[:polymorphic_key]) == record.id and 
+              join.send(@reflection.options[:polymorphic_type_key]) == "#{record.class.base_class}"
+            end)
+            @target.delete(record)
+          end
+        end
+      end
+      
+      # Clears all records from the association. Returns an empty array.
+      def clear(klass = nil)
+        load_target
+        return if @target.empty?
+        
+        if klass
+          delete(@target.select {|r| r.is_a? klass })
+        else
+          @owner.send(@reflection.through_reflection.name).clear
+          @target.clear
+        end
+        []
+      end
+            
+      protected
+
+#      undef :sum
+#      undef :create!
+
+      def construct_quoted_owner_attributes(*args) #:nodoc:
+        # no access to returning() here? why not?
+        type_key = @reflection.options[:foreign_type_key]
+        h = {@reflection.primary_key_name => @owner.id}
+        h[type_key] = @owner.class.base_class.name if type_key
+        h
+      end
+
+      def construct_from #:nodoc:
+        # build the FROM part of the query, in this case, the polymorphic join table
+        @reflection.klass.quoted_table_name
+      end
+
+      def construct_owner #:nodoc:
+        # the table name for the owner object's class
+        @owner.class.quoted_table_name
+      end
+      
+      def construct_owner_key #:nodoc:
+        # the primary key field for the owner object
+        @owner.class.primary_key
+      end
+
+      def construct_select(custom_select = nil) #:nodoc:
+        # build the select query
+        selected = custom_select || @reflection.options[:select]
+      end
+
+      def construct_joins(custom_joins = nil) #:nodoc:
+        # build the string of default joins
+        "JOIN #{construct_owner} AS polymorphic_parent ON #{construct_from}.#{@reflection.options[:foreign_key]} = polymorphic_parent.#{construct_owner_key} " + 
+        @reflection.options[:from].map do |plural|
+          klass = plural._as_class
+          "LEFT JOIN #{klass.quoted_table_name} ON #{construct_from}.#{@reflection.options[:polymorphic_key]} = #{klass.quoted_table_name}.#{klass.primary_key} AND #{construct_from}.#{@reflection.options[:polymorphic_type_key]} = #{@reflection.klass.quote_value(klass.base_class.name)}"
+        end.uniq.join(" ") + " #{custom_joins}"
+      end
+
+      def construct_conditions #:nodoc:
+        # build the fully realized condition string
+        conditions = construct_quoted_owner_attributes.map do |field, value|
+          "#{construct_from}.#{field} = #{@reflection.klass.quote_value(value)}" if value
+        end
+        conditions << custom_conditions if custom_conditions
+        "(" + conditions.compact.join(') AND (') + ")"
+      end
+
+      def custom_conditions #:nodoc:
+        # custom conditions... not as messy as has_many :through because our joins are a little smarter
+        if @reflection.options[:conditions]
+          "(" + interpolate_sql(@reflection.klass.send(:sanitize_sql, @reflection.options[:conditions])) + ")"
+        end
+      end
+
+      alias :construct_owner_attributes :construct_quoted_owner_attributes
+      alias :conditions :custom_conditions # XXX possibly not necessary
+      alias :sql_conditions :custom_conditions # XXX ditto      
+
+      # construct attributes for join for a particular record
+      def construct_join_attributes(record) #:nodoc:
+        {@reflection.options[:polymorphic_key] => record.id, 
+          @reflection.options[:polymorphic_type_key] => "#{record.class.base_class}",          
+          @reflection.options[:foreign_key] => @owner.id}.merge(@reflection.options[:foreign_type_key] ? 
+        {@reflection.options[:foreign_type_key] => "#{@owner.class.base_class}"} : {}) # for double-sided relationships
+      end
+                    
+      def build(attrs = nil) #:nodoc:
+        raise PolymorphicMethodNotSupportedError, "You can't associate new records."
+      end      
+
+    end   
+        
+  end
+end

data/lib/has_many_polymorphs/autoload.rb

@@ -0,0 +1,69 @@
+require 'initializer' unless defined? ::Rails::Initializer 
+require 'action_controller/dispatcher' unless defined? ::ActionController::Dispatcher
+
+module HasManyPolymorphs
+
+=begin rdoc    
+Searches for models that use <tt>has_many_polymorphs</tt> or <tt>acts_as_double_polymorphic_join</tt> and makes sure that they get loaded during app initialization. This ensures that helper methods are injected into the target classes. 
+
+Note that you can override DEFAULT_OPTIONS via Rails::Configuration#has_many_polymorphs_options. For example, if you need an application extension to be required before has_many_polymorphs loads your models, add an <tt>after_initialize</tt> block in <tt>config/environment.rb</tt> that appends to the <tt>'requirements'</tt> key:
+  Rails::Initializer.run do |config|     
+    # your other configuration here
+    
+    config.after_initialize do
+      config.has_many_polymorphs_options['requirements'] << 'lib/my_extension'
+    end    
+  end
+  
+=end
+
+  DEFAULT_OPTIONS = {
+    :file_pattern => "#{RAILS_ROOT}/app/models/**/*.rb",
+    :file_exclusions => ['svn', 'CVS', 'bzr'],
+    :methods => ['has_many_polymorphs', 'acts_as_double_polymorphic_join'],
+    :requirements => []}
+  
+  mattr_accessor :options
+  @@options = HashWithIndifferentAccess.new(DEFAULT_OPTIONS)      
+
+  # Dispatcher callback to load polymorphic relationships from the top down.
+  def self.autoload
+
+    _logger_debug "autoload hook invoked"
+    
+    options[:requirements].each do |requirement|
+      _logger_warn "forcing requirement load of #{requirement}"
+      require requirement
+    end
+  
+    Dir.glob(options[:file_pattern]).each do |filename|
+      next if filename =~ /#{options[:file_exclusions].join("|")}/
+      open filename do |file|
+        if file.grep(/#{options[:methods].join("|")}/).any?
+          begin
+            model = File.basename(filename)[0..-4].camelize
+            _logger_warn "preloading parent model #{model}"
+            model.constantize
+          rescue Object => e
+            _logger_warn "#{model} could not be preloaded: #{e.inspect}"
+          end
+        end
+      end
+    end
+  end  
+    
+end
+
+class Rails::Initializer #:nodoc:
+  # Make sure it gets loaded in the console, tests, and migrations
+  def after_initialize_with_autoload 
+    after_initialize_without_autoload
+    HasManyPolymorphs.autoload
+  end
+  alias_method_chain :after_initialize, :autoload 
+end
+
+ActionController::Dispatcher.to_prepare(:has_many_polymorphs_autoload) do
+  # Make sure it gets loaded in the app
+  HasManyPolymorphs.autoload
+end

data/lib/has_many_polymorphs/base.rb

@@ -0,0 +1,60 @@
+
+module ActiveRecord
+  class Base
+    
+    class << self
+    
+      # Interprets a polymorphic row from a unified SELECT, returning the appropriate ActiveRecord instance. Overrides ActiveRecord::Base.instantiate_without_callbacks.
+      def instantiate_with_polymorphic_checks(record)
+        if record['polymorphic_parent_class']
+          reflection = record['polymorphic_parent_class'].constantize.reflect_on_association(record['polymorphic_association_id'].to_sym)
+#          _logger_debug "Instantiating a polymorphic row for #{record['polymorphic_parent_class']}.reflect_on_association(:#{record['polymorphic_association_id']})"
+
+          # rewrite the record with the right column names
+          table_aliases = reflection.options[:table_aliases].dup
+          record = Hash[*table_aliases.keys.map {|key| [key, record[table_aliases[key]]] }.flatten]          
+          
+          # find the real child class
+          klass = record["#{self.table_name}.#{reflection.options[:polymorphic_type_key]}"].constantize
+          if sti_klass = record["#{klass.table_name}.#{klass.inheritance_column}"]
+            klass = klass.class_eval do compute_type(sti_klass) end # in case of namespaced STI models
+          end
+          
+          # check that the join actually joined to something
+          unless (child_id = record["#{self.table_name}.#{reflection.options[:polymorphic_key]}"]) == record["#{klass.table_name}.#{klass.primary_key}"]
+            raise ActiveRecord::Associations::PolymorphicError, 
+              "Referential integrity violation; child <#{klass.name}:#{child_id}> was not found for #{reflection.name.inspect}" 
+          end
+          
+          # eject the join keys
+          # XXX not very readable
+          record = Hash[*record._select do |column, value| 
+            column[/^#{klass.table_name}/]
+          end.map do |column, value|
+            [column[/\.(.*)/, 1], value]
+          end.flatten]
+                    
+          # allocate and assign values
+          returning(klass.allocate) do |obj|
+            obj.instance_variable_set("@attributes", record)
+            obj.instance_variable_set("@attributes_cache", Hash.new)
+            
+            if obj.respond_to_without_attributes?(:after_find)
+              obj.send(:callback, :after_find)
+            end
+            
+            if obj.respond_to_without_attributes?(:after_initialize)
+              obj.send(:callback, :after_initialize)
+            end
+            
+          end
+        else                       
+          instantiate_without_polymorphic_checks(record)
+        end
+      end
+      
+      alias_method_chain :instantiate, :polymorphic_checks 
+    end
+    
+  end
+end