activerecord 3.2.6 → 6.0.0

data/lib/active_record/associations/association_scope.rb

@@ -1,134 +1,166 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      include JoinHelper
-
-      attr_reader :association, :alias_tracker
+      def self.scope(association)
+        INSTANCE.scope(association)
+      end
 
-      delegate :klass, :owner, :reflection, :interpolate, :to => :association
-      delegate :chain, :conditions, :options, :source_options, :active_record, :to => :reflection
+      def self.create(&block)
+        block ||= lambda { |val| val }
+        new(block)
+      end
 
-      def initialize(association)
-        @association   = association
-        @alias_tracker = AliasTracker.new klass.connection
+      def initialize(value_transformation)
+        @value_transformation = value_transformation
       end
 
-      def scope
+      INSTANCE = create
+
+      def scope(association)
+        klass = association.klass
+        reflection = association.reflection
         scope = klass.unscoped
-        scope = scope.extending(*Array.wrap(options[:extend]))
+        owner = association.owner
+        chain = get_chain(reflection, association, scope.alias_tracker)
+
+        scope.extending! reflection.extensions
+        scope = add_constraints(scope, owner, chain)
+        scope.limit!(1) unless reflection.collection?
+        scope
+      end
 
-        # It's okay to just apply all these like this. The options will only be present if the
-        # association supports that option; this is enforced by the association builder.
-        scope = scope.apply_finder_options(options.slice(
-          :readonly, :include, :order, :limit, :joins, :group, :having, :offset, :select))
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
 
-        if options[:through] && !options[:include]
-          scope = scope.includes(source_options[:include])
+        binds << last_reflection.join_id_for(owner)
+        if last_reflection.type
+          binds << owner.class.polymorphic_name
         end
 
-        scope = scope.uniq if options[:uniq]
-
-        add_constraints(scope)
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.polymorphic_name
+          end
+        end
+        binds
       end
 
       private
+        attr_reader :value_transformation
 
-      def add_constraints(scope)
-        tables = construct_tables
-
-        chain.each_with_index do |reflection, i|
-          table, foreign_table = tables.shift, tables.first
+        def join(table, constraint)
+          table.create_join(table, table.create_on(constraint))
+        end
 
-          if reflection.source_macro == :has_and_belongs_to_many
-            join_table = tables.shift
+        def last_chain_scope(scope, reflection, owner)
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          foreign_key = join_keys.foreign_key
 
-            scope = scope.joins(join(
-              join_table,
-              table[reflection.association_primary_key].
-                eq(join_table[reflection.association_foreign_key])
-            ))
+          table = reflection.aliased_table
+          value = transform_value(owner[foreign_key])
+          scope = apply_scope(scope, table, key, value)
 
-            table, foreign_table = join_table, tables.first
+          if reflection.type
+            polymorphic_type = transform_value(owner.class.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, polymorphic_type)
           end
 
-          if reflection.source_macro == :belongs_to
-            if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(klass)
-            else
-              key = reflection.association_primary_key
-            end
+          scope
+        end
 
-            foreign_key = reflection.foreign_key
-          else
-            key         = reflection.foreign_key
-            foreign_key = reflection.active_record_primary_key
-          end
+        def transform_value(value)
+          value_transformation.call(value)
+        end
 
-          conditions = self.conditions[i]
+        def next_chain_scope(scope, reflection, next_reflection)
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          foreign_key = join_keys.foreign_key
 
-          if reflection == chain.last
-            scope = scope.where(table[key].eq(owner[foreign_key]))
+          table = reflection.aliased_table
+          foreign_table = next_reflection.aliased_table
+          constraint = table[key].eq(foreign_table[foreign_key])
 
-            if reflection.type
-              scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
-            end
+          if reflection.type
+            value = transform_value(next_reflection.klass.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, value)
+          end
 
-            conditions.each do |condition|
-              if options[:through] && condition.is_a?(Hash)
-                condition = disambiguate_condition(table, condition)
-              end
+          scope.joins!(join(foreign_table, constraint))
+        end
 
-              scope = scope.where(interpolate(condition))
-            end
-          else
-            constraint = table[key].eq(foreign_table[foreign_key])
+        class ReflectionProxy < SimpleDelegator # :nodoc:
+          attr_reader :aliased_table
 
