activerecord 4.0.4 → 4.1.16

data/lib/active_record/reflection.rb

@@ -4,11 +4,32 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :reflections
-      self.reflections = {}
+      class_attribute :_reflections, instance_writer: false
+      class_attribute :aggregate_reflections, instance_writer: false
+      self._reflections = {}
+      self.aggregate_reflections = {}
     end
 
-    # Reflection enables to interrogate Active Record classes and objects
+    def self.create(macro, name, scope, options, ar)
+      case macro
+      when :has_many, :belongs_to, :has_one
+        klass = options[:through] ? ThroughReflection : AssociationReflection
+      when :composed_of
+        klass = AggregateReflection
+      end
+
+      klass.new(macro, name, scope, options, ar)
+    end
+
+    def self.add_reflection(ar, name, reflection)
+      ar._reflections = ar._reflections.merge(name.to_sym => reflection)
+    end
+
+    def self.add_aggregate_reflection(ar, name, reflection)
+      ar.aggregate_reflections = ar.aggregate_reflections.merge(name.to_sym => reflection)
+    end
+
+    # \Reflection enables to interrogate Active Record classes and objects
     # about their associations and aggregations. This information can,
     # for example, be used in a form builder that takes an Active Record object
     # and creates input fields for all of the attributes depending on their type
@@ -17,22 +38,9 @@ module ActiveRecord
     # MacroReflection class has info for AggregateReflection and AssociationReflection
     # classes.
     module ClassMethods
-      def create_reflection(macro, name, scope, options, active_record)
-        case macro
-        when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
-          klass = options[:through] ? ThroughReflection : AssociationReflection
-          reflection = klass.new(macro, name, scope, options, active_record)
-        when :composed_of
-          reflection = AggregateReflection.new(macro, name, scope, options, active_record)
-        end
-
-        self.reflections = self.reflections.merge(name => reflection)
-        reflection
-      end
-
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
-        reflections.values.grep(AggregateReflection)
+        aggregate_reflections.values
       end
 
       # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
@@ -40,8 +48,25 @@ module ActiveRecord
       #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
       #
       def reflect_on_aggregation(aggregation)
-        reflection = reflections[aggregation]
-        reflection if reflection.is_a?(AggregateReflection)
+        aggregate_reflections[aggregation.to_sym]
+      end
+
+      # Returns a Hash of name of the reflection as the key and a AssociationReflection as the value.
+      #
+      #   Account.reflections # => {balance: AggregateReflection}
+      #
+      # @api public
+      def reflections
+        ref = {}
+        _reflections.each do |name, reflection|
+          parent_name, parent_reflection = reflection.parent_reflection
+          if parent_name
+            ref[parent_name] = parent_reflection
+          else
+            ref[name] = reflection
+          end
+        end
+        ref
       end
 
       # Returns an array of AssociationReflection objects for all the
@@ -54,8 +79,9 @@ module ActiveRecord
       #   Account.reflect_on_all_associations             # returns an array of all associations
       #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
       #
+      #   @api public
       def reflect_on_all_associations(macro = nil)
-        association_reflections = reflections.values.grep(AssociationReflection)
+        association_reflections = reflections.values
         macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
       end
 
@@ -64,12 +90,19 @@ module ActiveRecord
       #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
+      #   @api public
       def reflect_on_association(association)
-        reflection = reflections[association]
-        reflection if reflection.is_a?(AssociationReflection)
+        reflections[association.to_sym]
+      end
+
+      #   @api private
+      def _reflect_on_association(association) #:nodoc:
+        _reflections[association.to_sym]
       end
 
       # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      #
+      #   @api public
       def reflect_on_all_autosave_associations
         reflections.values.select { |reflection| reflection.options[:autosave] }
       end
@@ -100,7 +133,7 @@ module ActiveRecord
       # Returns the hash of options used for the macro.
       #
       # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>{ class_name: "Money" }</tt>
-      # <tt>has_many :clients</tt> returns +{}+
+      # <tt>has_many :clients</tt> returns <tt>{}</tt>
       attr_reader :options
 
       attr_reader :active_record
@@ -113,10 +146,20 @@ module ActiveRecord
         @scope         = scope
         @options       = options
         @active_record = active_record
