activerecord 5.2.8 → 6.0.0.beta1

data/lib/active_record/attribute_methods/dirty.rb

@@ -36,11 +36,12 @@ module ActiveRecord
         end
       end
 
-      # Did this attribute change when we last saved? This method can be invoked
-      # as +saved_change_to_name?+ instead of <tt>saved_change_to_attribute?("name")</tt>.
-      # Behaves similarly to +attribute_changed?+. This method is useful in
-      # after callbacks to determine if the call to save changed a certain
-      # attribute.
+      # Did this attribute change when we last saved?
+      #
+      # This method is useful in after callbacks to determine if an attribute
+      # was changed during the save that triggered the callbacks to run. It can
+      # be invoked as +saved_change_to_name?+ instead of
+      # <tt>saved_change_to_attribute?("name")</tt>.
       #
       # ==== Options
       #
@@ -57,19 +58,20 @@ module ActiveRecord
       # attribute was changed, the result will be an array containing the
       # original value and the saved value.
       #
-      # Behaves similarly to +attribute_change+. This method is useful in after
-      # callbacks, to see the change in an attribute that just occurred
-      #
-      # This method can be invoked as +saved_change_to_name+ in instead of
-      # <tt>saved_change_to_attribute("name")</tt>
+      # This method is useful in after callbacks, to see the change in an
+      # attribute during the save that triggered the callbacks to run. It can be
+      # invoked as +saved_change_to_name+ instead of
+      # <tt>saved_change_to_attribute("name")</tt>.
       def saved_change_to_attribute(attr_name)
         mutations_before_last_save.change_to_attribute(attr_name)
       end
 
       # Returns the original value of an attribute before the last save.
-      # Behaves similarly to +attribute_was+. This method is useful in after
-      # callbacks to get the original value of an attribute before the save that
-      # just occurred
+      #
+      # This method is useful in after callbacks to get the original value of an
+      # attribute before the save that triggered the callbacks to run. It can be
+      # invoked as +name_before_last_save+ instead of
+      # <tt>attribute_before_last_save("name")</tt>.
       def attribute_before_last_save(attr_name)
         mutations_before_last_save.original_value(attr_name)
       end
@@ -84,37 +86,73 @@ module ActiveRecord
         mutations_before_last_save.changes
       end
 
-      # Alias for +attribute_changed?+
+      # Will this attribute change the next time we save?
+      #
+      # This method is useful in validations and before callbacks to determine
+      # if the next call to +save+ will change a particular attribute. It can be
+      # invoked as +will_save_change_to_name?+ instead of
+      # <tt>will_save_change_to_attribute("name")</tt>.
+      #
+      # ==== Options
+      #
+      # +from+ When passed, this method will return false unless the original
+      # value is equal to the given option
+      #
+      # +to+ When passed, this method will return false unless the value will be
+      # changed to the given value
       def will_save_change_to_attribute?(attr_name, **options)
         mutations_from_database.changed?(attr_name, **options)
       end
 
-      # Alias for +attribute_change+
+      # Returns the change to an attribute that will be persisted during the
+      # next save.
+      #
+      # This method is useful in validations and before callbacks, to see the
+      # change to an attribute that will occur when the record is saved. It can
+      # be invoked as +name_change_to_be_saved+ instead of
+      # <tt>attribute_change_to_be_saved("name")</tt>.
+      #
+      # If the attribute will change, the result will be an array containing the
+      # original value and the new value about to be saved.
       def attribute_change_to_be_saved(attr_name)
         mutations_from_database.change_to_attribute(attr_name)
       end
 
-      # Alias for +attribute_was+
+      # Returns the value of an attribute in the database, as opposed to the
+      # in-memory value that will be persisted the next time the record is
+      # saved.
+      #
+      # This method is useful in validations and before callbacks, to see the
+      # original value of an attribute prior to any changes about to be
+      # saved. It can be invoked as +name_in_database+ instead of
+      # <tt>attribute_in_database("name")</tt>.
       def attribute_in_database(attr_name)
         mutations_from_database.original_value(attr_name)
       end
 
