activerecord 3.2.6 → 6.0.0

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

@@ -1,85 +1,130 @@
-require 'active_support/core_ext/object/inclusion'
+# frozen_string_literal: true
 
-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, :default]
+    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]
+      add_default_callbacks(model, reflection)       if reflection.options[:default]
     end
 
-    private
+    def self.add_counter_cache_callbacks(model, reflection)
+      cache_column = reflection.counter_cache_column
 
-      def add_counter_cache_callbacks(reflection)
-        cache_column = reflection.counter_cache_column
-        name         = self.name
+      model.after_update lambda { |record|
+        association = association(reflection.name)
 
-        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?
+        if association.target_changed?
+          association.increment_counters
+          association.decrement_counters_before_last_save
         end
-        model.after_create(method_name)
+      }
+
+      klass = reflection.class_name.safe_constantize
+      klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
+    end
 
-        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
-        mixin.redefine_method(method_name) do
-          record = send(name)
-          record.class.decrement_counter(cache_column, record.id) unless record.nil?
+    def self.touch_record(o, changes, foreign_key, name, touch, touch_method) # :nodoc:
+      old_foreign_id = changes[foreign_key] && changes[foreign_key].first
+
+      if old_foreign_id
+        association = o.association(name)
+        reflection = association.reflection
+        if reflection.polymorphic?
+          foreign_type = reflection.foreign_type
+          klass = changes[foreign_type] && changes[foreign_type].first || o.public_send(foreign_type)
+          klass = klass.constantize
+        else
+          klass = association.klass
         end
-        model.before_destroy(method_name)
+        primary_key = reflection.association_primary_key(klass)
+        old_record = klass.find_by(primary_key => old_foreign_id)
 
-        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__
-        )
+        if old_record
+          if touch != true
+            old_record.send(touch_method, touch)
+          else
+            old_record.send(touch_method)
+          end
+        end
       end
 
-      def add_touch_callbacks(reflection)
-        name        = self.name
-        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
-        touch       = options[:touch]
+      record = o.send name
+      if record && record.persisted?
+        if touch != true
+          record.send(touch_method, touch)
+        else
+          record.send(touch_method)
+        end
+      end
+    end
 
-        mixin.redefine_method(method_name) do
-          record = send(name)
+    def self.add_touch_callbacks(model, reflection)
+      foreign_key = reflection.foreign_key
+      name        = reflection.name
+      touch       = reflection.options[:touch]
 
-          unless record.nil?
-            if touch == true
-              record.touch
-            else
-              record.touch(touch)
-            end
-          end
-        end
+      callback = lambda { |changes_method| lambda { |record|
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, name, touch, belongs_to_touch_method)
+      }}
 
-        model.after_save(method_name)
-        model.after_touch(method_name)
-        model.after_destroy(method_name)
+      if reflection.counter_cache_column
+        touch_callback = callback.(:saved_changes)
+        update_callback = lambda { |record|
+          instance_exec(record, &touch_callback) unless association(reflection.name).target_changed?
+        }
+        model.after_update update_callback, if: :saved_changes?
+      else
+        model.after_create callback.(:saved_changes), if: :saved_changes?
+        model.after_update callback.(:saved_changes), if: :saved_changes?
+        model.after_destroy callback.(:changes_to_save)
       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
+      model.after_touch callback.(:changes_to_save)
+    end
 
-          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
+    def self.add_default_callbacks(model, reflection)
+      model.before_validation lambda { |o|
+        o.association(reflection.name).default(&reflection.options[:default])
+      }
+    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
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :define_callbacks, :define_validations,
+      :add_counter_cache_callbacks, :add_touch_callbacks, :add_default_callbacks, :add_destroy_callbacks
   end
 end

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

@@ -1,75 +1,72 @@
-module ActiveRecord::Associations::Builder
-  class CollectionAssociation < Association #:nodoc:
-    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
-
-    self.valid_options += [
-      :table_name, :order, :group, :having, :limit, :offset, :uniq, :finder_sql,
-      :counter_sql, :before_add, :after_add, :before_remove, :after_remove
-    ]
+# frozen_string_literal: true
 
-    attr_reader :block_extension
+require "active_record/associations"
 
