activerecord 3.2.19 → 5.0.0

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,78 +1,107 @@
 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_on_replace(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:
+        update_counters(-1)
+      end
+
+      def increment_counters # :nodoc:
+        update_counters(1)
+      end
+
       private
 
+        def update_counters(by)
+          if require_counter_update? && foreign_key_present?
+            if target && !stale_target?
+              target.increment!(reflection.counter_cache_column, by)
+            else
+              klass.update_counters(target_id, reflection.counter_cache_column => by)
+            end
+          end
+        end
+
         def find_target?
           !loaded? && foreign_key_present? && klass
         end
 
-        def update_counters(record)
-          counter_cache_name = reflection.counter_cache_column
-
-          if counter_cache_name && owner.persisted? && different_target?(record)
-            if record
-              record.class.increment_counter(counter_cache_name, record.id)
-            end
+        def require_counter_update?
+          reflection.counter_cache_column && owner.persisted?
+        end
 
-            if foreign_key_present?
-              klass.decrement_counter(counter_cache_name, target_id)
-            end
+        def update_counters_on_replace(record)
+          if require_counter_update? && different_target?(record)
+            owner.instance_variable_set :@_after_replace_counter_called, true
+            record.increment!(reflection.counter_cache_column)
+            decrement_counters
           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] && 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

@@ -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,7 +27,7 @@ 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
 

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

@@ -1,55 +1,143 @@
-module ActiveRecord::Associations::Builder
+# 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
+
+      extension = define_extensions model, name, &block
+      reflection = create_reflection model, name, scope, options, extension
+      define_accessors model, reflection
+      define_callbacks model, reflection
+      define_validations model, reflection
+      reflection
+    end
+
+    def self.create_reflection(model, name, scope, options, extension = nil)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
 
-    # Set by subclasses
-    class_attribute :macro
+      if scope.is_a?(Hash)
+        options = scope
+        scope   = nil
+      end
+
+      validate_options(options)
 
-    attr_reader :model, :name, :options, :reflection
+      scope = build_scope(scope, extension)
 
-    def self.build(model, name, options)
-      new(model, name, options).build
+      ActiveRecord::Reflection.create(macro, name, scope, options, model)
     end
 
-    def initialize(model, name, options)
-      @model, @name, @options = model, name, options
+    def self.build_scope(scope, extension)
+      new_scope = scope
+
+      if scope && scope.arity == 0
+        new_scope = proc { instance_exec(&scope) }
+      end
+
+      if extension
+        new_scope = wrap_scope new_scope, extension
+      end
+
+      new_scope
     end
 
-    def mixin
-      @model.generated_feature_methods
+    def self.wrap_scope(scope, extension)
+      scope
     end
 
-    def build
-      validate_options
-      reflection = model.create_reflection(self.class.macro, name, options, model)
-      define_accessors
-      reflection
+    def self.macro
+      raise NotImplementedError
+    end
+
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
     end
 
-    private
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
+    end
 
-      def validate_options
-        options.assert_valid_keys(self.class.valid_options)
+    def self.define_extensions(model, name)
+    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
-        mixin.redefine_method(name) do |*params|
-          association(name).reader(*params)
+    # 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 self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          association(:#{name}).reader(*args)
         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
   end
 end

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

@@ -1,88 +1,141 @@
-require 'active_support/core_ext/object/inclusion'
-
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class BelongsTo < SingularAssociation #:nodoc:
-    self.macro = :belongs_to
+    def self.macro
+      :belongs_to
+    end
 
-    self.valid_options += [:foreign_type, :polymorphic, :touch]
+    def self.valid_options(options)
+      super + [:polymorphic, :touch, :counter_cache, :optional]
+    end
 
-    def constructable?
-      !options[:polymorphic]
+    def self.valid_dependent_options
+      [:destroy, :delete]
     end
 
-    def build
-      reflection = super
-      add_counter_cache_callbacks(reflection) if options[:counter_cache]
-      add_touch_callbacks(reflection)         if options[:touch]
-      configure_dependency
-      reflection
+    def self.define_callbacks(model, reflection)
+      super
+      add_counter_cache_callbacks(model, reflection) if reflection.options[:counter_cache]
+      add_touch_callbacks(model, reflection)         if reflection.options[:touch]
     end
 