-      # Alias for +changed?+
+      # Will the next call to +save+ have any changes to persist?
       def has_changes_to_save?
         mutations_from_database.any_changes?
       end
 
-      # Alias for +changes+
+      # Returns a hash containing all the changes that will be persisted during
+      # the next save.
       def changes_to_save
         mutations_from_database.changes
       end
 
-      # Alias for +changed+
+      # Returns an array of the names of any attributes that will change when
+      # the record is next saved.
       def changed_attribute_names_to_save
         mutations_from_database.changed_attribute_names
       end
 
-      # Alias for +changed_attributes+
+      # Returns a hash of the attributes that will change when the record is
+      # next saved.
+      #
+      # The hash keys are the attribute names, and the hash values are the
+      # original attribute values in the database (as opposed to the in-memory
+      # values about to be saved).
       def attributes_in_database
         mutations_from_database.changed_values
       end
@@ -130,20 +168,20 @@ module ActiveRecord
           result
         end
 
-        def _update_record(*)
-          affected_rows = partial_writes? ? super(keys_for_partial_write) : super
+        def _update_record(attribute_names = attribute_names_for_partial_writes)
+          affected_rows = super
           changes_applied
           affected_rows
         end
 
-        def _create_record(*)
-          id = partial_writes? ? super(keys_for_partial_write) : super
+        def _create_record(attribute_names = attribute_names_for_partial_writes)
+          id = super
           changes_applied
           id
         end
 
-        def keys_for_partial_write
-          changed_attribute_names_to_save & self.class.column_names
+        def attribute_names_for_partial_writes
+          partial_writes? ? changed_attribute_names_to_save : attribute_names
         end
     end
   end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -14,38 +14,39 @@ module ActiveRecord
         [key] if key
       end
 
-      # Returns the primary key value.
+      # Returns the primary key column's value.
       def id
         sync_with_transaction_state
         primary_key = self.class.primary_key
         _read_attribute(primary_key) if primary_key
       end
 
-      # Sets the primary key value.
+      # Sets the primary key column's value.
       def id=(value)
         sync_with_transaction_state
         primary_key = self.class.primary_key
         _write_attribute(primary_key, value) if primary_key
       end
 
-      # Queries the primary key value.
+      # Queries the primary key column's value.
       def id?
         sync_with_transaction_state
         query_attribute(self.class.primary_key)
       end
 
-      # Returns the primary key value before type cast.
+      # Returns the primary key column's value before type cast.
       def id_before_type_cast
         sync_with_transaction_state
         read_attribute_before_type_cast(self.class.primary_key)
       end
 
-      # Returns the primary key previous value.
+      # Returns the primary key column's previous value.
       def id_was
         sync_with_transaction_state
         attribute_was(self.class.primary_key)
       end
 
+      # Returns the primary key column's value from the database.
       def id_in_database
         sync_with_transaction_state
         attribute_in_database(self.class.primary_key)
@@ -83,7 +84,7 @@ module ActiveRecord
           end
 
           def reset_primary_key #:nodoc:
-            if self == base_class
+            if base_class?
               self.primary_key = get_primary_key(base_class.name)
             else
               self.primary_key = base_class.primary_key
@@ -131,7 +132,7 @@ module ActiveRecord
             def suppress_composite_primary_key(pk)
               return pk unless pk.is_a?(Array)
 
-              warn <<-WARNING.strip_heredoc
+              warn <<~WARNING
                 WARNING: Active Record does not support composite primary key.
 
                 #{table_name} has composite primary key. Composite primary key is ignored.

data/lib/active_record/attribute_methods/read.rb

@@ -8,42 +8,19 @@ module ActiveRecord
       module ClassMethods # :nodoc:
         private
 
