activerecord 1.11.0 → 1.11.1

data/CHANGELOG

@@ -1,4 +1,23 @@
-*1.11.0* (5th July, 2005)
+*1.11.1* (11 July, 2005)
+
+* Added support for limit and offset with eager loading of has_one and belongs_to associations. Using the options with has_many and has_and_belongs_to_many associations will now raise an ActiveRecord::ConfigurationError #1692 [Rick Olsen]
+
+* Fixed that assume_bottom_position (in acts_as_list) could be called on items already last in the list and they would move one position away from the list #1648 [tyler@kianta.com]
+
+* Added ActiveRecord::Base.threaded_connections flag to turn off 1-connection per thread (required for thread safety). By default it's on, but WEBrick in Rails need it off #1685 [Sam Stephenson]
+
+* Correct reflected table name for singular associations.  #1688 [court3nay@gmail.com]
+
+* Fixed optimistic locking with SQL Server #1660 [tom@popdog.net]
+
+* Added ActiveRecord::Migrator.migrate that can figure out whether to go up or down based on the target version and the current
+
+* Added better error message for "packets out of order" #1630 [courtenay]
+
+* Fixed first run of "rake migrate" on PostgreSQL by not expecting a return value on the id #1640
+
+
+*1.11.0* (6 July, 2005)
 
 * Fixed that Yaml error message in fixtures hid the real error #1623 [Nicholas Seckar]
 

data/lib/active_record/acts/list.rb

@@ -173,7 +173,7 @@ module ActiveRecord
           end
 
           def assume_bottom_position
-            update_attribute(position_column, bottom_position_in_list.to_i + 1)
+            update_attribute(position_column, bottom_position_in_list.to_i + 1) unless last?
           end
   
           def assume_top_position

data/lib/active_record/associations.rb

@@ -168,7 +168,8 @@ module ActiveRecord
     # catch-all for performance problems, but its a great way to cut down on the number of queries in a situation as the one described above.
     #
     # Please note that because eager loading is fetching both models and associations in the same grab, it doesn't make sense to use the
-    # :limit property and it will be ignored if attempted.
+    # :limit and :offset options on has_many and has_and_belongs_to_many associations and an ConfigurationError exception will be raised 
+    # if attempted. It does, however, work just fine with has_one and belongs_to associations.
     #
     # Also have in mind that since the eager loading is pulling from multiple tables, you'll have to disambiguate any column references
     # in both conditions and orders. So :order => "posts.id DESC" will work while :order => "id DESC" will not. This may require that
@@ -739,13 +740,17 @@ module ActiveRecord
         end
 
         def find_with_associations(options = {})
-          reflections          = reflect_on_included_associations(options[:include])
+          reflections  = reflect_on_included_associations(options[:include])
+
+          guard_against_missing_reflections(reflections, options)
+          guard_against_unlimitable_reflections(reflections, options)
+          
           schema_abbreviations = generate_schema_abbreviations(reflections)
           primary_key_table    = generate_primary_key_table(reflections, schema_abbreviations)
 
-          rows        = select_all_rows(options, schema_abbreviations, reflections)
-          records, records_in_order     = { }, []
-          primary_key = primary_key_table[table_name]
+          rows                      = select_all_rows(options, schema_abbreviations, reflections)
+          records, records_in_order = { }, []
+          primary_key               = primary_key_table[table_name]
           
           for row in rows
             id = row[primary_key]
@@ -781,6 +786,24 @@ module ActiveRecord
           [ associations ].flatten.collect { |association| reflect_on_association(association) }
         end
 
