activerecord 3.0.0 → 4.0.0

data/lib/active_record/attribute_methods/read.rb

@@ -6,28 +6,23 @@ module ActiveRecord
       ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
 
       included do
-        attribute_method_suffix ""
-
-        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
-
-        # 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+).
+        # +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)
-          attribute_names.each {|attr| cached_attributes << attr.to_s}
+          cached_attributes.merge attribute_names.map { |attr| attr.to_s }
         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| attribute_types_cached_by_default.include?(c.type)}.map{|col| col.name}.to_set
+          @cached_attributes ||= columns.select { |c| cacheable_column?(c) }.map { |col| col.name }.to_set
         end
 
         # Returns +true+ if the provided attribute is being cached.
@@ -36,81 +31,77 @@ module ActiveRecord
         end
 
         protected
-          def define_method_attribute(attr_name)
-            if self.serialized_attributes[attr_name]
-              define_read_method_for_serialized_attribute(attr_name)
-            else
-              define_read_method(attr_name.to_sym, 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])
+        # 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.
+        #
+        # 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.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}
+              read_attribute(AttrNames::ATTR_#{safe_name}) { |n| missing_attribute(n, caller) }
             end
-          end
+            alias_method #{name.inspect}, :__temp__#{safe_name}
+            undef_method :__temp__#{safe_name}
+          STR
+        end
 
         private
-          # Define read method for serialized attribute.
-          def define_read_method_for_serialized_attribute(attr_name)
-            generated_attribute_methods.module_eval("def #{attr_name}; unserialize_attribute('#{attr_name}'); end", __FILE__, __LINE__)
-          end
 
-          # Define an attribute reader method.  Cope with nil column.
-          def define_read_method(symbol, attr_name, column)
-            cast_code = column.type_cast_code('v') if column
-            access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
-
-            unless attr_name.to_s == self.primary_key.to_s
-              access_code = 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
-            generated_attribute_methods.module_eval("def #{symbol}; #{access_code}; end", __FILE__, __LINE__)
+        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 data column is cast to a date object, like Date.new(2004, 12, 12)).
+      # 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)
-        attr_name = attr_name.to_s
-        attr_name = self.class.primary_key if attr_name == 'id'
-        if !(value = @attributes[attr_name]).nil?
-          if column = column_for_attribute(attr_name)
-            if unserializable_attribute?(attr_name, column)
-              unserialize_attribute(attr_name)
-            else
-              column.type_cast(value)
-            end
+        # 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 = @columns_hash.fetch(name) {
+            return @attributes.fetch(name) {
+              if name == 'id' && self.class.primary_key != name
+                read_attribute(self.class.primary_key)
+              end
+            }
+          }
+
+          value = @attributes.fetch(name) {
+            return block_given? ? yield(name) : nil
+          }
+
+          if self.class.cache_attribute?(name)
+            @attributes_cache[name] = column.type_cast(value)
           else
-            value
+            column.type_cast value
           end
-        else
-          nil
-        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[attr_name]
+        }
       end
 
-      # Returns the unserialized object of the attribute.
-      def unserialize_attribute(attr_name)
-        unserialized_object = object_from_yaml(@attributes[attr_name])
+      private
 
-        if unserialized_object.is_a?(self.class.serialized_attributes[attr_name]) || unserialized_object.nil?
-          @attributes.frozen? ? unserialized_object : @attributes[attr_name] = unserialized_object
-        else
-          raise SerializationTypeMismatch,
-            "#{attr_name} was supposed to be a #{self.class.serialized_attributes[attr_name]}, but was a #{unserialized_object.class.to_s}"
-        end
+      def attribute(attribute_name)
+        read_attribute(attribute_name)
       end
-
-      private
-        def attribute(attribute_name)
-          read_attribute(attribute_name)
-        end
     end
   end
 end

data/lib/active_record/attribute_methods/serialization.rb

