activerecord 3.1.0.rc4 → 3.1.0.rc5

data/lib/active_record/associations/has_one_association.rb

@@ -19,7 +19,7 @@ module ActiveRecord
 
             if owner.persisted? && save && !record.save
               nullify_owner_attributes(record)
-              set_owner_attributes(target)
+              set_owner_attributes(target) if target
               raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
             end
           end

data/lib/active_record/associations/join_helper.rb

@@ -32,8 +32,7 @@ module ActiveRecord
       end
 
       def table_alias_for(reflection, join = false)
-        name = alias_tracker.pluralize(reflection.name, reflection.active_record)
-        name << "_#{alias_suffix}"
+        name = "#{reflection.plural_name}_#{alias_suffix}"
         name << "_join" if join
         name
       end

data/lib/active_record/associations/preloader/association.rb

@@ -68,7 +68,8 @@ module ActiveRecord
         private
 
         def associated_records_by_owner
-          owner_keys = owners.map { |owner| owner[owner_key_name] }.compact.uniq
+          owners_map = owners_by_key
+          owner_keys = owners_map.keys.compact
 
           if klass.nil? || owner_keys.empty?
             records = []
@@ -84,7 +85,7 @@ module ActiveRecord
           records.each do |record|
             owner_key = record[association_key_name].to_s
 
-            owners_by_key[owner_key].each do |owner|
+            owners_map[owner_key].each do |owner|
               records_by_owner[owner] << record
             end
           end

data/lib/active_record/associations/singular_association.rb

@@ -18,16 +18,15 @@ module ActiveRecord
       end
 
       def create(attributes = {}, options = {}, &block)
-        build(attributes, options, &block).tap { |record| record.save }
+        create_record(attributes, options, &block)
       end
 
       def create!(attributes = {}, options = {}, &block)
-        build(attributes, options, &block).tap { |record| record.save! }
+        create_record(attributes, options, true, &block)
       end
 
       def build(attributes = {}, options = {})
-        record = reflection.build_association(attributes, options)
-        record.assign_attributes(create_scope.except(*record.changed), :without_protection => true)
+        record = build_record(attributes, options)
         yield(record) if block_given?
         set_new_record(record)
         record
@@ -51,6 +50,15 @@ module ActiveRecord
         def set_new_record(record)
           replace(record)
         end
+
+        def create_record(attributes, options, raise_error = false)
+          record = build_record(attributes, options)
+          yield(record) if block_given?
+          saved = record.save
+          set_new_record(record)
+          raise RecordInvalid.new(record) if !saved && raise_error
+          record
+        end
     end
   end
 end

data/lib/active_record/attribute_methods.rb

@@ -61,7 +61,7 @@ module ActiveRecord
       end
     end
 
-    def respond_to?(*args)
+    def respond_to?(name, include_private = false)
       self.class.define_attribute_methods unless self.class.attribute_methods_generated?
       super
     end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -7,7 +7,7 @@ module ActiveRecord
       # the record is not persisted? or has just been destroyed.
       def to_key
         key = send(self.class.primary_key)
-        [key] if key
+        persisted? && key ? [key] : nil
       end
 
       module ClassMethods

data/lib/active_record/attribute_methods/read.rb

@@ -99,8 +99,9 @@ module ActiveRecord
       # 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 respond_to? "_#{attr_name}"
-          send "_#{attr_name}" if @attributes.has_key?(attr_name.to_s)
+        method = "_#{attr_name}"
+        if respond_to? method
+          send method if @attributes.has_key?(attr_name.to_s)
         else
           _read_attribute attr_name
         end

data/lib/active_record/autosave_association.rb

@@ -347,7 +347,7 @@ module ActiveRecord
         end
 
         # reconstruct the scope now that we know the owner's id
-        association.send(:construct_scope) if association.respond_to?(:construct_scope)
+        association.send(:reset_scope) if association.respond_to?(:reset_scope)
       end
     end
 

data/lib/active_record/base.rb

