activerecord 6.0.1 → 6.1.0

data/lib/active_record/attribute_methods/read.rb

@@ -7,17 +7,14 @@ module ActiveRecord
 
       module ClassMethods # :nodoc:
         private
-
-          def define_method_attribute(name)
+          def define_method_attribute(name, owner:)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              generated_attribute_methods, name
+              owner, name
             ) do |temp_method_name, attr_name_expr|
-              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{temp_method_name}
-                  name = #{attr_name_expr}
-                  _read_attribute(name) { |n| missing_attribute(n, caller) }
-                end
-              RUBY
+              owner <<
+                "def #{temp_method_name}" <<
+                "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<
+                "end"
             end
           end
       end
@@ -30,14 +27,13 @@ module ActiveRecord
         name = self.class.attribute_aliases[name] || name
 
         name = @primary_key if name == "id" && @primary_key
-        _read_attribute(name, &block)
+        @attributes.fetch_value(name, &block)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the read_attribute API
       def _read_attribute(attr_name, &block) # :nodoc
-        sync_with_transaction_state if @transaction_state&.finalized?
-        @attributes.fetch_value(attr_name.to_s, &block)
+        @attributes.fetch_value(attr_name, &block)
       end
 
       alias :attribute :_read_attribute

data/lib/active_record/attribute_methods/serialization.rb

@@ -41,6 +41,12 @@ module ActiveRecord
         # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
         #   or a class name that the object type should be equal to.
         #
+        # ==== Options
+        #
+        # +default+ The default value to use when no value is provided. If this option
+        # is not passed, the previous default value (if any) will be used.
+        # Otherwise, the default will be +nil+.
+        #
         # ==== Example
         #
         #   # Serialize a preferences attribute.
@@ -57,7 +63,7 @@ module ActiveRecord
         #   class User < ActiveRecord::Base
         #     serialize :preferences, Hash
         #   end
-        def serialize(attr_name, class_name_or_coder = Object)
+        def serialize(attr_name, class_name_or_coder = Object, **options)
           # When ::JSON is used, force it to go through the Active Support JSON encoder
           # to ensure special objects (e.g. Active Record models) are dumped correctly
           # using the #as_json hook.
@@ -69,17 +75,16 @@ module ActiveRecord
             Coders::YAMLColumn.new(attr_name, class_name_or_coder)
           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)
+          decorate_attribute_type(attr_name.to_s, **options) do |cast_type|
+            if type_incompatible_with_serialize?(cast_type, class_name_or_coder)
+              raise ColumnNotSerializableError.new(attr_name, cast_type)
             end
 
-            Type::Serialized.new(type, coder)
+            Type::Serialized.new(cast_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

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/try"
+
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
       class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
+        def self.new(subtype)
+          self === subtype ? subtype : super
+        end
+
         def deserialize(value)
           convert_time_to_time_zone(super)
         end
@@ -25,7 +31,6 @@ module ActiveRecord
         end
 
         private
-
           def convert_time_to_time_zone(value)
             return if value.nil?
 
@@ -63,22 +68,14 @@ module ActiveRecord
       end
 
       module ClassMethods # :nodoc:
-        private
-
-          def inherited(subclass)
-            super
-            # We need to apply this decorator here, rather than on module inclusion. The closure
-            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
-            # sub class being decorated. As such, changes to `time_zone_aware_attributes`, or
-            # `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|
-                TimeZoneConverter.new(type)
-              end
-            end
+        def define_attribute(name, cast_type, **)
+          if create_time_zone_conversion_attribute?(name, cast_type)
+            cast_type = TimeZoneConverter.new(cast_type)
           end
+          super
+        end
 
+        private
           def create_time_zone_conversion_attribute?(name, cast_type)
             enabled_for_column = time_zone_aware_attributes &&
               !skip_time_zone_conversion_for_attributes.include?(name.to_sym)

data/lib/active_record/attribute_methods/write.rb

@@ -11,17 +11,14 @@ module ActiveRecord
 
       module ClassMethods # :nodoc:
         private
-
-          def define_method_attribute=(name)
+          def define_method_attribute=(name, owner:)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              generated_attribute_methods, name, writer: true,
+              owner, 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}
-                  _write_attribute(name, value)
-                end
-              RUBY
+              owner <<
+                "def #{temp_method_name}(value)" <<
+                "  _write_attribute(#{attr_name_expr}, value)" <<
+                "end"
             end
           end
       end
@@ -34,27 +31,21 @@ module ActiveRecord
         name = self.class.attribute_aliases[name] || name
 
         name = @primary_key if name == "id" && @primary_key
-        _write_attribute(name, value)
+        @attributes.write_from_user(name, value)
       end
 
       # 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:
-        sync_with_transaction_state if @transaction_state&.finalized?
-        @attributes.write_from_user(attr_name.to_s, value)
-        value
+        @attributes.write_from_user(attr_name, value)
       end
 
+      alias :attribute= :_write_attribute
+      private :attribute=
+
       private
         def write_attribute_without_type_cast(attr_name, value)