+        def guard_against_missing_reflections(reflections, options)
+          reflections.each do |r| 
+            raise(
+              ConfigurationError, 
+              "Association was not found; perhaps you misspelled it?  You specified :include => :#{options[:include].join(', :')}"
+            ) if r.nil? 
+          end
+        end
+        
+        def guard_against_unlimitable_reflections(reflections, options)
+          if (options[:offset] || options[:limit]) && !using_limitable_reflections?(reflections)
+            raise(
+              ConfigurationError, 
+              "You can not use offset and limit together with has_many or has_and_belongs_to_many associations"
+            )
+          end
+        end
+
         def generate_schema_abbreviations(reflections)
           schema = [ [ table_name, column_names ] ]
           schema += reflections.collect { |r| [ r.table_name, r.klass.column_names ] }
@@ -823,10 +846,14 @@ module ActiveRecord
           add_conditions!(sql, options[:conditions])
           add_sti_conditions!(sql, reflections)
           sql << "ORDER BY #{options[:order]} " if options[:order]
-          
+          add_limit!(sql, options) if using_limitable_reflections?(reflections)
           return sanitize_sql(sql)
         end
 
+        def using_limitable_reflections?(reflections)
+          reflections.reject { |r| [ :belongs_to, :has_one ].include?(r.macro) }.length.zero?
+        end
+
         def add_sti_conditions!(sql, reflections)
           sti_sql = ""
           reflections.each do |reflection|

data/lib/active_record/base.rb

@@ -26,6 +26,8 @@ module ActiveRecord #:nodoc:
   end
   class StaleObjectError < ActiveRecordError #:nodoc:
   end
+  class ConfigurationError < StandardError #:nodoc:
+  end
 
   class AttributeAssignmentError < ActiveRecordError #:nodoc:
     attr_reader :exception, :attribute
@@ -289,6 +291,11 @@ module ActiveRecord #:nodoc:
     # This is set to :local by default.
     cattr_accessor :default_timezone
     @@default_timezone = :local
+    
+    # Determines whether or not to use a connection for each thread, or a single shared connection for all threads.
+    # Defaults to true; Railties' WEBrick server sets this to false.
+    cattr_accessor :threaded_connections
+    @@threaded_connections = true
 
     class << self # Class methods
       # Find operates with three different retreval approaches:
@@ -331,7 +338,7 @@ module ActiveRecord #:nodoc:
 
         case args.first
           when :first
-            find(:all, options.merge({ :limit => 1 })).first
+            find(:all, options.merge(options[:include] ? { } : { :limit => 1 })).first
           when :all
             options[:include] ? find_with_associations(options) : find_by_sql(construct_finder_sql(options))
           else
@@ -836,7 +843,7 @@ module ActiveRecord #:nodoc:
         # MyApp::Business::Account would be appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)
           type_name_with_module(type_name).split("::").inject(Object) do |final_type, part|
-            final_type = final_type.const_get(part)
+            final_type.const_get(part)
           end
         end
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -86,6 +86,14 @@ module ActiveRecord
       end
     end
 
+    def self.active_connections #:nodoc:
+      if threaded_connections
+        Thread.current['active_connections'] ||= {}
+      else
+        @@active_connections ||= {}
+      end
+    end
+
     # Locate the connection of the nearest super class. This can be an
     # active or defined connections: if it is the latter, it will be
     # opened and set as the active connection for the class it was defined
@@ -94,7 +102,7 @@ module ActiveRecord
       klass = self
       ar_super = ActiveRecord::Base.superclass
       until klass == ar_super
-        if conn = (Thread.current['active_connections'] ||= {})[klass]
+        if conn = active_connections[klass]
           return conn
         elsif conn = @@defined_connections[klass]
           klass.connection = conn
@@ -109,7 +117,7 @@ module ActiveRecord
     def self.connected?
       klass = self
       until klass == ActiveRecord::Base.superclass
-        if Thread.current['active_connections'].is_a?(Hash) && Thread.current['active_connections'][klass]
+        if active_connections[klass]
           return true
         else
           klass = klass.superclass
@@ -125,8 +133,7 @@ module ActiveRecord
     def self.remove_connection(klass=self)
       conn = @@defined_connections[klass]
       @@defined_connections.delete(klass)