-            if reflection.type
-              type = chain[i + 1].klass.base_class.name
-              constraint = constraint.and(table[reflection.type].eq(type))
-            end
+          def initialize(reflection, aliased_table)
+            super(reflection)
+            @aliased_table = aliased_table
+          end
 
-            scope = scope.joins(join(foreign_table, constraint))
+          def all_includes; nil; end
+        end
 
-            unless conditions.empty?
-              scope = scope.where(sanitize(conditions, table))
-            end
+        def get_chain(reflection, association, tracker)
+          name = reflection.name
+          chain = [Reflection::RuntimeReflection.new(reflection, association)]
+          reflection.chain.drop(1).each do |refl|
+            aliased_table = tracker.aliased_table_for(
+              refl.table_name,
+              refl.alias_candidate(name),
+              refl.klass.type_caster
+            )
+            chain << ReflectionProxy.new(refl, aliased_table)
           end
+          chain
         end
 
-        scope
-      end
+        def add_constraints(scope, owner, chain)
+          scope = last_chain_scope(scope, chain.last, owner)
 
-      def alias_suffix
-        reflection.name
-      end
+          chain.each_cons(2) do |reflection, next_reflection|
+            scope = next_chain_scope(scope, reflection, next_reflection)
+          end
 
-      def table_name_for(reflection)
-        if reflection == self.reflection
-          # If this is a polymorphic belongs_to, we want to get the klass from the
-          # association because it depends on the polymorphic_type attribute of
-          # the owner
-          klass.table_name
-        else
-          reflection.table_name
-        end
-      end
+          chain_head = chain.first
+          chain.reverse_each do |reflection|
+            # Exclude the scope of the association itself, because that
+            # was already merged in the #scope method.
+            reflection.constraints.each do |scope_chain_item|
+              item = eval_scope(reflection, scope_chain_item, owner)
 
-      def disambiguate_condition(table, condition)
-        if condition.is_a?(Hash)
-          Hash[
-            condition.map do |k, v|
-              if v.is_a?(Hash)
-                [k, v]
-              else
-                [table.table_alias || table.name, { k => v }]
+              if scope_chain_item == chain_head.scope
+                scope.merge! item.except(:where, :includes, :unscope, :order)
               end
+
+              reflection.all_includes do
+                scope.includes! item.includes_values
+              end
+
+              scope.unscope!(*item.unscope_values)
+              scope.where_clause += item.where_clause
+              scope.order_values = item.order_values | scope.order_values
             end
-          ]
-        else
-          condition
+          end
+
+          scope
+        end
+
+        def apply_scope(scope, table, key, value)
+          if scope.table == table
+            scope.where!(key => value)
+          else
+            scope.where!(table.name => { key => value })
+          end
+        end
+
+        def eval_scope(reflection, scope, owner)
+          relation = reflection.build_scope(reflection.aliased_table)
+          relation.instance_exec(owner, &scope) || relation
         end
-      end
     end
   end
 end

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,78 +1,123 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Belongs To Associations
   module Associations
+    # = Active Record Belongs To Association
     class BelongsToAssociation < SingularAssociation #:nodoc:
-      def replace(record)
-        raise_on_type_mismatch(record) if record
+      def handle_dependency
+        return unless load_target
 
-        update_counters(record)
+        case options[:dependent]
+        when :destroy
+          target.destroy
+          raise ActiveRecord::Rollback unless target.destroyed?
+        else
+          target.send(options[:dependent])
+        end
+      end
+
+      def inversed_from(record)
         replace_keys(record)
-        set_inverse_instance(record)
+        super
+      end
 
-        @updated = true if record
+      def default(&block)
+        writer(owner.instance_exec(&block)) if reader.nil?
+      end
 
-        self.target = record
+      def reset
+        super
+        @updated = false
       end
 
       def updated?
         @updated
       end
 
-      private
+      def decrement_counters
+        update_counters(-1)
+      end
 