+        @klass         = options[:anonymous_class]
         @plural_name   = active_record.pluralize_table_names ?
                             name.to_s.pluralize : name.to_s
       end
 
+      def autosave=(autosave)
+        @automatic_inverse_of = false
+        @options[:autosave] = autosave
+        _, parent_reflection = self.parent_reflection
+        if parent_reflection
+          parent_reflection.autosave = autosave
+        end
+      end
+
       # Returns the class for the macro.
       #
       # <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
@@ -139,7 +182,7 @@ module ActiveRecord
         super ||
           other_aggregation.kind_of?(self.class) &&
           name == other_aggregation.name &&
-          other_aggregation.options &&
+          !other_aggregation.options.nil? &&
           active_record == other_aggregation.active_record
       end
 
@@ -178,9 +221,16 @@ module ActiveRecord
         @klass ||= active_record.send(:compute_type, class_name)
       end
 
-      def initialize(*args)
+      attr_reader :type, :foreign_type
+      attr_accessor :parent_reflection # [:name, Reflection]
+
+      def initialize(macro, name, scope, options, active_record)
         super
         @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
+        @automatic_inverse_of = nil
+        @type         = options[:as] && "#{options[:as]}_type"
+        @foreign_type = options[:foreign_type] || "#{name}_type"
+        @constructable = calculate_constructable(macro, options)
       end
 
       # Returns a new, unsaved instance of the associated class. +attributes+ will
@@ -189,12 +239,16 @@ module ActiveRecord
         klass.new(attributes, &block)
       end
 
+      def constructable? # :nodoc:
+        @constructable
+      end
+
       def table_name
-        @table_name ||= klass.table_name
+        klass.table_name
       end
 
       def quoted_table_name
-        @quoted_table_name ||= klass.quoted_table_name
+        klass.quoted_table_name
       end
 
       def join_table
@@ -205,16 +259,8 @@ module ActiveRecord
         @foreign_key ||= options[:foreign_key] || derive_foreign_key
       end
 
-      def foreign_type
-        @foreign_type ||= options[:foreign_type] || "#{name}_type"
-      end
-
-      def type
-        @type ||= options[:as] && "#{options[:as]}_type"
-      end
-
       def primary_key_column
-        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+        klass.columns_hash[klass.primary_key]
       end
 
       def association_foreign_key
@@ -238,20 +284,8 @@ module ActiveRecord
         end
       end
 
-      def columns(tbl_name)
-        @columns ||= klass.connection.columns(tbl_name)
-      end
-
-      def reset_column_information
-        @columns = nil
-      end
-
       def check_validity!
         check_validity_of_inverse!
-
-        if has_and_belongs_to_many? && association_foreign_key == foreign_key
-          raise HasAndBelongsToManyAssociationForeignKeyNeeded.new(self)
-        end
       end
 
       def check_validity_of_inverse!
@@ -267,7 +301,7 @@ module ActiveRecord
       end
 
       def source_reflection
-        nil
+        self
       end
 
       # A chain of reflections from this one back to the owner. For more see the explanation in
@@ -289,18 +323,18 @@ module ActiveRecord
       alias :source_macro :macro
 
       def has_inverse?
-        @options[:inverse_of]
+        inverse_name
       end
 
       def inverse_of
-        if has_inverse?
-          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
-        end
+        return unless inverse_name
+
+        @inverse_of ||= klass._reflect_on_association inverse_name
       end
 
       def polymorphic_inverse_of(associated_class)
         if has_inverse?
-          if inverse_relationship = associated_class.reflect_on_association(options[:inverse_of])
+          if inverse_relationship = associated_class._reflect_on_association(options[:inverse_of])
             inverse_relationship
           else
             raise InverseOfAssociationNotFoundError.new(self, associated_class)
@@ -333,10 +367,6 @@ module ActiveRecord
         macro == :belongs_to
       end
 
-      def has_and_belongs_to_many?
-        macro == :has_and_belongs_to_many
-      end
-
       def association_class
         case macro
         when :belongs_to
@@ -345,8 +375,6 @@ module ActiveRecord
           else
             Associations::BelongsToAssociation
           end
-        when :has_and_belongs_to_many
-          Associations::HasAndBelongsToManyAssociation
         when :has_many
           if options[:through]
             Associations::HasManyThroughAssociation
