activerecord 1.12.2 → 1.13.0

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -15,7 +15,7 @@ module ActiveRecord
         end
 
         db = SQLite3::Database.new(
-          config[:dbfile],
+          config[:database],
           :results_as_hash => true,
           :type_translation => false
         )
@@ -29,7 +29,7 @@ module ActiveRecord
         unless self.class.const_defined?(:SQLite)
           require_library_or_gem(config[:adapter])
 
-          db = SQLite::Database.new(config[:dbfile], 0)
+          db = SQLite::Database.new(config[:database], 0)
           db.show_datatypes   = "ON" if !defined? SQLite::Version
           db.results_as_hash  = true if defined? SQLite::Version
           db.type_translation = false
@@ -45,16 +45,17 @@ module ActiveRecord
 
       private
         def parse_config!(config)
-          # Require dbfile.
-          unless config.has_key?(:dbfile)
-            raise ArgumentError, "No database file specified. Missing argument: dbfile"
+          config[:database] ||= config[:dbfile]
+          # Require database.
+          unless config.has_key?(:database)
+            raise ArgumentError, "No database file specified. Missing argument: database"
           end
 
           # Allow database path relative to RAILS_ROOT, but only if
           # the database path is not the special path that tells
           # Sqlite build a database only in memory.
-          if Object.const_defined?(:RAILS_ROOT) && ':memory:' != config[:dbfile]
-            config[:dbfile] = File.expand_path(config[:dbfile], RAILS_ROOT)
+          if Object.const_defined?(:RAILS_ROOT) && ':memory:' != config[:database]
+            config[:database] = File.expand_path(config[:database], RAILS_ROOT)
           end
         end
     end
@@ -88,7 +89,7 @@ module ActiveRecord
     #
     # Options:
     #
-    # * <tt>:dbfile</tt> -- Path to the database file.
+    # * <tt>:database</tt> -- Path to the database file.
     class SQLiteAdapter < AbstractAdapter
       def adapter_name #:nodoc:
         'SQLite'

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -11,6 +11,12 @@ require 'active_record/connection_adapters/abstract_adapter'
 # Modifications (ODBC): Mark Imbriaco <mark.imbriaco@pobox.com>
 # Date: 6/26/2005
 #
+# Current maintainer: Ryan Tomayko <rtomayko@gmail.com>
+#
+# Modifications (Migrations): Tom Ward <tom@popdog.net>
+# Date: 27/10/2005
+#
+
 module ActiveRecord
   class Base
     def self.sqlserver_connection(config) #:nodoc:
@@ -71,6 +77,8 @@ module ActiveRecord
         when :datetime  then cast_to_datetime(value)
         when :timestamp then cast_to_time(value)
         when :time      then cast_to_time(value)
+        when :date      then cast_to_datetime(value)
+        when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or value.to_s == '1'
         else value
         end
       end
@@ -167,7 +175,7 @@ module ActiveRecord
           :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
           :string      => { :name => "varchar", :limit => 255  },
           :text        => { :name => "text" },
-          :integer     => { :name => "int"},
+          :integer     => { :name => "int" },
           :float       => { :name => "float", :limit => 8 },
           :datetime    => { :name => "datetime" },
           :timestamp   => { :name => "datetime" },
@@ -181,13 +189,17 @@ module ActiveRecord
       def adapter_name
         'SQLServer'
       end
+      
+      def supports_migrations? #:nodoc:
+        true
+      end
 
       def select_all(sql, name = nil)
         select(sql, name)
       end
 
       def select_one(sql, name = nil)
-        add_limit!(sql, nil)
+        add_limit!(sql, :limit => 1)
         result = select(sql, name)
         result.nil? ? nil : result.first
       end
@@ -306,15 +318,27 @@ module ActiveRecord
       end
 
       def add_limit_offset!(sql, options)
