activerecord 4.2.11.1 → 5.0.0

data/lib/active_record/readonly_attributes.rb

@@ -11,7 +11,7 @@ module ActiveRecord
       # Attributes listed as readonly will be used to create a new record but update operations will
       # ignore these fields.
       def attr_readonly(*attributes)
-        self._attr_readonly = Set.new(attributes.map { |a| a.to_s }) + (self._attr_readonly || [])
+        self._attr_readonly = Set.new(attributes.map(&:to_s)) + (self._attr_readonly || [])
       end
 
       # Returns an array of all the attributes that have been specified as readonly.

data/lib/active_record/reflection.rb

@@ -40,9 +40,9 @@ module ActiveRecord
       ar.aggregate_reflections = ar.aggregate_reflections.merge(name.to_s => reflection)
     end
 
-    # \Reflection enables interrogating of 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
+    # \Reflection enables the ability to examine the associations and aggregations of
+    # Active Record classes and objects. This information, for example,
+    # can 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
     # and displays the associations to other objects.
     #
@@ -62,20 +62,20 @@ module ActiveRecord
         aggregate_reflections[aggregation.to_s]
       end
 
-      # Returns a Hash of name of the reflection as the key and a AssociationReflection as the value.
+      # Returns a Hash of name of the reflection as the key and an AssociationReflection as the value.
       #
       #   Account.reflections # => {"balance" => AggregateReflection}
       #
-      # @api public
       def reflections
         @__reflections ||= begin
           ref = {}
 
           _reflections.each do |name, reflection|
-            parent_name, parent_reflection = reflection.parent_reflection
+            parent_reflection = reflection.parent_reflection
 
-            if parent_name
-              ref[parent_name] = parent_reflection
+            if parent_reflection
+              parent_name = parent_reflection.name
+              ref[parent_name.to_s] = parent_reflection
             else
               ref[name] = reflection
             end
@@ -95,10 +95,10 @@ 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
-        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+        association_reflections.select! { |reflection| reflection.macro == macro } if macro
+        association_reflections
       end
 
       # Returns the AssociationReflection object for the +association+ (use the symbol).
@@ -106,31 +106,42 @@ 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)
         reflections[association.to_s]
       end
 
-      #   @api private
       def _reflect_on_association(association) #:nodoc:
         _reflections[association.to_s]
       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
 
-      def clear_reflections_cache #:nodoc:
+      def clear_reflections_cache # :nodoc:
         @__reflections = nil
       end
     end
 
-    # Holds all the methods that are shared between MacroReflection, AssociationReflection
-    # and ThroughReflection
+    # Holds all the methods that are shared between MacroReflection and ThroughReflection.
+    #
+    #   AbstractReflection
+    #     MacroReflection
+    #       AggregateReflection
+    #       AssociationReflection
+    #         HasManyReflection
+    #         HasOneReflection
+    #         BelongsToReflection
+    #         HasAndBelongsToManyReflection
+    #     ThroughReflection
+    #       PolymorphicReflection
+    #         RuntimeReflection
     class AbstractReflection # :nodoc:
+      def through_reflection?
+        false
+      end
+
       def table_name
         klass.table_name
       end
@@ -159,17 +170,24 @@ module ActiveRecord
 
       JoinKeys = Struct.new(:key, :foreign_key) # :nodoc:
 
-      def join_keys(assoc_klass)
+      def join_keys(association_klass)
         JoinKeys.new(foreign_key, active_record_primary_key)
       end
 
-      def source_macro
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveRecord::Base.source_macro is deprecated and will be removed
-          without replacement.
-        MSG
+      def constraints
+        scope_chain.flatten
+      end
 
-        macro
+      def counter_cache_column
+        if belongs_to?
+          if options[:counter_cache] == true
+            "#{active_record.name.demodulize.underscore.pluralize}_count"
+          elsif options[:counter_cache]
+            options[:counter_cache].to_s
+          end
+        else
+          options[:counter_cache] ? options[:counter_cache].to_s : "#{name}_count"
+        end
       end
 
       def inverse_of
@@ -185,17 +203,54 @@ module ActiveRecord
           end
         end
       end
