activerecord 5.1.7 → 5.2.6

data/lib/active_record/attribute_methods/query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Query

data/lib/active_record/attribute_methods/read.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Read
       extend ActiveSupport::Concern
 
-      module ClassMethods
+      module ClassMethods # :nodoc:
         private
 
           # We want to generate the methods via module_eval rather than
@@ -29,9 +31,11 @@ module ActiveRecord
             temp_method = "__temp__#{safe_name}"
 
             ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+            sync_with_transaction_state = "sync_with_transaction_state" if name == primary_key
 
             generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
               def #{temp_method}
+                #{sync_with_transaction_state}
                 name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
                 _read_attribute(name) { |n| missing_attribute(n, caller) }
               end
@@ -54,7 +58,9 @@ module ActiveRecord
           attr_name.to_s
         end
 
-        name = self.class.primary_key if name == "id".freeze && self.class.primary_key
+        primary_key = self.class.primary_key
+        name = primary_key if name == "id".freeze && primary_key
+        sync_with_transaction_state if name == primary_key
         _read_attribute(name, &block)
       end
 
@@ -63,7 +69,7 @@ module ActiveRecord
       if defined?(JRUBY_VERSION)
         # This form is significantly faster on JRuby, and this is one of our biggest hotspots.
         # https://github.com/jruby/jruby/pull/2562
-        def _read_attribute(attr_name, &block) # :nodoc
+        def _read_attribute(attr_name, &block) # :nodoc:
           @attributes.fetch_value(attr_name.to_s, &block)
         end
       else

data/lib/active_record/attribute_methods/serialization.rb

@@ -1,8 +1,20 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Serialization
       extend ActiveSupport::Concern
 
+      class ColumnNotSerializableError < StandardError
+        def initialize(name, type)
+          super <<-EOS.strip_heredoc
+            Column `#{name}` of type #{type.class} does not support `serialize` feature.
+            Usually it means that you are trying to use `serialize`
+            on a column that already implements serialization natively.
+          EOS
+        end
+      end
+
       module ClassMethods
         # If you have an attribute that needs to be saved to the database as an
         # object, and retrieved as the same object, then specify the name of that
@@ -58,9 +70,20 @@ module ActiveRecord
           end
 
           decorate_attribute_type(attr_name, :serialize) do |type|
+            if type_incompatible_with_serialize?(type, class_name_or_coder)
+              raise ColumnNotSerializableError.new(attr_name, type)
+            end
+
             Type::Serialized.new(type, coder)
           end
         end
+
+        private
+
+          def type_incompatible_with_serialize?(type, class_name)
+            type.is_a?(ActiveRecord::Type::Json) && class_name == ::JSON ||
+              type.respond_to?(:type_cast_array, true) && class_name == ::Array
+          end
       end
     end
   end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
@@ -54,17 +56,13 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        mattr_accessor :time_zone_aware_attributes, instance_writer: false
-        self.time_zone_aware_attributes = false
-
-        class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false
-        self.skip_time_zone_conversion_for_attributes = []
+        mattr_accessor :time_zone_aware_attributes, instance_writer: false, default: false
 
-        class_attribute :time_zone_aware_types, instance_writer: false
-        self.time_zone_aware_types = [:datetime, :time]
+        class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false, default: []
+        class_attribute :time_zone_aware_types, instance_writer: false, default: [ :datetime, :time ]
       end
 
-      module ClassMethods
+      module ClassMethods # :nodoc:
         private
 
           def inherited(subclass)

data/lib/active_record/attribute_methods/write.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Write
@@ -7,17 +9,19 @@ module ActiveRecord
         attribute_method_suffix "="
       end
 
-      module ClassMethods
+      module ClassMethods # :nodoc:
         private
 
           def define_method_attribute=(name)
             safe_name = name.unpack("h*".freeze).first
             ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+            sync_with_transaction_state = "sync_with_transaction_state" if name == primary_key
 
             generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
               def __temp__#{safe_name}=(value)
                 name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-                write_attribute(name, value)