-        if options.has_key?(:limit) and options.has_key?(:offset) and !options[:limit].nil? and !options[:offset].nil?
-          options[:order] ||= "id ASC"
-          total_rows = @connection.select_all("SELECT count(*) as TotalRows from #{get_table_name(sql)}")[0][:TotalRows].to_i
-          if (options[:limit] + options[:offset]) > total_rows
-            options[:limit] = (total_rows - options[:offset] > 0) ? (total_rows - options[:offset]) : 1
+        if options[:limit] and options[:offset]
+          total_rows = @connection.select_all("SELECT count(*) as TotalRows from (#{sql.gsub(/SELECT/i, "SELECT TOP 1000000000")}) tally")[0][:TotalRows].to_i
+          if (options[:limit] + options[:offset]) >= total_rows
+            options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
           end
-          sql.gsub!(/SELECT/i, "SELECT * FROM ( SELECT TOP #{options[:limit]} * FROM ( SELECT TOP #{options[:limit] + options[:offset]}")<<" ) AS tmp1 ORDER BY #{change_order_direction(options[:order])} ) AS tmp2 ORDER BY #{options[:order]}"
-        else
-          sql.gsub!(/SELECT/i, "SELECT TOP #{options[:limit]}") unless options[:limit].nil?
+          sql.sub!(/^\s*SELECT/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT TOP #{options[:limit] + options[:offset]} ")
+          sql << ") AS tmp1"
+          if options[:order]
+            options[:order] = options[:order].split(',').map do |field|
+              parts = field.split(" ")
+              if sql =~ /#{parts[0]} AS (t\d_r\d\d?)/
+                  parts[0] = $1
+              end
+              parts.join(' ')
+            end.join(', ')
+            sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
+          else
+            sql << " ) AS tmp2"
+          end
+        elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
+          sql.sub!(/^\s*SELECT/i, "SELECT TOP #{options[:limit]}") unless options[:limit].nil?
         end
       end
 
@@ -331,6 +355,74 @@ module ActiveRecord
         execute "CREATE DATABASE #{name}"
       end
 
+      def tables(name = nil)
+        execute("SELECT table_name from information_schema.tables WHERE table_type = 'BASE TABLE'", name).inject([]) do |tables, field|
+          table_name = field[0]
+          tables << table_name unless table_name == 'dtproperties'
+          tables
+        end
+      end
+
+      def indexes(table_name, name = nil)
+        indexes = []
+        execute("EXEC sp_helpindex #{table_name}", name).each do |index| 
+          unique = index[1] =~ /unique/
+          primary = index[1] =~ /primary key/
+          if !primary
+            indexes << IndexDefinition.new(table_name, index[0], unique, index[2].split(", "))
+          end
+        end
+        indexes
+      end
+            
+      def rename_table(name, new_name)
+        execute "EXEC sp_rename '#{name}', '#{new_name}'"
+      end
+      
+      def remove_column(table_name, column_name)
+        execute "ALTER TABLE #{table_name} DROP COLUMN #{column_name}"
+      end 
+      
+      def rename_column(table, column, new_column_name)
+        execute "EXEC sp_rename '#{table}.#{column}', '#{new_column_name}'"
+      end
+      
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        sql_commands = ["ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"]
+        if options[:default]
+          remove_default_constraint(table_name, column_name)
+          sql_commands << "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{options[:default]} FOR #{column_name}"
+        end
+        sql_commands.each {|c|
+          execute(c)
+        }
+      end
+      
+      def remove_column(table_name, column_name)
+        remove_default_constraint(table_name, column_name)
+        execute "ALTER TABLE #{table_name} DROP COLUMN #{column_name}"
+      end
+      
+      def remove_default_constraint(table_name, column_name)
+        defaults = select "select def.name from sysobjects def, syscolumns col, sysobjects tab where col.cdefault = def.id and col.name = '#{column_name}' and tab.name = '#{table_name}' and col.id = tab.id"
+        defaults.each {|constraint|
+          execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["name"]}"
+        }
+      end
+      
+      def remove_index(table_name, options = {})
+        execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
+      end
+
+      def type_to_sql(type, limit = nil) #:nodoc:
+        native = native_database_types[type]
+        # if there's no :limit in the default type definition, assume that type doesn't support limits
+        limit = native[:limit] ? limit || native[:limit] : nil
+        column_type_sql = native[:name]
+        column_type_sql << "(#{limit})" if limit
+        column_type_sql
+      end
+
       private
         def select(sql, name = nil)
           rows = []
