activerecord 3.0.0 → 3.0.3

data/lib/active_record/associations/belongs_to_association.rb

@@ -14,7 +14,7 @@ module ActiveRecord
         counter_cache_name = @reflection.counter_cache_column
 
         if record.nil?
-          if counter_cache_name && !@owner.new_record?
+          if counter_cache_name && @owner.persisted?
             @reflection.klass.decrement_counter(counter_cache_name, previous_record_id) if @owner[@reflection.primary_key_name]
           end
 
@@ -22,13 +22,13 @@ module ActiveRecord
         else
           raise_on_type_mismatch(record)
 
-          if counter_cache_name && !@owner.new_record? && record.id != @owner[@reflection.primary_key_name]
+          if counter_cache_name && @owner.persisted? && record.id != @owner[@reflection.primary_key_name]
             @reflection.klass.increment_counter(counter_cache_name, record.id)
             @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
           end
 
           @target = (AssociationProxy === record ? record.target : record)
-          @owner[@reflection.primary_key_name] = record_id(record) unless record.new_record?
+          @owner[@reflection.primary_key_name] = record_id(record) if record.persisted?
           @updated = true
         end
 

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -34,7 +34,7 @@ module ActiveRecord
         end
 
         def insert_record(record, force = true, validate = true)
-          if record.new_record?
+          unless record.persisted?
             if force
               record.save!
             else
@@ -49,23 +49,20 @@ module ActiveRecord
             timestamps = record_timestamp_columns(record)
             timezone   = record.send(:current_time_from_proper_timezone) if timestamps.any?
 
-            attributes = columns.inject({}) do |attrs, column|
+            attributes = Hash[columns.map do |column|
               name = column.name
-              case name.to_s
+              value = case name.to_s
                 when @reflection.primary_key_name.to_s
-                  attrs[relation[name]] = @owner.id
+                  @owner.id
                 when @reflection.association_foreign_key.to_s
-                  attrs[relation[name]] = record.id
+                  record.id
                 when *timestamps
-                  attrs[relation[name]] = timezone
+                  timezone
                 else
-                  if record.has_attribute?(name)
-                    value = @owner.send(:quote_value, record[name], column)
-                    attrs[relation[name]] = value unless value.nil?
-                  end
+                  @owner.send(:quote_value, record[name], column) if record.has_attribute?(name)
               end
-              attrs
-            end
+              [relation[name], value] unless value.nil?
+            end]
 
             relation.insert(attributes)
           end
@@ -79,7 +76,7 @@ module ActiveRecord
           else
             relation = Arel::Table.new(@reflection.options[:join_table])
             relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
