activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/attribute_methods/read.rb

@@ -1,136 +1,85 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Read
       extend ActiveSupport::Concern
 
-      ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
-
-      included do
-        cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
-        self.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
-      end
-
-      module ClassMethods
-        # +cache_attributes+ allows you to declare which converted attribute values should
-        # be cached. Usually caching only pays off for attributes with expensive conversion
-        # methods, like time related columns (e.g. +created_at+, +updated_at+).
-        def cache_attributes(*attribute_names)
-          cached_attributes.merge attribute_names.map { |attr| attr.to_s }
-        end
-
-        # Returns the attributes which are cached. By default time related columns
-        # with datatype <tt>:datetime, :timestamp, :time, :date</tt> are cached.
-        def cached_attributes
-          @cached_attributes ||= columns.select { |c| cacheable_column?(c) }.map { |col| col.name }.to_set
-        end
-
-        # Returns +true+ if the provided attribute is being cached.
-        def cache_attribute?(attr_name)
-          cached_attributes.include?(attr_name)
-        end
-
-        def undefine_attribute_methods
-          generated_external_attribute_methods.module_eval do
-            instance_methods.each { |m| undef_method(m) }
-          end
-
-          super
-        end
-
-        def type_cast_attribute(attr_name, attributes, cache = {}) #:nodoc:
-          return unless attr_name
-          attr_name = attr_name.to_s
-
-          if generated_external_attribute_methods.method_defined?(attr_name)
-            if attributes.has_key?(attr_name) || attr_name == 'id'
-              generated_external_attribute_methods.send(attr_name, attributes[attr_name], attributes, cache, attr_name)
-            end
-          elsif !attribute_methods_generated?
-            # If we haven't generated the caster methods yet, do that and
-            # then try again
-            define_attribute_methods
-            type_cast_attribute(attr_name, attributes, cache)
-          else
-            # If we get here, the attribute has no associated DB column, so
-            # just return it verbatim.
-            attributes[attr_name]
-          end
-        end
+      module ClassMethods # :nodoc:
+        private
 
-        protected
-          # We want to generate the methods via module_eval rather than define_method,
-          # because define_method is slower on dispatch and uses more memory (because it
-          # creates a closure).
+          # 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.
-          def define_method_attribute(attr_name)
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__
-                #{internal_attribute_access_code(attr_name, attribute_cast_code(attr_name))}
-              end
-              alias_method '#{attr_name}', :__temp__
-              undef_method :__temp__
-            STR
-          end
-
-        private
+          # 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
 
-          def define_external_attribute_method(attr_name)
-            generated_external_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__(v, attributes, attributes_cache, attr_name)
-                #{external_attribute_access_code(attr_name, attribute_cast_code(attr_name))}
+            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
-              alias_method '#{attr_name}', :__temp__
-              undef_method :__temp__
             STR
-          end
-
-          def cacheable_column?(column)
-            attribute_types_cached_by_default.include?(column.type)
-          end
-
-          def internal_attribute_access_code(attr_name, cast_code)
-            access_code = "(v=@attributes[attr_name]) && #{cast_code}"
-
-            unless attr_name == primary_key
-              access_code.insert(0, "missing_attribute(attr_name, caller) unless @attributes.has_key?(attr_name); ")
-            end
 
-            if cache_attribute?(attr_name)
-              access_code = "@attributes_cache[attr_name] ||= (#{access_code})"
+            generated_attribute_methods.module_eval do
+              alias_method name, temp_method
+              undef_method temp_method
             end
-
-            "attr_name = '#{attr_name}'; #{access_code}"
           end
+      end
 
-          def external_attribute_access_code(attr_name, cast_code)
-            access_code = "v && #{cast_code}"
-
-            if cache_attribute?(attr_name)
-              access_code = "attributes_cache[attr_name] ||= (#{access_code})"
-            end
-
-            access_code
-          end
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after
+      # 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
+        end
 
-          def attribute_cast_code(attr_name)
-            columns_hash[attr_name].type_cast_code('v')
-          end
+        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
 
-      # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
-      # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
-      def read_attribute(attr_name)
-        self.class.type_cast_attribute(attr_name, @attributes, @attributes_cache)
+      # 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
       end
 
-      private
-        def attribute(attribute_name)
-          read_attribute(attribute_name)
-        end
+      alias :attribute :_read_attribute
+      private :attribute
     end
   end
 end

data/lib/active_record/attribute_methods/serialization.rb

@@ -1,119 +1,89 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Serialization
       extend ActiveSupport::Concern
 