-          sync_with_transaction_state if @transaction_state&.finalized?
-          @attributes.write_cast_value(attr_name.to_s, value)
-          value
-        end
-
-        # Dispatch target for <tt>*=</tt> attribute methods.
-        def attribute=(attribute_name, value)
-          _write_attribute(attribute_name, value)
+          @attributes.write_cast_value(attr_name, value)
         end
     end
   end

data/lib/active_record/attribute_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "mutex_m"
+require "active_support/core_ext/enumerable"
 
 module ActiveRecord
   # = Active Record Attribute Methods
@@ -18,8 +19,6 @@ module ActiveRecord
       include TimeZoneConversion
       include Dirty
       include Serialization
-
-      delegate :column_for_attribute, to: :class
     end
 
     RESTRICTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
@@ -28,6 +27,17 @@ module ActiveRecord
       include Mutex_m
     end
 
+    class << self
+      def dangerous_attribute_methods # :nodoc:
+        @dangerous_attribute_methods ||= (
+          Base.instance_methods +
+          Base.private_instance_methods -
+          Base.superclass.instance_methods -
+          Base.superclass.private_instance_methods
+        ).map { |m| -m.to_s }.to_set.freeze
+      end
+    end
+
     module ClassMethods
       def inherited(child_class) #:nodoc:
         child_class.initialize_generated_modules
@@ -97,7 +107,7 @@ module ActiveRecord
       # A method name is 'dangerous' if it is already (re)defined by Active Record, but
       # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
       def dangerous_attribute_method?(name) # :nodoc:
-        method_defined_within?(name, Base)
+        ::ActiveRecord::AttributeMethods.dangerous_attribute_methods.include?(name.to_s)
       end
 
       def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
@@ -115,13 +125,11 @@ 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)
-        RESTRICTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
-      end
+        return true if RESTRICTED_CLASS_METHODS.include?(method_name.to_s)
 
-      def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
-        if klass.respond_to?(name, true)
-          if superklass.respond_to?(name, true)
-            klass.method(name).owner != superklass.method(name).owner
+        if Base.respond_to?(method_name, true)
+          if Object.respond_to?(method_name, true)
+            Base.method(method_name).owner != Object.method(method_name).owner
           else
             true
           end
@@ -140,7 +148,7 @@ module ActiveRecord
       #   Person.attribute_method?(:age=)    # => true
       #   Person.attribute_method?(:nothing) # => false
       def attribute_method?(attribute)
-        super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, "")))
+        super || (table_exists? && column_names.include?(attribute.to_s.delete_suffix("=")))
       end
 
       # Returns an array of column names as strings if it's not an abstract class and
@@ -156,39 +164,27 @@ module ActiveRecord
           attribute_types.keys
         else
           []
-        end
+        end.freeze
       end
 
       # Returns true if the given attribute exists, otherwise false.
       #
       #   class Person < ActiveRecord::Base
+      #     alias_attribute :new_name, :name
       #   end
       #
-      #   Person.has_attribute?('name')   # => true
-      #   Person.has_attribute?(:age)     # => true
-      #   Person.has_attribute?(:nothing) # => false
+      #   Person.has_attribute?('name')     # => true
+      #   Person.has_attribute?('new_name') # => true
+      #   Person.has_attribute?(:age)       # => true
+      #   Person.has_attribute?(:nothing)   # => false
       def has_attribute?(attr_name)
-        attribute_types.key?(attr_name.to_s)
+        attr_name = attr_name.to_s
+        attr_name = attribute_aliases[attr_name] || attr_name
+        attribute_types.key?(attr_name)
       end
 
-      # Returns the column object for the named attribute.
-      # Returns a +ActiveRecord::ConnectionAdapters::NullColumn+ if the
-      # named attribute does not exist.
-      #
-      #   class Person < ActiveRecord::Base
-      #   end
-      #
-      #   person = Person.new
-      #   person.column_for_attribute(:name) # the result depends on the ConnectionAdapter
-      #   # => #<ActiveRecord::ConnectionAdapters::Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
-      #
-      #   person.column_for_attribute(:nothing)
-      #   # => #<ActiveRecord::ConnectionAdapters::NullColumn:0xXXX @name=nil, @sql_type=nil, @cast_type=#<Type::Value>, ...>
-      def column_for_attribute(name)
-        name = name.to_s
-        columns_hash.fetch(name) do
-          ConnectionAdapters::NullColumn.new(name)
-        end
+      def _has_attribute?(attr_name) # :nodoc:
+        attribute_types.key?(attr_name)
       end
     end
 
@@ -217,7 +213,7 @@ module ActiveRecord
       # have been allocated but not yet initialized.
       if defined?(@attributes)
         if name = self.class.symbol_column_to_string(name.to_sym)
-          return has_attribute?(name)
+          return _has_attribute?(name)
         end
       end
 
@@ -227,14 +223,22 @@ module ActiveRecord
     # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
     #
     #   class Person < ActiveRecord::Base
+    #     alias_attribute :new_name, :name
     #   end
     #
     #   person = Person.new
