activerecord 3.1.10 → 4.2.11

data/lib/active_record/associations/association_scope.rb

@@ -1,122 +1,183 @@
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      include JoinHelper
+      def self.scope(association, connection)
+        INSTANCE.scope association, connection
+      end
 
-      attr_reader :association, :alias_tracker
+      class BindSubstitution
+        def initialize(block)
+          @block = block
+        end
 
-      delegate :klass, :owner, :reflection, :interpolate, :to => :association
-      delegate :chain, :conditions, :options, :source_options, :active_record, :to => :reflection
+        def bind_value(scope, column, value, alias_tracker)
+          substitute = alias_tracker.connection.substitute_at(column)
+          scope.bind_values += [[column, @block.call(value)]]
+          substitute
+        end
+      end
 
-      def initialize(association)
-        @association   = association
-        @alias_tracker = AliasTracker.new
+      def self.create(&block)
+        block = block ? block : lambda { |val| val }
+        new BindSubstitution.new(block)
       end
 
-      def scope
-        scope = klass.unscoped
-        scope = scope.extending(*Array.wrap(options[:extend]))
+      def initialize(bind_substitution)
+        @bind_substitution = bind_substitution
+      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))
+      INSTANCE = create
 
-        if options[:through] && !options[:include]
-          scope = scope.includes(source_options[:include])
-        end
+      def scope(association, connection)
+        klass         = association.klass
+        reflection    = association.reflection
+        scope         = klass.unscoped
+        owner         = association.owner
+        alias_tracker = AliasTracker.empty connection
 
-        if select = select_value
-          scope = scope.select(select)
+        scope.extending! Array(reflection.options[:extend])
+        add_constraints(scope, owner, klass, reflection, alias_tracker)
+      end
+
+      def join_type
+        Arel::Nodes::InnerJoin
+      end
+
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        binds << last_reflection.join_id_for(owner)
+        if last_reflection.type
+          binds << owner.class.base_class.name
         end
 
-        add_constraints(scope)
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.base_class.name
+          end
+        end
+        binds
       end
 
       private
 
-      def select_value
-        select_value = options[:select]
-
-        if reflection.collection?
-          select_value ||= options[:uniq] && "DISTINCT #{reflection.quoted_table_name}.*"
+      def construct_tables(chain, klass, refl, alias_tracker)
+        chain.map do |reflection|
+          alias_tracker.aliased_table_for(
+            table_name_for(reflection, klass, refl),
+            table_alias_for(reflection, refl, reflection != refl)
+          )
         end
+      end
 
-        select_value
+      def table_alias_for(reflection, refl, join = false)
+        name = "#{reflection.plural_name}_#{alias_suffix(refl)}"
+        name << "_join" if join
+        name
       end
 
-      def add_constraints(scope)
-        tables = construct_tables
+      def join(table, constraint)
+        table.create_join(table, table.create_on(constraint), join_type)
+      end
 
-        chain.each_with_index do |reflection, i|
-          table, foreign_table = tables.shift, tables.first
+      def column_for(table_name, column_name, alias_tracker)
+        columns = alias_tracker.connection.schema_cache.columns_hash(table_name)
+        columns[column_name]
+      end
 
-          if reflection.source_macro == :has_and_belongs_to_many
-            join_table = tables.shift
+      def bind_value(scope, column, value, alias_tracker)
+        @bind_substitution.bind_value scope, column, value, alias_tracker
+      end
 
-            scope = scope.joins(join(
-              join_table,
-              table[reflection.association_primary_key].
-                eq(join_table[reflection.association_foreign_key])
-            ))
+      def bind(scope, table_name, column_name, value, tracker)
+        column   = column_for table_name, column_name, tracker
+        bind_value scope, column, value, tracker
+      end
 
-            table, foreign_table = join_table, tables.first
-          end
+      def last_chain_scope(scope, table, reflection, owner, tracker, assoc_klass)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
 
-          if reflection.source_macro == :belongs_to
-            if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(klass)
-            else
-              key = reflection.association_primary_key
-            end
+        bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
+        scope    = scope.where(table[key].eq(bind_val))
 
-            foreign_key = reflection.foreign_key
-          else
-            key         = reflection.foreign_key
-            foreign_key = reflection.active_record_primary_key
-          end
+        if reflection.type
+          value    = owner.class.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        else
+          scope
+        end
+      end
 
