activerecord 1.10.1 → 1.11.0

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = '1.10.1' + PKG_BUILD
+PKG_VERSION   = '1.11.0' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -28,20 +28,20 @@ task :default => [ :test_ruby_mysql, :test_mysql_ruby, :test_sqlite, :test_sqlit
 
 Rake::TestTask.new("test_ruby_mysql") { |t|
   t.libs << "test" << "test/connections/native_mysql"
-  t.pattern = 'test/*_test.rb'
+  t.pattern = 'test/*_test{,_mysql}.rb'
   t.verbose = true
 }
 
 Rake::TestTask.new("test_mysql_ruby") { |t|
   t.libs << "test" << "test/connections/native_mysql"
-  t.pattern = 'test/*_test.rb'
+  t.pattern = 'test/*_test{,_mysql}.rb'
   t.verbose = true
 }
 
-for adapter in %w( postgresql sqlite sqlite3 sqlserver db2 oci )
+for adapter in %w( postgresql sqlite sqlite3 sqlserver sqlserver_odbc db2 oci )
   Rake::TestTask.new("test_#{adapter}") { |t|
     t.libs << "test" << "test/connections/native_#{adapter}"
-    t.pattern = 'test/*_test.rb'
+    t.pattern = "test/*_test{,_#{adapter}}.rb"
     t.verbose = true
   }
 end
@@ -60,6 +60,12 @@ Rake::RDocTask.new { |rdoc|
   rdoc.rdoc_files.include('dev-utils/*.rb')
 }
 
+# Enhance rdoc task to copy referenced images also
+task :rdoc do
+  FileUtils.mkdir_p "doc/files/examples/"
+  FileUtils.copy "examples/associations.png", "doc/files/examples/associations.png"
+end
+
 
 # Create compressed packages
 
@@ -76,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.0.4' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.1.0' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"
@@ -130,13 +136,13 @@ end
 
 desc "Publish the beta gem"
 task :pgem => [:package] do 
-  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
-  `ssh davidhh@wrath.rubyonrails.com './gemupdate.sh'`
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
 end
 
 desc "Publish the API documentation"
 task :pdoc => [:rdoc] do 
-  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.com", "public_html/ar", "doc").upload
+  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.org", "public_html/ar", "doc").upload
 end
 
 desc "Publish the release files to RubyForge."
@@ -252,4 +258,4 @@ task :release => [:package] do
       first_file = false
     end
   end
-end
+end

data/test/aaa_create_tables_test.rb

@@ -1,58 +1,36 @@
+# The filename begins with "aaa" to ensure this is the first test.
 require 'abstract_unit'
 
-# The filename for this test begins with "aaa" so that
-# it will be the first test.
-
-class SqlFile < File
-  #Define an iterator that iterates over the statements in a .sql file.
-  #statements are separated by a semicolon.
-  def initialize(path)
-    super(path)
-  end
-  
-  def each_statement()
-    statement = ''
-    each_line { |line|
-      #The last character of each line is a line-feed, so we will check the next-to-last character
-      #to see if it is a semicolon.  A better way of doing this would be to look for a semicolon anywhere
-      #within the line in case multiple statements have been put on a single line.
-      #The last statement in the file must be followed by a line-feed.
-      if line.slice(-2,1)==';' then
-        statement = statement + line.slice(0,line.length-2) + "\n"
-        yield statement
-        statement = ''
-      else
-        statement = statement + line
-      end
-    }
-  end
-end
-
 class CreateTablesTest < Test::Unit::TestCase
   def setup
-    # This method is required by rake.
+    @base_path = "#{File.dirname(__FILE__)}/fixtures/db_definitions"
   end
 
-  def run_sql_file(connection, path)
-    sql_file = SqlFile.new(path)
-    sql_file.each_statement { |statement|
-    begin
-      #Skip errors.  If there is a problem creating the tables then it will show up in other tests.
-      connection.execute(statement)
-    rescue ActiveRecord::StatementInvalid
-    end }
+  def test_drop_and_create_main_tables
+    recreate ActiveRecord::Base
+    assert true
+  end
+  
+  def test_drop_and_create_courses_table
+    recreate Course, '2'
+    assert true
   end
 
-  def test_table_creation
-    adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
-    run_sql_file ActiveRecord::Base.connection, "#{File.dirname(__FILE__)}/fixtures/db_definitions/" + adapter_name + ".drop.sql"
-    run_sql_file ActiveRecord::Base.connection, "#{File.dirname(__FILE__)}/fixtures/db_definitions/" + adapter_name + ".sql"
+  private
+    def recreate(base, suffix = nil)
+      connection = base.connection
+      adapter_name = connection.adapter_name.downcase + suffix.to_s
+      execute_sql_file "#{@base_path}/#{adapter_name}.drop.sql", connection
+      execute_sql_file "#{@base_path}/#{adapter_name}.sql", connection
+    end
 
-    # Now do the same thing with the connection used by multiple_db_test.rb
-    adapter_name = Course.retrieve_connection.adapter_name.downcase
-    run_sql_file Course.retrieve_connection, "#{File.dirname(__FILE__)}/fixtures/db_definitions/" + adapter_name + "2.drop.sql"
-    run_sql_file Course.retrieve_connection, "#{File.dirname(__FILE__)}/fixtures/db_definitions/" + adapter_name + "2.sql"
-    
-    assert_equal 1,1
-  end
+    def execute_sql_file(path, connection)
+      File.read(path).split(';').each_with_index do |sql, i|
+        begin
+          connection.execute("\n\n-- statement ##{i}\n#{sql}\n") unless sql.blank?
+        rescue ActiveRecord::StatementInvalid
+          #$stderr.puts "warning: #{$!}"
+        end
+      end
+    end
 end

data/test/abstract_unit.rb

@@ -19,3 +19,6 @@ class Test::Unit::TestCase #:nodoc:
 end
 
 Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+Test::Unit::TestCase.use_instantiated_fixtures = false
+Test::Unit::TestCase.use_transactional_fixtures = (ENV['AR_TX_FIXTURES'] == "yes")
+

data/test/aggregations_test.rb

@@ -5,43 +5,43 @@ class AggregationsTest < Test::Unit::TestCase
   fixtures :customers
 
   def test_find_single_value_object
-    assert_equal 50, @david.balance.amount
-    assert_kind_of Money, @david.balance
-    assert_equal 300, @david.balance.exchange_to("DKK").amount
+    assert_equal 50, customers(:david).balance.amount
+    assert_kind_of Money, customers(:david).balance
+    assert_equal 300, customers(:david).balance.exchange_to("DKK").amount
   end
   
   def test_find_multiple_value_object
-    assert_equal @customers["david"]["address_street"], @david.address.street
+    assert_equal customers(:david).address_street, customers(:david).address.street
     assert(
-      @david.address.close_to?(Address.new("Different Street", @customers["david"]["address_city"], @customers["david"]["address_country"]))
+      customers(:david).address.close_to?(Address.new("Different Street", customers(:david).address_city, customers(:david).address_country))
     )
   end
   
   def test_change_single_value_object
-    @david.balance = Money.new(100)
-    @david.save
+    customers(:david).balance = Money.new(100)
+    customers(:david).save
     assert_equal 100, Customer.find(1).balance.amount
   end
   
   def test_immutable_value_objects
-    @david.balance = Money.new(100)
-    assert_raises(TypeError) {  @david.balance.instance_eval { @amount = 20 } }
+    customers(:david).balance = Money.new(100)
+    assert_raises(TypeError) {  customers(:david).balance.instance_eval { @amount = 20 } }
   end  
   
   def test_inferred_mapping
-    assert_equal "35.544623640962634", @david.gps_location.latitude
-    assert_equal "-105.9309951055148", @david.gps_location.longitude
+    assert_equal "35.544623640962634", customers(:david).gps_location.latitude
+    assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
     
-    @david.gps_location = GpsLocation.new("39x-110")
+    customers(:david).gps_location = GpsLocation.new("39x-110")
 
-    assert_equal "39", @david.gps_location.latitude
-    assert_equal "-110", @david.gps_location.longitude
+    assert_equal "39", customers(:david).gps_location.latitude
+    assert_equal "-110", customers(:david).gps_location.longitude
     
-    @david.save
+    customers(:david).save
     
-    @david.reload
+    customers(:david).reload
 
-    assert_equal "39", @david.gps_location.latitude
-    assert_equal "-110", @david.gps_location.longitude
+    assert_equal "39", customers(:david).gps_location.latitude
+    assert_equal "-110", customers(:david).gps_location.longitude
   end
-end
+end

data/test/association_callbacks_test.rb

@@ -0,0 +1,110 @@
+require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/comment'
+require 'fixtures/author'
+require 'fixtures/category'
+require 'fixtures/project'
+require 'fixtures/developer'
+
+class AssociationCallbacksTest < Test::Unit::TestCase
+  fixtures :posts, :authors, :projects, :developers
+
+  def setup
+    @david = authors(:david)
+    @thinking = posts(:thinking)
+    @authorless = posts(:authorless)
+    assert @david.post_log.empty?
+  end
+  
+  def test_adding_macro_callbacks
+    @david.posts_with_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}"], @david.post_log
+    @david.posts_with_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}", "before_adding#{@thinking.id}", 
+                  "after_adding#{@thinking.id}"], @david.post_log
+  end
+  
+  def test_adding_with_proc_callbacks
+    @david.posts_with_proc_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}"], @david.post_log
+    @david.posts_with_proc_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}", "before_adding#{@thinking.id}", 
+                  "after_adding#{@thinking.id}"], @david.post_log
+  end
+  
+  def test_removing_with_macro_callbacks
+    first_post, second_post = @david.posts_with_callbacks[0, 2]
+    @david.posts_with_callbacks.delete(first_post)
+    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}"], @david.post_log
+    @david.posts_with_callbacks.delete(second_post)
+    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}", "before_removing#{second_post.id}", 
+                  "after_removing#{second_post.id}"], @david.post_log
+  end
+
+  def test_removing_with_proc_callbacks
+    first_post, second_post = @david.posts_with_callbacks[0, 2]
+    @david.posts_with_proc_callbacks.delete(first_post)
+    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}"], @david.post_log
+    @david.posts_with_proc_callbacks.delete(second_post)
+    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}", "before_removing#{second_post.id}", 
+                  "after_removing#{second_post.id}"], @david.post_log
+  end
+  
+  def test_multiple_callbacks
+    @david.posts_with_multiple_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", "after_adding#{@thinking.id}", 
+                  "after_adding_proc#{@thinking.id}"], @david.post_log
+    @david.posts_with_multiple_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", "after_adding#{@thinking.id}", 
+                  "after_adding_proc#{@thinking.id}", "before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", 
+                  "after_adding#{@thinking.id}", "after_adding_proc#{@thinking.id}"], @david.post_log
+  end
+  
+  def test_has_and_belongs_to_many_add_callback
+    david = developers(:david)
+    ar = projects(:active_record)
+    assert ar.developers_log.empty?
+    ar.developers_with_callbacks << david
+    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], ar.developers_log
+    ar.developers_with_callbacks << david
+    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}", "before_adding#{david.id}", 
+                  "after_adding#{david.id}"], ar.developers_log
+  end
+  
+  def test_has_and_belongs_to_many_remove_callback
+    david = developers(:david)
+    jamis = developers(:jamis)
+    activerecord = projects(:active_record)
+    assert activerecord.developers_log.empty?
+    activerecord.developers_with_callbacks.delete(david)
+    assert_equal ["before_removing#{david.id}", "after_removing#{david.id}"], activerecord.developers_log
+    
+    activerecord.developers_with_callbacks.delete(jamis)
+    assert_equal ["before_removing#{david.id}", "after_removing#{david.id}", "before_removing#{jamis.id}", 
+                  "after_removing#{jamis.id}"], activerecord.developers_log
+  end
+  
+  def test_dont_add_if_before_callback_raises_exception
+    assert !@david.unchangable_posts.include?(@authorless)
+    begin
+      @david.unchangable_posts << @authorless
+    rescue Exception => e
+    end
+    assert @david.post_log.empty?
+    assert !@david.unchangable_posts.include?(@authorless)
+    @david.reload
+    assert !@david.unchangable_posts.include?(@authorless)
+  end
+  
+  def test_push_with_attributes
+    david = developers(:david)
+    activerecord = projects(:active_record)
+    assert activerecord.developers_log.empty?
+    activerecord.developers_with_callbacks.push_with_attributes(david, {})
+    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], activerecord.developers_log
+    activerecord.developers_with_callbacks.push_with_attributes(david, {})
+    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}", "before_adding#{david.id}", 
+                  "after_adding#{david.id}"], activerecord.developers_log
+  end
+end
+

