activerecord 2.0.2 → 2.0.4

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

@@ -89,7 +89,7 @@ module ActiveRecord
       # See also TableDefinition#column for details on how to create columns.
       def create_table(table_name, options = {})
         table_definition = TableDefinition.new(self)
-        table_definition.primary_key(options[:primary_key] || "id") unless options[:id] == false
+        table_definition.primary_key(options[:primary_key] || Base.get_primary_key(table_name)) unless options[:id] == false
 
         yield table_definition
 
@@ -255,26 +255,27 @@ module ActiveRecord
       def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
         if native = native_database_types[type]
           column_type_sql = native.is_a?(Hash) ? native[:name] : native
+
           if type == :decimal # ignore limit, use precision and scale
-            precision ||= native[:precision]
             scale ||= native[:scale]
-            if precision
+
+            if precision ||= native[:precision]
               if scale
                 column_type_sql << "(#{precision},#{scale})"
               else
                 column_type_sql << "(#{precision})"
               end
-            else
-              raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified" if scale
+            elsif scale
+              raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified"
             end
-            column_type_sql
-          else
-            limit ||= native[:limit]
-            column_type_sql << "(#{limit})" if limit
-            column_type_sql
+
+          elsif limit ||= native.is_a?(Hash) && native[:limit]
+            column_type_sql << "(#{limit})"
           end
+
+          column_type_sql
         else
-          column_type_sql = type
+          type
         end
       end
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -30,6 +30,7 @@ module ActiveRecord
         @connection, @logger = connection, logger
         @runtime = 0
         @last_verification = 0
+        @query_cache_enabled = false
       end
 
       # Returns the human-readable name of the adapter.  Use mixed case - one

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -346,7 +346,7 @@ module ActiveRecord
           # There are some incorrectly compiled postgres drivers out there
           # that don't define PGconn.escape.
           self.class.instance_eval do
-            undef_method(:quote_string)
+            remove_method(:quote_string)
           end
         end
         quote_string(s)
@@ -386,8 +386,8 @@ module ActiveRecord
 
       # Executes an INSERT query and returns the new record's ID
       def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        table = sql.split(" ", 4)[2]
-        super || last_insert_id(table, sequence_name || default_sequence_name(table, pk))
+        table = sql.split(" ", 4)[2].gsub('"', '')
+        super || pk && last_insert_id(table, sequence_name || default_sequence_name(table, pk))
       end
 
       # Queries the database and returns the results in an Array or nil otherwise.

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -304,13 +304,13 @@ module ActiveRecord
             yield @definition if block_given?
           end
 
-          copy_table_indexes(from, to)
+          copy_table_indexes(from, to, options[:rename] || {})
           copy_table_contents(from, to,
             @definition.columns.map {|column| column.name},
             options[:rename] || {})
         end
 
-        def copy_table_indexes(from, to) #:nodoc:
+        def copy_table_indexes(from, to, rename = {}) #:nodoc:
           indexes(from).each do |index|
             name = index.name
             if to == "altered_#{from}"
@@ -319,10 +319,17 @@ module ActiveRecord
               name = name[5..-1]
             end
 
-            # index name can't be the same
-            opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
-            opts[:unique] = true if index.unique
-            add_index(to, index.columns, opts)
+            to_column_names = columns(to).map(&:name)
+            columns = index.columns.map {|c| rename[c] || c }.select do |column|
+              to_column_names.include?(column)
+            end
+
+            unless columns.empty?
+              # index name can't be the same
+              opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
+              opts[:unique] = true if index.unique
+              add_index(to, columns, opts)
+            end
           end
         end
 

data/lib/active_record/fixtures.rb

@@ -438,7 +438,7 @@ end
 #
 # Any fixture labeled "DEFAULTS" is safely ignored.
 
-class Fixtures < YAML::Omap
+class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
   DEFAULT_FILTER_RE = /\.ya?ml$/
 
   @@all_cached_fixtures = {}
@@ -467,7 +467,7 @@ class Fixtures < YAML::Omap
   end
 
   def self.cache_fixtures(connection, fixtures)
-    cache_for_connection(connection).update(fixtures.index_by(&:table_name))
+    cache_for_connection(connection).update(fixtures.index_by { |f| f.table_name })
   end
 
   def self.instantiate_fixtures(object, table_name, fixtures, load_instances = true)
@@ -644,8 +644,16 @@ class Fixtures < YAML::Omap
     end
 
     def model_class
-      @model_class ||= @class_name.is_a?(Class) ?
-        @class_name : @class_name.constantize rescue nil
+      unless defined?(@model_class)
+        @model_class =
+          if @class_name.nil? || @class_name.is_a?(Class)
+            @class_name
+          else
+            @class_name.constantize rescue nil
+          end
+      end
+
+      @model_class
     end
 
     def primary_key_name