@@ -23,6 +23,7 @@ require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/object/blank'
+require 'active_support/deprecation'
 require 'arel'
 require 'active_record/errors'
 require 'active_record/log_subscriber'
@@ -428,10 +429,6 @@ module ActiveRecord #:nodoc:
     class_attribute :default_scopes, :instance_writer => false
     self.default_scopes = []
 
-    # Boolean flag to prevent infinite recursion when evaluating default scopes
-    class_attribute :apply_default_scope, :instance_writer => false
-    self.apply_default_scope = true
-
     # 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
@@ -714,6 +711,12 @@ module ActiveRecord #:nodoc:
         connection_pool.columns_hash[table_name]
       end
 
+      # Returns a hash where the keys are column names and the values are
+      # default values when instantiating the AR object for this table.
+      def column_defaults
+        connection_pool.column_defaults[table_name]
+      end
+
       # Returns an array of column names as strings.
       def column_names
         @column_names ||= columns.map { |column| column.name }
@@ -1054,6 +1057,13 @@ module ActiveRecord #:nodoc:
           if match = DynamicFinderMatch.match(method_id)
             attribute_names = match.attribute_names
             super unless all_attributes_exists?(attribute_names)
+            if arguments.size < attribute_names.size
+              ActiveSupport::Deprecation.warn(
+                "Calling dynamic finder with less number of arguments than the number of attributes in " \
+                "method name is deprecated and will raise an ArguementError in the next version of Rails. " \
+                "Please passing `nil' to the argument you want it to be nil."
+              )
+            end
             if match.finder?
               options = arguments.extract_options!
               relation = options.any? ? scoped(options) : scoped
@@ -1064,6 +1074,13 @@ module ActiveRecord #:nodoc:
           elsif match = DynamicScopeMatch.match(method_id)
             attribute_names = match.attribute_names
             super unless all_attributes_exists?(attribute_names)
+            if arguments.size < attribute_names.size
+              ActiveSupport::Deprecation.warn(
+                "Calling dynamic scope with less number of arguments than the number of attributes in " \
+                "method name is deprecated and will raise an ArguementError in the next version of Rails. " \
+                "Please passing `nil' to the argument you want it to be nil."
+              )
+            end
             if match.scope?
               self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
                 def self.#{method_id}(*args)                                    # def self.scoped_by_user_name_and_password(*args)
@@ -1209,11 +1226,11 @@ MSG
         end
 
         def current_scope #:nodoc:
-          Thread.current[:"#{self}_current_scope"]
+          Thread.current["#{self}_current_scope"]
         end
 
         def current_scope=(scope) #:nodoc:
-          Thread.current[:"#{self}_current_scope"] = scope
+          Thread.current["#{self}_current_scope"] = scope
         end
 
         # Use this macro in your model to set a default scope for all operations on
@@ -1266,11 +1283,11 @@ MSG
           self.default_scopes = default_scopes + [scope]
         end
 
-        # The apply_default_scope flag is used to prevent an infinite recursion situation where
+        # The @ignore_default_scope flag is used to prevent an infinite recursion situation where
         # a default scope references a scope which has a default scope which references a scope...
         def build_default_scope #:nodoc:
-          return unless apply_default_scope
-          self.apply_default_scope = false
+          return if defined?(@ignore_default_scope) && @ignore_default_scope
+          @ignore_default_scope = true
 
           if method(:default_scope).owner != Base.singleton_class
             default_scope
@@ -1286,7 +1303,7 @@ MSG
             end
           end
         ensure
-          self.apply_default_scope = true
+          @ignore_default_scope = false
         end
 
         # Returns the class type of the record using the current module as a prefix. So descendants of
@@ -1532,6 +1549,7 @@ MSG
         @marked_for_destruction = false
         @previously_changed = {}
         @changed_attributes = {}
+        @relation = nil
 
         ensure_proper_type
         set_serialized_attributes
@@ -1540,9 +1558,8 @@ MSG
 
         assign_attributes(attributes, options) if attributes
 