+                #{sync_with_transaction_state}
+                _write_attribute(name, value)
               end
               alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
               undef_method :__temp__#{safe_name}=
@@ -35,21 +39,29 @@ module ActiveRecord
           attr_name.to_s
         end
 
-        name = self.class.primary_key if name == "id".freeze && self.class.primary_key
-        @attributes.write_from_user(name, value)
-        value
+        primary_key = self.class.primary_key
+        name = primary_key if name == "id".freeze && primary_key
+        sync_with_transaction_state if name == primary_key
+        _write_attribute(name, value)
       end
 
-      def raw_write_attribute(attr_name, value) # :nodoc:
-        name = attr_name.to_s
-        @attributes.write_cast_value(name, value)
+      # This method exists to avoid the expensive primary_key check internally, without
+      # breaking compatibility with the write_attribute API
+      def _write_attribute(attr_name, value) # :nodoc:
+        @attributes.write_from_user(attr_name.to_s, value)
         value
       end
 
       private
+        def write_attribute_without_type_cast(attr_name, value)
+          name = attr_name.to_s
+          @attributes.write_cast_value(name, value)
+          value
+        end
+
         # Handle *= for method_missing.
         def attribute=(attribute_name, value)
-          write_attribute(attribute_name, value)
+          _write_attribute(attribute_name, value)
         end
     end
   end

data/lib/active_record/attribute_methods.rb

@@ -1,7 +1,6 @@
-require "active_support/core_ext/enumerable"
-require "active_support/core_ext/string/filters"
+# frozen_string_literal: true
+
 require "mutex_m"
-require "concurrent/map"
 
 module ActiveRecord
   # = Active Record Attribute Methods
@@ -34,7 +33,9 @@ module ActiveRecord
 
     BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
 
-    class GeneratedAttributeMethods < Module; end # :nodoc:
+    class GeneratedAttributeMethods < Module #:nodoc:
+      include Mutex_m
+    end
 
     module ClassMethods
       def inherited(child_class) #:nodoc:
@@ -43,7 +44,7 @@ module ActiveRecord
       end
 
       def initialize_generated_modules # :nodoc:
-        @generated_attribute_methods = GeneratedAttributeMethods.new { extend Mutex_m }
+        @generated_attribute_methods = GeneratedAttributeMethods.new
         @attribute_methods_generated = false
         include @generated_attribute_methods
 
@@ -62,7 +63,6 @@ module ActiveRecord
           super(attribute_names)
           @attribute_methods_generated = true
         end
-        true
       end
 
       def undefine_attribute_methods # :nodoc:
@@ -167,6 +167,57 @@ module ActiveRecord
         end
       end
 
+      # Regexp whitelist. Matches the following:
+      #   "#{table_name}.#{column_name}"
+      #   "#{column_name}"
+      COLUMN_NAME_WHITELIST = /\A(?:\w+\.)?\w+\z/i
+
+      # Regexp whitelist. Matches the following:
+      #   "#{table_name}.#{column_name}"
+      #   "#{table_name}.#{column_name} #{direction}"
+      #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
+      #   "#{table_name}.#{column_name} NULLS LAST"
+      #   "#{column_name}"
+      #   "#{column_name} #{direction}"
+      #   "#{column_name} #{direction} NULLS FIRST"
+      #   "#{column_name} NULLS LAST"
+      COLUMN_NAME_ORDER_WHITELIST = /
+        \A
+        (?:\w+\.)?
+        \w+
+        (?:\s+asc|\s+desc)?
+        (?:\s+nulls\s+(?:first|last))?
+        \z
+      /ix
+
+      def enforce_raw_sql_whitelist(args, whitelist: COLUMN_NAME_WHITELIST) # :nodoc:
+        unexpected = args.reject do |arg|
+          arg.kind_of?(Arel::Node) ||
+            arg.is_a?(Arel::Nodes::SqlLiteral) ||
+            arg.is_a?(Arel::Attributes::Attribute) ||
+            arg.to_s.split(/\s*,\s*/).all? { |part| whitelist.match?(part) }
+        end
+
+        return if unexpected.none?
+
+        if allow_unsafe_raw_sql == :deprecated
+          ActiveSupport::Deprecation.warn(
+            "Dangerous query method (method whose arguments are used as raw " \
+            "SQL) called with non-attribute argument(s): " \
+            "#{unexpected.map(&:inspect).join(", ")}. Non-attribute " \
+            "arguments will be disallowed in Rails 6.0. This method should " \
+            "not be called with user-provided values, such as request " \
+            "parameters or model attributes. Known-safe values can be passed " \
+            "by wrapping them in Arel.sql()."
+          )
+        else
+          raise(ActiveRecord::UnknownAttributeReference,
+            "Query method called with non-attribute argument(s): " +
+            unexpected.map(&:inspect).join(", ")
+          )
+        end
+      end
+
       # Returns true if the given attribute exists, otherwise false.
       #
       #   class Person < ActiveRecord::Base