-      Thread.current['active_connections'] ||= {}
-      Thread.current['active_connections'][klass] = nil
+      active_connections[klass] = nil
       conn.config if conn
     end
 
@@ -134,8 +141,7 @@ module ActiveRecord
     def self.connection=(spec)
       raise ConnectionNotEstablished unless spec
       conn = self.send(spec.adapter_method, spec.config)
-      Thread.current['active_connections'] ||= {}
-      Thread.current['active_connections'][self] = conn
+      active_connections[self] = conn
     end
 
     # Converts all strings in a hash to symbols.
@@ -361,7 +367,7 @@ module ActiveRecord
       def initialize_schema_information
         begin
           execute "CREATE TABLE schema_info (version #{type_to_sql(:integer)})"
-          insert "INSERT INTO schema_info (version) VALUES(0)"
+          execute "INSERT INTO schema_info (version) VALUES(0)"
         rescue ActiveRecord::StatementInvalid
           # Schema has been intialized
         end

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -129,6 +129,8 @@ module ActiveRecord
             @logger.info "Retrying invalid statement with reopened connection"
             log(sql, name) { @connection.query(sql) }
           end
+        elsif exception.message.split(":").first =~ /Packets out of order/
+          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem update mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information."
         else
           raise
         end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -66,7 +66,7 @@ module ActiveRecord
         return nil if value.nil? || value =~ /^\s*null\s*$/i
         case type
         when :string    then value
-        when :integer   then value == true || value == false ? value == true ? '1' : '0' : value.to_i
+        when :integer   then value == true || value == false ? value == true ? 1 : 0 : value.to_i
         when :float     then value.to_f
         when :datetime  then cast_to_datetime(value)
         when :timestamp then cast_to_time(value)
@@ -236,9 +236,9 @@ module ActiveRecord
       end
 
       def execute(sql, name = nil)
-        if sql =~ /^INSERT/i
+        if sql =~ /^\s*INSERT/i
           insert(sql, name)
-        elsif sql =~ /^UPDATE|DELETE/i
+        elsif sql =~ /^\s*UPDATE|^\s*DELETE/i
           log(sql, name) do
             @connection.execute(sql)
             retVal = select_one("SELECT @@ROWCOUNT AS AffectedRows")["AffectedRows"]

data/lib/active_record/migration.rb

@@ -108,6 +108,18 @@ module ActiveRecord
   #       add_column :items, :completed_items_count
   #     end
   #   end
+  #
+  # And some times you need to do something in SQL not abstracted directly by migrations:
+  #
+  #   class MakeJoinUnique < ActiveRecord::Migration
+  #     def self.up
+  #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
+  #     end
+  #
+  #     def self.down
+  #       execute "ALTER TABLE `pages_linked_pages` DROP INDEX `page_id_linked_page_id`"
+  #     end
+  #   end
   class Migration
     class << self
       def up() end
@@ -122,6 +134,17 @@ module ActiveRecord
 
   class Migrator#:nodoc:
     class << self
+      def migrate(migrations_path, target_version = nil)
+        case
+          when target_version.nil?, current_version < target_version
+            up(migrations_path, target_version)
+          when current_version > target_version
+            down(migrations_path, target_version)
+          when current_version == target_version
+            return # You're on the right version
+        end
+      end
+      
       def up(migrations_path, target_version = nil)
         self.new(:up, migrations_path, target_version).migrate
       end
@@ -146,7 +169,7 @@ module ActiveRecord
     end
 
     def migrate
-      migration_classes do |version, migration_class|
+      migration_classes.each do |(version, migration_class)|
         Base.logger.info("Reached target version: #{@target_version}") and break if reached_target_version?(version)
         next if irrelevant_migration?(version)
 
@@ -158,11 +181,13 @@ module ActiveRecord
 
     private
       def migration_classes