@@ -355,9 +447,9 @@ module ActiveRecord
         end
 
         def get_table_name(sql)
-          if sql =~ /into\s*([^\s]+)\s*|update\s*([^\s]+)\s*/i
+          if sql =~ /^\s*insert\s+into\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
             $1
-          elsif sql =~ /from\s*([^\s]+)\s*/i
+          elsif sql =~ /from\s+([^\(\s]+)\s*/i
             $1
           else
             nil
@@ -392,8 +484,8 @@ module ActiveRecord
 
         def get_special_columns(table_name)
           special = []
-          @table_columns = {} unless @table_columns
-          @table_columns[table_name] = columns(table_name) if @table_columns[table_name] == nil
+          @table_columns ||= {}
+          @table_columns[table_name] ||= columns(table_name)
           @table_columns[table_name].each do |col|
             special << col.name if col.is_special
           end
@@ -404,6 +496,7 @@ module ActiveRecord
           special_cols = get_special_columns(get_table_name(sql))
           for col in special_cols.to_a
             sql.gsub!(Regexp.new(" #{col.to_s} = "), " #{col.to_s} LIKE ")
+            sql.gsub!(/ORDER BY #{col.to_s}/i, '')
           end
           sql
         end

data/lib/active_record/fixtures.rb

@@ -20,7 +20,7 @@ end
 # This type of fixture is in YAML format and the preferred default. YAML is a file format which describes data structures
 # in a non-verbose, humanly-readable format. It ships with Ruby 1.8.1+.
 #
-# Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which is place in the directory appointed
+# Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which are placed in the directory appointed
 # by <tt>Test::Unit::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
 # put your files in <your-rails-app>/test/fixtures/). The fixture file ends with the .yml file extension (Rails example:
 # "<your-rails-app>/test/fixtures/web_sites.yml"). The format of a YAML fixture file looks like this:
@@ -56,7 +56,7 @@ end
 # = CSV fixtures
 #
 # Fixtures can also be kept in the Comma Separated Value format. Akin to YAML fixtures, CSV fixtures are stored
-# in a single file, but, instead end with the .csv file extension (Rails example: "<your-rails-app>/test/fixtures/web_sites.csv")
+# in a single file, but instead end with the .csv file extension (Rails example: "<your-rails-app>/test/fixtures/web_sites.csv")
 #
 # The format of this type of fixture file is much more compact than the others, but also a little harder to read by us
 # humans.  The first line of the CSV file is a comma-separated list of field names.  The rest of the file is then comprised
@@ -103,7 +103,7 @@ end
 # = Using Fixtures
 #
 # Since fixtures are a testing construct, we use them in our unit and functional tests.  There are two ways to use the
-# fixtures, but first lets take a look at a sample unit test found:
+# fixtures, but first let's take a look at a sample unit test found:
 #
 #   require 'web_site'
 #
@@ -139,7 +139,7 @@ end
 #
 # As seen above, the data hash created from the YAML fixtures would have @web_sites["rubyonrails"]["url"] return
 # "http://www.rubyonrails.org" and @web_sites["google"]["name"] would return "Google". The same fixtures, but loaded
-# from a CSV fixture file would be accessible via @web_sites["web_site_1"]["name"] == "Ruby on Rails" and have the individual
+# from a CSV fixture file, would be accessible via @web_sites["web_site_1"]["name"] == "Ruby on Rails" and have the individual
 # fixtures available as instance variables @web_site_1 and @web_site_2.
 #
 # If you do not wish to use instantiated fixtures (usually for performance reasons) there are two options.
@@ -218,7 +218,7 @@ class Fixtures < YAML::Omap
   def self.instantiate_fixtures(object, table_name, fixtures, load_instances=true)
     object.instance_variable_set "@#{table_name.to_s.gsub('.','_')}", fixtures
     if load_instances
-      ActiveRecord::Base.logger.silence do
+      ActiveRecord::Base.silence do
         fixtures.each do |name, fixture|
           if model = fixture.find
             object.instance_variable_set "@#{name}", model
@@ -241,7 +241,7 @@ class Fixtures < YAML::Omap
     table_names = table_names.flatten.map { |n| n.to_s }
     connection = block_given? ? yield : ActiveRecord::Base.connection
 
-    ActiveRecord::Base.logger.silence do
+    ActiveRecord::Base.silence do
       fixtures_map = {}
       fixtures = table_names.map do |table_name|
         fixtures_map[table_name] = Fixtures.new(connection, File.split(table_name.to_s).last, File.join(fixtures_directory, table_name.to_s))
@@ -270,7 +270,7 @@ class Fixtures < YAML::Omap
   def initialize(connection, table_name, fixture_path, file_filter = DEFAULT_FILTER_RE)
     @connection, @table_name, @fixture_path, @file_filter = connection, table_name, fixture_path, file_filter
 
-    @class_name = Inflector.classify(@table_name)
+    @class_name = ActiveRecord::Base.pluralize_table_names ? @table_name.singularize.camelize : @table_name.camelize
     @table_name = ActiveRecord::Base.table_name_prefix + @table_name + ActiveRecord::Base.table_name_suffix
     read_fixture_files
   end
@@ -436,8 +436,10 @@ module Test #:nodoc:
 
       def self.require_fixture_classes(table_names=nil)
         (table_names || fixture_table_names).each do |table_name| 
+          file_name = table_name.to_s
+          file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
           begin
-            require Inflector.singularize(table_name.to_s)
+            require file_name
           rescue LoadError
             # Let's hope the developer has included it himself
           end

data/lib/active_record/migration.rb

@@ -2,6 +2,12 @@ module ActiveRecord
   class IrreversibleMigration < ActiveRecordError#:nodoc:
   end
   
+  class DuplicateMigrationVersionError < ActiveRecordError#:nodoc:
+    def initialize(version)
+      super("Multiple migrations have the version number #{version}")
+    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
@@ -92,6 +98,7 @@ module ActiveRecord
   #   
   #     def self.down
   #       # not much we can do to restore deleted data
+  #       raise IrreversibleMigration
   #     end
   #   end
   #
@@ -109,7 +116,7 @@ module ActiveRecord
   #     end
   #   end
   #
-  # And some times you need to do something in SQL not abstracted directly by migrations:
+  # And sometimes you need to do something in SQL not abstracted directly by migrations:
   #
   #   class MakeJoinUnique < ActiveRecord::Migration
   #     def self.up
@@ -123,7 +130,7 @@ module ActiveRecord
   #
   # == Using the class after changing table
   #
-  # Some times you'll want to add a column in a migration and populate it immediately after. In that case, you'll need
+  # 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 class has the latest column data from 
   # after the new column was added. Example:
   #
@@ -208,15 +215,22 @@ module ActiveRecord
 
     private
       def migration_classes
-        migrations = migration_files.collect do |migration_file|
+        migrations = migration_files.inject([]) do |migrations, migration_file|
           load(migration_file)
           version, name = migration_version_and_name(migration_file)
-          [ version.to_i, migration_class(name) ]
+          assert_unique_migration_version(migrations, version.to_i)
+          migrations << [ version.to_i, migration_class(name) ] 
         end
-        
+
         down? ? migrations.sort.reverse : migrations.sort
       end
-    
+      
+      def assert_unique_migration_version(migrations, version)
+        if !migrations.empty? && migrations.transpose.first.include?(version)
+          raise DuplicateMigrationVersionError.new(version)
+        end
+      end
+      
       def migration_files
         files = Dir["#{@migrations_path}/[0-9]*_*.rb"].sort_by do |f|
           migration_version_and_name(f).first.to_i

data/lib/active_record/observer.rb

@@ -74,9 +74,10 @@ module ActiveRecord
   #
   # == Triggering Observers
   # 
-  # In order to activate an observer, you need to call Observer.instance. In Rails, this can be done in controllers
-  # using the short-hand of for example observer :comment_observer. Or directly from Active Record, with
-  # ActiveRecord::Base.observer(:comment_observer).
+  # In order to activate an observer, list it in the <tt>config.active_record.observers</tt> configuration setting in your
+  # <tt>config/environment.rb</tt> file.
+  #
+  #   config.active_record.observers = :comment_observer, :signup_observer
   class Observer
     include Singleton
 

data/lib/active_record/reflection.rb

@@ -21,12 +21,12 @@ module ActiveRecord
         base.module_eval <<-"end_eval"
           class << self
             alias_method :#{association_type}_without_reflection, :#{association_type}
-
-            def #{association_type}_with_reflection(association_id, options = {})
-              #{association_type}_without_reflection(association_id, options)
+      
+            def #{association_type}_with_reflection(association_id, options = {}, &block)
+              #{association_type}_without_reflection(association_id, options, &block)      
               reflect_on_all_associations << AssociationReflection.new(:#{association_type}, association_id, options, self)
             end
-
+      
             alias_method :#{association_type}, :#{association_type}_with_reflection
           end
         end_eval
@@ -34,7 +34,7 @@ module ActiveRecord
     end
 
     # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations.
-    # This information can for example be used in a form builder that took an Active Record object and created input
+    # This information can, for example, be used in a form builder that took an Active Record object and created input
     # fields for all of the attributes depending on their type and displayed the associations to other objects.
     #
     # You can find the interface for the AggregateReflection and AssociationReflection classes in the abstract MacroReflection class.

data/lib/active_record/transactions.rb

@@ -24,7 +24,7 @@ module ActiveRecord
 
     # Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. 
     # The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succeeded and
-    # vice versa. Transaction enforce the integrity of the database and guards the data against program errors or database break-downs.
+    # vice versa. Transactions enforce the integrity of the database and guard the data against program errors or database break-downs.
     # So basically you should use transaction blocks whenever you have a number of statements that must be executed together or
     # not at all. Example:
     #
@@ -62,7 +62,7 @@ module ActiveRecord
     #
     # == Object-level transactions
     #
-    # You can enable object-level transactions for Active Record objects, though. You do this by naming the each of the Active Records
+    # You can enable object-level transactions for Active Record objects, though. You do this by naming each of the Active Records
     # that you want to enable object-level transactions for, like this:
     #
     #   Account.transaction(david, mary) do

data/lib/active_record/validations.rb

@@ -1,14 +1,26 @@
 module ActiveRecord
-  class RecordInvalid < ActiveRecordError #:nodoc:
+  # Raised by save! and create! when the record is invalid.  Use the
+  # record method to retrieve the record which did not validate.
+  #   begin
+  #     complex_operation_that_calls_save!_internally
+  #   rescue ActiveRecord::RecordInvalid => invalid
+  #     puts invalid.record.errors
+  #   end
+  class RecordInvalid < ActiveRecordError
+    attr_reader :record
+    def initialize(record, *args)
+      @record = record
+      super(*args)
+    end
   end
-  
+
   # Active Record validation is reported to and from this object, which is used by Base#save to
   # determine whether the object in a valid state to be saved. See usage example in Validations.
   class Errors
     def initialize(base) # :nodoc:
       @base, @errors = base, {}
     end
-    
+
     @@default_error_messages = {
       :inclusion => "is not included in the list",
       :exclusion => "is reserved",
@@ -17,20 +29,20 @@ module ActiveRecord
       :accepted  => "must be accepted",
       :empty => "can't be empty",
       :blank => "can't be blank",
-      :too_long => "is too long (max is %d characters)", 
-      :too_short => "is too short (min is %d characters)", 
-      :wrong_length => "is the wrong length (should be %d characters)", 
+      :too_long => "is too long (max is %d characters)",
+      :too_short => "is too short (min is %d characters)",
+      :wrong_length => "is the wrong length (should be %d characters)",
       :taken => "has already been taken",
       :not_a_number => "is not a number"
     }
-      
+
     # Holds a hash with all the default error messages, such that they can be replaced by your own copy or localizations.
     cattr_accessor :default_error_messages
 
-    
+
     # Adds an error to the base object instead of any particular attribute. This is used
-    # to report errors that doesn't tie to any specific attribute, but rather to the object
-    # as a whole. These error messages doesn't get prepended with any field name when iterating
+    # to report errors that don't tie to any specific attribute, but rather to the object
+    # as a whole. These error messages don't get prepended with any field name when iterating
     # with each_full, so they should be complete sentences.
     def add_to_base(msg)
       add(:base, msg)
@@ -53,7 +65,7 @@ module ActiveRecord
         add(attr, msg) unless !value.nil? && !is_empty
       end
     end
-    
+
     # Will add an error message to each of the attributes in +attributes+ that is blank (using Object#blank?).
     def add_on_blank(attributes, msg = @@default_error_messages[:blank])
       for attr in [attributes].flatten
@@ -62,7 +74,7 @@ module ActiveRecord
       end
     end
 
-    # Will add an error message to each of the attributes in +attributes+ that has a length outside of the passed boundary +range+. 
+    # Will add an error message to each of the attributes in +attributes+ that has a length outside of the passed boundary +range+.
     # If the length is above the boundary, the too_long_msg message will be used. If below, the too_short_msg.
     def add_on_boundary_breaking(attributes, range, too_long_msg = @@default_error_messages[:too_long], too_short_msg = @@default_error_messages[:too_short])
       for attr in [attributes].flatten
@@ -98,12 +110,12 @@ module ActiveRecord
     def on_base
       on(:base)
     end
-    
+
     # Yields each attribute and associated message per error added.
     def each
       @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
     end
-    
+
     # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
     # through iteration as "First name can't be empty".
     def each_full
@@ -113,11 +125,11 @@ module ActiveRecord
     # Returns all the full error messages in an array.
     def full_messages
       full_messages = []
-      
-      @errors.each_key do |attr| 
+
+      @errors.each_key do |attr|
         @errors[attr].each do |msg|
           next if msg.nil?
-          
+
           if attr == "base"
             full_messages << msg
           else
@@ -125,7 +137,7 @@ module ActiveRecord
           end
         end
       end
-      
+
       return full_messages
     end
 
@@ -133,12 +145,12 @@ module ActiveRecord
     def empty?
       return @errors.empty?
     end
-    
+
     # Removes all the errors that have been added.
     def clear
       @errors = {}
     end
-    
+
     # Returns the total number of errors added. Two errors added to the same attribute will be counted as such
     # with this as well.
     def count
@@ -149,7 +161,7 @@ module ActiveRecord
   end
 
 
-  # Active Records implement validation by overwriting Base#validate (or the variations, +validate_on_create+ and 
+  # Active Records implement validation by overwriting Base#validate (or the variations, +validate_on_create+ and
   # +validate_on_update+). Each of these methods can inspect the state of the object, which usually means ensuring
   # that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
   #
@@ -179,7 +191,7 @@ module ActiveRecord
   #   person.errors.count                 # => 2
   #   person.errors.on "last_name"        # => "can't be empty"
   #   person.errors.on "phone_number"     # => "has invalid format"
-  #   person.errors.each_full { |msg| puts msg } 
+  #   person.errors.each_full { |msg| puts msg }
   #                                       # => "Last name can't be empty\n" +
   #                                            "Phone number has invalid format"
   #
@@ -312,7 +324,7 @@ module ActiveRecord
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
 
         attr_accessor *(attr_names.map { |n| "#{n}_confirmation" })
-	
+
         validates_each(attr_names, configuration) do |record, attr_name, value|
           record.errors.add(attr_name, configuration[:message]) unless record.send("#{attr_name}_confirmation").nil? or value == record.send("#{attr_name}_confirmation")
         end
@@ -341,7 +353,7 @@ module ActiveRecord
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
 
         attr_accessor *attr_names
-	
+
         validates_each(attr_names,configuration) do |record, attr_name, value|
           record.errors.add(attr_name, configuration[:message]) unless value == configuration[:accept]
         end
@@ -359,8 +371,8 @@ module ActiveRecord
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:blank], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
 
-        # can't use validates_each here, because it cannot cope with non-existant attributes,
-        # while errors.add_on_empty can	
+        # can't use validates_each here, because it cannot cope with nonexistent attributes,
+        # while errors.add_on_empty can
         attr_names.each do |attr_name|
           send(validation_method(configuration[:on])) do |record|
             unless configuration[:if] and not evaluate_condition(configuration[:if], record)
@@ -423,7 +435,7 @@ module ActiveRecord
 
         case option
         when :within, :in
-          raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range) 
+          raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range)
 
           too_short = options[:too_short] % option_value.begin
           too_long  = options[:too_long]  % option_value.end