-        result = yield self if block_given?
+        yield self if block_given?
         run_callbacks :initialize
-        result
       end
 
       # Populate +coder+ with attributes about this record that should be
@@ -1573,6 +1590,7 @@ MSG
       #   post.title # => 'hello world'
       def init_with(coder)
         @attributes = coder['attributes']
+        @relation = nil
 
         set_serialized_attributes
 
@@ -1636,7 +1654,8 @@ MSG
         when new_record?
           "#{self.class.model_name.cache_key}/new"
         when timestamp = self[:updated_at]
-          "#{self.class.model_name.cache_key}/#{id}-#{timestamp.to_s(:number)}"
+          timestamp = timestamp.utc.to_s(:number)
+          "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
         else
           "#{self.class.model_name.cache_key}/#{id}"
         end
@@ -1720,12 +1739,11 @@ MSG
         return unless new_attributes
 
         attributes = new_attributes.stringify_keys
-        role = options[:as] || :default
-
         multi_parameter_attributes = []
+        @mass_assignment_options = options
 
         unless options[:without_protection]
-          attributes = sanitize_for_mass_assignment(attributes, role)
+          attributes = sanitize_for_mass_assignment(attributes, mass_assignment_role)
         end
 
         attributes.each do |k, v|
@@ -1738,6 +1756,7 @@ MSG
           end
         end
 
+        @mass_assignment_options = nil
         assign_multiparameter_attributes(multi_parameter_attributes)
       end
 
@@ -1747,7 +1766,7 @@ MSG
       end
 
       # Returns an <tt>#inspect</tt>-like string for the value of the
-      # attribute +attr_name+. String attributes are elided after 50
+      # attribute +attr_name+. String attributes are truncated upto 50
       # characters, and Date and Time attributes are returned in the
       # <tt>:db</tt> format. Other attributes return the value of
       # <tt>#inspect</tt> without modification.
@@ -1792,16 +1811,12 @@ MSG
       # 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) ||
+        super ||
           comparison_object.instance_of?(self.class) &&
           id.present? &&
           comparison_object.id == id
       end
-
-      # Delegates to ==
-      def eql?(comparison_object)
-        self == comparison_object
-      end
+      alias :eql? :==
 
       # Delegates to id in order to allow two records of the same type and id to work with something like:
       #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
@@ -1819,6 +1834,15 @@ MSG
         @attributes.frozen?
       end
 
+      # Allows sort on objects
+      def <=>(other_object)
+        if other_object.is_a?(self.class)
+          self.to_key <=> other_object.to_key
+        else
+          nil
+        end
+      end
+
       # Backport dup from 1.9 so that initialize_dup() gets called
       unless Object.respond_to?(:initialize_dup)
         def dup # :nodoc:
@@ -1893,12 +1917,33 @@ MSG
         value
       end
 
+      def mass_assignment_options
+        @mass_assignment_options ||= {}
+      end
+
+      def mass_assignment_role
+        mass_assignment_options[:as] || :default
+      end
+
     private
 
+      # Under Ruby 1.9, Array#flatten will call #to_ary (recursively) on each of the elements
+      # of the array, and then rescues from the possible NoMethodError. If those elements are
+      # ActiveRecord::Base's, then this triggers the various method_missing's that we have,
+      # which significantly impacts upon performance.
+      #
+      # So we can avoid the method_missing hit by explicitly defining #to_ary as nil here.
+      #
+      # See also http://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary/
+      def to_ary # :nodoc:
+        nil
+      end
+
       def set_serialized_attributes
-        (@attributes.keys & self.class.serialized_attributes.keys).each do |key|
-          coder = self.class.serialized_attributes[key]
-          @attributes[key] = coder.load @attributes[key]
+        sattrs = self.class.serialized_attributes
+
+        sattrs.each do |key, coder|
+          @attributes[key] = coder.load @attributes[key] if @attributes.key?(key)
         end
       end
 