-    def self.build(model, name, options, &extension)
-      new(model, name, options, &extension).build
-    end
+module ActiveRecord::Associations::Builder # :nodoc:
+  class CollectionAssociation < Association #:nodoc:
+    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, &block)
+      if block_given?
+        extension_module_name = "#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&block)
+        model.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}"
-
-        # 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
-
-      def define_readers
-        super
+    # Defines the setter and getter methods for the collection_singular_ids.
+    def self.define_readers(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
+          association(:#{name}).ids_reader
         end
-      end
+      CODE
+    end
 
-      def define_writers
-        super
+    def self.define_writers(mixin, name)
+      super
 
-        name = self.name
-        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
-          association(name).ids_writer(ids)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
         end
-      end
+      CODE
+    end
+
+    private_class_method :valid_options, :define_callback, :define_extensions, :define_readers, :define_writers
   end
 end

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

@@ -1,57 +1,114 @@
-module ActiveRecord::Associations::Builder
-  class HasAndBelongsToMany < CollectionAssociation #:nodoc:
-    self.macro = :has_and_belongs_to_many
+# frozen_string_literal: true
 
-    self.valid_options += [:join_table, :association_foreign_key, :delete_sql, :insert_sql]
+module ActiveRecord::Associations::Builder # :nodoc:
+  class HasAndBelongsToMany # :nodoc:
+    attr_reader :lhs_model, :association_name, :options
 
-    def build
-      reflection = super
-      check_validity(reflection)
-      define_destroy_hook
-      reflection
+    def initialize(association_name, lhs_model, options)
+      @association_name = association_name
+      @lhs_model = lhs_model
+      @options = options
     end
 
-    private
+    def through_model
+      join_model = Class.new(ActiveRecord::Base) {
+        class << self
+          attr_accessor :left_model
+          attr_accessor :name
+          attr_accessor :table_name_resolver
+          attr_accessor :left_reflection
+          attr_accessor :right_reflection
+        end
 
-      def define_destroy_hook
-        name = self.name
-        model.send(:include, Module.new {
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def destroy_associations
-              association(#{name.to_sym.inspect}).delete_all_on_destroy
-              super
-            end
-          RUBY
-        })
-      end
+        def self.table_name
+          # Table name needs to be resolved lazily
+          # because RHS class might not have been loaded
+          @table_name ||= table_name_resolver.call
+        end
+
+        def self.compute_type(class_name)
+          left_model.compute_type class_name
+        end
+
+        def self.add_left_association(name, options)
+          belongs_to name, required: false, **options
+          self.left_reflection = _reflect_on_association(name)
+        end
+
+        def self.add_right_association(name, options)
+          rhs_name = name.to_s.singularize.to_sym
+          belongs_to rhs_name, required: false, **options
+          self.right_reflection = _reflect_on_association(rhs_name)
+        end
 
-      # TODO: These checks should probably be moved into the Reflection, and we should not be
-      #       redefining the options[:join_table] value - instead we should define a
-      #       reflection.join_table method.
-      def check_validity(reflection)
-        if reflection.association_foreign_key == reflection.foreign_key
-          raise ActiveRecord::HasAndBelongsToManyAssociationForeignKeyNeeded.new(reflection)
+        def self.retrieve_connection
+          left_model.retrieve_connection
         end
 
-        reflection.options[:join_table] ||= join_table_name(
-          model.send(:undecorated_table_name, model.to_s),
-          model.send(:undecorated_table_name, reflection.class_name)
-        )
+        private
+
+          def self.suppress_composite_primary_key(pk)
+            pk unless pk.is_a?(Array)
+          end
+      }
+
+      join_model.name                = "HABTM_#{association_name.to_s.camelize}"
+      join_model.table_name_resolver = -> { table_name }
+      join_model.left_model          = lhs_model
+
+      join_model.add_left_association :left_side, anonymous_class: lhs_model
+      join_model.add_right_association association_name, belongs_to_options(options)
+      join_model
+    end
+
+    def middle_reflection(join_model)
+      middle_name = [lhs_model.name.downcase.pluralize,
+                     association_name.to_s].sort.join("_").gsub("::", "_").to_sym
+      middle_options = middle_options join_model
+
+      HasMany.create_reflection(lhs_model,
+                                middle_name,
+                                nil,
+                                middle_options)
+    end
+
+    private
+
+      def middle_options(join_model)
+        middle_options = {}
+        middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
+        middle_options[:source] = join_model.left_reflection.name
+        if options.key? :foreign_key
+          middle_options[:foreign_key] = options[:foreign_key]
+        end
+        middle_options
       end
 
-      # Generates a join table name from two provided table names.
-      # The names in the join table names end up in lexicographic order.
-      #
-      #   join_table_name("members", "clubs")         # => "clubs_members"
-      #   join_table_name("members", "special_clubs") # => "members_special_clubs"
-      def join_table_name(first_table_name, second_table_name)
-        if first_table_name < second_table_name
-          join_table = "#{first_table_name}_#{second_table_name}"
+      def table_name
+        if options[:join_table]
+          options[:join_table].to_s
         else
-          join_table = "#{second_table_name}_#{first_table_name}"
+          class_name = options.fetch(:class_name) {
+            association_name.to_s.camelize.singularize
+          }
+          klass = lhs_model.send(:compute_type, class_name.to_s)
+          [lhs_model.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
+        end
+      end
+
+      def belongs_to_options(options)
+        rhs_options = {}
+
+        if options.key? :class_name
+          rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
+          rhs_options[:class_name] = options[:class_name]
+        end
+
+        if options.key? :association_foreign_key
+          rhs_options[:foreign_key] = options[:association_foreign_key]
         end
 
-        model.table_name_prefix + join_table + model.table_name_suffix
+        rhs_options
       end
   end
 end

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

@@ -1,71 +1,19 @@
-require 'active_support/core_ext/object/inclusion'
+# frozen_string_literal: true
 
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class HasMany < CollectionAssociation #:nodoc:
-    self.macro = :has_many
-
-    self.valid_options += [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of]
-
-    def build
-      reflection = super
-      configure_dependency
-      reflection
+    def self.macro
+      :has_many
     end
 
-    private
-
-      def configure_dependency
-        if options[:dependent]
-          unless options[:dependent].in?([:destroy, :delete_all, :nullify, :restrict])
-            raise ArgumentError, "The :dependent option expects either :destroy, :delete_all, " \
-                                 ":nullify or :restrict (#{options[:dependent].inspect})"
-          end
-
-          send("define_#{options[:dependent]}_dependency_method")
-          model.before_destroy dependency_method_name
-        end
-      end
-
-      def define_destroy_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          send(name).each do |o|
-            # No point in executing the counter update since we're going to destroy the parent anyway
-            counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
-            if o.respond_to?(counter_method)
-              class << o
-                self
-              end.send(:define_method, counter_method, Proc.new {})
-            end
-          end
-
-          send(name).delete_all
-        end
-      end
-
-      def define_delete_all_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          association(name).delete_all_on_destroy
-        end
-      end
-
-      def define_nullify_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          send(name).delete_all
-        end
-      end
+    def self.valid_options(options)
+      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache, :join_table, :foreign_type, :index_errors]
+    end
 
-      def define_restrict_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).empty?
-        end
-      end
+    def self.valid_dependent_options
+      [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception]
+    end
 
-      def dependency_method_name
-        "has_many_dependent_for_#{name}"
-      end
+    private_class_method :macro, :valid_options, :valid_dependent_options
   end
 end

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

@@ -1,62 +1,64 @@
-require 'active_support/core_ext/object/inclusion'
+# frozen_string_literal: true
 
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class HasOne < SingularAssociation #:nodoc:
-    self.macro = :has_one
-
-    self.valid_options += [:order, :as]
+    def self.macro
+      :has_one
+    end
 
-    class_attribute :through_options
-    self.through_options = [:through, :source, :source_type]
+    def self.valid_options(options)
+      valid = super + [:as, :touch]
+      valid += [:through, :source, :source_type] if options[:through]
+      valid
+    end
 
-    def constructable?
-      !options[:through]
+    def self.valid_dependent_options
+      [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
     end
 
-    def build
-      reflection = super
-      configure_dependency unless options[:through]
-      reflection
+    def self.define_callbacks(model, reflection)
+      super
+      add_touch_callbacks(model, reflection) if reflection.options[:touch]
     end
 
-    private
+    def self.add_destroy_callbacks(model, reflection)
+      super unless reflection.options[:through]
+    end
 
-      def validate_options
-        valid_options = self.class.valid_options
-        valid_options += self.class.through_options if options[:through]
-        options.assert_valid_keys(valid_options)
+    def self.define_validations(model, reflection)
+      super
+      if reflection.options[:required]
+        model.validates_presence_of reflection.name, message: :required
       end
+    end
 
-      def configure_dependency
-        if options[:dependent]
-          unless options[:dependent].in?([:destroy, :delete, :nullify, :restrict])
-            raise ArgumentError, "The :dependent option expects either :destroy, :delete, " \
-                                 ":nullify or :restrict (#{options[:dependent].inspect})"
-          end
+    def self.touch_record(o, name, touch)
+      record = o.send name
 
-          send("define_#{options[:dependent]}_dependency_method")
-          model.before_destroy dependency_method_name
-        end
-      end
+      return unless record && record.persisted?
 
-      def dependency_method_name
-        "has_one_dependent_#{options[:dependent]}_for_#{name}"
+      if touch != true
+        record.touch(touch)
+      else
+        record.touch
       end
+    end
 
-      def define_destroy_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          association(name).delete
-        end
-      end
-      alias :define_delete_dependency_method :define_destroy_dependency_method
-      alias :define_nullify_dependency_method :define_destroy_dependency_method
-
-      def define_restrict_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).nil?
-        end
-      end
+    def self.add_touch_callbacks(model, reflection)
+      name  = reflection.name
+      touch = reflection.options[:touch]
+
+      callback = lambda { |record|
+        HasOne.touch_record(record, name, touch)
+      }
+
+      model.after_create callback, if: :saved_changes?
+      model.after_update callback, if: :saved_changes?
+      model.after_destroy callback
+      model.after_touch callback
+    end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :add_destroy_callbacks,
+      :define_callbacks, :define_validations, :add_touch_callbacks
   end
 end