-        for migration_file in migration_files
+        migrations = migration_files.collect do |migration_file|
           load(migration_file)
           version, name = migration_version_and_name(migration_file)
-          yield version, migration_class(name)
+          [ version.to_i, migration_class(name) ]
         end
+        
+        down? ? migrations.sort.reverse : migrations.sort
       end
     
       def migration_files

data/lib/active_record/query_cache.rb

@@ -51,8 +51,7 @@ module ActiveRecord
         QueryCache.new(self.send(spec.adapter_method, spec.config)) :
         self.send(spec.adapter_method, spec.config)
       
-      Thread.current['active_connections'] ||= {}
-      Thread.current['active_connections'][self] = conn
+      active_connections[self] = conn
     end
   end
   

data/lib/active_record/reflection.rb

@@ -10,13 +10,13 @@ module ActiveRecord
 
           def composed_of_with_reflection(part_id, options = {})
             composed_of_without_reflection(part_id, options)
-            write_inheritable_array "aggregations", [ AggregateReflection.new(:composed_of, part_id, options, self) ]
+            reflect_on_all_aggregations << AggregateReflection.new(:composed_of, part_id, options, self)
           end
 
-          alias_method :composed_of, :composed_of_with_reflection          
+          alias_method :composed_of, :composed_of_with_reflection
         end
       end
-      
+
       for association_type in %w( belongs_to has_one has_many has_and_belongs_to_many )
         base.module_eval <<-"end_eval"
           class << self
@@ -24,16 +24,16 @@ module ActiveRecord
 
             def #{association_type}_with_reflection(association_id, options = {})
               #{association_type}_without_reflection(association_id, options)
