activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/attribute_methods/query.rb

@@ -19,10 +19,10 @@ module ActiveRecord
             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?

data/lib/active_record/attribute_methods/read.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/module/method_transplanting'
-
 module ActiveRecord
   module AttributeMethods
     module Read
@@ -36,68 +34,54 @@ module ActiveRecord
       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,25 +1,29 @@
+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)
+        def cast(value)
           if value.is_a?(Array)
-            value.map { |v| type_cast_from_user(v) }
+            value.map { |v| cast(v) }
+          elsif 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
           end
         end
 
+        private
+
         def convert_time_to_time_zone(value)
           if value.is_a?(Array)
             value.map { |v| convert_time_to_time_zone(v) }
@@ -29,6 +33,10 @@ module ActiveRecord
             value
           end
         end
+
+        def set_time_zone_without_conversion(value)
+          ::Time.zone.local_to_utc(value).in_time_zone
+        end
       end
 
       extend ActiveSupport::Concern
@@ -39,6 +47,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 +70,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 << :time
+            MESSAGE
+          end
+
+          result
         end
       end
     end

data/lib/active_record/attribute_methods/write.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/module/method_transplanting'
-
 module ActiveRecord
   module AttributeMethods
     module Write
@@ -25,38 +23,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
+        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
+          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 Integer and Float columns are
+      # specified +value+. Empty strings for fixnum 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_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.rb

@@ -10,6 +10,10 @@ module ActiveRecord
       attributes[name] || Attribute.null(name)
     end
 
+    def []=(name, value)
+      attributes[name] = value
+    end
+
     def values_before_type_cast
       attributes.transform_values(&:value_before_type_cast)
     end
@@ -24,11 +28,19 @@ module ActiveRecord
     end
 
     def keys
-      attributes.initialized_keys
+      attributes.each_key.select { |name| self[name].initialized? }
     end
 
-    def fetch_value(name)
-      self[name].value { |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 fetch_value(name, &block)
+        self[name].value(&block)
+      end
+    else
+      def fetch_value(name)
+        self[name].value { |n| yield n if block_given? }
+      end
     end
 
     def write_from_database(name, value)
@@ -48,6 +60,12 @@ module ActiveRecord
       super
     end
 
+    def deep_dup
+      dup.tap do |copy|
+        copy.instance_variable_set(:@attributes, attributes.deep_dup)
+      end
+    end
+
     def initialize_dup(_)
       @attributes = attributes.dup
       super
@@ -64,6 +82,15 @@ module ActiveRecord
       end
     end
 
+    def accessed
+      attributes.select { |_, attr| attr.has_been_read? }.keys
+    end
+
+    def map(&block)
+      new_attributes = attributes.transform_values(&block)
+      AttributeSet.new(new_attributes)
+    end
+
     def ==(other)
       attributes == other.attributes
     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