@@ -1908,8 +1953,9 @@ MSG
       # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself.
       # No such attribute would be set for objects of the Message class in that example.
       def ensure_proper_type
-        unless self.class.descends_from_active_record?
-          write_attribute(self.class.inheritance_column, self.class.sti_name)
+        klass = self.class
+        if klass.finder_needs_type_condition?
+          write_attribute(klass.inheritance_column, klass.sti_name)
         end
       end
 
@@ -2083,8 +2129,10 @@ MSG
       end
 
       def populate_with_current_scope_attributes
-        self.class.scoped.scope_for_create.each do |att,value|
-          respond_to?("#{att}=") && send("#{att}=", value)
+        return unless self.class.scope_attributes?
+
+        self.class.scope_attributes.each do |att,value|
+          send("#{att}=", value) if respond_to?("#{att}=")
         end
       end
 

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -60,6 +60,7 @@ module ActiveRecord
       attr_accessor :automatic_reconnect
       attr_reader :spec, :connections
       attr_reader :columns, :columns_hash, :primary_keys, :tables
+      attr_reader :column_defaults
 
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
       # object which describes database connection information (e.g. adapter,
@@ -106,6 +107,12 @@ module ActiveRecord
           }]
         end
 
+        @column_defaults = Hash.new do |h, table_name|
+          h[table_name] = Hash[columns[table_name].map { |col|
+            [col.name, col.default]
+          }]
+        end
+
         @primary_keys = Hash.new do |h, table_name|
           h[table_name] = with_connection do |conn|
             table_exists?(table_name) ? conn.primary_key(table_name) : 'id'
@@ -119,6 +126,7 @@ module ActiveRecord
 
         with_connection do |conn|
           conn.tables.each { |table| @tables[table] = true }
+          @tables[name] = true if !@tables.key?(name) && conn.table_exists?(name)
         end
 
         @tables.key? name
@@ -132,6 +140,7 @@ module ActiveRecord
       def clear_cache!
         @columns.clear
         @columns_hash.clear
+        @column_defaults.clear
         @tables.clear
       end
 
@@ -139,6 +148,7 @@ module ActiveRecord
       def clear_table_cache!(table_name)
         @columns.delete table_name
         @columns_hash.delete table_name
+        @column_defaults.delete table_name
         @primary_keys.delete table_name
       end
 
@@ -425,6 +435,14 @@ module ActiveRecord
           @testing = testing
         end
 
+        def method_missing(method_sym, *arguments, &block)
+          @body.send(method_sym, *arguments, &block)
+        end
+
+        def respond_to?(method_sym, include_private = false)
+          super || @body.respond_to?(method_sym)
+        end
+
         def each(&block)
           body.each(&block)
         end

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -328,7 +328,7 @@ module ActiveRecord
       end
 
       # Checks to see if a column exists. See SchemaStatements#column_exists?
-      def column_exists?(column_name, type = nil, options = nil)
+      def column_exists?(column_name, type = nil, options = {})
         @base.column_exists?(@table_name, column_name, type, options)
       end
 
@@ -386,13 +386,13 @@ module ActiveRecord
       # Removes the given index from the table.
       #
       # ===== Examples
-      # ====== Remove the suppliers_name_index in the suppliers table
-      #   t.remove_index :name
-      # ====== Remove the index named accounts_branch_id_index in the accounts table
+      # ====== Remove the index_table_name_on_column in the table_name table
+      #   t.remove_index :column
+      # ====== Remove the index named index_table_name_on_branch_id in the table_name table
       #   t.remove_index :column => :branch_id
-      # ====== Remove the index named accounts_branch_id_party_id_index in the accounts table
+      # ====== Remove the index named index_table_name_on_branch_id_and_party_id in the table_name table
       #   t.remove_index :column => [:branch_id, :party_id]
-      # ====== Remove the index named by_branch_party in the accounts table
+      # ====== Remove the index named by_branch_party in the table_name table
       #   t.remove_index :name => :by_branch_party
       def remove_index(options = {})
         @base.remove_index(@table_name, options)