activerecord 3.0.0.beta4 → 3.0.0.rc

data/lib/active_record/dynamic_finder_match.rb

@@ -1,4 +1,9 @@
 module ActiveRecord
+
+  # = Active Record Dynamic Finder Match
+  # 
+  # Provides dynamic attribute-based finders such as <tt>find_by_country</tt> 
+  # if, for example, the <tt>Person</tt> has an attribute with that name. 
   class DynamicFinderMatch
     def self.match(method)
       df_match = self.new(method)
@@ -37,6 +42,10 @@ module ActiveRecord
       @finder == :first && !@instantiator.nil?
     end
 
+    def creator?
+      @finder == :first && @instantiator == :create
+    end
+
     def bang?
       @bang
     end

data/lib/active_record/dynamic_scope_match.rb

@@ -1,4 +1,11 @@
 module ActiveRecord
+
+  # = Active Record Dynamic Scope Match
+  # 
+  # Provides dynamic attribute-based scopes such as <tt>scoped_by_price(4.99)</tt>
+  # if, for example, the <tt>Product</tt> has an attribute with that name. You can
+  # chain more <tt>scoped_by_* </tt> methods after the other. It acts like a named
+  # scope except that it's dynamic.
   class DynamicScopeMatch
     def self.match(method)
       ds_match = self.new(method)

data/lib/active_record/errors.rb

@@ -1,4 +1,7 @@
 module ActiveRecord
+
+  # = Active Record Errors
+  #
   # Generic Active Record exception class.
   class ActiveRecordError < StandardError
   end

data/lib/active_record/fixtures.rb

@@ -664,14 +664,13 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
     end
 
     def has_primary_key_column?
-      @has_primary_key_column ||= model_class && primary_key_name &&
-        model_class.columns.find { |c| c.name == primary_key_name }
+      @has_primary_key_column ||= primary_key_name &&
+        model_class.columns.any? { |c| c.name == primary_key_name }
     end
 
     def timestamp_column_names
-      @timestamp_column_names ||= %w(created_at created_on updated_at updated_on).select do |name|
-        column_names.include?(name)
-      end
+      @timestamp_column_names ||=
+        %w(created_at created_on updated_at updated_on) & column_names
     end
 
     def inheritance_column_name
@@ -872,7 +871,7 @@ module ActiveRecord
         table_names.each do |table_name|
           table_name = table_name.to_s.tr('./', '_')
 
-          define_method(table_name) do |*fixtures|
+          redefine_method(table_name) do |*fixtures|
             force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
 
             @fixture_cache[table_name] ||= {}

data/lib/active_record/locale/en.yml

@@ -4,7 +4,7 @@ en:
     #created_at: "Created at"
     #updated_at: "Updated at"
 
-  # ActiveRecord models configuration
+  # Active Record models configuration
   activerecord:
     errors:
       messages:

data/lib/active_record/locking/optimistic.rb

@@ -124,6 +124,7 @@ module ActiveRecord
             end
           end
 
+          @destroyed = true
           freeze
         end
 

data/lib/active_record/log_subscriber.rb