-          conditions = self.conditions[i]
+      def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
 
-          if reflection == chain.last
-            scope = scope.where(table[key].eq(owner[foreign_key]))
+        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    = next_reflection.klass.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        end
 
-            conditions.each do |condition|
-              if options[:through] && condition.is_a?(Hash)
-                condition = disambiguate_condition(table, condition)
-              end
+        scope = scope.joins(join(foreign_table, constraint))
+      end
 
-              scope = scope.where(interpolate(condition))
-            end
-          else
-            constraint = table[key].eq(foreign_table[foreign_key])
+      def add_constraints(scope, owner, assoc_klass, refl, tracker)
+        chain = refl.chain
+        scope_chain = refl.scope_chain
 
-            if reflection.type
-              type = chain[i + 1].klass.base_class.name
-              constraint = constraint.and(table[reflection.type].eq(type))
-            end
+        tables = construct_tables(chain, assoc_klass, refl, tracker)
+
+        owner_reflection = chain.last
+        table = tables.last
+        scope = last_chain_scope(scope, table, owner_reflection, owner, tracker, assoc_klass)
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          unless reflection == chain.last
+            next_reflection = chain[i + 1]
+            scope = next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+          end
+
+          is_first_chain = i == 0
+          klass = is_first_chain ? assoc_klass : reflection.klass
 
-            scope = scope.joins(join(foreign_table, constraint))
+          # Exclude the scope of the association itself, because that
+          # was already merged in the #scope method.
+          scope_chain[i].each do |scope_chain_item|
+            item  = eval_scope(klass, scope_chain_item, owner)
 
-            unless conditions.empty?
-              scope = scope.where(sanitize(conditions, table))
+            if scope_chain_item == refl.scope
+              scope.merge! item.except(:where, :includes, :bind)
             end
+
+            if is_first_chain
+              scope.includes! item.includes_values
+            end
+
+            scope.unscope!(*item.unscope_values)
+            scope.where_values += item.where_values
+            scope.bind_values  += item.bind_values
+            scope.order_values |= item.order_values
           end
         end
 
         scope
       end
 
-      def alias_suffix
-        reflection.name
+      def alias_suffix(refl)
+        refl.name
       end
 
-      def table_name_for(reflection)
-        if reflection == self.reflection
+      def table_name_for(reflection, klass, refl)
+        if reflection == refl
           # 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
@@ -126,20 +187,8 @@ module ActiveRecord
         end
       end
 
-      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 }]
-              end
-            end
-          ]
-        else
-          condition
-        end
+      def eval_scope(klass, scope, owner)
+        klass.unscoped.instance_exec(owner, &scope)
       end
     end
   end

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,78 +1,118 @@
 module ActiveRecord
-  # = Active Record Belongs To Associations
+  # = Active Record Belongs To Association
   module Associations
     class BelongsToAssociation < SingularAssociation #:nodoc:
-      def replace(record)
-        raise_on_type_mismatch(record) if record
 
-        update_counters(record)
-        replace_keys(record)
-        set_inverse_instance(record)
+      def handle_dependency
+        target.send(options[:dependent]) if load_target
+      end
 
-        @updated = true if record
+      def replace(record)
+        if record
+          raise_on_type_mismatch!(record)
+          update_counters(record)
+          replace_keys(record)
+          set_inverse_instance(record)
+          @updated = true
+        else
+          decrement_counters
+          remove_keys
+        end
 
         self.target = record
       end
 
+      def reset
+        super
+        @updated = false
+      end
+
       def updated?
         @updated
       end
 
+      def decrement_counters # :nodoc:
+        with_cache_name { |name| decrement_counter name }
+      end
+
+      def increment_counters # :nodoc:
+        with_cache_name { |name| increment_counter name }
+      end
+
       private
 
         def find_target?
           !loaded? && foreign_key_present? && klass
         end
 
-        def update_counters(record)
+        def with_cache_name
           counter_cache_name = reflection.counter_cache_column
+          return unless counter_cache_name && owner.persisted?
+          yield counter_cache_name
+        end
 
-          if counter_cache_name && owner.persisted? && different_target?(record)
-            if record
-              record.class.increment_counter(counter_cache_name, record.id)
-            end
+        def update_counters(record)
+          with_cache_name do |name|
+            return unless different_target? record
+            record.class.increment_counter(name, record.id)
+            decrement_counter name
+          end
+        end
+
+        def decrement_counter(counter_cache_name)
+          if foreign_key_present?
+            klass.decrement_counter(counter_cache_name, target_id)
+          end
+        end
 