@@ -681,7 +689,7 @@ class Fixtures < YAML::Omap
         Dir.entries(@fixture_path).each do |file|
           path = File.join(@fixture_path, file)
           if File.file?(path) and file !~ @file_filter
-            self[file] = Fixture.new(path, @class_name)
+            self[file] = Fixture.new(path, model_class)
           end
         end
       end
@@ -709,20 +717,20 @@ class Fixtures < YAML::Omap
               raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{name} (nil)"
             end
 
-            self[name] = Fixture.new(data, @class_name)
+            self[name] = Fixture.new(data, model_class)
           end
         end
       end
     end
 
     def read_csv_fixture_files
-      reader = CSV::Reader.create(erb_render(IO.read(csv_file_path)))
+      reader = CSV.parse(erb_render(IO.read(csv_file_path)))
       header = reader.shift
       i = 0
       reader.each do |row|
         data = {}
         row.each_with_index { |cell, j| data[header[j].to_s.strip] = cell.to_s.strip }
-        self["#{Inflector::underscore(@class_name)}_#{i+=1}"]= Fixture.new(data, @class_name)
+        self["#{Inflector::underscore(@class_name)}_#{i+=1}"] = Fixture.new(data, model_class)
       end
     end
 
@@ -758,9 +766,9 @@ class Fixture #:nodoc:
   class FormatError < FixtureError #:nodoc:
   end
 
-  attr_reader :class_name
+  attr_reader :model_class
 
-  def initialize(fixture, class_name)
+  def initialize(fixture, model_class)
     case fixture
       when Hash, YAML::Omap
         @fixture = fixture
@@ -770,7 +778,11 @@ class Fixture #:nodoc:
         raise ArgumentError, "Bad fixture argument #{fixture.inspect} during creation of #{class_name} fixture"
     end
 
-    @class_name = class_name
+    @model_class = model_class.is_a?(Class) ? model_class : model_class.constantize rescue nil
+  end
+
+  def class_name
+    @model_class.name if @model_class
   end
 
   def each
@@ -791,21 +803,18 @@ class Fixture #:nodoc:
   end
 
   def value_list
-    klass = @class_name.constantize rescue nil
-
     list = @fixture.inject([]) do |fixtures, (key, value)|
-      col = klass.columns_hash[key] if klass.respond_to?(:ancestors) && klass.ancestors.include?(ActiveRecord::Base)
+      col = model_class.columns_hash[key] if model_class.respond_to?(:ancestors) && model_class.ancestors.include?(ActiveRecord::Base)
       fixtures << ActiveRecord::Base.connection.quote(value, col).gsub('[^\]\\n', "\n").gsub('[^\]\\r', "\r")
     end
     list * ', '
   end
 
   def find
-    klass = @class_name.is_a?(Class) ? @class_name : Object.const_get(@class_name) rescue nil
-    if klass
-      klass.find(self[klass.primary_key])
+    if model_class
+      model_class.find(self[model_class.primary_key])
     else
-      raise FixtureClassNotFound, "The class #{@class_name.inspect} was not found."
+      raise FixtureClassNotFound, "No class attached to find."
     end
   end
 
@@ -916,8 +925,6 @@ module Test #:nodoc:
       end
 
       def setup_with_fixtures
-        return if @fixtures_setup
-        @fixtures_setup = true
         return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
 
         if pre_loaded_fixtures && !use_transactional_fixtures
@@ -949,8 +956,6 @@ module Test #:nodoc:
       alias_method :setup, :setup_with_fixtures
 
       def teardown_with_fixtures
-        return if @fixtures_teardown
-        @fixtures_teardown = true
         return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
 
         unless use_transactional_fixtures?
@@ -967,31 +972,24 @@ module Test #:nodoc:
       alias_method :teardown, :teardown_with_fixtures
 
       def self.method_added(method)
-        return if @__disable_method_added__
-        @__disable_method_added__ = true
-        
         case method.to_s
         when 'setup'
           unless method_defined?(:setup_without_fixtures)
             alias_method :setup_without_fixtures, :setup
-            define_method(:full_setup) do
+            define_method(:setup) do
               setup_with_fixtures
               setup_without_fixtures
             end
           end
-          alias_method :setup, :full_setup
         when 'teardown'
           unless method_defined?(:teardown_without_fixtures)
             alias_method :teardown_without_fixtures, :teardown
-            define_method(:full_teardown) do
+            define_method(:teardown) do
               teardown_without_fixtures
               teardown_with_fixtures
             end
           end
-          alias_method :teardown, :full_teardown
         end
-        
-        @__disable_method_added__ = false
       end
 
       private

data/lib/active_record/migration.rb

@@ -230,7 +230,7 @@ module ActiveRecord
       # recursively. We use @ignore_new_methods as a guard to indicate whether
       # it is safe for the call to proceed.
       def singleton_method_added(sym) #:nodoc:
-        return if @ignore_new_methods
+        return if defined?(@ignore_new_methods) && @ignore_new_methods
 
         begin
           @ignore_new_methods = true
