activerecord 3.1.10 → 4.2.11

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,100 +1,190 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/module/attribute_accessors'
 
 module ActiveRecord
   module AttributeMethods
-    module Dirty
+    module Dirty # :nodoc:
       extend ActiveSupport::Concern
+
       include ActiveModel::Dirty
-      include AttributeMethods::Write
 
       included do
         if self < ::ActiveRecord::Timestamp
           raise "You cannot include Dirty after Timestamp"
         end
 
-        class_attribute :partial_updates
-        self.partial_updates = true
+        class_attribute :partial_writes, instance_writer: false
+        self.partial_writes = true
       end
 
       # Attempts to +save+ the record and clears changed attributes if successful.
-      def save(*) #:nodoc:
+      def save(*)
         if status = super
-          @previously_changed = changes
-          @changed_attributes.clear
-        elsif IdentityMap.enabled?
-          IdentityMap.remove(self)
+          changes_applied
         end
         status
       end
 
       # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
-      def save!(*) #:nodoc:
+      def save!(*)
         super.tap do
-          @previously_changed = changes
-          @changed_attributes.clear
+          changes_applied
         end
-        rescue
-          IdentityMap.remove(self) if IdentityMap.enabled?
-          raise
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
-      def reload(*) #:nodoc:
+      def reload(*)
         super.tap do
-          @previously_changed.clear
-          @changed_attributes.clear
+          clear_changes_information
+        end
+      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
+
+      def clear_changes_information
+        super
+        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 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
+        self.class.column_defaults.each do |attr, orig_value|
+          set_attribute_was(attr, orig_value) if _field_changed?(attr, orig_value)
         end
       end
 
-    private
       # Wrap write_attribute to remember original attribute value.
       def write_attribute(attr, value)
         attr = attr.to_s
 
-        # The attribute already has an unsaved change.
+        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
+
+      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 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)
-          # Save Time objects as TimeWithZone if time_zone_aware_attributes == true
-          old = old.in_time_zone if clone_with_time_zone_conversion_attribute?(attr, old)
-          @changed_attributes[attr] = old if field_changed?(attr, old, value)
+          clone_attribute_value(:_read_attribute, attr)
         end
+      end
 
-        # Carry on.
-        super(attr, value)
+      def _update_record(*)
+        partial_writes? ? super(keys_for_partial_write) : super
       end
 
-      def update(*)
-        if partial_updates?
-          # Serialized attributes should always be written in case they've been
-          # changed in place.
-          super(changed | (attributes.keys & self.class.serialized_attributes.keys))
-        else
-          super
+      def _create_record(*)
+        partial_writes? ? super(keys_for_partial_write) : super
+      end
+
+      # Serialized attributes should always be written in case they've been
+      # changed in place.
+      def keys_for_partial_write
+        changed & persistable_attribute_names
+      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 field_changed?(attr, old, value)
-        if column = column_for_attribute(attr)
-          if column.number? && column.null && (old.nil? || old == 0) && value.blank?
-            # 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)
-            value = nil
-          else
-            value = column.type_cast(value)
-          end
+      def changed_in_place
+        self.class.attribute_names.select do |attr_name|
+          attribute_changed_in_place?(attr_name)
         end
+      end
+
+      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
 
-        old != value
+      def cache_changed_attributes
+        @cached_changed_attributes = changed_attributes
+        yield
+      ensure
+        clear_changed_attributes_cache
       end
 
-      def clone_with_time_zone_conversion_attribute?(attr, old)
-        old.class.name == "Time" && time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
+      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

@@ -1,75 +1,126 @@
+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 available
+      # Returns this record's primary key value wrapped in an Array if one is
+      # available.
       def to_key
-        key = send(self.class.primary_key)
+        sync_with_transaction_state
+        key = self.id
         [key] if key
       end
 