-            if foreign_key_present?
-              klass.decrement_counter(counter_cache_name, target_id)
+        def increment_counter(counter_cache_name)
+          if foreign_key_present?
+            klass.increment_counter(counter_cache_name, target_id)
+            if target && !stale_target? && counter_cache_available_in_memory?(counter_cache_name)
+              target.increment(counter_cache_name)
             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]
+          record.id != owner._read_attribute(reflection.foreign_key)
         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._read_attribute(reflection.association_primary_key(record.class))
+        end
+
+        def remove_keys
+          owner[reflection.foreign_key] = nil
         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
+          inverse && inverse.has_one?
         end
 
         def target_id
           if options[:primary_key]
             owner.send(reflection.name).try(:id)
           else
-            owner[reflection.foreign_key]
+            owner._read_attribute(reflection.foreign_key)
           end
         end
 
         def stale_state
-          owner[reflection.foreign_key].to_s
+          result = owner._read_attribute(reflection.foreign_key)
+          result && result.to_s
+        end
+
+        def counter_cache_available_in_memory?(counter_cache_name)
+          target.respond_to?(counter_cache_name)
         end
     end
   end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -11,7 +11,12 @@ module ActiveRecord
 
         def replace_keys(record)
           super
-          owner[reflection.foreign_type] = record && record.class.base_class.name
+          owner[reflection.foreign_type] = record.class.base_class.name
+        end
+
+        def remove_keys
+          super
+          owner[reflection.foreign_type] = nil
         end
 
         def different_target?(record)
@@ -22,12 +27,13 @@ module ActiveRecord
           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,53 +1,149 @@
+require 'active_support/core_ext/module/attribute_accessors'
+
+# 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
   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
+      # TODO: This class accessor is needed to make activerecord-deprecated_finders work.
+      # We can move it to a constant in 5.0.
+      attr_accessor :valid_options
+    end
+    self.extensions = []
 
-    # Set by subclasses
-    class_attribute :macro
+    self.valid_options = [:class_name, :anonymous_class, :foreign_key, :validate]
 
-    attr_reader :model, :name, :options, :reflection
+    attr_reader :name, :scope, :options
+
+    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
 
-    def self.build(model, name, options)
-      new(model, name, options).build
+      builder = create_builder model, name, scope, options, &block
+      reflection = builder.build(model)
+      define_accessors model, reflection
+      define_callbacks model, reflection
+      define_validations model, reflection
+      builder.define_extensions model
+      reflection
     end
 
-    def initialize(model, name, options)
-      @model, @name, @options = model, name, options
+    def self.create_builder(model, name, scope, options, &block)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+      new(model, name, scope, options, &block)
     end
 
-    def build
+    def initialize(model, name, scope, options)
+      # TODO: Move this to create_builder as soon we drop support to activerecord-deprecated_finders.
+      if scope.is_a?(Hash)
+        options = scope
+        scope   = nil
+      end
+
+      # TODO: Remove this model argument as soon we drop support to activerecord-deprecated_finders.
+      @name    = name
+      @scope   = scope
+      @options = options
+
       validate_options
-      reflection = model.create_reflection(self.class.macro, name, options, model)
-      define_accessors
-      reflection
+
+      if scope && scope.arity == 0
+        @scope = proc { instance_exec(&scope) }
+      end
     end
 
-    private
+    def build(model)
+      ActiveRecord::Reflection.create(macro, name, scope, options, model)
+    end
 
-      def validate_options
-        options.assert_valid_keys(self.class.valid_options)
+    def macro
+      raise NotImplementedError
+    end
+
+    def valid_options
+      Association.valid_options + Association.extensions.flat_map(&:valid_options)
+    end
+
+    def validate_options
+      options.assert_valid_keys(valid_options)
+    end
+
+    def define_extensions(model)
+    end
+
+    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
 
-      def define_readers
-        name = self.name
+    # 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
 
-        model.redefine_method(name) do |*params|
-          association(name).reader(*params)
+    def self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          association(:#{name}).reader(*args)
         end
-      end
-
-      def define_writers
-        name = self.name
+      CODE
+    end
 
-        model.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
+
+    private
+
+    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
   end
 end