-              and(relation[@reflection.association_foreign_key].in(records.map { |x| x.id }))
+              and(relation[@reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
             ).delete
           end
         end

data/lib/active_record/associations/has_many_through_association.rb

@@ -59,7 +59,7 @@ module ActiveRecord
         end
 
         def insert_record(record, force = true, validate = true)
-          if record.new_record?
+          unless record.persisted?
             if force
               record.save!
             else
@@ -68,8 +68,7 @@ module ActiveRecord
           end
 
           through_association = @owner.send(@reflection.through_reflection.name)
-          through_record = through_association.create!(construct_join_attributes(record))
-          through_association.proxy_target << through_record
+          through_association.create!(construct_join_attributes(record))
         end
 
         # TODO - add dependent option support

data/lib/active_record/associations/has_one_association.rb

@@ -35,18 +35,18 @@ module ActiveRecord
           if dependent? && !dont_save
             case @reflection.options[:dependent]
             when :delete
-              @target.delete unless @target.new_record?
+              @target.delete if @target.persisted?
               @owner.clear_association_cache
             when :destroy
-              @target.destroy unless @target.new_record?
+              @target.destroy if @target.persisted?
               @owner.clear_association_cache
             when :nullify
               @target[@reflection.primary_key_name] = nil
-              @target.save unless @owner.new_record? || @target.new_record?
+              @target.save if @owner.persisted? && @target.persisted?
             end
           else
             @target[@reflection.primary_key_name] = nil
-            @target.save unless @owner.new_record? || @target.new_record?
+            @target.save if @owner.persisted? && @target.persisted?
           end
         end
 
@@ -61,7 +61,7 @@ module ActiveRecord
         set_inverse_instance(obj, @owner)
         @loaded = true
 
-        unless @owner.new_record? or obj.nil? or dont_save
+        unless !@owner.persisted? or obj.nil? or dont_save
           return (obj.save ? self : false)
         else
           return (obj.nil? ? nil : self)
@@ -120,7 +120,7 @@ module ActiveRecord
           if replace_existing
             replace(record, true)
           else
-            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
+            record[@reflection.primary_key_name] = @owner.id if @owner.persisted?
             self.target = record
             set_inverse_instance(record, @owner)
           end

data/lib/active_record/associations/has_one_through_association.rb

@@ -21,7 +21,7 @@ module ActiveRecord
         if current_object
            new_value ? current_object.update_attributes(construct_join_attributes(new_value)) : current_object.destroy
         elsif new_value
-          if @owner.new_record?
+          unless @owner.persisted?
             self.target = new_value
             through_association = @owner.send(:association_instance_get, @reflection.through_reflection.name)
             through_association.build(construct_join_attributes(new_value))

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -13,10 +13,7 @@ module ActiveRecord
 
       # Returns a hash of attributes before typecasting and deserialization.
       def attributes_before_type_cast
-        self.attribute_names.inject({}) do |attrs, name|
-          attrs[name] = read_attribute_before_type_cast(name)
-          attrs
-        end
+        Hash[attribute_names.map { |name| [name, read_attribute_before_type_cast(name)] }]
       end
 
       private

data/lib/active_record/attribute_methods/primary_key.rb

@@ -3,10 +3,11 @@ module ActiveRecord
     module PrimaryKey
       extend ActiveSupport::Concern
 
-      # Returns this record's primary key value wrapped in an Array
-      # or nil if the record is a new_record?
+      # Returns this record's primary key value wrapped in an Array or nil if
+      # the record is not persisted? or has just been destroyed.
       def to_key
-        new_record? ? nil : [ id ]
+        key = send(self.class.primary_key)
+        [key] if key
       end
 
       module ClassMethods

data/lib/active_record/autosave_association.rb

@@ -208,7 +208,7 @@ module ActiveRecord
     # Returns whether or not this record has been changed in any way (including whether
     # any of its nested autosave associations are likewise changed)
     def changed_for_autosave?
-      new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
+      !persisted? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
     end
 
     private
@@ -222,7 +222,7 @@ module ActiveRecord
       elsif autosave
         association.target.find_all { |record| record.changed_for_autosave? }
       else
-        association.target.find_all { |record| record.new_record? }
+        association.target.find_all { |record| !record.persisted? }
       end
     end
 
@@ -248,7 +248,7 @@ module ActiveRecord
     # +reflection+.
     def validate_collection_association(reflection)
       if association = association_instance_get(reflection.name)
-        if records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave])
+        if records = associated_records_to_validate_or_save(association, !persisted?, reflection.options[:autosave])
           records.each { |record| association_valid?(reflection, record) }
         end
       end
@@ -277,7 +277,7 @@ module ActiveRecord
     # Is used as a before_save callback to check while saving a collection
     # association whether or not the parent was a new record before saving.
     def before_save_collection_association
-      @new_record_before_save = new_record?
+      @new_record_before_save = !persisted?
       true
     end
 
@@ -299,7 +299,7 @@ module ActiveRecord
 
             if autosave && record.marked_for_destruction?
               association.destroy(record)
-            elsif autosave != false && (@new_record_before_save || record.new_record?)
+            elsif autosave != false && (@new_record_before_save || !record.persisted?)
               if autosave
                 saved = association.send(:insert_record, record, false, false)
               else
@@ -334,7 +334,7 @@ module ActiveRecord
           association.destroy
         else
           key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-          if autosave != false && (new_record? || association.new_record? || association[reflection.primary_key_name] != key || autosave)
+          if autosave != false && (!persisted? || !association.persisted? || association[reflection.primary_key_name] != key || autosave)
             association[reflection.primary_key_name] = key
             saved = association.save(:validate => !autosave)
             raise ActiveRecord::Rollback if !saved && autosave
@@ -354,7 +354,7 @@ module ActiveRecord
         if autosave && association.marked_for_destruction?
           association.destroy
         elsif autosave != false
-          saved = association.save(:validate => !autosave) if association.new_record? || autosave
+          saved = association.save(:validate => !autosave) if !association.persisted? || autosave
 
           if association.updated?
             association_id = association.send(reflection.options[:primary_key] || :id)

data/lib/active_record/base.rb

@@ -205,7 +205,7 @@ module ActiveRecord #:nodoc:
   #
   #   # No 'Winter' tag exists
   #   winter = Tag.find_or_initialize_by_name("Winter")
-  #   winter.new_record? # true
+  #   winter.persisted? # false
   #
   # To find by a subset of the attributes to be used for instantiating a new object, pass a hash instead of
   # a list of parameters.
@@ -438,7 +438,7 @@ module ActiveRecord #:nodoc:
 
       delegate :find, :first, :last, :all, :destroy, :destroy_all, :exists?, :delete, :delete_all, :update, :update_all, :to => :scoped
       delegate :find_each, :find_in_batches, :to => :scoped