-    #   person.has_attribute?(:name)    # => true
-    #   person.has_attribute?('age')    # => true
-    #   person.has_attribute?(:nothing) # => false
+    #   person.has_attribute?(:name)     # => true
+    #   person.has_attribute?(:new_name) # => true
+    #   person.has_attribute?('age')     # => true
+    #   person.has_attribute?(:nothing)  # => false
     def has_attribute?(attr_name)
-      @attributes.key?(attr_name.to_s)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      @attributes.key?(attr_name)
+    end
+
+    def _has_attribute?(attr_name) # :nodoc:
+      @attributes.key?(attr_name)
     end
 
     # Returns an array of names for the attributes available on this object.
@@ -278,8 +282,10 @@ 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)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
       value = _read_attribute(attr_name)
-      format_for_inspect(value)
+      format_for_inspect(attr_name, value)
     end
 
     # Returns +true+ if the specified +attribute+ has been set by the user or by a
@@ -297,8 +303,10 @@ module ActiveRecord
     #   task.is_done = true
     #   task.attribute_present?(:title)   # => true
     #   task.attribute_present?(:is_done) # => true
-    def attribute_present?(attribute)
-      value = _read_attribute(attribute)
+    def attribute_present?(attr_name)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      value = _read_attribute(attr_name)
       !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
     end
 
@@ -377,8 +385,8 @@ module ActiveRecord
       end
 
       def attributes_with_values(attribute_names)
-        attribute_names.each_with_object({}) do |name, attrs|
-          attrs[name] = _read_attribute(name)
+        attribute_names.index_with do |name|
+          _read_attribute(name)
         end
       end
 
@@ -386,7 +394,7 @@ module ActiveRecord
       def attributes_for_update(attribute_names)
         attribute_names &= self.class.column_names
         attribute_names.delete_if do |name|
-          readonly_attribute?(name)
+          self.class.readonly_attribute?(name)
         end
       end
 
@@ -399,18 +407,20 @@ module ActiveRecord
         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
+      def format_for_inspect(name, value)
+        if value.nil?
           value.inspect
-        end
-      end
+        else
+          inspected_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(:inspect)}")
+          else
+            value.inspect
+          end
 
-      def readonly_attribute?(name)
-        self.class.readonly_attributes.include?(name)
+          inspection_filter.filter_param(name, inspected_value)
+        end
       end
 
       def pk_attribute?(name)

data/lib/active_record/attributes.rb

@@ -12,6 +12,9 @@ module ActiveRecord
     end
 
     module ClassMethods
+      ##
+      # :call-seq: attribute(name, cast_type = nil, **options)
+      #
       # Defines an attribute with a type on this model. It will override the
       # type of existing attributes if needed. This allows control over how
       # values are converted to and from SQL when assigned to a model. It also
@@ -205,13 +208,13 @@ module ActiveRecord
       # tracking is performed. The methods +changed?+ and +changed_in_place?+
       # will be called from ActiveModel::Dirty. See the documentation for those
       # methods in ActiveModel::Type::Value for more details.
-      def attribute(name, cast_type = Type::Value.new, **options)
+      def attribute(name, cast_type = nil, **options, &block)
         name = name.to_s
         reload_schema_from_cache
 
         self.attributes_to_define_after_schema_loads =
           attributes_to_define_after_schema_loads.merge(
-            name => [cast_type, options]
+            name => [cast_type || block, options]
           )
       end
 
@@ -246,16 +249,11 @@ module ActiveRecord
       def load_schema! # :nodoc:
         super
         attributes_to_define_after_schema_loads.each do |name, (type, options)|
-          if type.is_a?(Symbol)
-            type = ActiveRecord::Type.lookup(type, **options.except(:default))
-          end
-
-          define_attribute(name, type, **options.slice(:default))
+          define_attribute(name, _lookup_cast_type(name, type, options), **options.slice(:default))
         end
       end
 
       private
-
         NO_DEFAULT_PROVIDED = Object.new # :nodoc:
         private_constant :NO_DEFAULT_PROVIDED
 
@@ -274,6 +272,32 @@ module ActiveRecord
           end
           _default_attributes[name] = default_attribute
         end
+
+        def decorate_attribute_type(attr_name, **default)
+          type, options = attributes_to_define_after_schema_loads[attr_name]
+
+          default.with_defaults!(default: options[:default]) if options&.key?(:default)
+
+          attribute(attr_name, **default) do |cast_type|
+            if type && !type.is_a?(Proc)
+              cast_type = _lookup_cast_type(attr_name, type, options)
+            end
+
+            yield cast_type
+          end
+        end
+
+        def _lookup_cast_type(name, type, options)
+          case type
+          when Symbol
+            adapter_name = ActiveRecord::Type.adapter_name_from(self)
+            ActiveRecord::Type.lookup(type, **options.except(:default), adapter: adapter_name)
+          when Proc
+            type[type_for_attribute(name)]
+          else
+            type || type_for_attribute(name)
+          end
+        end
     end
   end
 end