activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/attribute_methods/serialization.rb

@@ -4,37 +4,19 @@ 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.
+        # 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
         #
@@ -42,11 +24,14 @@ module ActiveRecord
         # * +class_name+ - Optional, 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)
+          include Behavior
+
           coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
                     class_name
                   else
@@ -57,61 +42,107 @@ module ActiveRecord
           # 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)
+      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
-          end
+      class Type # :nodoc:
+        def initialize(column)
+          @column = column
+        end
 
-          attributes
+        def type_cast(value)
+          value.unserialized_value
         end
 
-        private
+        def type
+          @column.type
+        end
+      end
+
+      class Attribute < Struct.new(:coder, :value, :state) # :nodoc:
+        def unserialized_value
+          state == :serialized ? unserialize : 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
+          self.state = :unserialized
+          self.value = coder.load(value)
+        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
+          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
       end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,64 +1,58 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/inclusion'
-
 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_attribute :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
-          # The enhanced read method automatically converts the UTC time stored in the database to the time
-          # zone stored in Time.zone.
-          def attribute_cast_code(attr_name)
-            column = columns_hash[attr_name]
-
-            if create_time_zone_conversion_attribute?(attr_name, column)
-              typecast             = "v = #{super}"
-              time_zone_conversion = "v.acts_like?(:time) ? v.in_time_zone : v"
-
-              "((#{typecast}) && (#{time_zone_conversion}))"
-            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}=(original_time)
-                  original_time = nil if original_time.blank?
-                  time = original_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
-                  previous_time = attribute_changed?("#{attr_name}") ? changed_attributes["#{attr_name}"] : read_attribute(:#{attr_name})
-                  write_attribute(:#{attr_name}, original_time)
-                  #{attr_name}_will_change! if previous_time != time
-                  @attributes_cache["#{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 && !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) && column.type.in?([:datetime, :timestamp])
-          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,62 +9,55 @@ module ActiveRecord
 
       module ClassMethods
         protected
-          def define_method_attribute=(attr_name)
-            if attr_name =~ ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP
-              generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
-            else
-              generated_attribute_methods.send(:define_method, "#{attr_name}=") do |new_value|
-                write_attribute(attr_name, new_value)
-              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
-          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' && self.class.primary_key
         @attributes_cache.delete(attr_name)
         column = column_for_attribute(attr_name)
 
-        unless column || @attributes.has_key?(attr_name)
-          ActiveSupport::Deprecation.warn(
-            "You're trying to create an attribute `#{attr_name}'. Writing arbitrary " \
-            "attributes on a model is deprecated. Please just use `attr_writer` etc."
-          )
+        # 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
 
-        @attributes[attr_name] = type_cast_attribute_for_write(column, value)
+        if column || @attributes.has_key?(attr_name)
+          @attributes[attr_name] = type_cast_attribute_for_write(column, value)
+        else
+          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)
-          if column && column.number?
-            convert_number_column_value(value)
-          else
-            value
-          end
-        end
+      def type_cast_attribute_for_write(column, value)
+        return value unless column
 
-        def convert_number_column_value(value)
-          case value
-          when FalseClass
-            0
-          when TrueClass
-            1
-          when String
-            value.presence
-          else
-            value
-          end
-        end
+        column.type_cast_for_write value
+      end
     end
   end
 end

data/lib/active_record/autosave_association.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/array/wrap'
-
 module ActiveRecord
   # = Active Record Autosave Association
   #
@@ -18,7 +16,7 @@ module ActiveRecord
   # Note that it also means that associations marked for destruction won't
   # be destroyed directly. They will however still be marked for destruction.
   #
-  # Note that <tt>:autosave => false</tt> is not same as not declaring <tt>:autosave</tt>.
+  # Note that <tt>autosave: false</tt> is not same as not declaring <tt>:autosave</tt>.
   # When the <tt>:autosave</tt> option is not present new associations are saved.
   #
   # == Validation
@@ -30,16 +28,14 @@ module ActiveRecord
   # Association with autosave option defines several callbacks on your
   # model (before_save, after_create, after_update). Please note that
   # callbacks are executed in the order they were defined in
-  # model. You should avoid modyfing the association content, before
+  # model. You should avoid modifying the association content, before
   # autosave callbacks are executed. Placing your callbacks after
   # associations is usually a good practice.
   #
-  # == Examples
-  #
   # === One-to-one Example
   #
   #   class Post
-  #     has_one :author, :autosave => true
+  #     has_one :author, autosave: true
   #   end
   #
   # Saving changes to the parent and its associated model can now be performed
@@ -80,29 +76,30 @@ module ActiveRecord
   # When <tt>:autosave</tt> is not declared new children are saved when their parent is saved:
   #
   #   class Post
-  #     has_many :comments # :autosave option is no declared
+  #     has_many :comments # :autosave option is not declared
   #   end
   #
-  #   post = Post.new(:title => 'ruby rocks')
-  #   post.comments.build(:body => 'hello world')
+  #   post = Post.new(title: 'ruby rocks')
+  #   post.comments.build(body: 'hello world')
   #   post.save # => saves both post and comment
   #
-  #   post = Post.create(:title => 'ruby rocks')
-  #   post.comments.build(:body => 'hello world')
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.build(body: 'hello world')
   #   post.save # => saves both post and comment
   #
-  #   post = Post.create(:title => 'ruby rocks')
-  #   post.comments.create(:body => 'hello world')
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.create(body: 'hello world')
   #   post.save # => saves both post and comment
   #
-  # When <tt>:autosave</tt> is true all children is saved, no matter whether they are new records:
+  # When <tt>:autosave</tt> is true all children are saved, no matter whether they
+  # are new records or not:
   #
   #   class Post
-  #     has_many :comments, :autosave => true
+  #     has_many :comments, autosave: true
   #   end
   #
-  #   post = Post.create(:title => 'ruby rocks')
-  #   post.comments.create(:body => 'hello world')
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.create(body: 'hello world')
   #   post.comments[0].body = 'hi everyone'
   #   post.save # => saves both post and comment, with 'hi everyone' as body
   #
@@ -128,23 +125,17 @@ module ActiveRecord
   module AutosaveAssociation
     extend ActiveSupport::Concern
 
-    ASSOCIATION_TYPES = %w{ HasOne HasMany BelongsTo HasAndBelongsToMany }
-
     module AssociationBuilderExtension #:nodoc:
-      def self.included(base)
-        base.valid_options << :autosave
-      end
-
       def build
-        reflection = super
         model.send(:add_autosave_association_callbacks, reflection)
-        reflection
+        super
       end
     end
 
     included do
-      ASSOCIATION_TYPES.each do |type|
-        Associations::Builder.const_get(type).send(:include, AssociationBuilderExtension)
+      Associations::Builder::Association.class_eval do
+        self.valid_options << :autosave
+        include AssociationBuilderExtension
       end
     end
 
@@ -192,23 +183,21 @@ module ActiveRecord
             # Doesn't use after_save as that would save associations added in after_create/after_update twice
             after_create save_method
             after_update save_method
+          elsif reflection.macro == :has_one
+            define_method(save_method) { save_has_one_association(reflection) }
+            # Configures two callbacks instead of a single after_save so that
+            # the model may rely on their execution order relative to its
+            # own callbacks.
+            #
+            # For example, given that after_creates run before after_saves, if
+            # we configured instead an after_save there would be no way to fire
+            # a custom after_create callback after the child association gets
+            # created.
+            after_create save_method
+            after_update save_method
           else
-            if reflection.macro == :has_one
-              define_method(save_method) { save_has_one_association(reflection) }
-              # Configures two callbacks instead of a single after_save so that
-              # the model may rely on their execution order relative to its
-              # own callbacks.
-              #
-              # For example, given that after_creates run before after_saves, if
-              # we configured instead an after_save there would be no way to fire
-              # a custom after_create callback after the child association gets
-              # created.
-              after_create save_method
-              after_update save_method
-            else
-              define_non_cyclic_method(save_method, reflection) { save_belongs_to_association(reflection) }
-              before_save save_method
-            end
+            define_non_cyclic_method(save_method, reflection) { save_belongs_to_association(reflection) }
+            before_save save_method
           end
         end
 
@@ -297,7 +286,7 @@ module ActiveRecord
     def association_valid?(reflection, record)
       return true if record.destroyed? || record.marked_for_destruction?
 
-      unless valid = record.valid?
+      unless valid = record.valid?(validation_context)
         if reflection.options[:autosave]
           record.errors.each do |attribute, message|
             attribute = "#{reflection.name}.#{attribute}"
@@ -331,38 +320,34 @@ module ActiveRecord
         autosave = reflection.options[:autosave]
 
         if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
-          begin
-            if autosave
-              records_to_destroy = records.select(&:marked_for_destruction?)
-              records_to_destroy.each { |record| association.proxy.destroy(record) }
-              records -= records_to_destroy
+          records_to_destroy = []
+          records.each do |record|
+            next if record.destroyed?
+
+            saved = true
+
+            if autosave && record.marked_for_destruction?
+              records_to_destroy << record
+            elsif autosave != false && (@new_record_before_save || record.new_record?)
+              if autosave
+                saved = association.insert_record(record, false)
+              else
+                association.insert_record(record) unless reflection.nested?
+              end
+            elsif autosave
+              saved = record.save(:validate => false)
             end
 
-            records.each do |record|
-              next if record.destroyed?
-
-              saved = true
-
-              if autosave != false && (@new_record_before_save || record.new_record?)
-                if autosave
-                  saved = association.insert_record(record, false)
-                else
-                  association.insert_record(record) unless reflection.nested?
-                end
-              elsif autosave
-                saved = record.save(:validate => false)
-              end
+            raise ActiveRecord::Rollback unless saved
+          end
 
-              raise ActiveRecord::Rollback unless saved
-            end
-          rescue
-            records.each {|x| IdentityMap.remove(x) } if IdentityMap.enabled?
-            raise
+          records_to_destroy.each do |record|
+            association.destroy(record)
           end
         end
 
         # reconstruct the scope now that we know the owner's id
-        association.reset_scope if association.respond_to?(:reset_scope)
+        association.send(:reset_scope) if association.respond_to?(:reset_scope)
       end
     end
 
@@ -407,6 +392,7 @@ module ActiveRecord
         autosave = reflection.options[:autosave]
 
         if autosave && record.marked_for_destruction?
+          self[reflection.foreign_key] = nil
           record.destroy
         elsif autosave != false
           saved = record.save(:validate => !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)