@@ -356,15 +356,14 @@ module ActiveRecord
 
     private
       def migration_classes
-        migrations = migration_files.inject([]) do |migrations, migration_file|
+        classes = migration_files.inject([]) do |migrations, migration_file|
           load(migration_file)
           version, name = migration_version_and_name(migration_file)
           assert_unique_migration_version(migrations, version.to_i)
           migrations << migration_class(name, version.to_i)
-        end
+        end.sort_by(&:version)
 
-        sorted = migrations.sort_by { |m| m.version }
-        down? ? sorted.reverse : sorted
+        down? ? classes.reverse : classes
       end
 
       def assert_unique_migration_version(migrations, version)

data/lib/active_record/observer.rb

@@ -170,7 +170,7 @@ module ActiveRecord
       end
 
       def observed_subclasses
-        observed_classes.collect(&:subclasses).flatten
+        observed_classes.sum([]) { |klass| klass.send(:subclasses) }
       end
 
       def add_observer!(klass)

data/lib/active_record/transactions.rb

@@ -15,7 +15,7 @@ module ActiveRecord
       end
     end
 
-    # Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. 
+    # 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. 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
@@ -73,14 +73,12 @@ module ActiveRecord
     # trigger a ROLLBACK when raised, but not be re-raised by the transaction block.
     module ClassMethods
       def transaction(&block)
-        previous_handler = trap('TERM') { raise TransactionError, "Transaction aborted" }
         increment_open_transactions
 
         begin
           connection.transaction(Thread.current['start_db_transaction'], &block)
         ensure
           decrement_open_transactions
-          trap('TERM', previous_handler)
         end
       end
 
@@ -116,7 +114,7 @@ module ActiveRecord
     def rollback_active_record_state!
       id_present = has_attribute?(self.class.primary_key)
       previous_id = id
-      previous_new_record = @new_record
+      previous_new_record = new_record?
       yield
     rescue Exception
       @new_record = previous_new_record
@@ -125,7 +123,7 @@ module ActiveRecord
       else
         @attributes.delete(self.class.primary_key)
         @attributes_cache.delete(self.class.primary_key)
-      end  
+      end
       raise
     end
   end

data/lib/active_record/validations.rb

@@ -1,12 +1,12 @@
 module ActiveRecord
   # Raised by save! and create! when the record is invalid.  Use the
-  # record method to retrieve the record which did not validate.
+  # +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 #:nodoc:
+  class RecordInvalid < ActiveRecordError
     attr_reader :record
     def initialize(record)
       @record = record
@@ -633,7 +633,7 @@ module ActiveRecord
       #
       # Because this check is performed outside the database there is still a chance that duplicate values
       # will be inserted in two parallel transactions.  To guarantee against this you should create a 
-      # unique index on the field. See +create_index+ for more information.
+      # unique index on the field. See +add_index+ for more information.
       #
       # Configuration options:
       # * <tt>message</tt> - Specifies a custom error message (default is: "has already been taken")
@@ -707,6 +707,8 @@ module ActiveRecord
       #
       # Configuration options:
       # * <tt>message</tt> - A custom error message (default is: "is invalid")
+      # * <tt>allow_nil</tt> - If set to true, skips this validation if the attribute is null (default is: false)
+      # * <tt>allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is: false)
       # * <tt>with</tt> - The regular expression used to validate the format with (note: must be supplied!)
       # * <tt>on</tt> Specifies when this validation is active (default is :save, other options :create, :update)
       # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should

data/lib/active_record/version.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 2
     MINOR = 0
-    TINY  = 2
+    TINY  = 4
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/active_schema_test_mysql.rb

@@ -3,13 +3,16 @@ require 'abstract_unit'
 class ActiveSchemaTest < Test::Unit::TestCase
   def setup
     ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
-      alias_method :real_execute, :execute
+      alias_method :execute_without_stub, :execute
       def execute(sql, name = nil) return sql end
     end
   end
 
   def teardown
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:alias_method, :execute, :real_execute)
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+      remove_method :execute
+      alias_method :execute, :execute_without_stub
+    end
   end
 
   def test_drop_table

data/test/adapter_test.rb

@@ -76,6 +76,7 @@ class AdapterTest < Test::Unit::TestCase
     assert_equal 'dbo_posts',  @connection.table_alias_for('dbo.posts')
 
     class << @connection
+      remove_method :table_alias_length
       alias_method :table_alias_length, :old_table_alias_length
     end
   end

data/test/associations/callbacks_test.rb

@@ -128,7 +128,7 @@ class AssociationCallbacksTest < Test::Unit::TestCase
     callback_log = ["before_adding<new>", "after_adding<new>"]
     assert_equal callback_log, project.developers_log
     assert project.save
-    assert_equal 1, project.developers_with_callbacks.count
+    assert_equal 1, project.developers_with_callbacks.size
     assert_equal callback_log, project.developers_log
   end