-      delegate :select, :group, :order, :reorder, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :create_with, :to => :scoped
+      delegate :select, :group, :order, :reorder, :except, :limit, :offset, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :create_with, :to => :scoped
       delegate :count, :average, :minimum, :maximum, :sum, :calculate, :to => :scoped
 
       # Executes a custom SQL query against your database and returns all the results.  The results will
@@ -608,7 +608,7 @@ module ActiveRecord #:nodoc:
       # Defines the column name for use with single table inheritance. Use
       # <tt>set_inheritance_column</tt> to set a different value.
       def inheritance_column
-        @inheritance_column ||= "type".freeze
+        @inheritance_column ||= "type"
       end
 
       # Lazy-set the sequence name to the connection's default.  This method
@@ -684,7 +684,7 @@ module ActiveRecord #:nodoc:
 
       # Returns a hash of column objects for the table associated with this class.
       def columns_hash
-        @columns_hash ||= columns.inject({}) { |hash, column| hash[column.name] = column; hash }
+        @columns_hash ||= Hash[columns.map { |column| [column.name, column] }]
       end
 
       # Returns an array of column names as strings.
@@ -855,7 +855,7 @@ module ActiveRecord #:nodoc:
           if self == ActiveRecord::Base
             Arel::Table.engine
           else
-            connection_handler.connection_pools[name] ? Arel::Sql::Engine.new(self) : superclass.arel_engine
+            connection_handler.connection_pools[name] ? self : superclass.arel_engine
           end
         end
       end
@@ -890,6 +890,10 @@ module ActiveRecord #:nodoc:
         Thread.current[key] = Thread.current[key].presence || self.default_scoping.dup
       end
 
+      def before_remove_const #:nodoc:
+        reset_scoped_methods
+      end
+
       private
 
         def relation #:nodoc:
@@ -901,21 +905,9 @@ module ActiveRecord #:nodoc:
         # single-table inheritance model that makes it possible to create
         # objects of different types from the same table.
         def instantiate(record)
-          object = find_sti_class(record[inheritance_column]).allocate
-
-          object.instance_variable_set(:@attributes, record)
-          object.instance_variable_set(:@attributes_cache, {})
-          object.instance_variable_set(:@new_record, false)
-          object.instance_variable_set(:@readonly, false)
-          object.instance_variable_set(:@destroyed, false)
-          object.instance_variable_set(:@marked_for_destruction, false)
-          object.instance_variable_set(:@previously_changed, {})
-          object.instance_variable_set(:@changed_attributes, {})
-
-          object.send(:_run_find_callbacks)
-          object.send(:_run_initialize_callbacks)
-
-          object
+          model = find_sti_class(record[inheritance_column]).allocate
+          model.init_with('attributes' => record)
+          model
         end
 
         def find_sti_class(type_name)
@@ -939,7 +931,7 @@ module ActiveRecord #:nodoc:
         end
 
         def construct_finder_arel(options = {}, scope = nil)
-          relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : unscoped.merge(options)
+          relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
           relation = scope.merge(relation) if scope
           relation
         end
@@ -1039,8 +1031,9 @@ module ActiveRecord #:nodoc:
         end
 
         def all_attributes_exists?(attribute_names)
-          attribute_names = expand_attribute_names_for_aggregates(attribute_names)
-          attribute_names.all? { |name| column_methods_hash.include?(name.to_sym) }
+          expand_attribute_names_for_aggregates(attribute_names).all? { |name|
+            column_methods_hash.include?(name.to_sym)
+          }
         end
 
       protected
@@ -1096,9 +1089,9 @@ module ActiveRecord #:nodoc:
 
           if method_scoping.is_a?(Hash)
             # Dup first and second level of hash (method and params).
-            method_scoping = method_scoping.inject({}) do |hash, (method, params)|
-              hash[method] = (params == true) ? params : params.dup
-              hash
+            method_scoping = method_scoping.dup
+            method_scoping.each do |method, params|
+              method_scoping[method] = params.dup unless params == true
             end
 
             method_scoping.assert_valid_keys([ :find, :create ])
@@ -1167,6 +1160,7 @@ MSG
         #   Article.new.published    # => true
         #   Article.create.published # => true
         def default_scope(options = {})
+          reset_scoped_methods
           self.default_scoping << construct_finder_arel(options, default_scoping.pop)
         end
 
@@ -1174,6 +1168,10 @@ MSG
           scoped_methods.last
         end
 
+        def reset_scoped_methods #:nodoc:
+          Thread.current[:"#{self}_scoped_methods"] = nil
+        end
+
         # Returns the class type of the record using the current module as a prefix. So descendants of
         # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)
@@ -1395,7 +1393,7 @@ MSG
       def initialize(attributes = nil)
         @attributes = attributes_from_column_definition
         @attributes_cache = {}
-        @new_record = true
+        @persisted = false
         @readonly = false
         @destroyed = false
         @marked_for_destruction = false