-              write_inheritable_array "associations", [ AssociationReflection.new(:#{association_type}, association_id, options, self) ]
+              reflect_on_all_associations << AssociationReflection.new(:#{association_type}, association_id, options, self)
             end
 
-            alias_method :#{association_type}, :#{association_type}_with_reflection          
+            alias_method :#{association_type}, :#{association_type}_with_reflection
           end
         end_eval
       end
     end
 
-    # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. 
+    # 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
     # fields for all of the attributes depending on their type and displayed the associations to other objects.
     #
@@ -41,9 +41,9 @@ module ActiveRecord
     module ClassMethods
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
-        read_inheritable_attribute "aggregations"
+        read_inheritable_attribute(:aggregations) or write_inheritable_attribute(:aggregations, [])
       end
-      
+
       # Returns the AggregateReflection object for the named +aggregation+ (use the symbol). Example:
       #   Account.reflect_on_aggregation(:balance) # returns the balance AggregateReflection
       def reflect_on_aggregation(aggregation)
@@ -52,47 +52,47 @@ module ActiveRecord
 
       # Returns an array of AssociationReflection objects for all the aggregations in the class.
       def reflect_on_all_associations
-        read_inheritable_attribute "associations"
+        read_inheritable_attribute(:associations) or write_inheritable_attribute(:associations, [])
       end
-      
+
       # Returns the AssociationReflection object for the named +aggregation+ (use the symbol). Example:
       #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
       def reflect_on_association(association)
-        reflect_on_all_associations.find { |reflection| reflection.name == association } unless reflect_on_all_associations.nil?
+        reflect_on_all_associations.find { |reflection| reflection.name == association }
       end
     end
-    
 
-    # Abstract base class for AggregateReflection and AssociationReflection that describes the interface available for both of 
+
+    # Abstract base class for AggregateReflection and AssociationReflection that describes the interface available for both of
     # those classes. Objects of AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
       attr_reader :active_record
       def initialize(macro, name, options, active_record)
         @macro, @name, @options, @active_record = macro, name, options, active_record
       end
-      
+
       # Returns the name of the macro, so it would return :balance for "composed_of :balance, :class_name => 'Money'" or
       # :clients for "has_many :clients".
       def name
         @name
       end
-      
-      # Returns the name of the macro, so it would return :composed_of for 
+
+      # Returns the name of the macro, so it would return :composed_of for
       # "composed_of :balance, :class_name => 'Money'" or :has_many for "has_many :clients".
       def macro
         @macro
       end
-      
-      # Returns the hash of options used for the macro, so it would return { :class_name => "Money" } for 
+
+      # Returns the hash of options used for the macro, so it would return { :class_name => "Money" } for
       # "composed_of :balance, :class_name => 'Money'" or {} for "has_many :clients".
       def options
         @options
       end
-      
+
       # Returns the class for the macro, so "composed_of :balance, :class_name => 'Money'" would return the Money class and
       # "has_many :clients" would return the Client class.
       def klass() end
-      
+
       def ==(other_aggregation)
         name == other_aggregation.name && other_aggregation.options && active_record == other_aggregation.active_record
       end
@@ -102,9 +102,9 @@ module ActiveRecord
     # Holds all the meta-data about an aggregation as it was specified in the Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
       def klass
-        Object.const_get(options[:class_name] || name_to_class_name(name.id2name)) 
+        Object.const_get(options[:class_name] || name_to_class_name(name.id2name))
       end
-      
+
       private
         def name_to_class_name(name)
           name.capitalize.gsub(/_(.)/) { |s| $1.capitalize }
@@ -116,21 +116,23 @@ module ActiveRecord
       def klass
         @klass ||= active_record.send(:compute_type, (name_to_class_name(name.id2name)))
       end
-      
+
       def table_name
         @table_name ||= klass.table_name
       end
 
       private
         def name_to_class_name(name)
-          if name !~ /::/
-            class_name = active_record.send(
-              :type_name_with_module, 
-              (options[:class_name] || active_record.class_name(active_record.table_name_prefix + name + active_record.table_name_suffix))
-            )
+          if name =~ /::/
+            name
+          else
+            unless class_name = options[:class_name]
+              class_name = name.to_s.camelize
+              class_name = class_name.singularize if [:has_many, :has_and_belongs_to_many].include?(macro)
+            end
+            active_record.send(:type_name_with_module, class_name)
           end
-          return class_name || name
         end
     end
   end
-end
+end

data/lib/active_record/vendor/mysql411.rb

@@ -303,4 +303,13 @@ class Mysql
     end
     self
   end
+
+
+  # Get rid of GC.start in #free.
+  class Result
+    def free
+      @handle.skip_result
+      @handle = @fields = @data = nil
+    end
+  end
 end

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = '1.11.0' + PKG_BUILD
+PKG_VERSION   = '1.11.1' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -82,7 +82,7 @@ spec = Gem::Specification.new do |s|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
   
-  s.add_dependency('activesupport', '= 1.1.0' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.1.1' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"

data/test/associations_go_eager_test.rb

@@ -29,7 +29,7 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_equal posts(:thinking), posts[4]
     assert_equal posts(:welcome), posts[5]
   end
-  
+
   def test_loading_with_multiple_associations
     posts = Post.find(:all, :include => [ :comments, :author, :categories ], :order => "posts.id")
     assert_equal 2, posts.first.comments.size
@@ -48,10 +48,51 @@ class EagerAssociationTest < Test::Unit::TestCase
 
   def test_eager_association_loading_with_belongs_to
     comments = Comment.find(:all, :include => :post)
+    assert_equal 9, comments.length
     titles = comments.map { |c| c.post.title }
     assert titles.include?(posts(:welcome).title)
     assert titles.include?(posts(:sti_post_and_comments).title)
   end
+  
+  def test_eager_association_loading_with_belongs_to_and_limit
+    comments = Comment.find(:all, :include => :post, :limit => 5)
+    assert_equal 5, comments.length
+    assert_equal [1,2,3,5,6], comments.collect { |c| c.id }
+  end
+
+  def test_eager_association_loading_with_belongs_to_and_limit_and_conditions
+    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3)
+    assert_equal 3, comments.length
+    assert_equal [5,6,7], comments.collect { |c| c.id }
+  end
+
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset
+    comments = Comment.find(:all, :include => :post, :limit => 3, :offset => 2)
+    assert_equal 3, comments.length
+    assert_equal [3,5,6], comments.collect { |c| c.id }
+  end
+
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions
+    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3, :offset => 1)
+    assert_equal 3, comments.length
+    assert_equal [6,7,8], comments.collect { |c| c.id }
+  end
+  
+  def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
+    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1)
+    assert_equal 1, posts.length
+    assert_equal [4], posts.collect { |p| p.id }
+  end
+  
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations
+    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1, :offset => 1)
+    assert_equal 0, posts.length
+    assert_equal [], posts
+  end
+  
+  def test_eager_association_raise_on_limit
+    assert_raises(ActiveRecord::ConfigurationError) { Post.find(:all, :include => [:author, :comments], :limit => 1) }
+  end
 
   def test_eager_association_loading_with_habtm
     posts = Post.find(:all, :include => :categories, :order => "posts.id")
