activerecord 6.0.0

data/lib/active_record/associations/belongs_to_association.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    # = Active Record Belongs To Association
+    class BelongsToAssociation < SingularAssociation #:nodoc:
+      def handle_dependency
+        return unless load_target
+
+        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)
+        super
+      end
+
+      def default(&block)
+        writer(owner.instance_exec(&block)) if reader.nil?
+      end
+
+      def reset
+        super
+        @updated = false
+      end
+
+      def updated?
+        @updated
+      end
+
+      def decrement_counters
+        update_counters(-1)
+      end
+
+      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
+
+        foreign_key_was = owner.attribute_before_last_save(reflection.foreign_key)
+
+        if foreign_key_was && model_was < ActiveRecord::Base
+          update_counters_via_scope(model_was, foreign_key_was, -1)
+        end
+      end
+
+      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
+
+        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)
+          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._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.has_one?
+        end
+
+        def stale_state
+          result = owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+          result && result.to_s
+        end
+    end
+  end
+end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    # = Active Record Belongs To Polymorphic Association
+    class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
+      def klass
+        type = owner[reflection.foreign_type]
+        type.presence && type.constantize
+      end
+
+      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.polymorphic_name : nil
+        end
+
+        def inverse_reflection_for(record)
+          reflection.polymorphic_inverse_of(record.class)
+        end
+
+        def raise_on_type_mismatch!(record)
+          # A polymorphic association cannot have a type mismatch, by definition
+        end
+
+        def stale_state
+          foreign_key = super
+          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
+        end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# 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 << 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
+
+      scope = build_scope(scope)
+
+      ActiveRecord::Reflection.create(macro, name, scope, options, model)
+    end
+
+    def self.build_scope(scope)
+      if scope && scope.arity == 0
+        proc { instance_exec(&scope) }
+      else
+        scope
+      end
+    end
+
+    def self.macro
+      raise NotImplementedError
+    end
+
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
+    end
+
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
+    end
+
+    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
+
+      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 self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}
+          association(:#{name}).reader
+        end
+      CODE
+    end
+
+    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

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Associations::Builder # :nodoc:
+  class BelongsTo < SingularAssociation #:nodoc:
+    def self.macro
+      :belongs_to
+    end
+
+    def self.valid_options(options)
+      super + [:polymorphic, :touch, :counter_cache, :optional, :default]
+    end
+
+    def self.valid_dependent_options
+      [:destroy, :delete]
+    end
+
+    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
+
+    def self.add_counter_cache_callbacks(model, reflection)
+      cache_column = reflection.counter_cache_column
+
+      model.after_update lambda { |record|
+        association = association(reflection.name)
+
+        if association.target_changed?
+          association.increment_counters
+          association.decrement_counters_before_last_save
+        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, 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
+        primary_key = reflection.association_primary_key(klass)
+        old_record = klass.find_by(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
+
+      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 self.add_touch_callbacks(model, reflection)
+      foreign_key = reflection.foreign_key
+      name        = reflection.name
+      touch       = reflection.options[:touch]
+
+      callback = lambda { |changes_method| lambda { |record|
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, name, touch, belongs_to_touch_method)
+      }}
+
+      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
+
+      model.after_touch callback.(:changes_to_save)
+    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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_record/associations"
+
+module ActiveRecord::Associations::Builder # :nodoc:
+  class CollectionAssociation < Association #:nodoc:
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+    def self.valid_options(options)
+      super + [:table_name, :before_add,
+               :after_add, :before_remove, :after_remove, :extend]
+    end
+
+    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 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
+
+    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
+
+    # Defines the setter and getter methods for the collection_singular_ids.
+    def self.define_readers(mixin, name)
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
+        end
+      CODE
+    end
+
+    private_class_method :valid_options, :define_callback, :define_extensions, :define_readers, :define_writers
+  end
+end