+      # Returns the primary key value.
+      def id
+        if pk = self.class.primary_key
+          sync_with_transaction_state
+          _read_attribute(pk)
+        end
+      end
+
+      # Sets the primary key value.
+      def id=(value)
+        sync_with_transaction_state
+        write_attribute(self.class.primary_key, value) if self.class.primary_key
+      end
+
+      # Queries the primary key value.
+      def id?
+        sync_with_transaction_state
+        query_attribute(self.class.primary_key)
+      end
+
+      # Returns the primary key value before type cast.
+      def id_before_type_cast
+        sync_with_transaction_state
+        read_attribute_before_type_cast(self.class.primary_key)
+      end
+
+      # Returns the primary key previous value.
+      def id_was
+        sync_with_transaction_state
+        attribute_was(self.class.primary_key)
+      end
+
+      protected
+
+      def attribute_method?(attr_name)
+        attr_name == 'id' || super
+      end
+
       module ClassMethods
-        # Defines the primary key field -- can be overridden in subclasses. Overwriting will negate any effect of the
-        # primary_key_prefix_type setting, though.
+        def define_method_attribute(attr_name)
+          super
+
+          if attr_name == primary_key && attr_name != 'id'
+            generated_attribute_methods.send(:alias_method, :id, primary_key)
+          end
+        end
+
+        ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was).to_set
+
+        def dangerous_attribute_method?(method_name)
+          super && !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
 
-        # Returns a quoted version of the primary key name, used to construct SQL statements.
+        # 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
 
         def reset_primary_key #:nodoc:
-          key = self == base_class ? get_primary_key(base_class.name) :
-            base_class.primary_key
-
-          set_primary_key(key)
-          key
+          if self == base_class
+            self.primary_key = get_primary_key(base_class.name)
+          else
+            self.primary_key = base_class.primary_key
+          end
         end
 
         def get_primary_key(base_name) #:nodoc:
-          return 'id' unless base_name && !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 && connection.table_exists?(table_name)
-              connection.primary_key(table_name)
+            if ActiveRecord::Base != self && table_exists?
+              connection.schema_cache.primary_keys(table_name)
             else
               'id'
             end
           end
         end
 
-        attr_accessor :original_primary_key
-
-        # Attribute writer for the primary key column
-        def primary_key=(value)
-          @quoted_primary_key = nil
-          @primary_key = value
-
-          connection_pool.primary_keys[table_name] = @primary_key if connected?
-        end
-
-        # Sets the name of the primary key column to use to the given value,
-        # or (if the value is nil or false) to the value returned by the given
-        # block.
+        # Sets the name of the primary key column.
         #
         #   class Project < ActiveRecord::Base
-        #     set_primary_key "sysid"
+        #     self.primary_key = 'sysid'
         #   end
-        def set_primary_key(value = nil, &block)
+        #
+        # 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
-          @primary_key ||= ''
-          self.original_primary_key = @primary_key
-          value &&= value.to_s
-          self.primary_key = block_given? ? instance_eval(&block) : value
+          @attributes_builder = nil
         end
       end
     end

data/lib/active_record/attribute_methods/query.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/object/blank'
-
 module ActiveRecord
   module AttributeMethods
     module Query
@@ -10,8 +8,11 @@ module ActiveRecord
       end
 
       def query_attribute(attr_name)
-        unless value = read_attribute(attr_name)
-          false
+        value = self[attr_name]
+
+        case value
+        when true        then true
+        when false, nil  then false
         else
           column = self.class.columns_hash[attr_name]
           if column.nil?

data/lib/active_record/attribute_methods/read.rb

@@ -1,146 +1,103 @@
+require 'active_support/core_ext/module/method_transplanting'
+
 module ActiveRecord
   module AttributeMethods
     module Read
-      extend ActiveSupport::Concern
-
-      ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
-
-      included do
-        attribute_method_suffix ""
-
-        cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
-        self.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
-
-        # Undefine id so it can be used as an attribute name
-        undef_method(:id) if method_defined?(:id)
-      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 }
+      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
 
-        # 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
+      extend ActiveSupport::Concern
 
