activerecord 5.2.3

data/lib/active_record/associations/belongs_to_association.rb

@@ -0,0 +1,130 @@
+# 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 replace(record)
+        if record
+          raise_on_type_mismatch!(record)
+          update_counters_on_replace(record)
+          set_inverse_instance(record)
+          @updated = true
+        else
+          decrement_counters
+        end
+
+        replace_keys(record)
+
+        self.target = record
+      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 # :nodoc:
+        update_counters(-1)
+      end
+
+      def increment_counters # :nodoc:
+        update_counters(1)
+      end
+
+      def target_changed?
+        owner.saved_change_to_attribute?(reflection.foreign_key)
+      end
+
+      private
+
+        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
+              klass.update_counters(target_id, reflection.counter_cache_column => by, touch: reflection.options[:touch])
+            end
+          end
+        end
+
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
+        def require_counter_update?
+          reflection.counter_cache_column && owner.persisted?
+        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, touch: reflection.options[:touch])
+            decrement_counters
+          end
+        end
+
+        # Checks whether record is different to the current target, without loading it
+        def different_target?(record)
+          record._read_attribute(primary_key(record)) != owner._read_attribute(reflection.foreign_key)
+        end
+
+        def replace_keys(record)
+          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record)) : nil
+        end
+
+        def primary_key(record)
+          reflection.association_primary_key(record.class)
+        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 target_id
+          if options[:primary_key]
+            owner.send(reflection.name).try(:id)
+          else
+            owner._read_attribute(reflection.foreign_key)
+          end
+        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,40 @@
+# 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 different_target?(record)
+          super || record.class != klass
+        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,140 @@
+# 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
+
+      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)
+
+      validate_options(options)
+
+      scope = build_scope(scope, extension)
+
+      ActiveRecord::Reflection.create(macro, name, scope, options, model)
+    end
+
+    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 self.wrap_scope(scope, extension)
+      scope
+    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
+  end
+end

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

@@ -0,0 +1,163 @@
+# 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.define_accessors(mixin, reflection)
+      super
+      add_counter_cache_methods mixin
+    end
+
+    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_replace_counter_called ||= false)
+            @_after_replace_counter_called = false
+          elsif association(reflection.name).target_changed?
+            if reflection.polymorphic?
+              model     = attribute_in_database(reflection.foreign_type).try(:constantize)
+              model_was = attribute_before_last_save(reflection.foreign_type).try(:constantize)
+            else
+              model     = reflection.klass
+              model_was = reflection.klass
+            end
+
+            foreign_key_was = attribute_before_last_save foreign_key
+            foreign_key     = attribute_in_database foreign_key
+
+            if foreign_key && model.respond_to?(:increment_counter)
+              foreign_key = counter_cache_target(reflection, model, foreign_key)
+              model.increment_counter(cache_column, foreign_key)
+            end
+
+            if foreign_key_was && model_was.respond_to?(:decrement_counter)
+              foreign_key_was = counter_cache_target(reflection, model_was, foreign_key_was)
+              model_was.decrement_counter(cache_column, foreign_key_was)
+            end
+          end
+        end
+
+        private
+          def counter_cache_target(reflection, model, foreign_key)
+            primary_key = reflection.association_primary_key(model)
+            model.unscoped.where!(primary_key => foreign_key)
+          end
+      end
+    end
+
+    def self.add_counter_cache_callbacks(model, reflection)
+      cache_column = reflection.counter_cache_column
+
+      model.after_update lambda { |record|
+        record.belongs_to_counter_cache_after_update(reflection)
+      }
+
+      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
+      n           = reflection.name
+      touch       = reflection.options[:touch]
+
+      callback = lambda { |changes_method| lambda { |record|
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, n, touch, belongs_to_touch_method)
+      }}
+
+      unless reflection.counter_cache_column
+        model.after_create callback.(:saved_changes), if: :saved_changes?
+        model.after_destroy callback.(:changes_to_save)
+      end
+
+      model.after_update callback.(:saved_changes), if: :saved_changes?
+      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
+  end
+end