+
+      # This shit is nasty. We need to avoid the following situation:
+      #
+      #   * An associated record is deleted via record.destroy
+      #   * Hence the callbacks run, and they find a belongs_to on the record with a
+      #     :counter_cache options which points back at our owner. So they update the
+      #     counter cache.
+      #   * In which case, we must make sure to *not* update the counter cache, or else
+      #     it will be decremented twice.
+      #
+      # Hence this method.
+      def inverse_which_updates_counter_cache
+        return @inverse_which_updates_counter_cache if defined?(@inverse_which_updates_counter_cache)
+        @inverse_which_updates_counter_cache = klass.reflect_on_all_associations(:belongs_to).find do |inverse|
+          inverse.counter_cache_column == counter_cache_column
+        end
+      end
+      alias inverse_updates_counter_cache? inverse_which_updates_counter_cache
+
+      def inverse_updates_counter_in_memory?
+        inverse_of && inverse_which_updates_counter_cache == inverse_of
+      end
+
+      # Returns whether a counter cache should be used for this association.
+      #
+      # The counter_cache option must be given on either the owner or inverse
+      # association, and the column must be present on the owner.
+      def has_cached_counter?
+        options[:counter_cache] ||
+          inverse_which_updates_counter_cache && inverse_which_updates_counter_cache.options[:counter_cache] &&
+          !!active_record.columns_hash[counter_cache_column]
+      end
+
+      def counter_must_be_updated_by_has_many?
+        !inverse_updates_counter_in_memory? && has_cached_counter?
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}"
+      end
+
+      def chain
+        collect_join_chain
+      end
     end
+
     # Base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
-    #
-    #   MacroReflection
-    #     AssociationReflection
-    #       AggregateReflection
-    #       HasManyReflection
-    #       HasOneReflection
-    #       BelongsToReflection
-    #         ThroughReflection
     class MacroReflection < AbstractReflection
       # Returns the name of the macro.
       #
@@ -228,7 +283,7 @@ module ActiveRecord
       def autosave=(autosave)
         @automatic_inverse_of = false
         @options[:autosave] = autosave
-        _, parent_reflection = self.parent_reflection
+        parent_reflection = self.parent_reflection
         if parent_reflection
           parent_reflection.autosave = autosave
         end
@@ -296,7 +351,7 @@ module ActiveRecord
       end
 
       attr_reader :type, :foreign_type
-      attr_accessor :parent_reflection # [:name, Reflection]
+      attr_accessor :parent_reflection # Reflection
 
       def initialize(name, scope, options, active_record)
         super
@@ -343,14 +398,6 @@ module ActiveRecord
         @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
       end
 
-      def counter_cache_column
-        if options[:counter_cache] == true
-          "#{active_record.name.demodulize.underscore.pluralize}_count"
-        elsif options[:counter_cache]
-          options[:counter_cache].to_s
-        end
-      end
-
       def check_validity!
         check_validity_of_inverse!
       end
@@ -359,13 +406,10 @@ module ActiveRecord
         return unless scope
 
         if scope.arity > 0
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          raise ArgumentError, <<-MSG.squish
             The association scope '#{name}' is instance dependent (the scope
-            block takes an argument). Preloading happens before the individual
-            instances are created. This means that there is no instance being
-            passed to the association scope. This will most likely result in
-            broken or incorrect behavior. Joining, Preloading and eager loading
-            of these associations is deprecated and will be removed in the future.
+            block takes an argument). Preloading instance dependent scopes is
+            not supported.
           MSG
         end
       end
@@ -385,10 +429,16 @@ module ActiveRecord
 
       # A chain of reflections from this one back to the owner. For more see the explanation in
       # ThroughReflection.
-      def chain
+      def collect_join_chain
         [self]
       end
 
+      # This is for clearing cache on the reflection. Useful for tests that need to compare
+      # SQL queries on associations.
+      def clear_association_scope_cache # :nodoc:
+        @association_scope_cache.clear
+      end
+
       def nested?
         false
       end
@@ -399,6 +449,10 @@ module ActiveRecord
         scope ? [[scope]] : [[]]
       end
 
+      def has_scope?
+        scope
+      end
+
       def has_inverse?
         inverse_name
       end
@@ -444,28 +498,7 @@ module ActiveRecord
       # Returns +true+ if +self+ is a +has_one+ reflection.
       def has_one?; false; end
 