-        def find_target?
-          !loaded? && foreign_key_present? && klass
+      def increment_counters
+        update_counters(1)
+      end
+
+      def decrement_counters_before_last_save
+        if reflection.polymorphic?
+          model_was = owner.attribute_before_last_save(reflection.foreign_type).try(:constantize)
+        else
+          model_was = klass
         end
 
-        def update_counters(record)
-          counter_cache_name = reflection.counter_cache_column
+        foreign_key_was = owner.attribute_before_last_save(reflection.foreign_key)
 
-          if counter_cache_name && owner.persisted? && different_target?(record)
-            if record
-              record.class.increment_counter(counter_cache_name, record.id)
-            end
+        if foreign_key_was && model_was < ActiveRecord::Base
+          update_counters_via_scope(model_was, foreign_key_was, -1)
+        end
+      end
 
-            if foreign_key_present?
-              klass.decrement_counter(counter_cache_name, target_id)
+      def target_changed?
+        owner.saved_change_to_attribute?(reflection.foreign_key)
+      end
+
+      private
+        def replace(record)
+          if record
+            raise_on_type_mismatch!(record)
+            set_inverse_instance(record)
+            @updated = true
+          end
+
+          replace_keys(record)
+
+          self.target = record
+        end
+
+        def update_counters(by)
+          if require_counter_update? && foreign_key_present?
+            if target && !stale_target?
+              target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
+            else
+              update_counters_via_scope(klass, owner._read_attribute(reflection.foreign_key), by)
             end
           end
         end
 
-        # Checks whether record is different to the current target, without loading it
-        def different_target?(record)
-          record.nil? && owner[reflection.foreign_key] ||
-          record && record.id != owner[reflection.foreign_key]
+        def update_counters_via_scope(klass, foreign_key, by)
+          scope = klass.unscoped.where!(primary_key(klass) => foreign_key)
+          scope.update_counters(reflection.counter_cache_column => by, touch: reflection.options[:touch])
+        end
+
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
+        def require_counter_update?
+          reflection.counter_cache_column && owner.persisted?
         end
 
         def replace_keys(record)
-          if record
-            owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
-          else
-            owner[reflection.foreign_key] = nil
-          end
+          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record.class)) : nil
+        end
+
+        def primary_key(klass)
+          reflection.association_primary_key(klass)
         end
 
         def foreign_key_present?
-          owner[reflection.foreign_key]
+          owner._read_attribute(reflection.foreign_key)
         end
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
         # has_one associations.
         def invertible_for?(record)
           inverse = inverse_reflection_for(record)
-          inverse && inverse.macro == :has_one
-        end
-
-        def target_id
-          if options[:primary_key]
-            owner.send(reflection.name).try(:id)
-          else
-            owner[reflection.foreign_key]
-          end
+          inverse && inverse.has_one?
         end
 
         def stale_state
-          owner[reflection.foreign_key].to_s
+          result = owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+          result && result.to_s
         end
     end
   end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -1,33 +1,35 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Belongs To Polymorphic Association
   module Associations
+    # = Active Record Belongs To Polymorphic Association
     class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
       def klass
         type = owner[reflection.foreign_type]
         type.presence && type.constantize
       end
 
-      private
+      def target_changed?
+        super || owner.saved_change_to_attribute?(reflection.foreign_type)
+      end
 
+      private
         def replace_keys(record)
           super
-          owner[reflection.foreign_type] = record && record.class.base_class.name
-        end
-
-        def different_target?(record)
-          super || record.class != klass
+          owner[reflection.foreign_type] = record ? record.class.polymorphic_name : nil
         end
 
         def inverse_reflection_for(record)
           reflection.polymorphic_inverse_of(record.class)
         end
 
-        def raise_on_type_mismatch(record)
+        def raise_on_type_mismatch!(record)
           # A polymorphic association cannot have a type mismatch, by definition
         end
 
         def stale_state
-          [super, owner[reflection.foreign_type].to_s]
+          foreign_key = super
+          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
         end
     end
   end

data/lib/active_record/associations/builder/association.rb

@@ -1,55 +1,136 @@
-module ActiveRecord::Associations::Builder
+# frozen_string_literal: true
+
+# This is the parent Association class which defines the variables
+# used by all associations.
+#
+# The hierarchy is defined as follows:
+#  Association
+#    - SingularAssociation
+#      - BelongsToAssociation
+#      - HasOneAssociation
+#    - CollectionAssociation
+#      - HasManyAssociation
+
+module ActiveRecord::Associations::Builder # :nodoc:
   class Association #:nodoc:
