activerecord 5.1.0 → 5.2.0.rc1

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require "active_support/core_ext/module/attribute_accessors"
-require "active_record/attribute_mutation_tracker"
 
 module ActiveRecord
   module AttributeMethods
-    module Dirty # :nodoc:
+    module Dirty
       extend ActiveSupport::Concern
 
       include ActiveModel::Dirty
@@ -14,11 +14,10 @@ module ActiveRecord
           raise "You cannot include Dirty after Timestamp"
         end
 
-        class_attribute :partial_writes, instance_writer: false
-        self.partial_writes = true
+        class_attribute :partial_writes, instance_writer: false, default: true
 
-        after_create { changes_internally_applied }
-        after_update { changes_internally_applied }
+        after_create { changes_applied }
+        after_update { changes_applied }
 
         # Attribute methods for "changed in last call to save?"
         attribute_method_affix(prefix: "saved_change_to_", suffix: "?")
@@ -30,106 +29,16 @@ module ActiveRecord
         attribute_method_suffix("_change_to_be_saved", "_in_database")
       end
 
-      # Attempts to +save+ the record and clears changed attributes if successful.
-      def save(*)
-        if status = super
-          changes_applied
-        end
-        status
-      end
-
-      # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
-      def save!(*)
-        super.tap do
-          changes_applied
-        end
-      end
-
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          @previous_mutation_tracker = nil
-          clear_mutation_trackers
-          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        end
-      end
-
-      def initialize_dup(other) # :nodoc:
-        super
-        @attributes = self.class._default_attributes.map do |attr|
-          attr.with_value_from_user(@attributes.fetch_value(attr.name))
-        end
-        clear_mutation_trackers
-      end
-
-      def changes_internally_applied # :nodoc:
-        @mutations_before_last_save = mutation_tracker
-        forget_attribute_assignments
-        @mutations_from_database = AttributeMutationTracker.new(@attributes)
-      end
-
-      def changes_applied
-        @previous_mutation_tracker = mutation_tracker
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        clear_mutation_trackers
-      end
-
-      def clear_changes_information
-        @previous_mutation_tracker = nil
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        forget_attribute_assignments
-        clear_mutation_trackers
-      end
-
-      def raw_write_attribute(attr_name, *)
-        result = super
-        clear_attribute_change(attr_name)
-        result
-      end
-
-      def clear_attribute_changes(attr_names)
-        super
-        attr_names.each do |attr_name|
-          clear_attribute_change(attr_name)
-        end
-      end
-
-      def changed_attributes
-        # This should only be set by methods which will call changed_attributes
-        # multiple times when it is known that the computed value cannot change.
-        if defined?(@cached_changed_attributes)
-          @cached_changed_attributes
-        else
-          emit_warning_if_needed("changed_attributes", "saved_changes.transform_values(&:first)")
-          super.reverse_merge(mutation_tracker.changed_values).freeze
-        end
-      end
-
-      def changes
-        cache_changed_attributes do
-          emit_warning_if_needed("changes", "saved_changes")
-          super
-        end
-      end
-
-      def previous_changes
-        unless previous_mutation_tracker.equal?(mutations_before_last_save)
-          ActiveSupport::Deprecation.warn(<<-EOW.strip_heredoc)
-            The behavior of `previous_changes` inside of after callbacks is
-            deprecated without replacement. In the next release of Rails,
-            this method inside of `after_save` will return the changes that
-            were just saved.
-          EOW
+          @mutations_before_last_save = nil
+          @mutations_from_database = nil
         end
-        previous_mutation_tracker.changes
-      end
-
-      def attribute_changed_in_place?(attr_name)
-        mutation_tracker.changed_in_place?(attr_name)
       end
 
       # Did this attribute change when we last saved? This method can be invoked
-      # as `saved_change_to_name?` instead of `saved_change_to_attribute?("name")`.
+      # 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.
@@ -152,8 +61,8 @@ module ActiveRecord
       # 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
-      # `saved_change_to_attribute("name")`
+      # This method can be invoked as +saved_change_to_name+ in 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
@@ -166,7 +75,7 @@ module ActiveRecord
         mutations_before_last_save.original_value(attr_name)
       end
 