@@ -61,23 +102,23 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert posts[0].categories.include?(categories(:technology))
     assert posts[1].categories.include?(categories(:general))
   end
-  
+
   def test_eager_with_inheritance
     posts = SpecialPost.find(:all, :include => [ :comments ])
-  end  
+  end
 
   def test_eager_has_one_with_association_inheritance
     post = Post.find(4, :include => [ :very_special_comment ])
     assert_equal "VerySpecialComment", post.very_special_comment.class.to_s
-  end  
-  
+  end
+
   def test_eager_has_many_with_association_inheritance
     post = Post.find(4, :include => [ :special_comments ])
     post.special_comments.each do |special_comment|
       assert_equal "SpecialComment", special_comment.class.to_s
     end
-  end  
-  
+  end
+
   def test_eager_habtm_with_association_inheritance
     post = Post.find(6, :include => [ :special_categories ])
     assert_equal 1, post.special_categories.size
@@ -90,7 +131,17 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_not_nil companies(:first_firm).account
     f = Firm.find(:first, :include => :account,
             :conditions => ["companies.name = ?", "37signals"])
-    assert_not_nil companies(:first_firm, :reload).account
+    assert_not_nil f.account
+    assert_equal companies(:first_firm, :reload).account, f.account
   end
-end
 
+  def test_eager_with_invalid_association_reference
+    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
+      post = Post.find(6, :include=>[ :monkeys ])
+    }
+    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
+      post = Post.find(6, :include=>[ :monkeys, :elephants ])
+    }
+  end
+
+end

data/test/migration_test.rb

@@ -182,5 +182,20 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert !Person.column_methods_hash.include?(:last_name)
       assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
     end
+    
+    def test_migrator_going_down_due_to_version_target
+      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1)
+      ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations/', 0)
+
+      assert !Person.column_methods_hash.include?(:last_name)
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
+
+      ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations/')
+
+      Person.reset_column_information
+      assert Person.column_methods_hash.include?(:last_name)
+      assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
+      assert_equal "hello world", Reminder.find(:first).content
+    end
   end
 end

data/test/reflection_test.rb

@@ -17,7 +17,7 @@ class ReflectionTest < Test::Unit::TestCase
       @first.attribute_names
     )
   end
-  
+
   def test_columns
     assert_equal 12, Topic.columns.length
   end
@@ -30,7 +30,7 @@ class ReflectionTest < Test::Unit::TestCase
   def test_content_columns
     assert_equal 8, Topic.content_columns.length
   end
-  
+
   def test_column_string_type_and_limit
     assert_equal :string, @first.column_for_attribute("title").type
     assert_equal 255, @first.column_for_attribute("title").limit
@@ -39,10 +39,10 @@ class ReflectionTest < Test::Unit::TestCase
   def test_human_name_for_column
     assert_equal "Author name", @first.column_for_attribute("author_name").human_name
   end