@@ -0,0 +1,48 @@
+module ActiveRecord
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current["active_record_sql_runtime"] = value
+    end
+
+    def self.runtime
+      Thread.current["active_record_sql_runtime"] ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def initialize
+      super
+      @odd_or_even = false
+    end
+
+    def sql(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      name = '%s (%.1fms)' % [event.payload[:name], event.duration]
+      sql  = event.payload[:sql].squeeze(' ')
+
+      if odd?
+        name = color(name, CYAN, true)
+        sql  = color(sql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name}  #{sql}"
+    end
+
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+
+    def logger
+      ActiveRecord::Base.logger
+    end
+  end
+end
+
+ActiveRecord::LogSubscriber.attach_to :active_record

data/lib/active_record/migration.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/aliasing'
 
 module ActiveRecord
   # Exception that can be raised to stop migrations from going backwards.
@@ -29,11 +30,15 @@ module ActiveRecord
     end
   end
 
-  # Migrations can manage the evolution of a schema used by several physical databases. It's a solution
-  # to the common problem of adding a field to make a new feature work in your local database, but being unsure of how to
-  # push that change to other developers and to the production server. With migrations, you can describe the transformations
-  # in self-contained classes that can be checked into version control systems and executed against another database that
-  # might be one, two, or five versions behind.
+  # = Active Record Migrations
+  # 
+  # Migrations can manage the evolution of a schema used by several physical 
+  # databases. It's a solution to the common problem of adding a field to make
+  # a new feature work in your local database, but being unsure of how to
+  # push that change to other developers and to the production server. With 
+  # migrations, you can describe the transformations in self-contained classes
+  # that can be checked into version control systems and executed against 
+  # another database that might be one, two, or five versions behind.
   #
   # Example of a simple migration:
   #
@@ -47,10 +52,13 @@ module ActiveRecord
   #     end
   #   end
   #
-  # This migration will add a boolean flag to the accounts table and remove it if you're backing out of the migration.
-  # It shows how all migrations have two class methods +up+ and +down+ that describes the transformations required to implement
-  # or remove the migration. These methods can consist of both the migration specific methods like add_column and remove_column,
-  # but may also contain regular Ruby code for generating data needed for the transformations.
+  # This migration will add a boolean flag to the accounts table and remove it 
+  # if you're backing out of the migration. It shows how all migrations have 
+  # two class methods +up+ and +down+ that describes the transformations 
+  # required to implement or remove the migration. These methods can consist
+  # of both the migration specific methods like add_column and remove_column,
+  # but may also contain regular Ruby code for generating data needed for the 
+  # transformations.
   #
   # Example of a more complex migration that also needs to initialize data:
   #
@@ -64,7 +72,9 @@ module ActiveRecord
   #         t.integer  :position
   #       end
   #
-  #       SystemSetting.create :name => "notice", :label => "Use notice?", :value => 1
+  #       SystemSetting.create  :name => "notice", 
+  #                             :label => "Use notice?", 
+  #                             :value => 1
   #     end
   #
   #     def self.down
@@ -72,35 +82,49 @@ module ActiveRecord
   #     end
   #   end
   #
-  # This migration first adds the system_settings table, then creates the very first row in it using the Active Record model
-  # that relies on the table. It also uses the more advanced create_table syntax where you can specify a complete table schema
-  # in one block call.
+  # This migration first adds the system_settings table, then creates the very 
+  # first row in it using the Active Record model that relies on the table. It
+  # also uses the more advanced create_table syntax where you can specify a 
+  # complete table schema in one block call.
   #
   # == Available transformations
   #
-  # * <tt>create_table(name, options)</tt> Creates a table called +name+ and makes the table object available to a block
-  #   that can then add columns to it, following the same format as add_column. See example above. The options hash is for
-  #   fragments like "DEFAULT CHARSET=UTF-8" that are appended to the create table definition.
+  # * <tt>create_table(name, options)</tt> Creates a table called +name+ and 
+  #   makes the table object available to a block that can then add columns to it,
+  #   following the same format as add_column. See example above. The options hash 
+  #   is for fragments like "DEFAULT CHARSET=UTF-8" that are appended to the create 
+  #   table definition.
   # * <tt>drop_table(name)</tt>: Drops the table called +name+.
-  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+ to +new_name+.
-  # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column to the table called +table_name+
+  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+ 
+  #   to +new_name+.
+  # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column 
+  #   to the table called +table_name+
   #   named +column_name+ specified to be one of the following types:
-  #   <tt>:string</tt>, <tt>:text</tt>, <tt>:integer</tt>, <tt>:float</tt>, <tt>:decimal</tt>, <tt>:datetime</tt>, <tt>:timestamp</tt>, <tt>:time</tt>,
-  #   <tt>:date</tt>, <tt>:binary</tt>, <tt>:boolean</tt>. A default value can be specified by passing an
-  #   +options+ hash like <tt>{ :default => 11 }</tt>. Other options include <tt>:limit</tt> and <tt>:null</tt> (e.g. <tt>{ :limit => 50, :null => false }</tt>)
-  #   -- see ActiveRecord::ConnectionAdapters::TableDefinition#column for details.
-  # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames a column but keeps the type and content.
-  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes the column to a different type using the same
-  #   parameters as add_column.
-  # * <tt>remove_column(table_name, column_name)</tt>: Removes the column named +column_name+ from the table called +table_name+.
-  # * <tt>add_index(table_name, column_names, options)</tt>: Adds a new index with the name of the column. Other options include
-  #   <tt>:name</tt> and <tt>:unique</tt> (e.g. <tt>{ :name => "users_name_index", :unique => true }</tt>).
-  # * <tt>remove_index(table_name, index_name)</tt>: Removes the index specified by +index_name+.
+  #   <tt>:string</tt>, <tt>:text</tt>, <tt>:integer</tt>, <tt>:float</tt>, 
+  #   <tt>:decimal</tt>, <tt>:datetime</tt>, <tt>:timestamp</tt>, <tt>:time</tt>,
+  #   <tt>:date</tt>, <tt>:binary</tt>, <tt>:boolean</tt>. A default value can be
+  #   specified by passing an +options+ hash like <tt>{ :default => 11 }</tt>. 
+  #   Other options include <tt>:limit</tt> and <tt>:null</tt> (e.g. 
+  #   <tt>{ :limit => 50, :null => false }</tt>) -- see 
+  #   ActiveRecord::ConnectionAdapters::TableDefinition#column for details.
+  # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames
+  #   a column but keeps the type and content.
+  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes 
+  #   the column to a different type using the same parameters as add_column.
+  # * <tt>remove_column(table_name, column_name)</tt>: Removes the column named 
+  #   +column_name+ from the table called +table_name+.
+  # * <tt>add_index(table_name, column_names, options)</tt>: Adds a new index 
+  #   with the name of the column. Other options include
+  #   <tt>:name</tt> and <tt>:unique</tt> (e.g. 
+  #   <tt>{ :name => "users_name_index", :unique => true }</tt>).
+  # * <tt>remove_index(table_name, index_name)</tt>: Removes the index specified 
+  #   by +index_name+.
   #
   # == Irreversible transformations
   #
-  # Some transformations are destructive in a manner that cannot be reversed. Migrations of that kind should raise
-  # an <tt>ActiveRecord::IrreversibleMigration</tt> exception in their +down+ method.
+  # Some transformations are destructive in a manner that cannot be reversed. 
+  # Migrations of that kind should raise an <tt>ActiveRecord::IrreversibleMigration</tt> 
+  # exception in their +down+ method.
   #
   # == Running migrations from within Rails
   #
@@ -110,13 +134,15 @@ module ActiveRecord
   #   rails generate migration MyNewMigration
   #
   # where MyNewMigration is the name of your migration. The generator will
-  # create an empty migration file <tt>timestamp_my_new_migration.rb</tt> in the <tt>db/migrate/</tt>
-  # directory where <tt>timestamp</tt> is the UTC formatted date and time that the migration was generated.
+  # create an empty migration file <tt>timestamp_my_new_migration.rb</tt> 
+  # in the <tt>db/migrate/</tt> directory where <tt>timestamp</tt> is the 
+  # UTC formatted date and time that the migration was generated.
   #
   # You may then edit the <tt>self.up</tt> and <tt>self.down</tt> methods of
   # MyNewMigration.
   #
   # There is a special syntactic shortcut to generate migrations that add fields to a table.
+  #
   #   rails generate migration add_fieldname_to_tablename fieldname:string
   #
   # This will generate the file <tt>timestamp_add_fieldname_to_tablename</tt>, which will look like this:
@@ -191,9 +217,10 @@ module ActiveRecord
   #
   # == Using a model after changing its table
   #
-  # Sometimes you'll want to add a column in a migration and populate it immediately after. In that case, you'll need
-  # to make a call to Base#reset_column_information in order to ensure that the model has the latest column data from
-  # after the new column was added. Example:
+  # Sometimes you'll want to add a column in a migration and populate it 
+  # immediately after. In that case, you'll need to make a call to 
+  # <tt>Base#reset_column_information</tt> in order to ensure that the model has the 
+  # latest column data from after the new column was added. Example:
   #
   #   class AddPeopleSalary < ActiveRecord::Migration
   #     def self.up
@@ -257,7 +284,7 @@ module ActiveRecord
   #
   #    config.active_record.timestamped_migrations = false
   #
-  # In environment.rb.
+  # In application.rb.
   #
   class Migration
     @@verbose = true

data/lib/active_record/named_scope.rb

@@ -4,11 +4,12 @@ require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
+  # = Active Record Named \Scopes
   module NamedScope
     extend ActiveSupport::Concern
 
     module ClassMethods
-      # Returns an anonymous scope.
+      # Returns an anonymous \scope.
       #
       #   posts = Post.scoped
       #   posts.size # Fires "select count(*) from  posts" and returns the count
@@ -18,16 +19,17 @@ module ActiveRecord
       #   fruits = fruits.where(:colour => 'red') if options[:red_only]
       #   fruits = fruits.limit(10) if limited?
       #
-      # Anonymous \scopes tend to be useful when procedurally generating complex queries, where passing
-      # intermediate values (scopes) around as first-class objects is convenient.
+      # Anonymous \scopes tend to be useful when procedurally generating complex
+      # queries, where passing intermediate values (\scopes) around as first-class 
+      # objects is convenient.
       #
-      # You can define a scope that applies to all finders using ActiveRecord::Base.default_scope.
-      def scoped(options = {}, &block)
-        if options.present?
-          relation = scoped.apply_finder_options(options)
-          block_given? ? relation.extending(Module.new(&block)) : relation
+      # You can define a \scope that applies to all finders using 
+      # ActiveRecord::Base.default_scope.
+      def scoped(options = nil)
+        if options
+          scoped.apply_finder_options(options)
         else
-          current_scoped_methods ? unscoped.merge(current_scoped_methods) : unscoped.clone
+          current_scoped_methods ? relation.merge(current_scoped_methods) : relation.clone
         end
       end
 
@@ -35,7 +37,7 @@ module ActiveRecord
         read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
       end
 
-      # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
+      # Adds a class method for retrieving and querying objects. A \scope represents a narrowing of a database query,
       # such as <tt>where(:color => :red).select('shirts.*').includes(:washing_instructions)</tt>.
       #
       #   class Shirt < ActiveRecord::Base
@@ -85,28 +87,40 @@ module ActiveRecord
       #   end
       def scope(name, scope_options = {}, &block)
         name = name.to_sym
+        valid_scope_name?(name)
 
-        if !scopes[name] && respond_to?(name, true)
-          logger.warn "Creating scope :#{name}. " \
-                      "Overwriting existing method #{self.name}.#{name}."
-        end
+        extension = Module.new(&block) if block_given?
 
         scopes[name] = lambda do |*args|
           options = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
 
-          relation = scoped
-          relation = options.is_a?(Hash) ? relation.apply_finder_options(options) : scoped.merge(options) if options
-          block_given? ? relation.extending(Module.new(&block)) : relation
+          relation = if options.is_a?(Hash)
+            scoped.apply_finder_options(options)
+          elsif options
+            scoped.merge(options)
+          else
+            scoped
+          end
+
+          extension ? relation.extending(extension) : relation
         end
 
-        singleton_class.send :define_method, name, &scopes[name]
+        singleton_class.send(:redefine_method, name, &scopes[name])
       end
 
       def named_scope(*args, &block)
         ActiveSupport::Deprecation.warn("Base.named_scope has been deprecated, please use Base.scope instead", caller)
         scope(*args, &block)
       end
-    end
 
+    protected
+
+      def valid_scope_name?(name)
+        if !scopes[name] && respond_to?(name, true)
+          logger.warn "Creating scope :#{name}. " \
+                      "Overwriting existing method #{self.name}.#{name}."
+        end
+      end
+    end
   end
 end

data/lib/active_record/nested_attributes.rb

@@ -15,7 +15,7 @@ module ActiveRecord
       self.nested_attributes_options = {}
     end
 
-    # == Nested Attributes
+    # = Active Record Nested Attributes
     #
     # Nested attributes allow you to save attributes on associated records
     # through the parent. By default nested attribute updating is turned off,
@@ -25,6 +25,7 @@ module ActiveRecord
     #
     # The attribute writer is named after the association, which means that
     # in the following example, two new methods are added to your model:
+    # 
     # <tt>author_attributes=(attributes)</tt> and
     # <tt>pages_attributes=(attributes)</tt>.
     #
@@ -132,7 +133,7 @@ module ActiveRecord
     #   member.posts.first.title # => 'Kari, the awesome Ruby documentation browser!'
     #   member.posts.second.title # => 'The egalitarian assumption of the modern citizen'
     #
-    #  Alternatively, :reject_if also accepts a symbol for using methods:
+    # Alternatively, :reject_if also accepts a symbol for using methods:
     #
     #    class Member < ActiveRecord::Base
     #      has_many :posts
@@ -144,7 +145,7 @@ module ActiveRecord
     #      accepts_nested_attributes_for :posts, :reject_if => :reject_posts
     #
     #      def reject_posts(attributed)
-    #        attributed['title].blank?
+    #        attributed['title'].blank?
     #      end
     #    end
     #
@@ -212,7 +213,7 @@ module ActiveRecord
       #   that will reject a record where all the attributes are blank.
       # [:limit]
       #   Allows you to specify the maximum number of the associated records that
-      #   can be processes with the nested attributes. If the size of the
+      #   can be processed with the nested attributes. If the size of the
       #   nested attributes array exceeds the specified limit, NestedAttributes::TooManyRecords
       #   exception is raised. If omitted, any number associations can be processed.
       #   Note that the :limit option is only applicable to one-to-many associations.
@@ -278,7 +279,7 @@ module ActiveRecord
     # Assigns the given attributes to the association.
     #
     # If update_only is false and the given attributes include an <tt>:id</tt>
-    # that matches the existing record’s id, then the existing record will be
+    # that matches the existing record's id, then the existing record will be
     # modified. If update_only is true, a new record is only created when no
     # object exists. Otherwise a new record will be built.
     #
@@ -295,7 +296,9 @@ module ActiveRecord
         assign_to_or_mark_for_destruction(record, attributes, options[:allow_destroy])
 
       elsif attributes['id']
-        raise_nested_attributes_record_not_found(association_name, attributes['id'])
+        existing_record = self.class.reflect_on_association(association_name).klass.find(attributes['id'])
+        assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+        self.send(association_name.to_s+'=', existing_record)
 
       elsif !reject_new_record?(association_name, attributes)
         method = "build_#{association_name}"
@@ -365,11 +368,16 @@ module ActiveRecord
           unless reject_new_record?(association_name, attributes)
             association.build(attributes.except(*UNASSIGNABLE_KEYS))
           end
+
+        elsif existing_records.count == 0 #Existing record but not yet associated
+          existing_record = self.class.reflect_on_association(association_name).klass.find(attributes['id'])
+          association.send(:add_record_to_target_with_callbacks, existing_record) unless association.loaded?
+          assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+
         elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes['id'].to_s }
           association.send(:add_record_to_target_with_callbacks, existing_record) unless association.loaded?
           assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
-        else
-          raise_nested_attributes_record_not_found(association_name, attributes['id'])
+
         end
       end
     end
@@ -389,7 +397,7 @@ module ActiveRecord
       ConnectionAdapters::Column.value_to_boolean(hash['_destroy'])
     end
 
-    # Determines if a new record should be build by checking for
+    # Determines if a new record should be built by checking for
     # has_destroy_flag? or if a <tt>:reject_if</tt> proc exists for this
     # association and evaluates to +true+.
     def reject_new_record?(association_name, attributes)
@@ -405,9 +413,5 @@ module ActiveRecord
       end
     end
 
-    def raise_nested_attributes_record_not_found(association_name, record_id)
-      reflection = self.class.reflect_on_association(association_name)
-      raise RecordNotFound, "Couldn't find #{reflection.klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
-    end
   end
 end