-      # Did the last call to `save` have any changes to change?
+      # Did the last call to +save+ have any changes to change?
       def saved_changes?
         mutations_before_last_save.any_changes?
       end
@@ -176,116 +85,46 @@ module ActiveRecord
         mutations_before_last_save.changes
       end
 
-      # Alias for `attribute_changed?`
+      # Alias for +attribute_changed?+
       def will_save_change_to_attribute?(attr_name, **options)
         mutations_from_database.changed?(attr_name, **options)
       end
 
-      # Alias for `attribute_change`
+      # Alias for +attribute_change+
       def attribute_change_to_be_saved(attr_name)
         mutations_from_database.change_to_attribute(attr_name)
       end
 
-      # Alias for `attribute_was`
+      # Alias for +attribute_was+
       def attribute_in_database(attr_name)
         mutations_from_database.original_value(attr_name)
       end
 
-      # Alias for `changed?`
+      # Alias for +changed?+
       def has_changes_to_save?
         mutations_from_database.any_changes?
       end
 
-      # Alias for `changes`
+      # Alias for +changes+
       def changes_to_save
         mutations_from_database.changes
       end
 
-      # Alias for `changed`
+      # Alias for +changed+
       def changed_attribute_names_to_save
-        changes_to_save.keys
+        mutations_from_database.changed_attribute_names
       end
 
-      # Alias for `changed_attributes`
+      # Alias for +changed_attributes+
       def attributes_in_database
-        changes_to_save.transform_values(&:first)
-      end
-
-      def attribute_was(*)
-        emit_warning_if_needed("attribute_was", "attribute_before_last_save")
-        super
-      end
-
-      def attribute_change(*)
-        emit_warning_if_needed("attribute_change", "saved_change_to_attribute")
-        super
-      end
-
-      def attribute_changed?(*)
-        emit_warning_if_needed("attribute_changed?", "saved_change_to_attribute?")
-        super
-      end
-
-      def changed?(*)
-        emit_warning_if_needed("changed?", "saved_changes?")
-        super
-      end
-
-      def changed(*)
-        emit_warning_if_needed("changed", "saved_changes.keys")
-        super
+        mutations_from_database.changed_values
       end
 
       private
-
-        def mutation_tracker
-          unless defined?(@mutation_tracker)
-            @mutation_tracker = nil
-          end
-          @mutation_tracker ||= AttributeMutationTracker.new(@attributes)
-        end
-
-        def emit_warning_if_needed(method_name, new_method_name)
-          unless mutation_tracker.equal?(mutations_from_database)
-            ActiveSupport::Deprecation.warn(<<-EOW.squish)
-              The behavior of `#{method_name}` inside of after callbacks will
-              be changing in the next version of Rails. The new return value will reflect the
-              behavior of calling the method after `save` returned (e.g. the opposite of what
-              it returns now). To maintain the current behavior, use `#{new_method_name}`
-              instead.
-            EOW
-          end
-        end
-
-        def mutations_from_database
-          unless defined?(@mutations_from_database)
-            @mutations_from_database = nil
-          end
-          @mutations_from_database ||= mutation_tracker
-        end
-
-        def changes_include?(attr_name)
-          super || mutation_tracker.changed?(attr_name)
-        end
-
-        def clear_attribute_change(attr_name)
-          mutation_tracker.forget_change(attr_name)
-          mutations_from_database.forget_change(attr_name)
-        end
-
-        def attribute_will_change!(attr_name)
-          super
-          if self.class.has_attribute?(attr_name)
-            mutations_from_database.force_change(attr_name)
-          else
-            ActiveSupport::Deprecation.warn(<<-EOW.squish)
-              #{attr_name} is not an attribute known to Active Record.
-              This behavior is deprecated and will be removed in the next
-              version of Rails. If you'd like #{attr_name} to be managed
-              by Active Record, add `attribute :#{attr_name} to your class.
-            EOW
-            mutations_from_database.deprecated_force_change(attr_name)
-          end
+        def write_attribute_without_type_cast(attr_name, _)
+          result = super
+          clear_attribute_change(attr_name)
+          result
         end
 
         def _update_record(*)
@@ -299,35 +138,6 @@ module ActiveRecord
         def keys_for_partial_write
           changed_attribute_names_to_save & self.class.column_names
         end
-
-        def forget_attribute_assignments
-          @attributes = @attributes.map(&:forgetting_assignment)
-        end
-
-        def clear_mutation_trackers
-          @mutation_tracker = nil
-          @mutations_from_database = nil
-          @mutations_before_last_save = nil
-        end
-
-        def previous_mutation_tracker
-          @previous_mutation_tracker ||= NullMutationTracker.instance
-        end
-
-        def mutations_before_last_save
-          @mutations_before_last_save ||= previous_mutation_tracker
-        end
-
-        def cache_changed_attributes
-          @cached_changed_attributes = changed_attributes
-          yield
-        ensure
-          clear_changed_attributes_cache
-        end
-
-        def clear_changed_attributes_cache
-          remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
-        end
     end
   end
 end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 
 module ActiveRecord
@@ -8,23 +10,22 @@ module ActiveRecord
       # Returns this record's primary key value wrapped in an array if one is
       # available.
       def to_key
-        sync_with_transaction_state
         key = id
         [key] if key
       end
 
       # Returns the primary key value.
       def id
-        if pk = self.class.primary_key
-          sync_with_transaction_state
-          _read_attribute(pk)
-        end
+        sync_with_transaction_state
+        primary_key = self.class.primary_key
+        _read_attribute(primary_key) if primary_key
       end
 
       # Sets the primary key value.
       def id=(value)
         sync_with_transaction_state
-        write_attribute(self.class.primary_key, value) if self.class.primary_key
+        primary_key = self.class.primary_key
+        _write_attribute(primary_key, value) if primary_key
       end
 
       # Queries the primary key value.
@@ -57,16 +58,12 @@ module ActiveRecord
         end
 
         module ClassMethods
-          def define_method_attribute(attr_name)
-            super
+          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database).to_set
 
-            if attr_name == primary_key && attr_name != "id"
-              generated_attribute_methods.send(:alias_method, :id, primary_key)
-            end
+          def instance_method_already_implemented?(method_name)
+            super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
           end
 
-          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database).to_set
-
           def dangerous_attribute_method?(method_name)
             super && !ID_ATTRIBUTE_METHODS.include?(method_name)
           end

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
 

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,30 +39,29 @@ module ActiveRecord
           attr_name.to_s
         end
 
-        write_attribute_with_type_cast(name, value, true)
+        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:
-        write_attribute_with_type_cast(attr_name, value, false)
+      # 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
-        # Handle *= for method_missing.
-        def attribute=(attribute_name, value)
-          write_attribute(attribute_name, value)
+        def write_attribute_without_type_cast(attr_name, value)
+          name = attr_name.to_s
+          @attributes.write_cast_value(name, value)
+          value
         end
 
-        def write_attribute_with_type_cast(attr_name, value, should_type_cast)
-          attr_name = attr_name.to_s
-          attr_name = self.class.primary_key if attr_name == "id" && self.class.primary_key
-
-          if should_type_cast
-            @attributes.write_from_user(attr_name, value)
-          else
-            @attributes.write_cast_value(attr_name, value)
-          end
-
-          value
+        # Handle *= for method_missing.
+        def 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,46 @@ 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}"
+      #   "#{column_name}"
+      #   "#{column_name} #{direction}"
+      COLUMN_NAME_ORDER_WHITELIST = /\A(?:\w+\.)?\w+(?:\s+asc|\s+desc)?\z/i
+
+      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 +276,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+.
@@ -416,7 +456,7 @@ module ActiveRecord
         arel_table = self.class.arel_table
 
         attribute_names.each do |name|
-          attrs[arel_table[name]] = typecasted_attribute_value(name)
+          attrs[arel_table[name]] = _read_attribute(name)
         end
         attrs
       end
@@ -443,9 +483,5 @@ module ActiveRecord
       def pk_attribute?(name)
         name == self.class.primary_key
       end
-
-      def typecasted_attribute_value(name)
-        _read_attribute(name)
-      end
   end
 end