-  
+
   def test_integer_columns
     assert_equal :integer, @first.column_for_attribute("id").type
-  end  
+  end
 
   def test_aggregation_reflection
     reflection_for_address = ActiveRecord::Reflection::AggregateReflection.new(
@@ -61,23 +61,32 @@ class ReflectionTest < Test::Unit::TestCase
       [ reflection_for_address, reflection_for_balance, reflection_for_gps_location ],
       Customer.reflect_on_all_aggregations
     )
-    
+
     assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address)
-    
+
     assert_equal Address, Customer.reflect_on_aggregation(:address).klass
   end
-  
-  def test_association_reflection
-    reflection_for_clients = ActiveRecord::Reflection::AssociationReflection.new(
-      :has_many, :clients, { :order => "id", :dependent => true }, Firm
-    )
+
+  def test_has_many_reflection
+    reflection_for_clients = ActiveRecord::Reflection::AssociationReflection.new(:has_many, :clients, { :order => "id", :dependent => true }, Firm)
 
     assert_equal reflection_for_clients, Firm.reflect_on_association(:clients)
 
     assert_equal Client, Firm.reflect_on_association(:clients).klass
+    assert_equal 'companies', Firm.reflect_on_association(:clients).table_name
+
     assert_equal Client, Firm.reflect_on_association(:clients_of_firm).klass
+    assert_equal 'companies', Firm.reflect_on_association(:clients_of_firm).table_name
+  end
+
+  def test_has_one_reflection
+    reflection_for_account = ActiveRecord::Reflection::AssociationReflection.new(:has_one, :account, { :foreign_key => "firm_id", :dependent => true }, Firm)
+    assert_equal reflection_for_account, Firm.reflect_on_association(:account)
+
+    assert_equal Account, Firm.reflect_on_association(:account).klass
+    assert_equal 'accounts', Firm.reflect_on_association(:account).table_name
   end
-  
+
   def test_association_reflection_in_modules
     assert_equal MyApplication::Business::Client, MyApplication::Business::Firm.reflect_on_association(:clients_of_firm).klass
     assert_equal MyApplication::Business::Firm, MyApplication::Billing::Account.reflect_on_association(:firm).klass

data/test/threaded_connections_test.rb

@@ -0,0 +1,34 @@
+require 'abstract_unit'
+
+class ThreadedConnectionsTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
+
+  fixtures :topics
+
+  def setup
+    @connection = ActiveRecord::Base.remove_connection
+    @connections = []
+  end
+  
+  def gather_connections(use_threaded_connections)
+    ActiveRecord::Base.threaded_connections = use_threaded_connections
+    ActiveRecord::Base.establish_connection(@connection)
+    
+    5.times do
+      Thread.new do
+        Topic.find :first
+        @connections << ActiveRecord::Base.active_connections.values.first
+      end.join
+    end
+  end
+
+  def test_threaded_connections
+    gather_connections(true)
+    assert_equal @connections.uniq.length, 5
+  end
+
+  def test_unthreaded_connections
+    gather_connections(false)
+    assert_equal @connections.uniq.length, 1
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: activerecord
 version: !ruby/object:Gem::Version 
-  version: 1.11.0
-date: 2005-07-06
+  version: 1.11.1
+date: 2005-07-11
 summary: Implements the ActiveRecord pattern for ORM.
 require_paths: 
   - lib
@@ -110,6 +110,7 @@ files:
   - test/reflection_test.rb
   - test/schema_test_postgresql.rb
   - test/thread_safety_test.rb
+  - test/threaded_connections_test.rb
   - test/transactions_test.rb
   - test/unconnected_test.rb
   - test/validations_test.rb
@@ -247,5 +248,5 @@ dependencies:
         - 
           - "="
           - !ruby/object:Gem::Version 
-            version: 1.1.0
+            version: 1.1.1
       version: