activerecord 4.1.15 → 4.2.0.beta1

data/lib/active_record/attribute_methods/dirty.rb

@@ -34,28 +34,43 @@ module ActiveRecord
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          reset_changes
+          clear_changes_information
         end
       end
 
-    def initialize_dup(other) # :nodoc:
-      super
-      init_changed_attributes
-    end
+      def initialize_dup(other) # :nodoc:
+        super
+        calculate_changes_from_defaults
+      end
+
+      def changed?
+        super || changed_in_place.any?
+      end
+
+      def changed
+        super | changed_in_place
+      end
+
+      def changes_applied
+        super
+        store_original_raw_attributes
+      end
 
-    private
-      def initialize_internals_callback
+      def clear_changes_information
         super
-        init_changed_attributes
+        original_raw_attributes.clear
+      end
+
+      def changed_attributes
+        super.reverse_merge(attributes_changed_in_place).freeze
       end
 
-      def init_changed_attributes
+      private
+
+      def calculate_changes_from_defaults
         @changed_attributes = nil
-        # Intentionally avoid using #column_defaults since overridden defaults (as is done in
-        # optimistic locking) won't get written unless they get marked as changed
-        self.class.columns.each do |c|
-          attr, orig_value = c.name, c.default
-          changed_attributes[attr] = orig_value if _field_changed?(attr, orig_value, @attributes[attr])
+        self.class.column_defaults.each do |attr, orig_value|
+          set_attribute_was(attr, orig_value) if _field_changed?(attr, orig_value)
         end
       end
 
@@ -63,19 +78,35 @@ module ActiveRecord
       def write_attribute(attr, value)
         attr = attr.to_s
 
-        save_changed_attribute(attr, value)
+        old_value = old_attribute_value(attr)
+
+        result = super
+        store_original_raw_attribute(attr)
+        save_changed_attribute(attr, old_value)
+        result
+      end
+
+      def raw_write_attribute(attr, value)
+        attr = attr.to_s
+
+        result = super
+        original_raw_attributes[attr] = value
+        result
+      end
 
-        super(attr, value)
+      def save_changed_attribute(attr, old_value)
+        if attribute_changed?(attr)
+          clear_attribute_changes(attr) unless _field_changed?(attr, old_value)
+        else
+          set_attribute_was(attr, old_value) if _field_changed?(attr, old_value)
+        end
       end
 
-      def save_changed_attribute(attr, value)
-        # The attribute already has an unsaved change.
+      def old_attribute_value(attr)
         if attribute_changed?(attr)
-          old = changed_attributes[attr]
-          changed_attributes.delete(attr) unless _field_changed?(attr, old, value)
+          changed_attributes[attr]
         else
-          old = clone_attribute_value(:read_attribute, attr)
-          changed_attributes[attr] = old if _field_changed?(attr, old, value)
+          clone_attribute_value(:read_attribute, attr)
         end
       end
 
@@ -93,34 +124,46 @@ module ActiveRecord
         changed
       end
 
-      def _field_changed?(attr, old, value)
-        if column = column_for_attribute(attr)
-          if column.number? && (changes_from_nil_to_empty_string?(column, old, value) ||
-                                changes_from_zero_to_string?(old, value))
-            value = nil
-          else
-            value = column.type_cast(value)
-          end
+      def _field_changed?(attr, old_value)
+        @attributes[attr].changed_from?(old_value)
+      end
+
+      def attributes_changed_in_place
+        changed_in_place.each_with_object({}) do |attr_name, h|
+          orig = @attributes[attr_name].original_value
+          h[attr_name] = orig
         end
+      end
+
+      def changed_in_place
+        self.class.attribute_names.select do |attr_name|
+          changed_in_place?(attr_name)
+        end
+      end
 
-        old != value
+      def changed_in_place?(attr_name)
+        old_value = original_raw_attribute(attr_name)
+        @attributes[attr_name].changed_in_place_from?(old_value)
       end
 