@@ -366,11 +394,96 @@ module ActiveRecord
         options.key? :polymorphic
       end
 
+      VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_one, :belongs_to]
+      INVALID_AUTOMATIC_INVERSE_OPTIONS = [:conditions, :through, :polymorphic, :foreign_key]
+
+      protected
+
+        def actual_source_reflection # FIXME: this is a horrible name
+          self
+        end
+
       private
+
+        def calculate_constructable(macro, options)
+          case macro
+          when :belongs_to
+            !options[:polymorphic]
+          when :has_one
+            !options[:through]
+          else
+            true
+          end
+        end
+
+        # Attempts to find the inverse association name automatically.
+        # If it cannot find a suitable inverse association name, it returns
+        # nil.
+        def inverse_name
+          options.fetch(:inverse_of) do
+            if @automatic_inverse_of == false
+              nil
+            else
+              @automatic_inverse_of ||= automatic_inverse_of
+            end
+          end
+        end
+
+        # returns either nil or the inverse association name that it finds.
+        def automatic_inverse_of
+          if can_find_inverse_of_automatically?(self)
+            inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_record.name.demodulize).to_sym
+
+            begin
+              reflection = klass._reflect_on_association(inverse_name)
+            rescue NameError
+              # Give up: we couldn't compute the klass type so we won't be able
+              # to find any associations either.
+              reflection = false
+            end
+
+            if valid_inverse_reflection?(reflection)
+              return inverse_name
+            end
+          end
+
+          false
+        end
+
+        # Checks if the inverse reflection that is returned from the
+        # +automatic_inverse_of+ method is a valid reflection. We must
+        # make sure that the reflection's active_record name matches up
+        # with the current reflection's klass name.
+        #
+        # Note: klass will always be valid because when there's a NameError
+        # from calling +klass+, +reflection+ will already be set to false.
+        def valid_inverse_reflection?(reflection)
+          reflection &&
+            klass.name == reflection.active_record.name &&
+            can_find_inverse_of_automatically?(reflection)
+        end
+
+        # Checks to see if the reflection doesn't have any options that prevent
+        # us from being able to guess the inverse automatically. First, the
+        # <tt>inverse_of</tt> option cannot be set to false. Second, we must
+        # have <tt>has_many</tt>, <tt>has_one</tt>, <tt>belongs_to</tt> associations.
+        # Third, we must not have options such as <tt>:polymorphic</tt> or
+        # <tt>:foreign_key</tt> which prevent us from correctly guessing the
+        # inverse association.
+        #
+        # Anything with a scope can additionally ruin our attempt at finding an
+        # inverse, so we exclude reflections with scopes.
+        def can_find_inverse_of_automatically?(reflection)
+          reflection.options[:inverse_of] != false &&
+            VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
+            !INVALID_AUTOMATIC_INVERSE_OPTIONS.any? { |opt| reflection.options[opt] } &&
+            !reflection.scope
+        end
+
         def derive_class_name
-          class_name = name.to_s.camelize
+          class_name = name.to_s
           class_name = class_name.singularize if collection?
-          class_name
+          class_name.camelize
         end
 
         def derive_foreign_key
@@ -398,7 +511,12 @@ module ActiveRecord
       delegate :foreign_key, :foreign_type, :association_foreign_key,
                :active_record_primary_key, :type, :to => :source_reflection
 
-      # Gets the source of the through reflection. It checks both a singularized
+      def initialize(macro, name, scope, options, active_record)
+        super
+        @source_reflection_name = options[:source]
+      end
+
+      # Returns the source of the through reflection. It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
       #   class Post < ActiveRecord::Base
@@ -412,12 +530,13 @@ module ActiveRecord
       #   end
       #
       #   tags_reflection = Post.reflect_on_association(:tags)
-      #
-      #   taggings_reflection = tags_reflection.source_reflection
+      #   tags_reflection.source_reflection
       #   # => <ActiveRecord::Reflection::AssociationReflection: @macro=:belongs_to, @name=:tag, @active_record=Tagging, @plural_name="tags">
       #
       def source_reflection
-        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+        if source_reflection_name
+          through_reflection.klass._reflect_on_association(source_reflection_name)
+        end
       end
 
       # Returns the AssociationReflection object specified in the <tt>:through</tt> option
