activerecord 4.1.16 → 4.2.11.3

data/lib/active_record/attribute_assignment.rb

@@ -11,6 +11,15 @@ module ActiveRecord
     # If the passed hash responds to <tt>permitted?</tt> method and the return value
     # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
     # exception is raised.
+    #
+    #   cat = Cat.new(name: "Gorby", status: "yawning")
+    #   cat.attributes # =>  { "name" => "Gorby", "status" => "yawning", "created_at" => nil, "updated_at" => nil}
+    #   cat.assign_attributes(status: "sleeping")
+    #   cat.attributes # =>  { "name" => "Gorby", "status" => "sleeping", "created_at" => nil, "updated_at" => nil }
+    #
+    # New attributes will be persisted in the database when the object is saved.
+    #
+    # Aliased to <tt>attributes=</tt>.
     def assign_attributes(new_attributes)
       if !new_attributes.respond_to?(:stringify_keys)
         raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
@@ -60,7 +69,7 @@ module ActiveRecord
     # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
     # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
     # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
-    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Fixnum and
+    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
     # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
     def assign_multiparameter_attributes(pairs)
       execute_callstack_for_multiparameter_attributes(
@@ -106,7 +115,7 @@ module ActiveRecord
     end
 
     class MultiparameterAttribute #:nodoc:
-      attr_reader :object, :name, :values, :column
+      attr_reader :object, :name, :values, :cast_type
 
       def initialize(object, name, values)
         @object = object
@@ -117,22 +126,22 @@ module ActiveRecord
       def read_value
         return if values.values.compact.empty?
 
-        @column = object.class.reflect_on_aggregation(name.to_sym) || object.column_for_attribute(name)
-        klass   = column.klass
+        @cast_type = object.type_for_attribute(name)
+        klass = cast_type.klass
 
         if klass == Time
           read_time
         elsif klass == Date
           read_date
         else
-          read_other(klass)
+          read_other
         end
       end
 
       private
 
       def instantiate_time_object(set_values)
-        if object.class.send(:create_time_zone_conversion_attribute?, name, column)
+        if object.class.send(:create_time_zone_conversion_attribute?, name, cast_type)
           Time.zone.local(*set_values)
         else
           Time.send(object.class.default_timezone, *set_values)
@@ -140,9 +149,9 @@ module ActiveRecord
       end
 
       def read_time
-        # If column is a :time (and not :date or :timestamp) there is no need to validate if
+        # If column is a :time (and not :date or :datetime) there is no need to validate if
         # there are year/month/day fields
-        if column.type == :time
+        if cast_type.type == :time
           # if the column is a time set the values to their defaults as January 1, 1970, but only if they're nil
           { 1 => 1970, 2 => 1, 3 => 1 }.each do |key,value|
             values[key] ||= value
@@ -172,13 +181,12 @@ module ActiveRecord
         end
       end
 
-      def read_other(klass)
+      def read_other
         max_position = extract_max_param
         positions    = (1..max_position)
         validate_required_parameters!(positions)
 
-        set_values = values.values_at(*positions)
-        klass.new(*set_values)
+        values.slice(*positions)
       end
 
       # Checks whether some blank date parameter exists. Note that this is different

data/lib/active_record/attribute_decorators.rb

@@ -0,0 +1,66 @@
+module ActiveRecord
+  module AttributeDecorators # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attribute_type_decorations, instance_accessor: false # :internal:
+      self.attribute_type_decorations = TypeDecorator.new
+    end
+
+    module ClassMethods # :nodoc:
+      def decorate_attribute_type(column_name, decorator_name, &block)
+        matcher = ->(name, _) { name == column_name.to_s }
+        key = "_#{column_name}_#{decorator_name}"
+        decorate_matching_attribute_types(matcher, key, &block)
+      end
+
+      def decorate_matching_attribute_types(matcher, decorator_name, &block)
+        clear_caches_calculated_from_columns
+        decorator_name = decorator_name.to_s
+
+        # Create new hashes so we don't modify parent classes
+        self.attribute_type_decorations = attribute_type_decorations.merge(decorator_name => [matcher, block])
+      end
+
+      private
+
+      def add_user_provided_columns(*)
+        super.map do |column|
+          decorated_type = attribute_type_decorations.apply(column.name, column.cast_type)
+          column.with_type(decorated_type)
+        end
+      end
+    end
+
+    class TypeDecorator # :nodoc:
+      delegate :clear, to: :@decorations
+
+      def initialize(decorations = {})
+        @decorations = decorations
+      end
+
+      def merge(*args)
+        TypeDecorator.new(@decorations.merge(*args))
+      end
+
+      def apply(name, type)
+        decorations = decorators_for(name, type)
+        decorations.inject(type) do |new_type, block|
+          block.call(new_type)
+        end
+      end
+
+      private
+
+      def decorators_for(name, type)
+        matching(name, type).map(&:last)
+      end
+
+      def matching(name, type)
+        @decorations.values.select do |(matcher, _)|
+          matcher.call(name, type)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -28,6 +28,7 @@ module ActiveRecord
 
       included do
         attribute_method_suffix "_before_type_cast"
+        attribute_method_suffix "_came_from_user?"
       end
 
       # Returns the value of the attribute identified by +attr_name+ before
@@ -43,7 +44,7 @@ module ActiveRecord
       #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
       #   task.read_attribute_before_type_cast(:completed_on)  # => "2012-10-21"
       def read_attribute_before_type_cast(attr_name)
-        @attributes[attr_name.to_s]
+        @attributes[attr_name.to_s].value_before_type_cast
       end
 
       # Returns a hash of attributes before typecasting and deserialization.
@@ -57,7 +58,7 @@ module ActiveRecord
       #   task.attributes_before_type_cast
       #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>"2012-10-21", "created_at"=>nil, "updated_at"=>nil}
       def attributes_before_type_cast
-        @attributes
+        @attributes.values_before_type_cast
       end
 
       private
@@ -66,6 +67,10 @@ module ActiveRecord
       def attribute_before_type_cast(attribute_name)
         read_attribute_before_type_cast(attribute_name)
       end
+
+      def attribute_came_from_user?(attribute_name)
+        @attributes[attribute_name].came_from_user?
+      end
     end
   end
 end

data/lib/active_record/attribute_methods/dirty.rb

@@ -34,28 +34,57 @@ 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
+        @original_raw_attributes = nil
+        calculate_changes_from_defaults
+      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
+        # This should only be set by methods which will call changed_attributes
+        # multiple times when it is known that the computed value cannot change.
+        if defined?(@cached_changed_attributes)
+          @cached_changed_attributes
+        else
+          super.reverse_merge(attributes_changed_in_place).freeze
+        end
       end
 
-      def init_changed_attributes
+      def changes
+        cache_changed_attributes do
+          super
+        end
+      end
+
+      def attribute_changed_in_place?(attr_name)
+        old_value = original_raw_attribute(attr_name)
+        @attributes[attr_name].changed_in_place_from?(old_value)
+      end
+
+      private
+
+      def changes_include?(attr_name)
+        super || attribute_changed_in_place?(attr_name)
+      end
+
+      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 +92,36 @@ 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)
+        clear_changed_attributes_cache
+        if attribute_changed_by_setter?(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
 
@@ -90,37 +136,55 @@ module ActiveRecord
       # Serialized attributes should always be written in case they've been
       # changed in place.
       def keys_for_partial_write
-        changed
+        changed & persistable_attribute_names
       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
 
-        old != value
+      def changed_in_place
+        self.class.attribute_names.select do |attr_name|
+          attribute_changed_in_place?(attr_name)
+        end
       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 store_original_raw_attribute(attr_name)
+        original_raw_attributes[attr_name] = @attributes[attr_name].value_for_database rescue nil
+      end
+
+      def store_original_raw_attributes
+        attribute_names.each do |attr|
+          store_original_raw_attribute(attr)
+        end
       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 cache_changed_attributes
+        @cached_changed_attributes = changed_attributes
+        yield
+      ensure
+        clear_changed_attributes_cache
       end
 
-      def non_zero?(value)
-        value !~ /\A0+(\.0+)?\z/
+      def clear_changed_attributes_cache
+        remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
       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?
@@ -122,6 +120,7 @@ module ActiveRecord
         def primary_key=(value)
           @primary_key        = value && value.to_s
           @quoted_primary_key = nil
+          @attributes_builder = nil
         end
       end
     end

data/lib/active_record/attribute_methods/query.rb

@@ -8,7 +8,7 @@ module ActiveRecord
       end
 
       def query_attribute(attr_name)
-        value = read_attribute(attr_name) { |n| missing_attribute(n, caller) }
+        value = self[attr_name]
 
         case value
         when true        then true

data/lib/active_record/attribute_methods/read.rb

@@ -22,12 +22,12 @@ 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}
             name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{const_name}
-            read_attribute(name) { |n| missing_attribute(n, caller) }
+            _read_attribute(name) { |n| missing_attribute(n, caller) }
           end
           EOMETHOD
         end
@@ -35,35 +35,20 @@ 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 "Calling `#{method_name}` is no longer necessary. All attributes are cached."
         end
 
-        protected
-
         if Module.methods_transplantable?
           def define_method_attribute(name)
             method = ReaderMethodCache[name]
@@ -79,7 +64,7 @@ module ActiveRecord
             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) }
+                _read_attribute(name) { |n| missing_attribute(n, caller) }
               end
             STR
 
@@ -89,51 +74,29 @@ 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
 
+      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)
-        # 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
-          }
+        name = self.class.primary_key if name == ID
+        _read_attribute(name, &block)
+      end
 
-          if self.class.cache_attribute?(name)
-            @attributes_cache[name] = column.type_cast(value)
-          else
-            column.type_cast value
-          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? }
       end
 
       private
 
       def attribute(attribute_name)
-        read_attribute(attribute_name)
+        _read_attribute(attribute_name)
       end
     end
   end