-      def association_class
-        case macro
-        when :belongs_to
-          if polymorphic?
-            Associations::BelongsToPolymorphicAssociation
-          else
-            Associations::BelongsToAssociation
-          end
-        when :has_many
-          if options[:through]
-            Associations::HasManyThroughAssociation
-          else
-            Associations::HasManyAssociation
-          end
-        when :has_one
-          if options[:through]
-            Associations::HasOneThroughAssociation
-          else
-            Associations::HasOneAssociation
-          end
-        end
-      end
+      def association_class; raise NotImplementedError; end
 
       def polymorphic?
         options[:polymorphic]
@@ -474,6 +507,18 @@ module ActiveRecord
       VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_one, :belongs_to]
       INVALID_AUTOMATIC_INVERSE_OPTIONS = [:conditions, :through, :polymorphic, :foreign_key]
 
+      def add_as_source(seed)
+        seed
+      end
+
+      def add_as_polymorphic_through(reflection, seed)
+        seed + [PolymorphicReflection.new(self, reflection)]
+      end
+
+      def add_as_through(seed)
+        seed + [self]
+      end
+
       protected
 
         def actual_source_reflection # FIXME: this is a horrible name
@@ -483,14 +528,7 @@ module ActiveRecord
       private
 
         def calculate_constructable(macro, options)
-          case macro
-          when :belongs_to
-            !polymorphic?
-          when :has_one
-            !options[:through]
-          else
-            true
-          end
+          true
         end
 
         # Attempts to find the inverse association name automatically.
@@ -506,7 +544,7 @@ module ActiveRecord
           end
         end
 
-        # returns either nil or the inverse association name that it finds.
+        # returns either false 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
@@ -583,42 +621,66 @@ module ActiveRecord
     end
 
     class HasManyReflection < AssociationReflection # :nodoc:
-      def initialize(name, scope, options, active_record)
-        super(name, scope, options, active_record)
-      end
-
       def macro; :has_many; end
 
       def collection?; true; end
-    end
 
-    class HasOneReflection < AssociationReflection # :nodoc:
-      def initialize(name, scope, options, active_record)
-        super(name, scope, options, active_record)
+      def association_class
+        if options[:through]
+          Associations::HasManyThroughAssociation
+        else
+          Associations::HasManyAssociation
+        end
       end
+    end
 
+    class HasOneReflection < AssociationReflection # :nodoc:
       def macro; :has_one; end
 
       def has_one?; true; end
-    end
 
-    class BelongsToReflection < AssociationReflection # :nodoc:
-      def initialize(name, scope, options, active_record)
-        super(name, scope, options, active_record)
+      def association_class
+        if options[:through]
+          Associations::HasOneThroughAssociation
+        else
+          Associations::HasOneAssociation
+        end
       end
 
+      private
+
+        def calculate_constructable(macro, options)
+          !options[:through]
+        end
+    end
+
+    class BelongsToReflection < AssociationReflection # :nodoc:
       def macro; :belongs_to; end
 
       def belongs_to?; true; end
 
-      def join_keys(assoc_klass)
-        key = polymorphic? ? association_primary_key(assoc_klass) : association_primary_key
+      def association_class
+        if polymorphic?
+          Associations::BelongsToPolymorphicAssociation
+        else
+          Associations::BelongsToAssociation
+        end
+      end
+
+      def join_keys(association_klass)
+        key = polymorphic? ? association_primary_key(association_klass) : association_primary_key
         JoinKeys.new(key, foreign_key)
       end
 
       def join_id_for(owner) # :nodoc:
         owner[foreign_key]
       end
+
+      private
+
+        def calculate_constructable(macro, options)
+          !polymorphic?
+        end
     end
 
     class HasAndBelongsToManyReflection < AssociationReflection # :nodoc:
@@ -646,6 +708,10 @@ module ActiveRecord
         @source_reflection_name = delegate_reflection.options[:source]
       end
 
+      def through_reflection?
+        true
+      end
+
       def klass
         @klass ||= delegate_reflection.compute_class(class_name)
       end
@@ -704,14 +770,16 @@ module ActiveRecord
       #   # => [<ActiveRecord::Reflection::ThroughReflection: @delegate_reflection=#<ActiveRecord::Reflection::HasManyReflection: @name=:tags...>,
       #         <ActiveRecord::Reflection::HasManyReflection: @name=:taggings, @options={}, @active_record=Post>]
       #