-      included do
-        # Returns a hash of all the attributes that have been specified for serialization as
-        # keys and their class restriction as values.
-        class_attribute :serialized_attributes
-        self.serialized_attributes = {}
-      end
-
-      class Attribute < Struct.new(:coder, :value, :state)
-        def unserialized_value
-          state == :serialized ? unserialize : value
-        end
-
-        def serialized_value
-          state == :unserialized ? serialize : value
-        end
-
-        def unserialize
-          self.state = :unserialized
-          self.value = coder.load(value)
-        end
-
-        def serialize
-          self.state = :serialized
-          self.value = coder.dump(value)
+      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 attribute using this method and it will be handled automatically.
-        # The serialization is done through YAML. If +class_name+ is specified, the serialized object must be of that
-        # class on retrieval or SerializationTypeMismatch will be raised.
+        # 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
+        # attribute using this method and it will be handled automatically. The
+        # serialization is done through YAML. If +class_name+ is specified, the
+        # serialized object must be of that class on assignment and retrieval.
+        # Otherwise SerializationTypeMismatch will be raised.
+        #
+        # Empty objects as <tt>{}</tt>, in the case of +Hash+, or <tt>[]</tt>, in the case of
+        # +Array+, will always be persisted as null.
+        #
+        # Keep in mind that database adapters handle certain serialization tasks
+        # for you. For instance: +json+ and +jsonb+ types in PostgreSQL will be
+        # converted between JSON object/array syntax and Ruby +Hash+ or +Array+
+        # objects transparently. There is no need to use #serialize in this
+        # case.
+        #
+        # For more complex cases, such as conversion to or from your application
+        # domain objects, consider using the ActiveRecord::Attributes API.
         #
         # ==== Parameters
         #
         # * +attr_name+ - The field name that should be serialized.
-        # * +class_name+ - Optional, class name that the object type should be equal to.
+        # * +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.
         #
         # ==== Example
-        #   # Serialize a preferences attribute
+        #
+        #   # Serialize a preferences attribute.
         #   class User < ActiveRecord::Base
         #     serialize :preferences
         #   end
-        def serialize(attr_name, class_name = Object)
-          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
-                    class_name
-                  else
-                    Coders::YAMLColumn.new(class_name)
-                  end
-
-          # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy
-          # has its own hash of own serialized attributes
-          self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
-        end
-
-        def initialize_attributes(attributes, options = {}) #:nodoc:
-          serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
-          super(attributes, options)
-
-          serialized_attributes.each do |key, coder|
-            if attributes.key?(key)
-              attributes[key] = Attribute.new(coder, attributes[key], serialized)
-            end
-          end
-
-          attributes
-        end
-
-        private
-
-        def attribute_cast_code(attr_name)
-          if serialized_attributes.include?(attr_name)
-            "v.unserialized_value"
+        #
+        #   # Serialize preferences using JSON as coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, JSON
+        #   end
+        #
+        #   # Serialize preferences as Hash using YAML coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, Hash
+        #   end
+        def serialize(attr_name, class_name_or_coder = Object)
+          # 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.
+          coder = if class_name_or_coder == ::JSON
+            Coders::JSON
+          elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+            class_name_or_coder
           else
-            super
+            Coders::YAMLColumn.new(attr_name, class_name_or_coder)
           end
-        end
-      end
 
-      def type_cast_attribute_for_write(column, value)
-        if column && coder = self.class.serialized_attributes[column.name]
-          Attribute.new(coder, value, :unserialized)
-        else
-          super
-        end
-      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
 
-      def _field_changed?(attr, old, value)
-        if self.class.serialized_attributes.include?(attr)
-          old != value
-        else
-          super
+            Type::Serialized.new(type, coder)
+          end
         end
-      end
 
-      def read_attribute_before_type_cast(attr_name)
-        if serialized_attributes.include?(attr_name)
-          super.unserialized_value
-        else
-          super
-        end
-      end
+        private
 
-      def attributes_before_type_cast
-        super.dup.tap do |attributes|
-          self.class.serialized_attributes.each_key do |key|
-            if attributes.key?(key)
-              attributes[key] = attributes[key].unserialized_value
-            end
+          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
   end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,63 +1,89 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/inclusion'
+# frozen_string_literal: true
 
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
-      extend ActiveSupport::Concern
+      class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
+        def deserialize(value)
+          convert_time_to_time_zone(super)
+        end
 
-      included do
-        cattr_accessor :time_zone_aware_attributes, :instance_writer => false
-        self.time_zone_aware_attributes = false
+        def cast(value)
+          return if value.nil?
 
-        class_attribute :skip_time_zone_conversion_for_attributes, :instance_writer => false
-        self.skip_time_zone_conversion_for_attributes = []
-      end
+          if value.is_a?(Hash)
+            set_time_zone_without_conversion(super)
+          elsif value.respond_to?(:in_time_zone)
+            begin
+              super(user_input_in_time_zone(value)) || super
+            rescue ArgumentError
+              nil
+            end
+          else
+            map_avoiding_infinite_recursion(super) { |v| cast(v) }
+          end
+        end
 