-      def changes_from_nil_to_empty_string?(column, old, value)
-        # For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
-        # Hence we don't record it as a change if the value changes from nil to ''.
-        # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
-        # be typecast back to 0 (''.to_i => 0)
-        column.null && (old.nil? || old == 0) && value.blank?
+      def original_raw_attribute(attr_name)
+        original_raw_attributes.fetch(attr_name) do
+          read_attribute_before_type_cast(attr_name)
+        end
+      end
+
+      def original_raw_attributes
+        @original_raw_attributes ||= {}
       end
 
-      def changes_from_zero_to_string?(old, value)
-        # For columns with old 0 and value non-empty string
-        old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
+      def store_original_raw_attribute(attr_name)
+        original_raw_attributes[attr_name] = @attributes[attr_name].value_for_database
       end
 
-      def non_zero?(value)
-        value !~ /\A0+(\.0+)?\z/
+      def store_original_raw_attributes
+        attribute_names.each do |attr|
+          store_original_raw_attribute(attr)
+        end
       end
     end
   end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -15,9 +15,10 @@ module ActiveRecord
 
       # Returns the primary key value.
       def id
-        return unless self.class.primary_key
-        sync_with_transaction_state
-        read_attribute(self.class.primary_key)
+        if pk = self.class.primary_key
+          sync_with_transaction_state
+          read_attribute(pk)
+        end
       end
 
       # Sets the primary key value.
@@ -88,12 +89,9 @@ module ActiveRecord
         end
 
         def get_primary_key(base_name) #:nodoc:
-          return 'id' if base_name.blank?
-
-          case primary_key_prefix_type
-          when :table_name
+          if base_name && primary_key_prefix_type == :table_name
             base_name.foreign_key(false)
-          when :table_name_with_underscore
+          elsif base_name && primary_key_prefix_type == :table_name_with_underscore
             base_name.foreign_key
           else
             if ActiveRecord::Base != self && table_exists?

data/lib/active_record/attribute_methods/read.rb

@@ -22,7 +22,7 @@ module ActiveRecord
         # 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_cache in read_attribute.
+        # key the @attributes in read_attribute.
         def method_body(method_name, const_name)
           <<-EOMETHOD
           def #{method_name}
@@ -35,35 +35,22 @@ module ActiveRecord
 
       extend ActiveSupport::Concern
 
-      ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
-
-      included do
-        class_attribute :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 }
+        [:cache_attributes, :cached_attributes, :cache_attribute?].each do |method_name|
+          define_method method_name do |*|
+            cached_attributes_deprecation_warning(method_name)
+            true
+          end
         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
+        protected
 
-        # Returns +true+ if the provided attribute is being cached.
-        def cache_attribute?(attr_name)
-          cached_attributes.include?(attr_name)
+        def cached_attributes_deprecation_warning(method_name)
+          ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+            Calling `#{method_name}` is no longer necessary. All attributes are cached.
+          MESSAGE
         end
 
-        protected
-
         if Module.methods_transplantable?
           def define_method_attribute(name)
             method = ReaderMethodCache[name]
@@ -89,45 +76,15 @@ module ActiveRecord
             end
           end
         end
-
-        private
-
-        def cacheable_column?(column)
-          if attribute_types_cached_by_default == ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
-            ! serialized_attributes.include? column.name
-          else
-            attribute_types_cached_by_default.include?(column.type)
-          end
-        end
       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)
-        # If it's cached, just return it
-        # We use #[] first as a perf optimization for non-nil values. See https://gist.github.com/jonleighton/3552829.
+      def read_attribute(attr_name, &block)
         name = attr_name.to_s
-        @attributes_cache[name] || @attributes_cache.fetch(name) {
-          column = @column_types_override[name] if @column_types_override
-          column ||= @column_types[name]
-
-          return @attributes.fetch(name) {
-            if name == 'id' && self.class.primary_key != name
-              read_attribute(self.class.primary_key)
-            end
-          } unless column
-
-          value = @attributes.fetch(name) {
-            return block_given? ? yield(name) : nil
-          }
-
-          if self.class.cache_attribute?(name)
-            @attributes_cache[name] = column.type_cast(value)
-          else
-            column.type_cast value
-          end
-        }
+        name = self.class.primary_key if name == 'id'
+        @attributes.fetch_value(name, &block)
       end
 
       private

