activerecord 3.2.22.4 → 4.0.13

data/lib/active_record/attribute_methods/primary_key.rb

@@ -1,56 +1,79 @@
+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
+        sync_with_transaction_state
         key = self.id
         [key] if key
       end
 
-      # Returns the primary key value
+      # Returns the primary key value.
       def id
+        sync_with_transaction_state
         read_attribute(self.class.primary_key)
       end
 
-      # Sets the primary key value
+      # Sets the primary key value.
       def id=(value)
-        write_attribute(self.class.primary_key, value)
+        sync_with_transaction_state
+        write_attribute(self.class.primary_key, value) if self.class.primary_key
       end
 
-      # Queries the primary key value
+      # 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
         def define_method_attribute(attr_name)
           super
 
           if attr_name == primary_key && attr_name != 'id'
             generated_attribute_methods.send(:alias_method, :id, primary_key)
-            generated_external_attribute_methods.module_eval <<-CODE, __FILE__, __LINE__
-              def id(v, attributes, attributes_cache, attr_name)
-                attr_name = '#{primary_key}'
-                send(attr_name, attributes[attr_name], attributes, attributes_cache, attr_name)
-              end
-            CODE
           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', 'id=', 'id?'].include?(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.
+        # 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
@@ -64,7 +87,7 @@ module ActiveRecord
         end
 
         def get_primary_key(base_name) #:nodoc:
-          return 'id' unless base_name && !base_name.blank?
+          return 'id' if base_name.blank?
 
           case primary_key_prefix_type
           when :table_name
@@ -73,39 +96,30 @@ module ActiveRecord
             base_name.foreign_key
           else
             if ActiveRecord::Base != self && table_exists?
-              connection.schema_cache.primary_keys[table_name]
+              connection.schema_cache.primary_keys(table_name)
             else
               'id'
             end
           end
         end
 
-        def original_primary_key #:nodoc:
-          deprecated_original_property_getter :primary_key
-        end
-
         # Sets the name of the primary key column.
         #
         #   class Project < ActiveRecord::Base
-        #     self.primary_key = "sysid"
+        #     self.primary_key = 'sysid'
         #   end
         #
-        # You can also define the primary_key method yourself:
+        # You can also define the +primary_key+ method yourself:
         #
         #   class Project < ActiveRecord::Base
         #     def self.primary_key
-        #       "foo_" + super
+        #       'foo_' + super
         #     end
         #   end
+        #
         #   Project.primary_key # => "foo_id"
         def primary_key=(value)
-          @original_primary_key = @primary_key if defined?(@primary_key)
-          @primary_key          = value && value.to_s
-          @quoted_primary_key   = nil
-        end
-
-        def set_primary_key(value = nil, &block) #:nodoc:
-          deprecated_property_setter :primary_key, value, block
+          @primary_key        = value && value.to_s
           @quoted_primary_key = nil
         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 = read_attribute(attr_name) { |n| missing_attribute(n, caller) }
+
+        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

@@ -6,14 +6,15 @@ module ActiveRecord
       ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
 
       included do
-        cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
+        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+).
+        # +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 }
         end
@@ -29,108 +30,84 @@ module ActiveRecord
           cached_attributes.include?(attr_name)
         end
 
-        def undefine_attribute_methods
-          generated_external_attribute_methods.module_eval do
-            instance_methods.each { |m| undef_method(m) }
-          end
-
-          super
-        end
-
-        def type_cast_attribute(attr_name, attributes, cache = {}) #:nodoc:
-          return unless attr_name
-          attr_name = attr_name.to_s
+        protected
 
-          if generated_external_attribute_methods.method_defined?(attr_name)
-            if attributes.has_key?(attr_name) || attr_name == 'id'
-              generated_external_attribute_methods.send(attr_name, attributes[attr_name], attributes, cache, attr_name)
+        # 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_cache in read_attribute.
+        def define_method_attribute(name)
+          safe_name = name.unpack('h*').first
+          generated_attribute_methods::AttrNames.set_name_cache safe_name, name
+
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}
+              read_attribute(AttrNames::ATTR_#{safe_name}) { |n| missing_attribute(n, caller) }
             end
-          elsif !attribute_methods_generated?
-            # If we haven't generated the caster methods yet, do that and
-            # then try again
-            define_attribute_methods
-            type_cast_attribute(attr_name, attributes, cache)
-          else
-            # If we get here, the attribute has no associated DB column, so
-            # just return it verbatim.
-            attributes[attr_name]
-          end
+            alias_method #{name.inspect}, :__temp__#{safe_name}
+            undef_method :__temp__#{safe_name}
+          STR
         end
 
-        protected
-          # We want to generate the methods via module_eval rather than define_method,
-          # because define_method is slower on dispatch and uses more memory (because it
-          # creates a closure).
-          #
-          # 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.
-          def define_method_attribute(attr_name)
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__
-                #{internal_attribute_access_code(attr_name, attribute_cast_code(attr_name))}
-              end
-              alias_method '#{attr_name}', :__temp__
-              undef_method :__temp__
-            STR
-          end
-
         private
 
-          def define_external_attribute_method(attr_name)
-            generated_external_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__(v, attributes, attributes_cache, attr_name)
-                #{external_attribute_access_code(attr_name, attribute_cast_code(attr_name))}
-              end
-              alias_method '#{attr_name}', :__temp__
-              undef_method :__temp__
-            STR
-          end
-
-          def cacheable_column?(column)
+        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
 
-          def internal_attribute_access_code(attr_name, cast_code)
-            access_code = "(v=@attributes[attr_name]) && #{cast_code}"
-
-            unless attr_name == primary_key
-              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
-
-            "attr_name = '#{attr_name}'; #{access_code}"
-          end
-
-          def external_attribute_access_code(attr_name, cast_code)
-            access_code = "v && #{cast_code}"
-
-            if cache_attribute?(attr_name)
-              access_code = "attributes_cache[attr_name] ||= (#{access_code})"
+      # 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)
+        # 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.
+        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
 
-            access_code
-          end
+          value = @attributes.fetch(name) {
+            return block_given? ? yield(name) : nil
+          }
 
-          def attribute_cast_code(attr_name)
-            columns_hash[attr_name].type_cast_code('v')
+          if self.class.cache_attribute?(name)
+            @attributes_cache[name] = column.type_cast(value)
+          else
+            column.type_cast value
           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)