@@ -429,10 +548,11 @@ module ActiveRecord
       #   end
       #
       #   tags_reflection = Post.reflect_on_association(:tags)
-      #   taggings_reflection = tags_reflection.through_reflection
+      #   tags_reflection.through_reflection
+      #   # => <ActiveRecord::Reflection::AssociationReflection: @macro=:has_many, @name=:taggings, @active_record=Post, @plural_name="taggings">
       #
       def through_reflection
-        @through_reflection ||= active_record.reflect_on_association(options[:through])
+        active_record._reflect_on_association(options[:through])
       end
 
       # Returns an array of reflections which are involved in this association. Each item in the
@@ -454,7 +574,9 @@ module ActiveRecord
       #
       def chain
         @chain ||= begin
-          chain = source_reflection.chain + through_reflection.chain
+          a = source_reflection.chain
+          b = through_reflection.chain
+          chain = a + b
           chain[0] = self # Use self so we don't lose the information from :source_type
           chain
         end
@@ -489,8 +611,11 @@ module ActiveRecord
           through_scope_chain = through_reflection.scope_chain.map(&:dup)
 
           if options[:source_type]
-            through_scope_chain.first <<
-              through_reflection.klass.where(foreign_type => options[:source_type])
+            type = foreign_type
+            source_type = options[:source_type]
+            through_scope_chain.first << lambda { |object|
+              where(type => source_type)
+            }
           end
 
           # Recursively fill out the rest of the array from the through reflection
@@ -505,7 +630,7 @@ module ActiveRecord
 
       # A through association is nested if there would be more than one join table
       def nested?
-        chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
+        chain.length > 2
       end
 
       # We want to use the klass from this reflection, rather than just delegate straight to
@@ -514,12 +639,7 @@ module ActiveRecord
       def association_primary_key(klass = nil)
         # Get the "actual" source reflection if the immediate source reflection has a
         # source reflection itself
-        source_reflection = self.source_reflection
-        while source_reflection.source_reflection
-          source_reflection = source_reflection.source_reflection
-        end
-
-        source_reflection.options[:primary_key] || primary_key(klass || self.klass)
+        actual_source_reflection.options[:primary_key] || primary_key(klass || self.klass)
       end
 
       # Gets an array of possible <tt>:through</tt> source reflection names in both singular and plural form.
@@ -534,7 +654,32 @@ module ActiveRecord
       #   # => [:tag, :tags]
       #
       def source_reflection_names
-        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+        (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }.uniq
+      end
+
+      def source_reflection_name # :nodoc:
+        return @source_reflection_name.to_sym if @source_reflection_name
+
+        names = [name.to_s.singularize, name].collect { |n| n.to_sym }.uniq
+        names = names.find_all { |n|
+          through_reflection.klass._reflect_on_association(n)
+        }
+
+        if names.length > 1
+          example_options = options.dup
+          example_options[:source] = source_reflection_names.first
+          ActiveSupport::Deprecation.warn <<-eowarn
+Ambiguous source reflection for through association.  Please specify a :source
+directive on your declaration like:
+
+  class #{active_record.name} < ActiveRecord::Base
+    #{macro} :#{name}, #{example_options}
+  end
+
+          eowarn
+        end
+
+        @source_reflection_name = names.first
       end
 
       def source_options
@@ -573,6 +718,12 @@ module ActiveRecord
         check_validity_of_inverse!
       end
 
+      protected
+
+      def actual_source_reflection # FIXME: this is a horrible name
+        source_reflection.actual_source_reflection
+      end
+
       private
         def derive_class_name
           # get the class_name of the belongs_to association of the through reflection

data/lib/active_record/relation/batches.rb

@@ -11,7 +11,7 @@ module ActiveRecord
     # The #find_each method uses #find_in_batches with a batch size of 1000 (or as
     # specified by the +:batch_size+ option).
     #
-    #   Person.all.find_each do |person|
+    #   Person.find_each do |person|
     #     person.do_awesome_stuff
     #   end
     #
@@ -19,53 +19,103 @@ module ActiveRecord
     #     person.party_all_night!
     #   end
     #