data/lib/active_record/attribute_methods/serialization.rb

@@ -3,20 +3,7 @@ module ActiveRecord
     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, instance_accessor: false
-        self.serialized_attributes = {}
-      end
-
       module ClassMethods
-        ##
-        # :method: serialized_attributes
-        #
-        # Returns a hash of all the attributes that have been specified for
-        # serialization as keys and their class restriction as values.
-
         # 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
@@ -50,8 +37,6 @@ module ActiveRecord
         #     serialize :preferences, Hash
         #   end
         def serialize(attr_name, class_name_or_coder = Object)
-          include Behavior
-
           # 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.
@@ -63,140 +48,21 @@ module ActiveRecord
                     Coders::YAMLColumn.new(class_name_or_coder)
                   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
-      end
-
-      class Type # :nodoc:
-        def initialize(column)
-          @column = column
-        end
-
-        def type_cast(value)
-          if value.state == :serialized
-            value.unserialized_value @column.type_cast value.value
-          else
-            value.unserialized_value
+          decorate_attribute_type(attr_name, :serialize) do |type|
+            Type::Serialized.new(type, coder)
           end
         end
 
-        def type
-          @column.type
-        end
-
-        def accessor
-          ActiveRecord::Store::IndifferentHashAccessor
-        end
-      end
-
-      class Attribute < Struct.new(:coder, :value, :state) # :nodoc:
-        def unserialized_value(v = value)
-          state == :serialized ? unserialize(v) : value
-        end
-
-        def serialized_value
-          state == :unserialized ? serialize : value
-        end
-
-        def unserialize(v)
-          self.state = :unserialized
-          self.value = coder.load(v)
-        end
-
-        def serialize
-          self.state = :serialized
-          self.value = coder.dump(value)
-        end
-      end
-
-      # This is only added to the model when serialize is called, which
-      # ensures we do not make things slower when serialization is not used.
-      module Behavior # :nodoc:
-        extend ActiveSupport::Concern
-
-        module ClassMethods # :nodoc:
-          def initialize_attributes(attributes, options = {})
-            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
-        end
-
-        def should_record_timestamps?
-          super || (self.record_timestamps && (attributes.keys & self.class.serialized_attributes.keys).present?)
-        end
-
-        def keys_for_partial_write
-          super | (attributes.keys & self.class.serialized_attributes.keys)
-        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
-
-        def raw_type_cast_attribute_for_write(column, value)
-          if column && coder = self.class.serialized_attributes[column.name]
-            Attribute.new(coder, value, :serialized)
-          else
-            super
-          end
-        end
-
-        def _field_changed?(attr, old, value)
-          if self.class.serialized_attributes.include?(attr)
-            old != value
-          else
-            super
-          end
-        end
-
-        def read_attribute_before_type_cast(attr_name)
-          if self.class.serialized_attributes.include?(attr_name)
-            super.unserialized_value
-          else
-            super
-          end
-        end
-
-        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
-            end
-          end
-        end
-
-        def typecasted_attribute_value(name)
-          if self.class.serialized_attributes.include?(name)
-            @attributes[name].serialized_value
-          else
-            super
-          end
-        end
-
-        def attributes_for_coder
-          attribute_names.each_with_object({}) do |name, attrs|
-            attrs[name] = if self.class.serialized_attributes.include?(name)
-                            @attributes[name].serialized_value
-                          else
-                            read_attribute(name)
-                          end
-          end
+        def serialized_attributes
+          ActiveSupport::Deprecation.warn(<<-WARNING.strip_heredoc)
+            `serialized_attributes` is deprecated without replacement, and will
+            be removed in Rails 5.0.
+          WARNING
+          @serialized_attributes ||= Hash[
+            columns.select { |t| t.cast_type.is_a?(Type::Serialized) }.map { |c|
+              [c.name, c.cast_type.coder]
+            }
+          ]
         end
       end
     end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,18 +1,27 @@
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
-      class Type # :nodoc:
-        def initialize(column)
-          @column = column
+      class TimeZoneConverter < SimpleDelegator # :nodoc:
+        def type_cast_from_database(value)
+          convert_time_to_time_zone(super)
         end
 
