activerecord 4.2.6 → 5.0.0

data/lib/active_record/attribute_methods/read.rb

@@ -1,10 +1,11 @@
-require 'active_support/core_ext/module/method_transplanting'
-
 module ActiveRecord
   module AttributeMethods
     module Read
-      ReaderMethodCache = Class.new(AttributeMethodCache) {
-        private
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        protected
+
         # 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
@@ -23,81 +24,52 @@ module ActiveRecord
         # 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
-
-        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}"
+        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
+          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
+          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
           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.primary_key if name == 'id'.freeze
         _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? }
+      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
+      alias :attribute :_read_attribute
+      private :attribute
 
-      def attribute(attribute_name)
-        _read_attribute(attribute_name)
-      end
     end
   end
 end

data/lib/active_record/attribute_methods/serialization.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/filters'
-
 module ActiveRecord
   module AttributeMethods
     module Serialization
@@ -11,7 +9,19 @@ module ActiveRecord
         # 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
         #
@@ -51,19 +61,6 @@ module ActiveRecord
             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
-
-          @serialized_attributes ||= Hash[
-            columns.select { |t| t.cast_type.is_a?(Type::Serialized) }.map { |c|
-              [c.name, c.cast_type.coder]
-            }
-          ]
-        end
       end
     end
   end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,32 +1,54 @@
+require 'active_support/core_ext/string/strip'
+
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
       class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
-        include Type::Decorator
-
-        def type_cast_from_database(value)
+        def deserialize(value)
           convert_time_to_time_zone(super)
         end
 
-        def type_cast_from_user(value)
-          if value.is_a?(Array)
-            value.map { |v| type_cast_from_user(v) }
+        def cast(value)
+          return if value.nil?
+
+          if value.is_a?(Hash)
+            set_time_zone_without_conversion(super)
           elsif value.respond_to?(:in_time_zone)
             begin
-              value.in_time_zone || super
+              super(user_input_in_time_zone(value)) || super
             rescue ArgumentError
               nil
             end
+          else
+            map_avoiding_infinite_recursion(super) { |v| cast(v) }
           end
         end
 
+        private
+
         def convert_time_to_time_zone(value)
-          if value.is_a?(Array)
-            value.map { |v| convert_time_to_time_zone(v) }
-          elsif value.acts_like?(:time)
+          return if value.nil?
+
+          if value.acts_like?(:time)
             value.in_time_zone
-          else
+          elsif value.is_a?(::Float)
             value
+          else
+            map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
+          end
+        end
+
+        def set_time_zone_without_conversion(value)
+          ::Time.zone.local_to_utc(value).in_time_zone
+        end
+
+        def map_avoiding_infinite_recursion(value)
+          map(value) do |v|
+            if value.equal?(v)
+              nil
+            else
+              yield(v)
+            end
           end
         end
       end
@@ -39,6 +61,9 @@ module ActiveRecord
 
         class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false
         self.skip_time_zone_conversion_for_attributes = []
+
+        class_attribute :time_zone_aware_types, instance_writer: false
+        self.time_zone_aware_types = [:datetime, :not_explicitly_configured]
       end
 
       module ClassMethods
@@ -59,9 +84,31 @@ module ActiveRecord
         end
 
         def create_time_zone_conversion_attribute?(name, cast_type)
-          time_zone_aware_attributes &&
-            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) &&
-            (:datetime == cast_type.type)
+          enabled_for_column = time_zone_aware_attributes &&
+            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym)
+          result = enabled_for_column &&
+            time_zone_aware_types.include?(cast_type.type)
+
+          if enabled_for_column &&
+            !result &&
+            cast_type.type == :time &&
+            time_zone_aware_types.include?(:not_explicitly_configured)
+            ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+              Time columns will become time zone aware in Rails 5.1. This
+              still causes `String`s to be parsed as if they were in `Time.zone`,
+              and `Time`s to be converted to `Time.zone`.
+
+              To keep the old behavior, you must add the following to your initializer:
+
+                  config.active_record.time_zone_aware_types = [:datetime]
+
+              To silence this deprecation warning, add the following:
+
+                  config.active_record.time_zone_aware_types = [:datetime, :time]
+            MESSAGE
+          end
+
+          result
         end
       end
     end

data/lib/active_record/attribute_methods/write.rb

@@ -1,21 +1,6 @@
-require 'active_support/core_ext/module/method_transplanting'
-
 module ActiveRecord
   module AttributeMethods
     module Write
-      WriterMethodCache = Class.new(AttributeMethodCache) {
-        private
-
-        def method_body(method_name, const_name)
-          <<-EOMETHOD
-          def #{method_name}(value)
-            name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{const_name}
-            write_attribute(name, value)
-          end
-          EOMETHOD
-        end
-      }.new
-
       extend ActiveSupport::Concern
 
       included do
@@ -25,38 +10,29 @@ module ActiveRecord
       module ClassMethods
         protected
 