@@ -460,7 +472,7 @@ module ActiveRecord
       #     validates_uniqueness_of :user_name, :scope => "account_id"
       #   end
       #
-      # When the record is created, a check is performed to make sure that no record exist in the database with the given value for the specified
+      # When the record is created, a check is performed to make sure that no record exists in the database with the given value for the specified
       # attribute (that maps to a column). When the record is updated, the same check is made but disregarding the record itself.
       #
       # Configuration options:
@@ -483,8 +495,8 @@ module ActiveRecord
           end
         end
       end
-      
-      # Validates whether the value of the specified attribute is of the correct form by matching it against the regular expression 
+
+      # Validates whether the value of the specified attribute is of the correct form by matching it against the regular expression
       # provided.
       #
       #   class Person < ActiveRecord::Base
@@ -528,9 +540,9 @@ module ActiveRecord
       def validates_inclusion_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:inclusion], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
- 
+
         enum = configuration[:in] || configuration[:within]
- 
+
         raise(ArgumentError, "An object with the method include? is required must be supplied as the :in option of the configuration hash") unless enum.respond_to?("include?")
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
@@ -565,7 +577,7 @@ module ActiveRecord
         end
       end
 
-      # Validates whether the associated object or objects are all themselves valid. Works with any kind of association.
+      # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
       #
       #   class Book < ActiveRecord::Base
       #     has_many :pages