-        def type_cast(value)
-          value = @column.type_cast(value)
-          value.acts_like?(:time) ? value.in_time_zone : value
+        def type_cast_from_user(value)
+          if value.is_a?(Array)
+            value.map { |v| type_cast_from_user(v) }
+          elsif value.respond_to?(:in_time_zone)
+            value.in_time_zone
+          end
         end
 
-        def type
-          @column.type
+        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)
+            value.in_time_zone
+          else
+            value
+          end
         end
       end
 
@@ -27,43 +36,26 @@ module ActiveRecord
       end
 
       module ClassMethods
-        protected
-        # 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}=(time)
-                time_with_zone = convert_value_to_time_zone("#{attr_name}", time)
-                previous_time = attribute_changed?("#{attr_name}") ? changed_attributes["#{attr_name}"] : read_attribute(:#{attr_name})
-                write_attribute(:#{attr_name}, time)
-                #{attr_name}_will_change! if previous_time != time_with_zone
-                @attributes_cache["#{attr_name}"] = time_with_zone
-              end
-            EOV
-            generated_attribute_methods.module_eval(method_body, __FILE__, line)
-          else
-            super
+        private
+
+        def inherited(subclass)
+          # 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
+          super
         end
 
-        private
-        def create_time_zone_conversion_attribute?(name, column)
+        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 == column.type || :timestamp == column.type)
-        end
-      end
-
-      private
-
-      def convert_value_to_time_zone(attr_name, value)
-        if value.is_a?(Array)
-          value.map { |v| convert_value_to_time_zone(attr_name, v) }
-        elsif value.respond_to?(:in_time_zone)
-          value.in_time_zone || self.class.columns_hash[attr_name].type_cast(value)
-        else
-          nil
+            (:datetime == cast_type.type)
         end
       end
     end

data/lib/active_record/attribute_methods/write.rb

@@ -26,8 +26,6 @@ module ActiveRecord
         protected
 
         if Module.methods_transplantable?
-          # See define_method_attribute in read.rb for an explanation of
-          # this code.
           def define_method_attribute=(name)
             method = WriterMethodCache[name]
             generated_attribute_methods.module_eval {
@@ -55,11 +53,11 @@ module ActiveRecord
       # 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, :type_cast_attribute_for_write)
+        write_attribute_with_type_cast(attr_name, value, true)
       end
 
       def raw_write_attribute(attr_name, value)
-        write_attribute_with_type_cast(attr_name, value, :raw_type_cast_attribute_for_write)
+        write_attribute_with_type_cast(attr_name, value, false)
       end
 
       private
@@ -68,30 +66,17 @@ module ActiveRecord
         write_attribute(attribute_name, value)
       end
 
-      def type_cast_attribute_for_write(column, value)
-        return value unless column
-
-        column.type_cast_for_write value
-      end
-      alias_method :raw_type_cast_attribute_for_write, :type_cast_attribute_for_write
-
-      def write_attribute_with_type_cast(attr_name, value, type_cast_method)
+      def write_attribute_with_type_cast(attr_name, value, should_type_cast)
         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)
 
-        # If we're dealing with a binary column, write the data to the cache
-        # so we don't attempt to typecast multiple times.
-        if column && column.binary?
-          @attributes_cache[attr_name] = value
-        end
-
-        if column || @attributes.has_key?(attr_name)
-          @attributes[attr_name] = send(type_cast_method, column, value)
+        if should_type_cast
+          @attributes.write_from_user(attr_name, value)
         else
-          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
+          @attributes.write_from_database(attr_name, value)
         end
+
+        value
       end
     end
   end