-      module ClassMethods
-        protected
-          # The enhanced read method automatically converts the UTC time stored in the database to the time
-          # zone stored in Time.zone.
-          def attribute_cast_code(attr_name)
-            column = columns_hash[attr_name]
+        private
 
-            if create_time_zone_conversion_attribute?(attr_name, column)
-              typecast             = "v = #{super}"
-              time_zone_conversion = "v.acts_like?(:time) ? v.in_time_zone : v"
+          def convert_time_to_time_zone(value)
+            return if value.nil?
 
-              "((#{typecast}) && (#{time_zone_conversion}))"
+            if value.acts_like?(:time)
+              value.in_time_zone
+            elsif value.is_a?(::Float)
+              value
             else
-              super
+              map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
             end
           end
 
-          # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-          # This enhanced write method will automatically convert the time passed to it to the zone stored in Time.zone.
-          def define_method_attribute=(attr_name)
-            if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
-              method_body, line = <<-EOV, __LINE__ + 1
-                def #{attr_name}=(original_time)
-                  original_time = nil if original_time.blank?
-                  time = original_time
-                  unless time.acts_like?(:time)
-                    time = time.is_a?(String) ? Time.zone.parse(time) : time.to_time rescue time
-                  end
-                  time = time.in_time_zone rescue nil if time
-                  previous_time = attribute_changed?("#{attr_name}") ? changed_attributes["#{attr_name}"] : read_attribute(:#{attr_name})
-                  write_attribute(:#{attr_name}, original_time)
-                  #{attr_name}_will_change! if previous_time != time
-                  @attributes_cache["#{attr_name}"] = time
-                end
-              EOV
-              generated_attribute_methods.module_eval(method_body, __FILE__, line)
-            else
-              super
+          def set_time_zone_without_conversion(value)
+            ::Time.zone.local_to_utc(value).try(:in_time_zone) if value
+          end
+
+          def map_avoiding_infinite_recursion(value)
+            map(value) do |v|
+              if value.equal?(v)
+                nil
+              else
+                yield(v)
+              end
             end
           end
+      end
 
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_accessor :time_zone_aware_attributes, instance_writer: false, default: false
+
+        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 # :nodoc:
         private
-          def create_time_zone_conversion_attribute?(name, column)
-            time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) && column.type.in?([:datetime, :timestamp])
+
+          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
+          end
+
+          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)
+
+            enabled_for_column && time_zone_aware_types.include?(cast_type.type)
           end
       end
     end

data/lib/active_record/attribute_methods/write.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Write
@@ -7,63 +9,59 @@ module ActiveRecord
         attribute_method_suffix "="
       end
 
-      module ClassMethods
-        protected
-          def define_method_attribute=(attr_name)
-            if attr_name =~ ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP
-              generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
-            else
-              generated_attribute_methods.send(:define_method, "#{attr_name}=") do |new_value|
-                write_attribute(attr_name, new_value)
+      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}
+                #{sync_with_transaction_state}
+                _write_attribute(name, value)
               end
-            end
+              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+              undef_method :__temp__#{safe_name}=
+            STR
           end
       end
 
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings
-      # for fixnum and float columns are turned into +nil+.
+      # Updates the attribute identified by <tt>attr_name</tt> with the
+      # specified +value+. Empty strings for Integer and Float columns are
+      # turned into +nil+.
       def write_attribute(attr_name, value)
-        attr_name = attr_name.to_s
-        attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
-        @attributes_cache.delete(attr_name)
-        column = column_for_attribute(attr_name)
-
-        unless column || @attributes.has_key?(attr_name)
-          ActiveSupport::Deprecation.warn(
-            "You're trying to create an attribute `#{attr_name}'. Writing arbitrary " \
-            "attributes on a model is deprecated. Please just use `attr_writer` etc."
-          )
+        name = if self.class.attribute_alias?(attr_name)
+          self.class.attribute_alias(attr_name).to_s
+        else
+          attr_name.to_s
         end
 
-        @attributes[attr_name] = type_cast_attribute_for_write(column, 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
-      alias_method :raw_write_attribute, :write_attribute
 
-      private
-        # Handle *= for method_missing.
-        def attribute=(attribute_name, value)
-          write_attribute(attribute_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:
+        @attributes.write_from_user(attr_name.to_s, value)
+        value
+      end
 
-        def type_cast_attribute_for_write(column, value)
-          if column && column.number?
-            convert_number_column_value(value)
-          else
-            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
 
-        def convert_number_column_value(value)
-          case value
-          when FalseClass
-            0
-          when TrueClass
-            1
-          when String
-            value.presence
-          else
-            value
-          end
+        # Handle *= for method_missing.
+        def attribute=(attribute_name, value)
+          _write_attribute(attribute_name, value)
         end
     end
   end