activerecord 4.2.8 → 6.0.0

data/lib/active_record/attribute_methods/primary_key.rb

@@ -1,128 +1,136 @@
-require 'set'
+# frozen_string_literal: true
+
+require "set"
 
 module ActiveRecord
   module AttributeMethods
     module PrimaryKey
       extend ActiveSupport::Concern
 
-      # Returns this record's primary key value wrapped in an Array if one is
+      # Returns this record's primary key value wrapped in an array if one is
       # available.
       def to_key
-        sync_with_transaction_state
-        key = self.id
+        key = id
         [key] if key
       end
 
-      # Returns the primary key value.
+      # Returns the primary key column's value.
       def id
-        if pk = self.class.primary_key
-          sync_with_transaction_state
-          _read_attribute(pk)
-        end
+        _read_attribute(@primary_key)
       end
 
-      # Sets the primary key value.
+      # Sets the primary key column's value.
       def id=(value)
-        sync_with_transaction_state
-        write_attribute(self.class.primary_key, value) if self.class.primary_key
+        _write_attribute(@primary_key, value)
       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)
+        query_attribute(@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)
+        read_attribute_before_type_cast(@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)
+        attribute_was(@primary_key)
       end
 
-      protected
-
-      def attribute_method?(attr_name)
-        attr_name == 'id' || super
+      # Returns the primary key column's value from the database.
+      def id_in_database
+        attribute_in_database(@primary_key)
       end
 
-      module ClassMethods
-        def define_method_attribute(attr_name)
-          super
+      private
 
-          if attr_name == primary_key && attr_name != 'id'
-            generated_attribute_methods.send(:alias_method, :id, primary_key)
-          end
+        def attribute_method?(attr_name)
+          attr_name == "id" || super
         end
 
-        ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was).to_set
+        module ClassMethods
+          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
+          def instance_method_already_implemented?(method_name)
+            super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
+          end
 
-        # Defines the primary key field -- can be overridden in subclasses.
-        # Overwriting will negate any effect of the +primary_key_prefix_type+
-        # setting, though.
-        def primary_key
-          @primary_key = reset_primary_key unless defined? @primary_key
-          @primary_key
-        end
+          def dangerous_attribute_method?(method_name)
+            super && !ID_ATTRIBUTE_METHODS.include?(method_name)
+          end
 
-        # Returns a quoted version of the primary key name, used to construct
-        # SQL statements.
-        def quoted_primary_key
-          @quoted_primary_key ||= connection.quote_column_name(primary_key)
-        end
+          # Defines the primary key field -- can be overridden in subclasses.
+          # Overwriting will negate any effect of the +primary_key_prefix_type+
+          # setting, though.
+          def primary_key
+            @primary_key = reset_primary_key unless defined? @primary_key
+            @primary_key
+          end
 
-        def reset_primary_key #:nodoc:
-          if self == base_class
-            self.primary_key = get_primary_key(base_class.name)
-          else
-            self.primary_key = base_class.primary_key
+          # Returns a quoted version of the primary key name, used to construct
+          # SQL statements.
+          def quoted_primary_key
+            @quoted_primary_key ||= connection.quote_column_name(primary_key)
           end
-        end
 
-        def get_primary_key(base_name) #:nodoc:
-          if base_name && primary_key_prefix_type == :table_name
-            base_name.foreign_key(false)
-          elsif base_name && primary_key_prefix_type == :table_name_with_underscore
-            base_name.foreign_key
-          else
-            if ActiveRecord::Base != self && table_exists?
-              connection.schema_cache.primary_keys(table_name)
+          def reset_primary_key #:nodoc:
+            if base_class?
+              self.primary_key = get_primary_key(base_class.name)
             else
-              'id'
+              self.primary_key = base_class.primary_key
             end
           end
-        end
 
-        # Sets the name of the primary key column.
-        #
-        #   class Project < ActiveRecord::Base
-        #     self.primary_key = 'sysid'
-        #   end
-        #
-        # You can also define the +primary_key+ method yourself:
-        #
-        #   class Project < ActiveRecord::Base
-        #     def self.primary_key
-        #       'foo_' + super
-        #     end
-        #   end
-        #
-        #   Project.primary_key # => "foo_id"
-        def primary_key=(value)
-          @primary_key        = value && value.to_s
-          @quoted_primary_key = nil
-          @attributes_builder = nil
+          def get_primary_key(base_name) #:nodoc:
+            if base_name && primary_key_prefix_type == :table_name
+              base_name.foreign_key(false)
+            elsif base_name && primary_key_prefix_type == :table_name_with_underscore
+              base_name.foreign_key
+            else
+              if ActiveRecord::Base != self && table_exists?
+                pk = connection.schema_cache.primary_keys(table_name)
+                suppress_composite_primary_key(pk)
+              else
+                "id"
+              end
+            end
+          end
+
+          # Sets the name of the primary key column.
+          #
+          #   class Project < ActiveRecord::Base
+          #     self.primary_key = 'sysid'
+          #   end
+          #
+          # You can also define the #primary_key method yourself:
+          #
+          #   class Project < ActiveRecord::Base
+          #     def self.primary_key
+          #       'foo_' + super
+          #     end
+          #   end
+          #
+          #   Project.primary_key # => "foo_id"
+          def primary_key=(value)
+            @primary_key        = value && -value.to_s
+            @quoted_primary_key = nil
+            @attributes_builder = nil
+          end
+
+          private
+
+            def suppress_composite_primary_key(pk)
+              return pk unless pk.is_a?(Array)
+
+              warn <<~WARNING
+                WARNING: Active Record does not support composite primary key.
+
+                #{table_name} has composite primary key. Composite primary key is ignored.
+              WARNING
+            end
         end