-          # We want to generate the methods via module_eval rather than
-          # define_method, because define_method is slower on dispatch.
-          # Evaluating many similar methods may use more memory as the instruction
-          # sequences are duplicated and cached (in MRI).  define_method may
-          # be slower on dispatch, but if you're careful about the closure
-          # created, then define_method will consume much less memory.
-          #
-          # But sometimes the database might return columns with
-          # characters that are not allowed in normal method names (like
-          # 'my_column(omg)'. So to work around this we first define with
-          # the __temp__ identifier, and then use alias method to rename
-          # it to what we want.
-          #
-          # We are also defining a constant to hold the frozen string of
-          # the attribute name. Using a constant means that we do not have
-          # to allocate an object on each call to the attribute method.
-          # Making it frozen means that it doesn't get duped when used to
-          # key the @attributes in read_attribute.
           def define_method_attribute(name)
-            safe_name = name.unpack("h*".freeze).first
-            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
-            STR
-
-            generated_attribute_methods.module_eval do
-              alias_method name, temp_method
-              undef_method temp_method
+            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
+              generated_attribute_methods, name
+            ) do |temp_method_name, attr_name_expr|
+              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{temp_method_name}
+                  #{sync_with_transaction_state}
+                  name = #{attr_name_expr}
+                  _read_attribute(name) { |n| missing_attribute(n, caller) }
+                end
+              RUBY
             end
           end
       end
@@ -52,30 +29,21 @@ module ActiveRecord
       # it has been typecast (for example, "2004-12-12" in a date column is cast
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name, &block)
-        name = if self.class.attribute_alias?(attr_name)
-          self.class.attribute_alias(attr_name).to_s
-        else
-          attr_name.to_s
+        name = attr_name.to_s
+        if self.class.attribute_alias?(name)
+          name = self.class.attribute_alias(name)
         end
 
         primary_key = self.class.primary_key
-        name = primary_key if name == "id".freeze && primary_key
+        name = primary_key if name == "id" && primary_key
         sync_with_transaction_state if name == primary_key
         _read_attribute(name, &block)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the read_attribute API
-      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:
-          @attributes.fetch_value(attr_name.to_s, &block)
-        end
-      else
-        def _read_attribute(attr_name) # :nodoc:
-          @attributes.fetch_value(attr_name.to_s) { |n| yield n if block_given? }
-        end
+      def _read_attribute(attr_name, &block) # :nodoc
+        @attributes.fetch_value(attr_name.to_s, &block)
       end
 
       alias :attribute :_read_attribute

data/lib/active_record/attribute_methods/serialization.rb

@@ -7,7 +7,7 @@ module ActiveRecord
 
       class ColumnNotSerializableError < StandardError
         def initialize(name, type)
-          super <<-EOS.strip_heredoc
+          super <<~EOS
             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.

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -73,7 +73,7 @@ module ActiveRecord
             # `skip_time_zone_conversion_for_attributes` would not be picked up.
             subclass.class_eval do
               matcher = ->(name, type) { create_time_zone_conversion_attribute?(name, type) }
-              decorate_matching_attribute_types(matcher, :_time_zone_conversion) do |type|
+              decorate_matching_attribute_types(matcher, "_time_zone_conversion") do |type|
                 TimeZoneConverter.new(type)
               end
             end

data/lib/active_record/attribute_methods/write.rb

@@ -13,19 +13,19 @@ module ActiveRecord
         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}
-                #{sync_with_transaction_state}
-                _write_attribute(name, value)
-              end
-              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
-              undef_method :__temp__#{safe_name}=
-            STR
+            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
+              generated_attribute_methods, name, writer: true,
+            ) do |temp_method_name, attr_name_expr|
+              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{temp_method_name}(value)
+                  name = #{attr_name_expr}
+                  #{sync_with_transaction_state}
+                  _write_attribute(name, value)
+                end
+              RUBY
+            end
           end
       end
 
@@ -33,14 +33,13 @@ module ActiveRecord
       # specified +value+. Empty strings for Integer and Float columns are
       # turned into +nil+.
       def write_attribute(attr_name, value)
