activerecord 5.1.5 → 5.2.1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2017 David Heinemeier Hansson
+Copyright (c) 2004-2018 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -26,7 +26,7 @@ The Product class is automatically mapped to the table named "products",
 which might look like this:
 
    CREATE TABLE products (
-     id int NOT NULL auto_increment,
+     id bigint NOT NULL auto_increment,
      name varchar(255),
      PRIMARY KEY  (id)
    );
@@ -162,7 +162,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
 == Philosophy
 
 Active Record is an implementation of the object-relational mapping (ORM)
-pattern[http://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
+pattern[https://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
 name described by Martin Fowler:
 
   "An object that wraps a row in a database table or view,
@@ -192,14 +192,14 @@ The latest version of Active Record can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/activerecord
+* https://github.com/rails/rails/tree/5-2-stable/activerecord
 
 
 == License
 
 Active Record is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
@@ -208,7 +208,7 @@ API documentation is at:
 
 * http://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 

data/examples/performance.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record"
 require "benchmark/ips"
 

data/examples/simple.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record"
 
 class Person < ActiveRecord::Base

data/lib/active_record/aggregations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # See ActiveRecord::Aggregations::ClassMethods for documentation
   module Aggregations
@@ -33,7 +35,7 @@ module ActiveRecord
       # the database).
       #
       #   class Customer < ActiveRecord::Base
-      #     composed_of :balance, class_name: "Money", mapping: %w(amount currency)
+      #     composed_of :balance, class_name: "Money", mapping: %w(balance amount)
       #     composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
       #   end
       #
@@ -175,9 +177,9 @@ module ActiveRecord
       #
       # Once a #composed_of relationship is specified for a model, records can be loaded from the database
       # by specifying an instance of the value object in the conditions hash. The following example
-      # finds all customers with +balance_amount+ equal to 20 and +balance_currency+ equal to "USD":
+      # finds all customers with +address_street+ equal to "May Street" and +address_city+ equal to "Chicago":
       #
-      #   Customer.where(balance: Money.new(20, "USD"))
+      #   Customer.where(address: Address.new("May Street", "Chicago"))
       #
       module ClassMethods
         # Adds reader and writer methods for manipulating a value object:
@@ -210,8 +212,7 @@ module ActiveRecord
         #
         # Option examples:
         #   composed_of :temperature, mapping: %w(reading celsius)
-        #   composed_of :balance, class_name: "Money", mapping: %w(balance amount),
-        #                         converter: Proc.new { |balance| balance.to_money }
+        #   composed_of :balance, class_name: "Money", mapping: %w(balance amount)
         #   composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
         #   composed_of :gps_location
         #   composed_of :gps_location, allow_nil: true

data/lib/active_record/association_relation.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class AssociationRelation < Relation
-    def initialize(klass, table, predicate_builder, association)
-      super(klass, table, predicate_builder)
+    def initialize(klass, association)
+      super(klass)
       @association = association
     end
 

data/lib/active_record/associations/alias_tracker.rb

@@ -1,51 +1,41 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/conversions"
 
 module ActiveRecord
   module Associations
     # Keeps track of table aliases for ActiveRecord::Associations::JoinDependency
     class AliasTracker # :nodoc:
-      attr_reader :aliases
-
-      def self.create(connection, initial_table)
-        aliases = Hash.new(0)
-        aliases[initial_table] = 1
-        new(connection, aliases)
-      end
-
-      def self.create_with_joins(connection, initial_table, joins)
+      def self.create(connection, initial_table, joins)
         if joins.empty?
-          create(connection, initial_table)
+          aliases = Hash.new(0)
         else
           aliases = Hash.new { |h, k|
             h[k] = initial_count_for(connection, k, joins)
           }
-          aliases[initial_table] = 1
-          new(connection, aliases)
         end
+        aliases[initial_table] = 1
+        new(connection, aliases)
       end
 
       def self.initial_count_for(connection, name, table_joins)
-        # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
-        quoted_name = connection.quote_table_name(name).downcase
+        quoted_name = nil
 
         counts = table_joins.map do |join|
           if join.is_a?(Arel::Nodes::StringJoin)
+            # quoted_name should be case ignored as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name ||= connection.quote_table_name(name)
+
             # Table names + table aliases
-            join.left.downcase.scan(
-              /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+            join.left.scan(
+              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name}|#{name})\sON/i
             ).size
-          elsif join.respond_to? :left
-            join.left.table_name == name ? 1 : 0
+          elsif join.is_a?(Arel::Nodes::Join)
+            join.left.name == name ? 1 : 0
+          elsif join.is_a?(Hash)
+            join[name]
           else
-            # this branch is reached by two tests:
-            #
-            # activerecord/test/cases/associations/cascaded_eager_loading_test.rb:37
-            #   with :posts
-            #
-            # activerecord/test/cases/associations/eager_test.rb:1133
-            #   with :comments
-            #
-            0
+            raise ArgumentError, "joins list should be initialized by list of Arel::Nodes::Join"
           end
         end
 
@@ -79,6 +69,8 @@ module ActiveRecord
         end
       end
 
+      attr_reader :aliases
+
       private
 
         def truncate(name)

data/lib/active_record/associations/association.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/wrap"
 
 module ActiveRecord
@@ -17,7 +19,6 @@ module ActiveRecord
     #         HasManyThroughAssociation + ThroughAssociation
     class Association #:nodoc:
       attr_reader :owner, :target, :reflection
-      attr_accessor :inversed
 
       delegate :options, to: :reflection
 
@@ -30,14 +31,6 @@ module ActiveRecord
         reset_scope
       end
 
-      # Returns the name of the table of the associated class:
-      #
-      #   post.comments.aliased_table_name # => "comments"
-      #
-      def aliased_table_name
-        klass.table_name
-      end
-
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
@@ -73,7 +66,7 @@ module ActiveRecord
       #
       # Note that if the target has not been loaded, it is not considered stale.
       def stale_target?
-        !inversed && loaded? && @stale_state != stale_state
+        !@inversed && loaded? && @stale_state != stale_state
       end
 
       # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
@@ -94,7 +87,7 @@ module ActiveRecord
       # actually gets built.
       def association_scope
         if klass
-          @association_scope ||= AssociationScope.scope(self, klass.connection)
+          @association_scope ||= AssociationScope.scope(self)
         end
       end
 
@@ -104,23 +97,24 @@ module ActiveRecord
 
       # Set the inverse association, if possible
       def set_inverse_instance(record)
-        if invertible_for?(record)
-          inverse = record.association(inverse_reflection_for(record).name)
-          inverse.target = owner
-          inverse.inversed = true
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from(owner)
         end
         record
       end
 
       # Remove the inverse association, if possible
       def remove_inverse_instance(record)
-        if invertible_for?(record)
-          inverse = record.association(inverse_reflection_for(record).name)
-          inverse.target = nil
-          inverse.inversed = false
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from(nil)
         end
       end
 
+      def inversed_from(record)
+        self.target = record
+        @inversed = !!record
+      end
+
       # Returns the class of the target. belongs_to polymorphic overrides this to look at the
       # polymorphic_type field on the owner.
       def klass
@@ -130,14 +124,14 @@ module ActiveRecord
       # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
       # through association's scope)
       def target_scope
-        AssociationRelation.create(klass, klass.arel_table, klass.predicate_builder, self).merge!(klass.all)
+        AssociationRelation.create(klass, self).merge!(klass.all)
       end
 
       def extensions
         extensions = klass.default_extensions | reflection.extensions
 
-        if scope = reflection.scope
-          extensions |= klass.unscoped.instance_exec(owner, &scope).extensions
+        if reflection.scope
+          extensions |= reflection.scope_for(klass.unscoped, owner).extensions
         end
 
         extensions
@@ -162,17 +156,9 @@ module ActiveRecord
         reset
       end
 
-      def interpolate(sql, record = nil)
-        if sql.respond_to?(:to_proc)
-          owner.instance_exec(record, &sql)
-        else
-          sql
-        end
-      end
-
-      # We can't dump @reflection since it contains the scope proc
+      # We can't dump @reflection and @through_reflection since it contains the scope proc
       def marshal_dump
-        ivars = (instance_variables - [:@reflection]).map { |name| [name, instance_variable_get(name)] }
+        ivars = (instance_variables - [:@reflection, :@through_reflection]).map { |name| [name, instance_variable_get(name)] }
         [@reflection.name, ivars]
       end
 
@@ -187,8 +173,8 @@ module ActiveRecord
         skip_assign = [reflection.foreign_key, reflection.type].compact
         assigned_keys = record.changed_attribute_names_to_save
         assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
-        attributes = create_scope.except(*(assigned_keys - skip_assign))
-        record.assign_attributes(attributes)
+        attributes = scope_for_create.except!(*(assigned_keys - skip_assign))
+        record.send(:_assign_attributes, attributes) if attributes.any?
         set_inverse_instance(record)
       end
 
@@ -201,6 +187,9 @@ module ActiveRecord
       end
 
       private
+        def scope_for_create
+          scope.scope_for_create
+        end
 
         def find_target?
           !loaded? && (!owner.new_record? || foreign_key_present?) && klass
@@ -212,8 +201,8 @@ module ActiveRecord
           if (reflection.has_one? || reflection.collection?) && !options[:through]
             attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
 
-            if reflection.options[:as]
-              attributes[reflection.type] = owner.class.base_class.name
+            if reflection.type
+              attributes[reflection.type] = owner.class.polymorphic_name
             end
           end
 
@@ -251,6 +240,12 @@ module ActiveRecord
           end
         end
 
+        def inverse_association_for(record)
+          if invertible_for?(record)
+            record.association(inverse_reflection_for(record).name)
+          end
+        end
+
         # Can be redefined by subclasses, notably polymorphic belongs_to
         # The record parameter is necessary to support polymorphic inverses as we must check for
         # the association in the specific class of the record.
@@ -280,11 +275,12 @@ module ActiveRecord
         def build_record(attributes)
           reflection.build_association(attributes) do |record|
             initialize_attributes(record, attributes)
+            yield(record) if block_given?
           end
         end
 
         # Returns true if statement cache should be skipped on the association reader.
-        def skip_statement_cache?
+        def skip_statement_cache?(scope)
           reflection.has_scope? ||
             scope.eager_loading? ||
             klass.scope_attributes? ||

data/lib/active_record/associations/association_scope.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      def self.scope(association, connection)
-        INSTANCE.scope(association, connection)
+      def self.scope(association)
+        INSTANCE.scope(association)
       end
 
       def self.create(&block)
@@ -16,20 +18,15 @@ module ActiveRecord
 
       INSTANCE = create
 
-      def scope(association, connection)
+      def scope(association)
         klass = association.klass
         reflection = association.reflection
         scope = klass.unscoped
         owner = association.owner
-        alias_tracker = AliasTracker.create connection, association.klass.table_name
-        chain_head, chain_tail = get_chain(reflection, association, alias_tracker)
+        chain = get_chain(reflection, association, scope.alias_tracker)
 
         scope.extending! reflection.extensions
-        add_constraints(scope, owner, reflection, chain_head, chain_tail)
-      end
-
-      def join_type
-        Arel::Nodes::InnerJoin
+        add_constraints(scope, owner, chain)
       end
 
       def self.get_bind_values(owner, chain)
@@ -38,12 +35,12 @@ module ActiveRecord
 
         binds << last_reflection.join_id_for(owner)
         if last_reflection.type
-          binds << owner.class.base_class.name
+          binds << owner.class.polymorphic_name
         end
 
         chain.each_cons(2).each do |reflection, next_reflection|
           if reflection.type
-            binds << next_reflection.klass.base_class.name
+            binds << next_reflection.klass.polymorphic_name
           end
         end
         binds
@@ -57,19 +54,20 @@ module ActiveRecord
 
       private
         def join(table, constraint)
-          table.create_join(table, table.create_on(constraint), join_type)
+          table.create_join(table, table.create_on(constraint))
         end
 
-        def last_chain_scope(scope, table, reflection, owner)
+        def last_chain_scope(scope, reflection, owner)
           join_keys = reflection.join_keys
           key = join_keys.key
           foreign_key = join_keys.foreign_key
 
+          table = reflection.aliased_table
           value = transform_value(owner[foreign_key])
           scope = apply_scope(scope, table, key, value)
 
           if reflection.type
-            polymorphic_type = transform_value(owner.class.base_class.name)
+            polymorphic_type = transform_value(owner.class.polymorphic_name)
             scope = apply_scope(scope, table, reflection.type, polymorphic_type)
           end
 
@@ -80,15 +78,17 @@ module ActiveRecord
           value_transformation.call(value)
         end
 
-        def next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
+        def next_chain_scope(scope, reflection, next_reflection)
           join_keys = reflection.join_keys
           key = join_keys.key
           foreign_key = join_keys.foreign_key
 
+          table = reflection.aliased_table
+          foreign_table = next_reflection.aliased_table
           constraint = table[key].eq(foreign_table[foreign_key])
 
           if reflection.type
-            value = transform_value(next_reflection.klass.base_class.name)
+            value = transform_value(next_reflection.klass.polymorphic_name)
             scope = apply_scope(scope, table, reflection.type, value)
           end
 
@@ -96,12 +96,11 @@ module ActiveRecord
         end
 
         class ReflectionProxy < SimpleDelegator # :nodoc:
-          attr_accessor :next
-          attr_reader :alias_name
+          attr_reader :aliased_table
 
-          def initialize(reflection, alias_name)
+          def initialize(reflection, aliased_table)
             super(reflection)
-            @alias_name = alias_name
+            @aliased_table = aliased_table
           end
 
           def all_includes; nil; end
@@ -109,43 +108,34 @@ module ActiveRecord
 
         def get_chain(reflection, association, tracker)
           name = reflection.name
-          runtime_reflection = Reflection::RuntimeReflection.new(reflection, association)
-          previous_reflection = runtime_reflection
+          chain = [Reflection::RuntimeReflection.new(reflection, association)]
           reflection.chain.drop(1).each do |refl|
-            alias_name = tracker.aliased_table_for(
+            aliased_table = tracker.aliased_table_for(
               refl.table_name,
               refl.alias_candidate(name),
               refl.klass.type_caster
             )
-            proxy = ReflectionProxy.new(refl, alias_name)
-            previous_reflection.next = proxy
-            previous_reflection = proxy
+            chain << ReflectionProxy.new(refl, aliased_table)
           end
-          [runtime_reflection, previous_reflection]
+          chain
         end
 
-        def add_constraints(scope, owner, refl, chain_head, chain_tail)
-          owner_reflection = chain_tail
-          table = owner_reflection.alias_name
-          scope = last_chain_scope(scope, table, owner_reflection, owner)
-
-          reflection = chain_head
-          while reflection
-            table = reflection.alias_name
-            next_reflection = reflection.next
+        def add_constraints(scope, owner, chain)
+          scope = last_chain_scope(scope, chain.last, owner)
 
-            unless reflection == chain_tail
-              foreign_table = next_reflection.alias_name
-              scope = next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
-            end
+          chain.each_cons(2) do |reflection, next_reflection|
+            scope = next_chain_scope(scope, reflection, next_reflection)
+          end
 
+          chain_head = chain.first
+          chain.reverse_each do |reflection|
             # Exclude the scope of the association itself, because that
             # was already merged in the #scope method.
             reflection.constraints.each do |scope_chain_item|
-              item = eval_scope(reflection.klass, table, scope_chain_item, owner)
+              item = eval_scope(reflection, scope_chain_item, owner)
 
-              if scope_chain_item == refl.scope
-                scope.merge! item.except(:where, :includes)
+              if scope_chain_item == chain_head.scope
+                scope.merge! item.except(:where, :includes, :unscope, :order)
               end
 
               reflection.all_includes do
@@ -154,10 +144,8 @@ module ActiveRecord
 
               scope.unscope!(*item.unscope_values)
               scope.where_clause += item.where_clause
-              scope.order_values |= item.order_values
+              scope.order_values = item.order_values | scope.order_values
             end
-
-            reflection = next_reflection
           end
 
           scope
@@ -171,9 +159,9 @@ module ActiveRecord
           end
         end
 
-        def eval_scope(klass, table, scope, owner)
-          predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
-          ActiveRecord::Relation.create(klass, table, predicate_builder).instance_exec(owner, &scope)
+        def eval_scope(reflection, scope, owner)
+          relation = reflection.build_scope(reflection.aliased_table)
+          relation.instance_exec(owner, &scope) || relation
         end
     end
   end

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,26 +1,41 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Belongs To Association
   module Associations
+    # = Active Record Belongs To Association
     class BelongsToAssociation < SingularAssociation #:nodoc:
       def handle_dependency
-        target.send(options[:dependent]) if load_target
+        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)
-          replace_keys(record)
           set_inverse_instance(record)
           @updated = true
         else
           decrement_counters
-          remove_keys
         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
@@ -42,6 +57,10 @@ module ActiveRecord
         update_counters(1)
       end
 
+      def target_changed?
+        owner.saved_change_to_attribute?(reflection.foreign_key)
+      end
+
       private
 
         def update_counters(by)
@@ -65,22 +84,22 @@ module ActiveRecord
         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)
+            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.id != owner._read_attribute(reflection.foreign_key)
+          record._read_attribute(primary_key(record)) != owner._read_attribute(reflection.foreign_key)
         end
 
         def replace_keys(record)
-          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
+          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record)) : nil
         end
 
-        def remove_keys
-          owner[reflection.foreign_key] = nil
+        def primary_key(record)
+          reflection.association_primary_key(record.class)
         end
 
         def foreign_key_present?

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -1,22 +1,22 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Belongs To Polymorphic Association
   module Associations
+    # = Active Record Belongs To Polymorphic Association
     class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
       def klass
         type = owner[reflection.foreign_type]
         type.presence && type.constantize
       end
 
-      private
+      def target_changed?
+        super || owner.saved_change_to_attribute?(reflection.foreign_type)
+      end
 
+      private
         def replace_keys(record)
           super
-          owner[reflection.foreign_type] = record.class.base_class.name
-        end
-
-        def remove_keys
-          super
-          owner[reflection.foreign_type] = nil
+          owner[reflection.foreign_type] = record ? record.class.polymorphic_name : nil
         end
 
         def different_target?(record)