data/test/associations_go_eager_test.rb

@@ -3,47 +3,54 @@ require 'fixtures/post'
 require 'fixtures/comment'
 require 'fixtures/author'
 require 'fixtures/category'
+require 'fixtures/company'
 
 class EagerAssociationTest < Test::Unit::TestCase
-  fixtures :posts, :comments, :authors, :categories, :categories_posts
+  fixtures :posts, :comments, :authors, :categories, :categories_posts,
+            :companies, :accounts
 
   def test_loading_with_one_association
     posts = Post.find(:all, :include => :comments)
-    assert_equal 2, posts.first.comments.size
-    assert posts.first.comments.include?(@greetings)
+    post = posts.find { |p| p.id == 1 }
+    assert_equal 2, post.comments.size
+    assert post.comments.include?(comments(:greetings))
 
     post = Post.find(:first, :include => :comments, :conditions => "posts.title = 'Welcome to the weblog'")
     assert_equal 2, post.comments.size
-    assert post.comments.include?(@greetings)
+    assert post.comments.include?(comments(:greetings))
   end
 
   def test_with_ordering
     posts = Post.find(:all, :include => :comments, :order => "posts.id DESC")
-    assert_equal @authorless, posts[0]
-    assert_equal @thinking, posts[1]
-    assert_equal @welcome, posts[2]
+    assert_equal posts(:sti_habtm), posts[0]
+    assert_equal posts(:sti_post_and_comments), posts[1]
+    assert_equal posts(:sti_comments), posts[2]
+    assert_equal posts(:authorless), posts[3]
+    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
     assert_equal 2, posts.first.categories.size