@@ -1404,10 +1402,7 @@ MSG
 
         ensure_proper_type
 
-        if scope = self.class.send(:current_scoped_methods)
-          create_with = scope.scope_for_create
-          create_with.each { |att,value| self.send("#{att}=", value) } if create_with
-        end
+        populate_with_current_scope_attributes
         self.attributes = attributes unless attributes.nil?
 
         result = yield self if block_given?
@@ -1433,13 +1428,29 @@ MSG
         clear_aggregation_cache
         clear_association_cache
         @attributes_cache = {}
-        @new_record = true
+        @persisted = false
         ensure_proper_type
 
-        if scope = self.class.send(:current_scoped_methods)
-          create_with = scope.scope_for_create
-          create_with.each { |att,value| self.send("#{att}=", value) } if create_with
-        end
+        populate_with_current_scope_attributes
+      end
+
+      # Initialize an empty model object from +coder+.  +coder+ must contain
+      # the attributes necessary for initializing an empty model object.  For
+      # example:
+      #
+      #   class Post < ActiveRecord::Base
+      #   end
+      #
+      #   post = Post.allocate
+      #   post.init_with('attributes' => { 'title' => 'hello world' })
+      #   post.title # => 'hello world'
+      def init_with(coder)
+        @attributes = coder['attributes']
+        @attributes_cache, @previously_changed, @changed_attributes = {}, {}, {}
+        @readonly = @destroyed = @marked_for_destruction = false
+        @persisted = true
+        _run_find_callbacks
+        _run_initialize_callbacks
       end
 
       # Returns a String, which Action Pack uses for constructing an URL to this
@@ -1478,7 +1489,7 @@ MSG
       #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
       def cache_key
         case
-        when new_record?
+        when !persisted?
           "#{self.class.model_name.cache_key}/new"
         when timestamp = self[:updated_at]
           "#{self.class.model_name.cache_key}/#{id}-#{timestamp.to_s(:number)}"
@@ -1596,11 +1607,20 @@ MSG
         self.class.columns_hash[name.to_s]
       end
 
-      # Returns true if the +comparison_object+ is the same object, or is of the same type and has the same id.
+      # Returns true if +comparison_object+ is the same exact object, or +comparison_object+ 
+      # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
+      #
+      # Note that new records are different from any other record by definition, unless the
+      # other record is the receiver itself. Besides, if you fetch existing records with
+      # +select+ and leave the ID out, you're on your own, this predicate will return false.
+      #
+      # Note also that destroying a record preserves its ID in the model instance, so deleted
+      # models are still comparable.
       def ==(comparison_object)
         comparison_object.equal?(self) ||
-          (comparison_object.instance_of?(self.class) &&
-            comparison_object.id == id && !comparison_object.new_record?)
+          comparison_object.instance_of?(self.class) &&
+          id.present? &&
+          comparison_object.id == id
       end
 
       # Delegates to ==
@@ -1645,7 +1665,7 @@ MSG
       # Returns the contents of the record as a nicely formatted string.
       def inspect
         attributes_as_nice_string = self.class.column_names.collect { |name|
-          if has_attribute?(name) || new_record?
+          if has_attribute?(name) || !persisted?
             "#{name}: #{attribute_for_inspect(name)}"
           end
         }.compact.join(", ")
@@ -1697,8 +1717,8 @@ MSG
             if include_readonly_attributes || (!include_readonly_attributes && !self.class.readonly_attributes.include?(name))
               value = read_attribute(name)
 
-              if value && ((self.class.serialized_attributes.has_key?(name) && (value.acts_like?(:date) || value.acts_like?(:time))) || value.is_a?(Hash) || value.is_a?(Array))
-                value = value.to_yaml
+              if value && self.class.serialized_attributes.key?(name)
+                value = YAML.dump value
               end
               attrs[self.class.arel_table[name]] = value
             end
@@ -1805,10 +1825,7 @@ MSG
       end
 
       def quote_columns(quoter, hash)
-        hash.inject({}) do |quoted, (name, value)|
-          quoted[quoter.quote_column_name(name)] = value
-          quoted
-        end
+        Hash[hash.map { |name, value| [quoter.quote_column_name(name), value] }]
       end
 
       def quoted_comma_pair_list(quoter, hash)
@@ -1831,6 +1848,13 @@ MSG
         return string unless string.is_a?(String) && string =~ /^---/
         YAML::load(string) rescue string
       end
+
+      def populate_with_current_scope_attributes
+        if scope = self.class.send(:current_scoped_methods)
+          create_with = scope.scope_for_create
+          create_with.each { |att,value| self.respond_to?(:"#{att}=") && self.send("#{att}=", value) } if create_with
+        end
+      end
   end
 
   Base.class_eval do