-    #  You can also pass the +:start+ option to specify
-    #  an offset to control the starting point.
-    def find_each(options = {})
-      find_in_batches(options) do |records|
-        records.each { |record| yield record }
-      end
-    end
-
-    # Yields each batch of records that was found by the find +options+ as
-    # an array. The size of each batch is set by the +:batch_size+
-    # option; the default is 1000.
+    # If you do not provide a block to #find_each, it will return an Enumerator
+    # for chaining with other methods:
+    #
+    #   Person.find_each.with_index do |person, index|
+    #     person.award_trophy(index + 1)
+    #   end
     #
-    # You can control the starting point for the batch processing by
-    # supplying the +:start+ option. This is especially useful if you
-    # want multiple workers dealing with the same processing queue. You can
-    # make worker 1 handle all the records between id 0 and 10,000 and
-    # worker 2 handle from 10,000 and beyond (by setting the +:start+
-    # option on that worker).
+    # ==== Options
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:start</tt> - Specifies the starting point for the batch processing.
+    # This is especially useful if you want multiple workers dealing with
+    # the same processing queue. You can make worker 1 handle all the records
+    # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
+    # (by setting the +:start+ option on that worker).
     #
-    # It's not possible to set the order. That is automatically set to
+    #   # Let's process for a batch of 2000 records, skipping the first 2000 rows
+    #   Person.find_each(start: 2000, batch_size: 2000) do |person|
+    #     person.party_all_night!
+    #   end
+    #
+    # NOTE: It's not possible to set the order. That is automatically set to
     # ascending on the primary key ("id ASC") to make the batch ordering
     # work. This also means that this method only works with integer-based
-    # primary keys. You can't set the limit either, that's used to control
+    # primary keys.
+    #
+    # NOTE: You can't set the limit either, that's used to control
     # the batch sizes.
+    def find_each(options = {})
+      if block_given?
+        find_in_batches(options) do |records|
+          records.each { |record| yield record }
+        end
+      else
+        enum_for :find_each, options do
+          options[:start] ? where(table[primary_key].gteq(options[:start])).size : size
+        end
+      end
+    end
+
+    # Yields each batch of records that was found by the find +options+ as
+    # an array.
     #
     #   Person.where("age > 21").find_in_batches do |group|
     #     sleep(50) # Make sure it doesn't get too crowded in there!
     #     group.each { |person| person.party_all_night! }
     #   end
     #
+    # If you do not provide a block to #find_in_batches, it will return an Enumerator
+    # for chaining with other methods:
+    #
+    #   Person.find_in_batches.with_index do |group, batch|
+    #     puts "Processing group ##{batch}"
+    #     group.each(&:recover_from_last_night!)
+    #   end
+    #
+    # To be yielded each record one by one, use #find_each instead.
+    #
+    # ==== Options
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:start</tt> - Specifies the starting point for the batch processing.
+    # This is especially useful if you want multiple workers dealing with
+    # the same processing queue. You can make worker 1 handle all the records
+    # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
+    # (by setting the +:start+ option on that worker).
+    #
     #   # Let's process the next 2000 records
-    #   Person.all.find_in_batches(start: 2000, batch_size: 2000) do |group|
+    #   Person.find_in_batches(start: 2000, batch_size: 2000) do |group|
     #     group.each { |person| person.party_all_night! }
     #   end
+    #
+    # NOTE: It's not possible to set the order. That is automatically set to
+    # ascending on the primary key ("id ASC") to make the batch ordering
+    # work. This also means that this method only works with integer-based
+    # primary keys.
+    #
+    # NOTE: You can't set the limit either, that's used to control
+    # the batch sizes.
     def find_in_batches(options = {})
       options.assert_valid_keys(:start, :batch_size)
 
       relation = self
+      start = options[:start]
+      batch_size = options[:batch_size] || 1000
+
+      unless block_given?
+        return to_enum(:find_in_batches, options) do
+          total = start ? where(table[primary_key].gteq(start)).size : size
+          (total - 1).div(batch_size) + 1
+        end
+      end
 
       if logger && (arel.orders.present? || arel.taken.present?)
         logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
       end
 
-      start = options.delete(:start)
-      batch_size = options.delete(:batch_size) || 1000
-
       relation = relation.reorder(batch_order).limit(batch_size)
+      relation.reverse_order_value = false
       records = start ? relation.where(table[primary_key].gteq(start)).to_a : relation.to_a
 
       while records.any?