-    assert posts.first.comments.include?(@greetings)
+    assert posts.first.comments.include?(comments(:greetings))
   end
 
   def test_loading_from_an_association
-    posts = @david.posts.find(:all, :include => :comments, :order => "posts.id")
+    posts = authors(:david).posts.find(:all, :include => :comments, :order => "posts.id")
     assert_equal 2, posts.first.comments.size
   end
 
   def test_loading_with_no_associations
-    assert_nil Post.find(@authorless.id, :include => :author).author
+    assert_nil Post.find(posts(:authorless).id, :include => :author).author
   end
 
   def test_eager_association_loading_with_belongs_to
     comments = Comment.find(:all, :include => :post)
-    assert_equal @welcome.title, comments.first.post.title
-    assert_equal @thinking.title, comments.last.post.title
+    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_habtm
@@ -51,12 +58,39 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_equal 2, posts[0].categories.size
     assert_equal 1, posts[1].categories.size
     assert_equal 0, posts[2].categories.size
-    assert posts[0].categories.include?(@technology)
-    assert posts[1].categories.include?(@general)
+    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  
+
+  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  
+  
+  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  
+  
+  def test_eager_habtm_with_association_inheritance
+    post = Post.find(6, :include => [ :special_categories ])
+    assert_equal 1, post.special_categories.size
+    post.special_categories.each do |special_category|
+      assert_equal "SpecialCategory", special_category.class.to_s
+    end
+  end
+
+  def test_eager_with_has_one_dependent_does_not_destroy_dependent
+    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
+  end
 end