@@ -0,0 +1,162 @@
+module ActiveRecord
+  module AttributeMethods
+    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
+        # 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.
+        #
+        # ==== Example
+        #
+        #   # Serialize a preferences attribute.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences
+        #   end
+        def serialize(attr_name, class_name = Object)
+          include Behavior
+
+          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
+                    class_name
+                  else
+                    Coders::YAMLColumn.new(class_name)
+                  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
+
+      # *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
+
+      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
+
+        def type
+          @column.type
+        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 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 _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
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,60 +1,58 @@
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
+      class Type # :nodoc:
+        def initialize(column)
+          @column = column
+        end
+
+        def type_cast(value)
+          value = @column.type_cast(value)
+          value.acts_like?(:time) ? value.in_time_zone : value
+        end
+
+        def type
+          @column.type
+        end
+      end
+
       extend ActiveSupport::Concern
 
       included do
-        cattr_accessor :time_zone_aware_attributes, :instance_writer => false
+        mattr_accessor :time_zone_aware_attributes, instance_writer: false
         self.time_zone_aware_attributes = false
 
-        class_inheritable_accessor :skip_time_zone_conversion_for_attributes, :instance_writer => false
+        class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false
         self.skip_time_zone_conversion_for_attributes = []
       end
 
       module ClassMethods
         protected
-          # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-          # This enhanced read method automatically converts the UTC time stored in the database to the time
-          # 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}(reload = false)
-                  cached = @attributes_cache['#{attr_name}']
-                  return cached if cached && !reload
-                  time = read_attribute('#{attr_name}')
-                  @attributes_cache['#{attr_name}'] = time.acts_like?(:time) ? time.in_time_zone : time
-                end
-              EOV
-              generated_attribute_methods.module_eval(method_body, __FILE__, line)
-            else
-              super
-            end
-          end
-
-          # 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)
-                  unless time.acts_like?(:time)
-                    time = time.is_a?(String) ? Time.zone.parse(time) : time.to_time rescue time
-                  end
-                  time = time.in_time_zone rescue nil if time
-                  write_attribute(:#{attr_name}, time)
-                end
-              EOV
-              generated_attribute_methods.module_eval(method_body, __FILE__, line)
-            else
-              super
-            end
+        # 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 = time.respond_to?(:in_time_zone) ? time.in_time_zone : nil
+                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
           end
+        end
 
         private
-          def create_time_zone_conversion_attribute?(name, column)
-            time_zone_aware_attributes && !skip_time_zone_conversion_for_attributes.include?(name.to_sym) && [:datetime, :timestamp].include?(column.type)
-          end
+        def create_time_zone_conversion_attribute?(name, column)
+          time_zone_aware_attributes &&
+            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) &&
+            [:datetime, :timestamp].include?(column.type)
+        end
       end
     end
   end

data/lib/active_record/attribute_methods/write.rb

@@ -9,29 +9,55 @@ module ActiveRecord
 
       module ClassMethods
         protected
-          def define_method_attribute=(attr_name)
-            generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
-          end
+
+        # See define_method_attribute in read.rb for an explanation of
+        # this code.
+        def define_method_attribute=(name)
+          safe_name = name.unpack('h*').first
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}=(value)
+              write_attribute(AttrNames::ATTR_#{safe_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 fixnum and float columns are turned into +nil+.
+      # Updates the attribute identified by <tt>attr_name</tt> with the
+      # specified +value+. Empty strings for fixnum and float columns are
+      # turned into +nil+.
       def write_attribute(attr_name, value)
         attr_name = attr_name.to_s
-        attr_name = self.class.primary_key if attr_name == 'id'
+        attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
         @attributes_cache.delete(attr_name)
-        if (column = column_for_attribute(attr_name)) && column.number?
-          @attributes[attr_name] = convert_number_column_value(value)
+        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] = type_cast_attribute_for_write(column, value)
         else
-          @attributes[attr_name] = value
+          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
         end
       end
+      alias_method :raw_write_attribute, :write_attribute
 
       private
-        # Handle *= for method_missing.
-        def attribute=(attribute_name, value)
-          write_attribute(attribute_name, value)
-        end
+      # Handle *= for method_missing.
+      def attribute=(attribute_name, value)
+        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
     end
   end
 end