-        name = if self.class.attribute_alias?(attr_name)
-          self.class.attribute_alias(attr_name).to_s
-        else
-          attr_name.to_s
+        name = attr_name.to_s
+        if self.class.attribute_alias?(name)
+          name = self.class.attribute_alias(name)
         end
 
         primary_key = self.class.primary_key
-        name = primary_key if name == "id".freeze && primary_key
+        name = primary_key if name == "id" && primary_key
         sync_with_transaction_state if name == primary_key
         _write_attribute(name, value)
       end

data/lib/active_record/attribute_methods.rb

@@ -22,16 +22,7 @@ module ActiveRecord
       delegate :column_for_attribute, to: :class
     end
 
-    AttrNames = Module.new {
-      def self.set_name_cache(name, value)
-        const_name = "ATTR_#{name}"
-        unless const_defined? const_name
-          const_set const_name, value.dup.freeze
-        end
-      end
-    }
-
-    BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
+    RESTRICTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
 
     class GeneratedAttributeMethods < Module #:nodoc:
       include Mutex_m
@@ -59,7 +50,7 @@ module ActiveRecord
         # attribute methods.
         generated_attribute_methods.synchronize do
           return false if @attribute_methods_generated
-          superclass.define_attribute_methods unless self == base_class
+          superclass.define_attribute_methods unless base_class?
           super(attribute_names)
           @attribute_methods_generated = true
         end
@@ -123,7 +114,7 @@ module ActiveRecord
       # A class method is 'dangerous' if it is already (re)defined by Active Record, but
       # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
       def dangerous_class_method?(method_name)
-        BLACKLISTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
+        RESTRICTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
       end
 
       def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
@@ -167,12 +158,14 @@ module ActiveRecord
         end
       end
 
-      # Regexp whitelist. Matches the following:
+      # Regexp for column names (with or without a table name prefix). Matches
+      # the following:
       #   "#{table_name}.#{column_name}"
       #   "#{column_name}"
-      COLUMN_NAME_WHITELIST = /\A(?:\w+\.)?\w+\z/i
+      COLUMN_NAME = /\A(?:\w+\.)?\w+\z/i
 
-      # Regexp whitelist. Matches the following:
+      # Regexp for column names with order (with or without a table name
+      # prefix, with or without various order modifiers). Matches the following:
       #   "#{table_name}.#{column_name}"
       #   "#{table_name}.#{column_name} #{direction}"
       #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
@@ -181,7 +174,7 @@ module ActiveRecord
       #   "#{column_name} #{direction}"
       #   "#{column_name} #{direction} NULLS FIRST"
       #   "#{column_name} NULLS LAST"
-      COLUMN_NAME_ORDER_WHITELIST = /
+      COLUMN_NAME_WITH_ORDER = /
         \A
         (?:\w+\.)?
         \w+
@@ -190,12 +183,10 @@ module ActiveRecord
         \z
       /ix
 
-      def enforce_raw_sql_whitelist(args, whitelist: COLUMN_NAME_WHITELIST) # :nodoc:
+      def disallow_raw_sql!(args, permit: COLUMN_NAME) # :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) }
+          Arel.arel_node?(arg) ||
+            arg.to_s.split(/\s*,\s*/).all? { |part| permit.match?(part) }
         end
 
         return if unexpected.none?
@@ -270,21 +261,14 @@ module ActiveRecord
     def respond_to?(name, include_private = false)
       return false unless super
 
-      case name
-      when :to_partial_path
-        name = "to_partial_path".freeze
-      when :to_model
-        name = "to_model".freeze
-      else
-        name = name.to_s
-      end
-
       # If the result is true then check for the select case.
       # For queries selecting a subset of columns, return false for unselected columns.
       # We check defined?(@attributes) not to issue warnings if called on objects that
       # have been allocated but not yet initialized.
-      if defined?(@attributes) && self.class.column_names.include?(name)
-        return has_attribute?(name)
+      if defined?(@attributes)
+        if name = self.class.symbol_column_to_string(name.to_sym)
+          return has_attribute?(name)
+        end
       end
 
       true