-      def chain
-        @chain ||= begin
-          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
+      def collect_join_chain
+        collect_join_reflections [self]
+      end
+
+      # This is for clearing cache on the reflection. Useful for tests that need to compare
+      # SQL queries on associations.
+      def clear_association_scope_cache # :nodoc:
+        delegate_reflection.clear_association_scope_cache
+        source_reflection.clear_association_scope_cache
+        through_reflection.clear_association_scope_cache
       end
 
       # Consider the following example:
@@ -755,23 +823,19 @@ module ActiveRecord
         end
       end
 
-      def join_keys(assoc_klass)
-        source_reflection.join_keys(assoc_klass)
+      def has_scope?
+        scope || options[:source_type] ||
+          source_reflection.has_scope? ||
+          through_reflection.has_scope?
       end
 
-      # The macro used by the source association
-      def source_macro
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveRecord::Base.source_macro is deprecated and will be removed
-          without replacement.
-        MSG
-
-        source_reflection.source_macro
+      def join_keys(association_klass)
+        source_reflection.join_keys(association_klass)
       end
 
       # A through association is nested if there would be more than one join table
       def nested?
-        chain.length > 2
+        source_reflection.through_reflection? || through_reflection.through_reflection?
       end
 
       # We want to use the klass from this reflection, rather than just delegate straight to
@@ -801,7 +865,7 @@ module ActiveRecord
       def source_reflection_name # :nodoc:
         return @source_reflection_name if @source_reflection_name
 
-        names = [name.to_s.singularize, name].collect { |n| n.to_sym }.uniq
+        names = [name.to_s.singularize, name].collect(&:to_sym).uniq
         names = names.find_all { |n|
           through_reflection.klass._reflect_on_association(n)
         }
@@ -810,7 +874,7 @@ module ActiveRecord
           example_options = options.dup
           example_options[:source] = source_reflection_names.first
           ActiveSupport::Deprecation.warn \
-            "Ambiguous source reflection for through association.  Please " \
+            "Ambiguous source reflection for through association. Please " \
             "specify a :source directive on your declaration like:\n" \
             "\n" \
             "  class #{active_record.name} < ActiveRecord::Base\n" \
@@ -865,6 +929,33 @@ module ActiveRecord
         check_validity_of_inverse!
       end
 
+      def constraints
+        scope_chain = source_reflection.constraints
+        scope_chain << scope if scope
+        scope_chain
+      end
+
+      def add_as_source(seed)
+        collect_join_reflections seed
+      end
+
+      def add_as_polymorphic_through(reflection, seed)
+        collect_join_reflections(seed + [PolymorphicReflection.new(self, reflection)])
+      end
+
+      def add_as_through(seed)
+        collect_join_reflections(seed + [self])
+      end
+
+      def collect_join_reflections(seed)
+        a = source_reflection.add_as_source seed
+        if options[:source_type]
+          through_reflection.add_as_polymorphic_through self, a
+        else
+          through_reflection.add_as_through a
+        end
+      end
+
       protected
 
         def actual_source_reflection # FIXME: this is a horrible name
@@ -889,5 +980,81 @@ module ActiveRecord
         delegate(*delegate_methods, to: :delegate_reflection)
 
     end
+
+    class PolymorphicReflection < ThroughReflection # :nodoc:
+      def initialize(reflection, previous_reflection)
+        @reflection = reflection
+        @previous_reflection = previous_reflection
+      end
+
+      def klass
+        @reflection.klass
+      end
+
+      def scope
+        @reflection.scope
+      end
+
+      def table_name
+        @reflection.table_name
+      end
+
+      def plural_name
+        @reflection.plural_name
+      end
+
+      def join_keys(association_klass)
+        @reflection.join_keys(association_klass)
+      end
+
+      def type
+        @reflection.type
+      end
+
+      def constraints
+        @reflection.constraints + [source_type_info]
+      end
+
+      def source_type_info
+        type = @previous_reflection.foreign_type
+        source_type = @previous_reflection.options[:source_type]
+        lambda { |object| where(type => source_type) }
+      end
+    end
+
+    class RuntimeReflection < PolymorphicReflection # :nodoc:
+      attr_accessor :next
+
+      def initialize(reflection, association)
+        @reflection = reflection
+        @association = association
+      end
+
+      def klass
+        @association.klass
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      def constraints
+        @reflection.constraints
+      end
+
+      def source_type_info
+        @reflection.source_type_info
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}_join"
+      end
+
+      def alias_name
+        Arel::Table.new(table_name)
+      end
+
+      def all_includes; yield; end
+    end
   end
 end