-        self.class.type_cast_attribute(attr_name, @attributes, @attributes_cache)
+        }
       end
 
       private
-        def attribute(attribute_name)
-          read_attribute(attribute_name)
-        end
+
+      def attribute(attribute_name)
+        read_attribute(attribute_name)
+      end
     end
   end
 end

data/lib/active_record/attribute_methods/serialization.rb

@@ -4,114 +4,177 @@ module ActiveRecord
       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
+        # 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
 
-      class Attribute < Struct.new(:coder, :value, :state)
-        def unserialized_value
-          state == :serialized ? unserialize : value
-        end
-
-        def serialized_value
-          state == :unserialized ? serialize : value
-        end
-
-        def unserialize
-          self.state = :unserialized
-          self.value = coder.load(value)
-        end
-
-        def serialize
-          self.state = :serialized
-          self.value = coder.dump(value)
-        end
-      end
-
       module ClassMethods
-        # 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 serialization is done through YAML. If +class_name+ is specified, the serialized object must be of that
-        # class on retrieval or SerializationTypeMismatch will be raised.
+        ##
+        # :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
+        # serialization is done through YAML. If +class_name+ is specified, the
+        # serialized object must be of that class on retrieval or
+        # <tt>SerializationTypeMismatch</tt> will be raised.
         #
         # ==== Parameters
         #
         # * +attr_name+ - The field name that should be serialized.
-        # * +class_name+ - Optional, class name that the object type should be equal to.
+        # * +class_name_or_coder+ - Optional, a coder object, which responds to `.load` / `.dump`
+        #   or a class name that the object type should be equal to.
         #
         # ==== Example
-        #   # Serialize a preferences attribute
+        #
+        #   # Serialize a preferences attribute.
         #   class User < ActiveRecord::Base
         #     serialize :preferences
         #   end
-        def serialize(attr_name, class_name = Object)
-          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
-                    class_name
+        #
+        #   # Serialize preferences using JSON as coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, JSON
+        #   end
+        #
+        #   # Serialize preferences as Hash using YAML coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, Hash
+        #   end
+        def serialize(attr_name, class_name_or_coder = Object)
+          include Behavior
+
+          coder = if [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+                    class_name_or_coder
                   else
-                    Coders::YAMLColumn.new(class_name)
+                    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
 
-        def initialize_attributes(attributes, options = {}) #:nodoc:
-          serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
-          super(attributes, options)
+      # *DEPRECATED*: Use ActiveRecord::AttributeMethods::Serialization::ClassMethods#serialized_attributes class level method instead.
+      def serialized_attributes
+        message = "Instance level serialized_attributes method is deprecated, please use class level method."
+        ActiveSupport::Deprecation.warn message
+        defined?(@serialized_attributes) ? @serialized_attributes : self.class.serialized_attributes
+      end
 
-          serialized_attributes.each do |key, coder|
-            if attributes.key?(key)
-              attributes[key] = Attribute.new(coder, attributes[key], serialized)
-            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
           end
+        end
 
-          attributes
+        def type
+          @column.type
         end
+      end
 
-        private
+      class Attribute < Struct.new(:coder, :value, :state) # :nodoc:
+        def unserialized_value(v = value)
+          state == :serialized ? unserialize(v) : value
+        end
 
-        def attribute_cast_code(attr_name)
-          if serialized_attributes.include?(attr_name)
-            "v.unserialized_value"
+        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 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
-      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
+        def _field_changed?(attr, old, value)
+          if self.class.serialized_attributes.include?(attr)
+            old != value
+          else
+            super
+          end
         end
-      end
 
-      def _field_changed?(attr, old, value)
-        if self.class.serialized_attributes.include?(attr)
-          old != value
-        else
-          super
+        def read_attribute_before_type_cast(attr_name)
+          if self.class.serialized_attributes.include?(attr_name)
+            super.unserialized_value
+          else
+            super
+          end
         end
-      end
 
-      def read_attribute_before_type_cast(attr_name)
-        if serialized_attributes.include?(attr_name)
-          super.unserialized_value
-        else
-          super
+        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
-      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
+        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
         end
       end