-        if Module.methods_transplantable?
-          def define_method_attribute=(name)
-            method = WriterMethodCache[name]
-            generated_attribute_methods.module_eval {
-              define_method "#{name}=", method
-            }
-          end
-        else
-          def define_method_attribute=(name)
-            safe_name = name.unpack('h*').first
-            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-
-            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)
-              end
-              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
-              undef_method :__temp__#{safe_name}=
-            STR
-          end
+        def define_method_attribute=(name)
+          safe_name = name.unpack('h*'.freeze).first
+          ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+          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)
+            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
+      # specified +value+. Empty strings for Integer and Float columns are
       # turned into +nil+.
       def write_attribute(attr_name, value)
         write_attribute_with_type_cast(attr_name, value, true)
       end
 
-      def raw_write_attribute(attr_name, value)
+      def raw_write_attribute(attr_name, value) # :nodoc:
         write_attribute_with_type_cast(attr_name, value, false)
       end
 

data/lib/active_record/attribute_methods.rb

@@ -1,7 +1,7 @@
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/string/filters'
 require 'mutex_m'
-require 'thread_safe'
+require 'concurrent/map'
 
 module ActiveRecord
   # = Active Record Attribute Methods
@@ -34,30 +34,6 @@ module ActiveRecord
 
     BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
 
-    class AttributeMethodCache
-      def initialize
-        @module = Module.new
-        @method_cache = ThreadSafe::Cache.new
-      end
-
-      def [](name)
-        @method_cache.compute_if_absent(name) do
-          safe_name = name.unpack('h*').first
-          temp_method = "__temp__#{safe_name}"
-          ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-          @module.module_eval method_body(temp_method, safe_name), __FILE__, __LINE__
-          @module.instance_method temp_method
-        end
-      end
-
-      private
-
-      # Override this method in the subclasses for method body.
-      def method_body(method_name, const_name)
-        raise NotImplementedError, "Subclasses must implement a method_body(method_name, const_name) method."
-      end
-    end
-
     class GeneratedAttributeMethods < Module; end # :nodoc:
 
     module ClassMethods
@@ -83,7 +59,7 @@ module ActiveRecord
         generated_attribute_methods.synchronize do
           return false if @attribute_methods_generated
           superclass.define_attribute_methods unless self == base_class
-          super(column_names)
+          super(attribute_names)
           @attribute_methods_generated = true
         end
         true
@@ -96,7 +72,7 @@ module ActiveRecord
         end
       end
 
-      # Raises a <tt>ActiveRecord::DangerousAttributeError</tt> exception when an
+      # Raises an ActiveRecord::DangerousAttributeError exception when an
       # \Active \Record method is defined in the model, otherwise +false+.
       #
       #   class Person < ActiveRecord::Base
@@ -106,7 +82,7 @@ module ActiveRecord
       #   end
       #
       #   Person.instance_method_already_implemented?(:save)
-      #   # => ActiveRecord::DangerousAttributeError: save is defined by ActiveRecord
+      #   # => ActiveRecord::DangerousAttributeError: save is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name.
       #
       #   Person.instance_method_already_implemented?(:name)
       #   # => false
@@ -150,7 +126,7 @@ module ActiveRecord
         BLACKLISTED_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
+      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
@@ -185,14 +161,27 @@ module ActiveRecord
       #   # => ["id", "created_at", "updated_at", "name", "age"]
       def attribute_names
         @attribute_names ||= if !abstract_class? && table_exists?
-            column_names
+            attribute_types.keys
           else
             []
           end
       end
 
+      # Returns true if the given attribute exists, otherwise false.
+      #
+      #   class Person < ActiveRecord::Base
+      #   end
+      #
+      #   Person.has_attribute?('name')   # => true
+      #   Person.has_attribute?(:age)     # => true
+      #   Person.has_attribute?(:nothing) # => false
+      def has_attribute?(attr_name)
+        attribute_types.key?(attr_name.to_s)
+      end
+
       # Returns the column object for the named attribute.
-      # Returns nil if the named attribute does not exist.
+      # Returns a +ActiveRecord::ConnectionAdapters::NullColumn+ if the
+      # named attribute does not exist.
       #
       #   class Person < ActiveRecord::Base
       #   end
@@ -202,23 +191,18 @@ module ActiveRecord
       #   # => #<ActiveRecord::ConnectionAdapters::Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
       #
       #   person.column_for_attribute(:nothing)
-      #   # => nil
+      #   # => #<ActiveRecord::ConnectionAdapters::NullColumn:0xXXX @name=nil, @sql_type=nil, @cast_type=#<Type::Value>, ...>
       def column_for_attribute(name)
-        column = columns_hash[name.to_s]
-        if column.nil?
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `#column_for_attribute` will return a null object for non-existent
-            columns in Rails 5. Use `#has_attribute?` if you need to check for
-            an attribute's existence.
-          MSG
+        name = name.to_s
+        columns_hash.fetch(name) do
+          ConnectionAdapters::NullColumn.new(name)
         end
-        column
       end
     end
 
     # A Person object with a name attribute can ask <tt>person.respond_to?(:name)</tt>,
     # <tt>person.respond_to?(:name=)</tt>, and <tt>person.respond_to?(:name?)</tt>
-    # which will all return +true+. It also define the attribute methods if they have
+    # which will all return +true+. It also defines the attribute methods if they have
     # not been generated.
     #
     #   class Person < ActiveRecord::Base
@@ -234,7 +218,15 @@ module ActiveRecord
     #   person.respond_to(:nothing) # => false
     def respond_to?(name, include_private = false)
       return false unless super
-      name = name.to_s
+
+      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.
@@ -342,7 +334,7 @@ module ActiveRecord
     #
     # Note: +:id+ is always present.
     #
-    # Alias for the <tt>read_attribute</tt> method.
+    # Alias for the #read_attribute method.
     #
     #   class Person < ActiveRecord::Base
     #     belongs_to :organization
@@ -360,7 +352,7 @@ module ActiveRecord
     end
 
     # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-    # (Alias for the protected <tt>write_attribute</tt> method).
+    # (Alias for the protected #write_attribute method).
     #
     #   class Person < ActiveRecord::Base
     #   end
@@ -368,11 +360,44 @@ module ActiveRecord
     #   person = Person.new
     #   person[:age] = '22'
     #   person[:age] # => 22
-    #   person[:age] # => Fixnum
+    #   person[:age].class # => Integer
     def []=(attr_name, value)
       write_attribute(attr_name, value)
     end
 
+    # Returns the name of all database fields which have been read from this
+    # model. This can be useful in development mode to determine which fields
+    # need to be selected. For performance critical pages, selecting only the
+    # required fields can be an easy performance win (assuming you aren't using
+    # all of the fields on the model).
+    #
+    # For example:
+    #
+    #   class PostsController < ActionController::Base
+    #     after_action :print_accessed_fields, only: :index
+    #
+    #     def index
+    #       @posts = Post.all
+    #     end
+    #
+    #     private
+    #
+    #     def print_accessed_fields
+    #       p @posts.first.accessed_fields
+    #     end
+    #   end
+    #
+    # Which allows you to quickly change your code to:
+    #
+    #   class PostsController < ActionController::Base
+    #     def index
+    #       @posts = Post.select(:id, :title, :author_id, :updated_at)
+    #     end
+    #   end
+    def accessed_fields
+      @attributes.accessed
+    end
+
     protected
 
     def clone_attribute_value(reader_method, attribute_name) # :nodoc:

data/lib/active_record/attribute_mutation_tracker.rb

@@ -0,0 +1,70 @@
+module ActiveRecord
+  class AttributeMutationTracker # :nodoc:
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def changed_values
+      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+        if changed?(attr_name)
+          result[attr_name] = attributes[attr_name].original_value
+        end
+      end
+    end
+
+    def changes
+      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+        if changed?(attr_name)
+          result[attr_name] = [attributes[attr_name].original_value, attributes.fetch_value(attr_name)]
+        end
+      end
+    end
+
+    def changed?(attr_name)
+      attr_name = attr_name.to_s
+      attributes[attr_name].changed?
+    end
+
+    def changed_in_place?(attr_name)
+      attributes[attr_name].changed_in_place?
+    end
+
+    def forget_change(attr_name)
+      attr_name = attr_name.to_s
+      attributes[attr_name] = attributes[attr_name].forgetting_assignment
+    end
+
+    protected
+
+    attr_reader :attributes
+
+    private
+
+    def attr_names
+      attributes.keys
+    end
+  end
+
+  class NullMutationTracker # :nodoc:
+    include Singleton
+
+    def changed_values
+      {}
+    end
+
+    def changes
+      {}
+    end
+
+    def changed?(*)
+      false
+    end
+
+    def changed_in_place?(*)
+      false
+    end
+
+    def forget_change(*)
+    end
+  end
+end

data/lib/active_record/attribute_set/builder.rb

@@ -22,7 +22,7 @@ module ActiveRecord
   end
 
   class LazyAttributeHash # :nodoc:
-    delegate :transform_values, to: :materialize
+    delegate :transform_values, :each_key, to: :materialize
 
     def initialize(types, values, additional_types)
       @types = types
@@ -47,12 +47,14 @@ module ActiveRecord
       delegate_hash[key] = value
     end
 
-    def initialized_keys
-      delegate_hash.keys | values.keys
+    def deep_dup
+      dup.tap do |copy|
+        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
+      end
     end
 
     def initialize_dup(_)
-      @delegate_hash = delegate_hash.transform_values(&:dup)
+      @delegate_hash = Hash[delegate_hash]
       super
     end