@@ -236,7 +287,7 @@ module ActiveRecord
         return has_attribute?(name)
       end
 
-      return true
+      true
     end
 
     # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
@@ -401,24 +452,18 @@ module ActiveRecord
 
     private
 
-      def arel_attributes_with_values_for_create(attribute_names)
-        arel_attributes_with_values(attributes_for_create(attribute_names))
+      def attributes_with_values_for_create(attribute_names)
+        attributes_with_values(attributes_for_create(attribute_names))
       end
 
-      def arel_attributes_with_values_for_update(attribute_names)
-        arel_attributes_with_values(attributes_for_update(attribute_names))
+      def attributes_with_values_for_update(attribute_names)
+        attributes_with_values(attributes_for_update(attribute_names))
       end
 
-      # Returns a Hash of the Arel::Attributes and attribute values that have been
-      # typecasted for use in an Arel insert/update method.
-      def arel_attributes_with_values(attribute_names)
-        attrs = {}
-        arel_table = self.class.arel_table
-
-        attribute_names.each do |name|
-          attrs[arel_table[name]] = typecasted_attribute_value(name)
+      def attributes_with_values(attribute_names)
+        attribute_names.each_with_object({}) do |name, attrs|
+          attrs[name] = _read_attribute(name)
         end
-        attrs
       end
 
       # Filters the primary keys and readonly attributes from the attribute names.
@@ -443,9 +488,5 @@ module ActiveRecord
       def pk_attribute?(name)
         name == self.class.primary_key
       end
-
-      def typecasted_attribute_value(name)
-        _read_attribute(name)
-      end
   end
 end

data/lib/active_record/attributes.rb

@@ -1,4 +1,6 @@
-require "active_record/attribute/user_provided_default"
+# frozen_string_literal: true
+
+require "active_model/attribute/user_provided_default"
 
 module ActiveRecord
   # See ActiveRecord::Attributes::ClassMethods for documentation
@@ -6,8 +8,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :attributes_to_define_after_schema_loads, instance_accessor: false # :internal:
-      self.attributes_to_define_after_schema_loads = {}
+      class_attribute :attributes_to_define_after_schema_loads, instance_accessor: false, default: {} # :internal:
     end
 
     module ClassMethods
@@ -249,14 +250,14 @@ module ActiveRecord
           if value == NO_DEFAULT_PROVIDED
             default_attribute = _default_attributes[name].with_type(type)
           elsif from_user