-    class_attribute :valid_options
-    self.valid_options = [:class_name, :foreign_key, :select, :conditions, :include, :extend, :readonly, :validate]
+    class << self
+      attr_accessor :extensions
+    end
+    self.extensions = []
+
+    VALID_OPTIONS = [:class_name, :anonymous_class, :foreign_key, :validate] # :nodoc:
+
+    def self.build(model, name, scope, options, &block)
+      if model.dangerous_attribute_method?(name)
+        raise ArgumentError, "You tried to define an association named #{name} on the model #{model.name}, but " \
+                             "this will conflict with a method #{name} already defined by Active Record. " \
+                             "Please choose a different association name."
+      end
+
+      reflection = create_reflection(model, name, scope, options, &block)
+      define_accessors model, reflection
+      define_callbacks model, reflection
+      define_validations model, reflection
+      reflection
+    end
+
+    def self.create_reflection(model, name, scope, options, &block)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+      validate_options(options)
+
+      extension = define_extensions(model, name, &block)
+      options[:extend] = [*options[:extend], extension] if extension
 
-    # Set by subclasses
-    class_attribute :macro
+      scope = build_scope(scope)
 
-    attr_reader :model, :name, :options, :reflection
+      ActiveRecord::Reflection.create(macro, name, scope, options, model)
+    end
 
-    def self.build(model, name, options)
-      new(model, name, options).build
+    def self.build_scope(scope)
+      if scope && scope.arity == 0
+        proc { instance_exec(&scope) }
+      else
+        scope
+      end
     end
 
-    def initialize(model, name, options)
-      @model, @name, @options = model, name, options
+    def self.macro
+      raise NotImplementedError
     end
 
-    def mixin
-      @model.generated_feature_methods
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
     end
 
-    def build
-      validate_options
-      reflection = model.create_reflection(self.class.macro, name, options, model)
-      define_accessors
-      reflection
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
     end
 
-    private
+    def self.define_extensions(model, name)
+    end
 
-      def validate_options
-        options.assert_valid_keys(self.class.valid_options)
+    def self.define_callbacks(model, reflection)
+      if dependent = reflection.options[:dependent]
+        check_dependent_options(dependent)
+        add_destroy_callbacks(model, reflection)
       end
 
-      def define_accessors
-        define_readers
-        define_writers
+      Association.extensions.each do |extension|
+        extension.build model, reflection
       end
+    end
+
+    # Defines the setter and getter methods for the association
+    # class Post < ActiveRecord::Base
+    #   has_many :comments
+    # end
+    #
+    # Post.first.comments and Post.first.comments= methods are defined by this method...
+    def self.define_accessors(model, reflection)
+      mixin = model.generated_association_methods
+      name = reflection.name
+      define_readers(mixin, name)
+      define_writers(mixin, name)
+    end
 
-      def define_readers
-        name = self.name
-        mixin.redefine_method(name) do |*params|
-          association(name).reader(*params)
+    def self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}
+          association(:#{name}).reader
         end
-      end
+      CODE
+    end
 
-      def define_writers
-        name = self.name
-        mixin.redefine_method("#{name}=") do |value|
-          association(name).writer(value)
+    def self.define_writers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          association(:#{name}).writer(value)
         end
+      CODE
+    end
+
+    def self.define_validations(model, reflection)
+      # noop
+    end
+
+    def self.valid_dependent_options
+      raise NotImplementedError
+    end
+
+    def self.check_dependent_options(dependent)
+      unless valid_dependent_options.include? dependent
+        raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
       end
+    end
+
+    def self.add_destroy_callbacks(model, reflection)
+      name = reflection.name
+      model.before_destroy lambda { |o| o.association(name).handle_dependency }
+    end
+
+    private_class_method :build_scope, :macro, :valid_options, :validate_options, :define_extensions,
+      :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations,
+      :valid_dependent_options, :check_dependent_options, :add_destroy_callbacks
   end
 end