-      end
     end
   end
 end

data/lib/active_record/attribute_methods/query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Query
@@ -14,15 +16,14 @@ module ActiveRecord
         when true        then true
         when false, nil  then false
         else
-          column = self.class.columns_hash[attr_name]
-          if column.nil?
+          if !type_for_attribute(attr_name) { false }
             if Numeric === value || value !~ /[^0-9]/
               !value.to_i.zero?
             else
-              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
               !value.blank?
             end
-          elsif column.number?
+          elsif value.respond_to?(:zero?)
             !value.zero?
           else
             !value.blank?
@@ -31,7 +32,7 @@ module ActiveRecord
       end
 
       private
-        # Handle *? for method_missing.
+        # Dispatch target for <tt>*?</tt> attribute methods.
         def attribute?(attribute_name)
           query_attribute(attribute_name)
         end

data/lib/active_record/attribute_methods/read.rb

@@ -1,103 +1,47 @@
-require 'active_support/core_ext/module/method_transplanting'
+# frozen_string_literal: true
 
 module ActiveRecord
   module AttributeMethods
     module Read
-      ReaderMethodCache = Class.new(AttributeMethodCache) {
-        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 method_body(method_name, const_name)
-          <<-EOMETHOD
-          def #{method_name}
-            name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{const_name}
-            _read_attribute(name) { |n| missing_attribute(n, caller) }
-          end
-          EOMETHOD
-        end
-      }.new
-
       extend ActiveSupport::Concern
 
-      module ClassMethods
-        [:cache_attributes, :cached_attributes, :cache_attribute?].each do |method_name|
-          define_method method_name do |*|
-            cached_attributes_deprecation_warning(method_name)
-            true
-          end
-        end
-
-        protected
-
-        def cached_attributes_deprecation_warning(method_name)
-          ActiveSupport::Deprecation.warn "Calling `#{method_name}` is no longer necessary. All attributes are cached."
-        end
+      module ClassMethods # :nodoc:
+        private
 
-        if Module.methods_transplantable?
-          def define_method_attribute(name)
-            method = ReaderMethodCache[name]
-            generated_attribute_methods.module_eval { define_method name, method }
-          end
-        else
           def define_method_attribute(name)
-            safe_name = name.unpack('h*').first
-            temp_method = "__temp__#{safe_name}"
-
-            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def #{temp_method}
-                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}
+                  name = #{attr_name_expr}
+                  _read_attribute(name) { |n| missing_attribute(n, caller) }
+                end
+              RUBY
             end
           end
-        end
       end
 
-      ID = 'id'.freeze
-
       # 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 = attr_name.to_s
-        name = self.class.primary_key if name == ID
+        name = self.class.attribute_aliases[name] || name
+
+        name = @primary_key if name == "id" && @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
-      def _read_attribute(attr_name) # :nodoc:
-        @attributes.fetch_value(attr_name.to_s) { |n| yield n if block_given? }
+      def _read_attribute(attr_name, &block) # :nodoc
+        sync_with_transaction_state if @transaction_state&.finalized?
+        @attributes.fetch_value(attr_name.to_s, &block)
       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,22 +1,44 @@
-require 'active_support/core_ext/string/filters'
+# frozen_string_literal: true
 
 module ActiveRecord
   module AttributeMethods
     module Serialization
       extend ActiveSupport::Concern
 
+      class ColumnNotSerializableError < StandardError
+        def initialize(name, type)
+          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.
+          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 assignment and retrieval.
-        # Otherwise <tt>SerializationTypeMismatch</tt> will be raised.
+        # 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_or_coder+ - Optional, a coder object, which responds to `.load` / `.dump`
+        # * +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
@@ -40,30 +62,28 @@ module ActiveRecord
           # 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
-                    Coders::YAMLColumn.new(class_name_or_coder)
-                  end
+            Coders::JSON
+          elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+            class_name_or_coder
+          else
+            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)
+            end
+
             Type::Serialized.new(type, coder)
           end
         end
 
-        def serialized_attributes
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `serialized_attributes` is deprecated without replacement, and will
-            be removed in Rails 5.0.
-          MSG
+        private
 
-          @serialized_attributes ||= Hash[
-            columns.select { |t| t.cast_type.is_a?(Type::Serialized) }.map { |c|
-              [c.name, c.cast_type.coder]
-            }
-          ]
-        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