-            default_attribute = Attribute::UserProvidedDefault.new(
+            default_attribute = ActiveModel::Attribute::UserProvidedDefault.new(
               name,
               value,
               type,
               _default_attributes.fetch(name.to_s) { nil },
             )
           else
-            default_attribute = Attribute.from_database(name, value, type)
+            default_attribute = ActiveModel::Attribute.from_database(name, value, type)
           end
           _default_attributes[name] = default_attribute
         end

data/lib/active_record/autosave_association.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record Autosave Association
   #
@@ -140,8 +142,7 @@ module ActiveRecord
 
     included do
       Associations::Builder::Association.extensions << AssociationBuilderExtension
-      mattr_accessor :index_nested_attribute_errors, instance_writer: false
-      self.index_nested_attribute_errors = false
+      mattr_accessor :index_nested_attribute_errors, instance_writer: false, default: false
     end
 
     module ClassMethods # :nodoc:
@@ -216,13 +217,7 @@ module ActiveRecord
               method = :validate_single_association
             end
 
-            define_non_cyclic_method(validation_method) do
-              send(method, reflection)
-              # TODO: remove the following line as soon as the return value of
-              # callbacks is ignored, that is, returning `false` does not
-              # display a deprecation warning or halts the callback chain.
-              true
-            end
+            define_non_cyclic_method(validation_method) { send(method, reflection) }
             validate validation_method
             after_validation :_ensure_no_duplicate_errors
           end
@@ -277,7 +272,7 @@ module ActiveRecord
       # or saved. If +autosave+ is +false+ only new records will be returned,
       # unless the parent is/was a new record itself.
       def associated_records_to_validate_or_save(association, new_record, autosave)
-        if new_record
+        if new_record || custom_validation_context?
           association && association.target
         elsif autosave
           association.target.find_all(&:changed_for_autosave?)
@@ -309,7 +304,7 @@ module ActiveRecord
       def validate_single_association(reflection)
         association = association_instance_get(reflection.name)
         record      = association && association.reader
-        association_valid?(reflection, record) if record
+        association_valid?(reflection, record) if record && (record.changed_for_autosave? || custom_validation_context?)
       end
 
       # Validate the associated records if <tt>:validate</tt> or
@@ -329,7 +324,7 @@ module ActiveRecord
       def association_valid?(reflection, record, index = nil)
         return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
-        context = validation_context unless [:create, :update].include?(validation_context)
+        context = validation_context if custom_validation_context?
 
         unless valid = record.valid?(context)
           if reflection.options[:autosave]
@@ -369,7 +364,6 @@ module ActiveRecord
       # association whether or not the parent was a new record before saving.
       def before_save_collection_association
         @new_record_before_save = new_record?
-        true
       end
 
       def after_save_collection_association
@@ -388,10 +382,14 @@ module ActiveRecord
         if association = association_instance_get(reflection.name)
           autosave = reflection.options[:autosave]
 
+          # By saving the instance variable in a local variable,
+          # we make the whole callback re-entrant.
+          new_record_before_save = @new_record_before_save
+
           # reconstruct the scope now that we know the owner's id
-          association.reset_scope if association.respond_to?(:reset_scope)
+          association.reset_scope
 
-          if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+          if records = associated_records_to_validate_or_save(association, new_record_before_save, autosave)
             if autosave
               records_to_destroy = records.select(&:marked_for_destruction?)
               records_to_destroy.each { |record| association.destroy(record) }
@@ -403,11 +401,16 @@ module ActiveRecord
 
               saved = true
 
-              if autosave != false && (@new_record_before_save || record.new_record?)
+              if autosave != false && (new_record_before_save || record.new_record?)
                 if autosave
                   saved = association.insert_record(record, false)
-                else
-                  association.insert_record(record) unless reflection.nested?
+                elsif !reflection.nested?
+                  association_saved = association.insert_record(record)
+
+                  if reflection.validate?
+                    errors.add(reflection.name) unless association_saved
+                    saved = association_saved
+                  end
                 end
               elsif autosave
                 saved = record.save(validate: false)
@@ -442,6 +445,9 @@ module ActiveRecord
             if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
               unless reflection.through_reflection
                 record[reflection.foreign_key] = key
+                if inverse_reflection = reflection.inverse_of
+                  record.association(inverse_reflection.name).loaded!
+                end
               end
 
               saved = record.save(validate: !autosave)
@@ -455,10 +461,16 @@ module ActiveRecord
       # If the record is new or it has changed, returns true.
       def record_changed?(reflection, record, key)
         record.new_record? ||
-          (record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != key) ||
+          association_foreign_key_changed?(reflection, record, key) ||
           record.will_save_change_to_attribute?(reflection.foreign_key)
       end
 
+      def association_foreign_key_changed?(reflection, record, key)
+        return false if reflection.through_reflection?
+
+        record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != key
+      end
+
       # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
       #
       # In addition, it will destroy the association if it was marked for destruction.
@@ -487,6 +499,10 @@ module ActiveRecord
         end
       end
 
+      def custom_validation_context?
+        validation_context && [:create, :update].exclude?(validation_context)
+      end
+
       def _ensure_no_duplicate_errors
         errors.messages.each_key do |attribute|
           errors[attribute].uniq!

data/lib/active_record/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "yaml"
 require "active_support/benchmarkable"
 require "active_support/dependencies"

data/lib/active_record/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record \Callbacks
   #
@@ -96,9 +98,9 @@ module ActiveRecord
   # == Types of callbacks
   #
   # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
-  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects
+  # inline methods (using a proc). Method references and callback objects
   # are the recommended approaches, inline methods using a proc are sometimes appropriate (such as for
-  # creating mix-ins), and inline eval methods are deprecated.
+  # creating mix-ins).
   #
   # The method reference callbacks work by specifying a protected or private method available in the object, like this:
   #
@@ -230,7 +232,7 @@ module ActiveRecord
   #
   # For example:
   #
-  #   class Topic
+  #   class Topic < ActiveRecord::Base
   #     has_many :children
   #
   #     after_save :log_children
@@ -238,7 +240,7 @@ module ActiveRecord
   #
   #     private
   #
-  #     def log_chidren
+  #     def log_children
   #       # Child processing
   #     end
   #
@@ -255,7 +257,7 @@ module ActiveRecord
   #
   # For example:
   #
-  #   class Topic
+  #   class Topic < ActiveRecord::Base
   #     has_many :children
   #
   #     after_commit :log_children
@@ -263,7 +265,7 @@ module ActiveRecord
   #
   #     private
   #
-  #     def log_chidren
+  #     def log_children
   #       # Child processing
   #     end
   #

data/lib/active_record/coders/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Coders # :nodoc:
     class JSON # :nodoc:

data/lib/active_record/coders/yaml_column.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "yaml"
 
 module ActiveRecord

data/lib/active_record/collection_cache_key.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module CollectionCacheKey
     def collection_cache_key(collection = all, timestamp_column = :updated_at) # :nodoc:
-      query_signature = Digest::MD5.hexdigest(collection.to_sql)
+      query_signature = ActiveSupport::Digest.hexdigest(collection.to_sql)
       key = "#{collection.model_name.cache_key}/query-#{query_signature}"
 
       if collection.loaded? || collection.distinct_value
@@ -10,24 +12,26 @@ module ActiveRecord
           timestamp = collection.max_by(&timestamp_column)._read_attribute(timestamp_column)
         end
       else
-        column_type = type_for_attribute(timestamp_column.to_s)
-        column = "#{connection.quote_table_name(collection.table_name)}.#{connection.quote_column_name(timestamp_column)}"
+        if collection.eager_loading?
+          collection = collection.send(:apply_join_dependency)
+        end
+        column_type = type_for_attribute(timestamp_column)
+        column = connection.column_name_from_arel_node(collection.arel_attribute(timestamp_column))
         select_values = "COUNT(*) AS #{connection.quote_column_name("size")}, MAX(%s) AS timestamp"
 
         if collection.has_limit_or_offset?
-          query = collection.spawn
-          query.select_values = [column]
+          query = collection.select("#{column} AS collection_cache_key_timestamp")
           subquery_alias = "subquery_for_cache_key"
-          subquery_column = "#{subquery_alias}.#{timestamp_column}"
+          subquery_column = "#{subquery_alias}.collection_cache_key_timestamp"
           subquery = query.arel.as(subquery_alias)
-          arel = Arel::SelectManager.new(query.engine).project(select_values % subquery_column).from(subquery)
+          arel = Arel::SelectManager.new(subquery).project(select_values % subquery_column)
         else
           query = collection.unscope(:order)
           query.select_values = [select_values % column]
           arel = query.arel
         end
 
-        result = connection.select_one(arel, nil, query.bound_attributes)
+        result = connection.select_one(arel, nil)
 
         if result.blank?
           size = 0