-    private
+    def self.define_accessors(mixin, reflection)
+      super
+      add_counter_cache_methods mixin
+    end
 
-      def add_counter_cache_callbacks(reflection)
-        cache_column = reflection.counter_cache_column
-        name         = self.name
+    def self.add_counter_cache_methods(mixin)
+      return if mixin.method_defined? :belongs_to_counter_cache_after_update
+
+      mixin.class_eval do
+        def belongs_to_counter_cache_after_update(reflection)
+          foreign_key  = reflection.foreign_key
+          cache_column = reflection.counter_cache_column
+
+          if (@_after_create_counter_called ||= false)
+            @_after_create_counter_called = false
+          elsif (@_after_replace_counter_called ||= false)
+            @_after_replace_counter_called = false
+          elsif attribute_changed?(foreign_key) && !new_record?
+            if reflection.polymorphic?
+              model     = attribute(reflection.foreign_type).try(:constantize)
+              model_was = attribute_was(reflection.foreign_type).try(:constantize)
+            else
+              model     = reflection.klass
+              model_was = reflection.klass
+            end
 
-        method_name = "belongs_to_counter_cache_after_create_for_#{name}"
-        mixin.redefine_method(method_name) do
-          record = send(name)
-          record.class.increment_counter(cache_column, record.id) unless record.nil?
-        end
-        model.after_create(method_name)
+            foreign_key_was = attribute_was foreign_key
+            foreign_key     = attribute foreign_key
 
-        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
-        mixin.redefine_method(method_name) do
-          record = send(name)
+            if foreign_key && model.respond_to?(:increment_counter)
+              model.increment_counter(cache_column, foreign_key)
+            end
 
-          if record && !self.destroyed?
-            record.class.decrement_counter(cache_column, record.id)
+            if foreign_key_was && model_was.respond_to?(:decrement_counter)
+              model_was.decrement_counter(cache_column, foreign_key_was)
+            end
           end
         end
-        model.before_destroy(method_name)
-
-        model.send(:module_eval,
-          "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
-        )
       end
+    end
 
-      def add_touch_callbacks(reflection)
-        name        = self.name
-        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
-        touch       = options[:touch]
+    def self.add_counter_cache_callbacks(model, reflection)
+      cache_column = reflection.counter_cache_column
 
-        mixin.redefine_method(method_name) do
-          record = send(name)
+      model.after_update lambda { |record|
+        record.belongs_to_counter_cache_after_update(reflection)
+      }
 
-          unless record.nil?
-            if touch == true
-              record.touch
-            else
-              record.touch(touch)
-            end
+      klass = reflection.class_name.safe_constantize
+      klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
+    end
+
+    def self.touch_record(o, foreign_key, name, touch, touch_method) # :nodoc:
+      old_foreign_id = o.changed_attributes[foreign_key]
+
+      if old_foreign_id
+        association = o.association(name)
+        reflection = association.reflection
+        if reflection.polymorphic?
+          klass = o.public_send("#{reflection.foreign_type}_was").constantize
+        else
+          klass = association.klass
+        end
+        old_record = klass.find_by(klass.primary_key => old_foreign_id)
+
+        if old_record
+          if touch != true
+            old_record.send(touch_method, touch)
+          else
+            old_record.send(touch_method)
           end
         end
+      end
 
-        model.after_save(method_name)
-        model.after_touch(method_name)
-        model.after_destroy(method_name)
+      record = o.send name
+      if record && record.persisted?
+        if touch != true
+          record.send(touch_method, touch)
+        else
+          record.send(touch_method)
+        end
       end
+    end
 
-      def configure_dependency
-        if options[:dependent]
-          unless options[:dependent].in?([:destroy, :delete])
-            raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
-          end
+    def self.add_touch_callbacks(model, reflection)
+      foreign_key = reflection.foreign_key
+      n           = reflection.name
+      touch       = reflection.options[:touch]
 
-          method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
-          model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-            def #{method_name}
-              association = #{name}
-              association.#{options[:dependent]} if association
-            end
-          eoruby
-          model.after_destroy method_name
-        end
+      callback = lambda { |record|
+        BelongsTo.touch_record(record, foreign_key, n, touch, belongs_to_touch_method)
+      }
+
+      model.after_save    callback, if: :changed?
+      model.after_touch   callback
+      model.after_destroy callback
+    end
+
+    def self.add_destroy_callbacks(model, reflection)
+      model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
+    end
+
+    def self.define_validations(model, reflection)
+      if reflection.options.key?(:required)
+        reflection.options[:optional] = !reflection.options.delete(:required)
+      end
+
+      if reflection.options[:optional].nil?
+        required = model.belongs_to_required_by_default
+      else
+        required = !reflection.options[:optional]
       end