-        # Returns +true+ if the provided attribute is being cached.
-        def cache_attribute?(attr_name)
-          cached_attributes.include?(attr_name)
+      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 define_method_attribute(attr_name)
-            if serialized_attributes.include?(attr_name)
-              define_read_method_for_serialized_attribute(attr_name)
-            else
-              define_read_method(attr_name, attr_name, columns_hash[attr_name])
-            end
 
-            if attr_name == primary_key && attr_name != "id"
-              define_read_method('id', attr_name, columns_hash[attr_name])
-            end
-          end
-
-        private
-          def cacheable_column?(column)
-            serialized_attributes.include?(column.name) || attribute_types_cached_by_default.include?(column.type)
-          end
+        def cached_attributes_deprecation_warning(method_name)
+          ActiveSupport::Deprecation.warn "Calling `#{method_name}` is no longer necessary. All attributes are cached."
+        end
 
-          # Define read method for serialized attribute.
-          def define_read_method_for_serialized_attribute(attr_name)
-            access_code = "@attributes_cache['#{attr_name}'] ||= @attributes['#{attr_name}']"
-            generated_attribute_methods.module_eval("def _#{attr_name}; #{access_code}; end; alias #{attr_name} _#{attr_name}", __FILE__, __LINE__)
+        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}"
 
-          # Define an attribute reader method.  Cope with nil column.
-          # method_name is the same as attr_name except when a non-standard primary key is used,
-          # we still define #id as an accessor for the key
-          def define_read_method(method_name, attr_name, column)
-            cast_code = column.type_cast_code('v')
-            access_code = "(v=@attributes['#{attr_name}']) && #{cast_code}"
-
-            unless attr_name.to_s == self.primary_key.to_s
-              access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
-            end
-
-            if cache_attribute?(attr_name)
-              access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
-            end
-
-            # Where possible, generate the method by evalling a string, as this will result in
-            # faster accesses because it avoids the block eval and then string eval incurred
-            # by the second branch.
-            #
-            # The second, slower, branch is necessary to support instances where the database
-            # returns columns with extra stuff in (like 'my_column(omg)').
-            if method_name =~ ActiveModel::AttributeMethods::COMPILABLE_REGEXP
-              generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__
-                def _#{method_name}
-                  #{access_code}
-                end
+            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 
-                alias #{method_name} _#{method_name}
-              STR
-            else
-              generated_attribute_methods.module_eval do
-                define_method("_#{method_name}") { eval(access_code) }
-                alias_method(method_name, "_#{method_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
-            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 data column is cast to a date object, like Date.new(2004, 12, 12)).
-      def read_attribute(attr_name)
-        method = "_#{attr_name}"
-        if respond_to? method
-          send method if @attributes.has_key?(attr_name.to_s)
-        else
-          _read_attribute attr_name
-        end
-      end
+            STR
 
-      def _read_attribute(attr_name)
-        attr_name = attr_name.to_s
-        attr_name = self.class.primary_key if attr_name == 'id'
-        value = @attributes[attr_name]
-        unless value.nil?
-          if column = column_for_attribute(attr_name)
-            if unserializable_attribute?(attr_name, column)
-              unserialize_attribute(attr_name)
-            else
-              column.type_cast(value)
+            generated_attribute_methods.module_eval do
+              alias_method name, temp_method
+              undef_method temp_method
             end
-          else
-            value
           end
         end
       end
 
-      # Returns true if the attribute is of a text column and marked for serialization.
-      def unserializable_attribute?(attr_name, column)
-        column.text? && self.class.serialized_attributes.include?(attr_name)
-      end
+      ID = 'id'.freeze
 
-      # Returns the unserialized object of the attribute.
-      def unserialize_attribute(attr_name)
-        coder = self.class.serialized_attributes[attr_name]
-        unserialized_object = coder.load(@attributes[attr_name])
+      # 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
+        _read_attribute(name, &block)
+      end
 
-        @attributes.frozen? ? unserialized_object : @attributes[attr_name] = unserialized_object
+      # 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)
-        end
+
+      def attribute(attribute_name)
+        _read_attribute(attribute_name)
+      end
     end
   end
 end