@@ -344,15 +328,8 @@ module ActiveRecord
     #   person.attribute_for_inspect(:tag_ids)
     #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
     def attribute_for_inspect(attr_name)
-      value = read_attribute(attr_name)
-
-      if value.is_a?(String) && value.length > 50
-        "#{value[0, 50]}...".inspect
-      elsif value.is_a?(Date) || value.is_a?(Time)
-        %("#{value.to_s(:db)}")
-      else
-        value.inspect
-      end
+      value = _read_attribute(attr_name)
+      format_for_inspect(value)
     end
 
     # Returns +true+ if the specified +attribute+ has been set by the user or by a
@@ -443,23 +420,12 @@ module ActiveRecord
       @attributes.accessed
     end
 
-    protected
-
-      def attribute_method?(attr_name) # :nodoc:
+    private
+      def attribute_method?(attr_name)
         # We check defined? because Syck calls respond_to? before actually calling initialize.
         defined?(@attributes) && @attributes.key?(attr_name)
       end
 
-    private
-
-      def attributes_with_values_for_create(attribute_names)
-        attributes_with_values(attributes_for_create(attribute_names))
-      end
-
-      def attributes_with_values_for_update(attribute_names)
-        attributes_with_values(attributes_for_update(attribute_names))
-      end
-
       def attributes_with_values(attribute_names)
         attribute_names.each_with_object({}) do |name, attrs|
           attrs[name] = _read_attribute(name)
@@ -468,7 +434,8 @@ module ActiveRecord
 
       # Filters the primary keys and readonly attributes from the attribute names.
       def attributes_for_update(attribute_names)
-        attribute_names.reject do |name|
+        attribute_names &= self.class.column_names
+        attribute_names.delete_if do |name|
           readonly_attribute?(name)
         end
       end
@@ -476,11 +443,22 @@ module ActiveRecord
       # Filters out the primary keys, from the attribute names, when the primary
       # key is to be generated (e.g. the id attribute has no value).
       def attributes_for_create(attribute_names)
-        attribute_names.reject do |name|
+        attribute_names &= self.class.column_names
+        attribute_names.delete_if do |name|
           pk_attribute?(name) && id.nil?
         end
       end
 
+      def format_for_inspect(value)
+        if value.is_a?(String) && value.length > 50
+          "#{value[0, 50]}...".inspect
+        elsif value.is_a?(Date) || value.is_a?(Time)
+          %("#{value.to_s(:db)}")
+        else
+          value.inspect
+        end
+      end
+
       def readonly_attribute?(name)
         self.class.readonly_attributes.include?(name)
       end

data/lib/active_record/autosave_association.rb

@@ -149,7 +149,7 @@ module ActiveRecord
       private
 
         def define_non_cyclic_method(name, &block)
-          return if method_defined?(name)
+          return if instance_methods(false).include?(name)
           define_method(name) do |*args|
             result = true; @_already_called ||= {}
             # Loop prevention for validation of associations
@@ -272,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 || custom_validation_context?
+        if new_record
           association && association.target
         elsif autosave
           association.target.find_all(&:changed_for_autosave?)
@@ -304,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 && (record.changed_for_autosave? || custom_validation_context?)
+        association_valid?(reflection, record) if record
       end
 
       # Validate the associated records if <tt>:validate</tt> or
@@ -324,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 if custom_validation_context?
+        context = validation_context unless [:create, :update].include?(validation_context)
 
         unless valid = record.valid?(context)
           if reflection.options[:autosave]
@@ -382,14 +382,10 @@ 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 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) }
@@ -401,7 +397,7 @@ 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)
                 elsif !reflection.nested?
@@ -461,16 +457,10 @@ module ActiveRecord
       # If the record is new or it has changed, returns true.
       def record_changed?(reflection, record, key)
         record.new_record? ||
-          association_foreign_key_changed?(reflection, record, key) ||
+          (record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != 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.
@@ -499,10 +489,6 @@ 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!