+
+      super
+
+      if required
+        model.validates_presence_of reflection.name, message: :required
+      end
+    end
   end
 end

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

@@ -1,75 +1,83 @@
-module ActiveRecord::Associations::Builder
-  class CollectionAssociation < Association #:nodoc:
-    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+# This class is inherited by the has_many and has_many_and_belongs_to_many association classes
 
-    self.valid_options += [
-      :table_name, :order, :group, :having, :limit, :offset, :uniq, :finder_sql,
-      :counter_sql, :before_add, :after_add, :before_remove, :after_remove
-    ]
+require 'active_record/associations'
 
-    attr_reader :block_extension
+module ActiveRecord::Associations::Builder # :nodoc:
+  class CollectionAssociation < Association #:nodoc:
 
-    def self.build(model, name, options, &extension)
-      new(model, name, options, &extension).build
-    end
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
-    def initialize(model, name, options, &extension)
-      super(model, name, options)
-      @block_extension = extension
+    def self.valid_options(options)
+      super + [:table_name, :before_add,
+               :after_add, :before_remove, :after_remove, :extend]
     end
 
-    def build
-      wrap_block_extension
-      reflection = super
-      CALLBACKS.each { |callback_name| define_callback(callback_name) }
-      reflection
+    def self.define_callbacks(model, reflection)
+      super
+      name    = reflection.name
+      options = reflection.options
+      CALLBACKS.each { |callback_name|
+        define_callback(model, callback_name, name, options)
+      }
     end
 
-    def writable?
-      true
+    def self.define_extensions(model, name)
+      if block_given?
+        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&Proc.new)
+        model.parent.const_set(extension_module_name, extension)
+      end
     end
 
-    private
-
-      def wrap_block_extension
-        options[:extend] = Array.wrap(options[:extend])
-
-        if block_extension
-          silence_warnings do
-            model.parent.const_set(extension_module_name, Module.new(&block_extension))
-          end
-          options[:extend].push("#{model.parent}::#{extension_module_name}".constantize)
+    def self.define_callback(model, callback_name, name, options)
+      full_callback_name = "#{callback_name}_for_#{name}"
+
+      # TODO : why do i need method_defined? I think its because of the inheritance chain
+      model.class_attribute full_callback_name unless model.method_defined?(full_callback_name)
+      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+        case callback
+        when Symbol
+          ->(method, owner, record) { owner.send(callback, record) }
+        when Proc
+          ->(method, owner, record) { callback.call(owner, record) }
+        else
+          ->(method, owner, record) { callback.send(method, owner, record) }
         end
       end
+      model.send "#{full_callback_name}=", callbacks
+    end
 
-      def extension_module_name
-        @extension_module_name ||= "#{model.to_s.demodulize}#{name.to_s.camelize}AssociationExtension"
-      end
-
-      def define_callback(callback_name)
-        full_callback_name = "#{callback_name}_for_#{name}"
+    # Defines the setter and getter methods for the collection_singular_ids.
+    def self.define_readers(mixin, name)
+      super
 
-        # TODO : why do i need method_defined? I think its because of the inheritance chain
-        model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
-        model.send("#{full_callback_name}=", Array.wrap(options[callback_name.to_sym]))
-      end
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
+        end
+      CODE
+    end
 
-      def define_readers
-        super
+    def self.define_writers(mixin, name)
+      super
 
-        name = self.name
-        mixin.redefine_method("#{name.to_s.singularize}_ids") do
-          association(name).ids_reader
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
         end
-      end
-
-      def define_writers
-        super
+      CODE
+    end
 
-        name = self.name
-        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
-          association(name).ids_writer(ids)
+    def self.wrap_scope(scope, mod)
+      if scope
+        if scope.arity > 0
+          proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        else
+          proc { instance_exec(&scope).extending(mod) }
         end
+      else
+        proc { extending(mod) }
       end
+    end
   end
 end