@@ -597,11 +609,11 @@ module ActiveRecord
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
-          record.errors.add(attr_name, configuration[:message]) unless 
+          record.errors.add(attr_name, configuration[:message]) unless
             (value.is_a?(Array) ? value : [value]).all? { |r| r.nil? or r.valid? }
         end
       end
-      
+
       # Validates whether the value of the specified attribute is numeric by trying to convert it to
       # a float with Kernel.Float (if <tt>integer</tt> is false) or applying it to the regular expression
       # <tt>/^[\+\-]?\d+$/</tt> (if <tt>integer</tt> is set to true).
@@ -636,9 +648,23 @@ module ActiveRecord
               record.errors.add(attr_name, configuration[:message])
             end
           end
-      	end
+        end
       end
 
+
+      # Creates an object just like Base.create but calls save! instead of save
+      # so an exception is raised if the record is invalid.
+      def create!(attributes = nil)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr) }
+        else
+          object = new(attributes)
+          object.save!
+          object
+        end
+      end
+
+
       private
         def write_inheritable_set(key, methods)
           existing_methods = read_inheritable_attribute(key) || []
@@ -665,10 +691,14 @@ module ActiveRecord
       end
     end
 
-    # Attempts to save the record just like Base.save but will raise a RecordInvalid exception instead of returning false
+    # Attempts to save the record just like Base#save but will raise a RecordInvalid exception instead of returning false
     # if the record is not valid.
     def save!
-      valid? ? save(false) : raise(RecordInvalid)
+      if valid?
+        save(false)
+      else
+        raise RecordInvalid.new(self)
+      end
     end
 
     # Updates a single attribute and saves the record without going through the normal validation procedure.
@@ -688,7 +718,7 @@ module ActiveRecord
 
       if new_record?
         run_validations(:validate_on_create)
-        validate_on_create 
+        validate_on_create
       else
         run_validations(:validate_on_update)
         validate_on_update
@@ -705,7 +735,7 @@ module ActiveRecord
     protected
       # Overwrite this method for validation checks on all saves and use Errors.add(field, msg) for invalid attributes.
       def validate #:doc:
-      end 
+      end
 
       # Overwrite this method for validation checks used only on creation.
       def validate_on_create #:doc: