Rails 2.3.3.1

Update to latest Rails.
A little bit of jiggery-pokery is involved, since they
neglected to re-include vendored Rack in this release.

vendor/rails/activerecord/test/cases/associations/belongs_to_associations_test.rb

@@ -14,6 +14,7 @@ require 'models/tagging'
 require 'models/comment'
 require 'models/sponsor'
 require 'models/member'
+require 'models/essay'
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
@@ -25,6 +26,11 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert !Client.find(3).firm.nil?, "Microsoft should have a firm"
   end
 
+  def test_belongs_to_with_primary_key
+    client = Client.create(:name => "Primary key client", :firm_name => companies(:first_firm).name)
+    assert_equal companies(:first_firm).name, client.firm_with_primary_key.name
+  end
+
   def test_proxy_assignment
     account = Account.find(1)
     assert_nothing_raised { account.firm = account.firm }
@@ -47,6 +53,13 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal apple.id, citibank.firm_id
   end
 
+  def test_natural_assignment_with_primary_key
+    apple = Firm.create("name" => "Apple")
+    citibank = Client.create("name" => "Primary key client")
+    citibank.firm_with_primary_key = apple
+    assert_equal apple.name, citibank.firm_name
+  end
+
   def test_no_unexpected_aliasing
     first_firm = companies(:first_firm)
     another_firm = companies(:another_firm)
@@ -69,6 +82,15 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal apple, citibank.firm
   end
 
+  def test_creating_the_belonging_object_with_primary_key
+    client = Client.create(:name => "Primary key client")
+    apple  = client.create_firm_with_primary_key("name" => "Apple")
+    assert_equal apple, client.firm_with_primary_key
+    client.save
+    client.reload
+    assert_equal apple, client.firm_with_primary_key
+  end
+
   def test_building_the_belonging_object
     citibank = Account.create("credit_limit" => 10)
     apple    = citibank.build_firm("name" => "Apple")
@@ -76,6 +98,13 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal apple.id, citibank.firm_id
   end
 
+  def test_building_the_belonging_object_with_primary_key
+    client = Client.create(:name => "Primary key client")
+    apple  = client.build_firm_with_primary_key("name" => "Apple")
+    client.save
+    assert_equal apple.name, client.firm_name
+  end
+
   def test_natural_assignment_to_nil
     client = Client.find(3)
     client.firm = nil
@@ -84,6 +113,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_nil client.client_of
   end
 
+  def test_natural_assignment_to_nil_with_primary_key
+    client = Client.create(:name => "Primary key client", :firm_name => companies(:first_firm).name)
+    client.firm_with_primary_key = nil
+    client.save
+    assert_nil client.firm_with_primary_key(true)
+    assert_nil client.client_of
+  end
+
   def test_with_different_class_name
     assert_equal Company.find(1).name, Company.find(3).firm_with_other_name.name
     assert_not_nil Company.find(3).firm_with_other_name, "Microsoft should have a firm"
@@ -110,6 +147,17 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
   end
 
+  def test_belongs_to_with_primary_key_counter
+    debate = Topic.create("title" => "debate")
+    assert_equal 0, debate.send(:read_attribute, "replies_count"), "No replies yet"
+
+    trash = debate.replies_with_primary_key.create("title" => "blah!", "content" => "world around!")
+    assert_equal 1, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply created"
+
+    trash.destroy
+    assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
+  end
+
   def test_belongs_to_counter_with_assigning_nil
     p = Post.find(1)
     c = Comment.find(1)
@@ -122,6 +170,18 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, Post.find(p.id).comments.size
   end
 
+  def test_belongs_to_with_primary_key_counter_with_assigning_nil
+    debate = Topic.create("title" => "debate")
+    reply  = Reply.create("title" => "blah!", "content" => "world around!", "parent_title" => "debate")
+
+    assert_equal debate.title, reply.parent_title
+    assert_equal 1, Topic.find(debate.id).send(:read_attribute, "replies_count")
+
+    reply.topic_with_primary_key = nil
+
+    assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count")
+  end
+
   def test_belongs_to_counter_with_reassigning
     t1 = Topic.create("title" => "t1")
     t2 = Topic.create("title" => "t2")
@@ -219,6 +279,18 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal firm, final_cut.firm(true)
   end
 
+  def test_assignment_before_child_saved_with_primary_key
+    final_cut = Client.new("name" => "Final Cut")
+    firm = Firm.find(1)
+    final_cut.firm_with_primary_key = firm
+    assert final_cut.new_record?
+    assert final_cut.save
+    assert !final_cut.new_record?
+    assert !firm.new_record?
+    assert_equal firm, final_cut.firm_with_primary_key
+    assert_equal firm, final_cut.firm_with_primary_key(true)
+  end
+
   def test_new_record_with_foreign_key_but_no_object
     c = Client.new("firm_id" => 1)
     assert_equal Firm.find(:first), c.firm_with_basic_id
@@ -297,26 +369,52 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     member = Member.create
     sponsor.sponsorable = member
     assert_equal "Member", sponsor.sponsorable_type
-    
+
     # should update when assigning a new record
     sponsor = Sponsor.new
     member = Member.new
     sponsor.sponsorable = member
     assert_equal "Member", sponsor.sponsorable_type
   end
-  
+
+  def test_polymorphic_assignment_with_primary_key_foreign_type_field_updating
+    # should update when assigning a saved record
+    essay = Essay.new
+    writer = Author.create(:name => "David")
+    essay.writer = writer
+    assert_equal "Author", essay.writer_type
+
+    # should update when assigning a new record
+    essay = Essay.new
+    writer = Author.new
+    essay.writer = writer
+    assert_equal "Author", essay.writer_type
+  end
+
   def test_polymorphic_assignment_updates_foreign_id_field_for_new_and_saved_records
     sponsor = Sponsor.new
     saved_member = Member.create
     new_member = Member.new
-    
+
     sponsor.sponsorable = saved_member
     assert_equal saved_member.id, sponsor.sponsorable_id
-    
+
     sponsor.sponsorable = new_member
     assert_equal nil, sponsor.sponsorable_id
   end
 
+  def test_polymorphic_assignment_with_primary_key_updates_foreign_id_field_for_new_and_saved_records
+    essay = Essay.new
+    saved_writer = Author.create(:name => "David")
+    new_writer = Author.new
+
+    essay.writer = saved_writer
+    assert_equal saved_writer.name, essay.writer_id
+
+    essay.writer = new_writer
+    assert_equal nil, essay.writer_id
+  end
+
   def test_belongs_to_proxy_should_not_respond_to_private_methods
     assert_raise(NoMethodError) { companies(:first_firm).private_method }
     assert_raise(NoMethodError) { companies(:second_client).firm.private_method }

vendor/rails/activerecord/test/cases/associations/eager_test.rb

@@ -223,6 +223,18 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
 
+  def test_eager_association_loading_with_belongs_to_and_conditions_hash
+    comments = []
+    assert_nothing_raised do
+      comments = Comment.find(:all, :include => :post, :conditions => {:posts => {:id => 4}}, :limit => 3, :order => 'comments.id')
+    end
+    assert_equal 3, comments.length
+    assert_equal [5,6,7], comments.collect { |c| c.id }
+    assert_no_queries do
+      comments.first.post
+    end
+  end
+
   def test_eager_association_loading_with_belongs_to_and_conditions_string_with_quoted_table_name
     quoted_posts_id= Comment.connection.quote_table_name('posts') + '.' + Comment.connection.quote_column_name('id')
     assert_nothing_raised do

vendor/rails/activerecord/test/cases/associations/has_many_associations_test.rb

@@ -719,6 +719,12 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert Client.find(:all, :conditions => "firm_id=#{firm.id}").empty?
   end
 
+  def test_dependence_for_associations_with_hash_condition
+    david = authors(:david)
+    post = posts(:thinking).id
+    assert_difference('Post.count', -1) { assert david.destroy }
+  end
+
   def test_destroy_dependent_when_deleted_from_association
     firm = Firm.find(:first)
     assert_equal 2, firm.clients.size

vendor/rails/activerecord/test/cases/associations/has_one_through_associations_test.rb

@@ -43,7 +43,14 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       @member.reload      
     end
   end
-  
+
+  def test_set_record_to_nil_should_delete_association
+    @member.club = nil
+    @member.reload
+    assert_equal nil, @member.current_membership
+    assert_nil @member.club
+  end
+
   def test_has_one_through_polymorphic
     assert_equal clubs(:moustache_club), @member.sponsor_club
   end

vendor/rails/activerecord/test/cases/associations/inner_join_association_test.rb

@@ -29,6 +29,11 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     assert_match /INNER JOIN .?categories.? ON.*AND.*.?General.?.*TERMINATING_MARKER/, sql
   end
 
+  def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
+    result = Author.find(:all, :joins => [:thinking_posts, :welcome_posts])
+    assert_equal authors(:david), result.first
+  end
+
   def test_construct_finder_sql_unpacks_nested_joins
     sql = Author.send(:construct_finder_sql, :joins => {:posts => [[:comments]]})
     assert_no_match /inner join.*inner join.*inner join/i, sql, "only two join clauses should be present"

vendor/rails/activerecord/test/cases/autosave_association_test.rb

@@ -38,6 +38,17 @@ class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
 end
 
 class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
+  def test_should_save_parent_but_not_invalid_child
+    firm = Firm.new(:name => 'GlobalMegaCorp')
+    assert firm.valid?
+
+    firm.build_account_using_primary_key
+    assert !firm.build_account_using_primary_key.valid?
+
+    assert firm.save
+    assert firm.account_using_primary_key.new_record?
+  end
+
   def test_save_fails_for_invalid_has_one
     firm = Firm.find(:first)
     assert firm.valid?
@@ -126,6 +137,17 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
 end
 
 class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
+  def test_should_save_parent_but_not_invalid_child
+    client = Client.new(:name => 'Joe (the Plumber)')
+    assert client.valid?
+
+    client.build_firm
+    assert !client.firm.valid?
+
+    assert client.save
+    assert client.firm.new_record?
+  end
+
   def test_save_fails_for_invalid_belongs_to
     assert log = AuditLog.create(:developer_id => 0, :message => "")
 

vendor/rails/activerecord/test/cases/base_test.rb

@@ -1756,7 +1756,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_scoped_find_with_group_and_having
-    developers = Developer.with_scope(:find => { :group => 'salary', :having => "SUM(salary) > 10000", :select => "SUM(salary) as salary" }) do
+    developers = Developer.with_scope(:find => { :group => 'developers.salary', :having => "SUM(salary) > 10000", :select => "SUM(salary) as salary" }) do
       Developer.find(:all)
     end
     assert_equal 3, developers.size
@@ -2014,7 +2014,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_inspect_instance
     topic = topics(:first)
-    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, type: nil>), topic.inspect
+    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, parent_title: nil, type: nil>), topic.inspect
   end
 
   def test_inspect_new_instance

vendor/rails/activerecord/test/cases/calculations_test.rb

@@ -2,6 +2,9 @@ require "cases/helper"
 require 'models/company'
 require 'models/topic'
 require 'models/edge'
+require 'models/owner'
+require 'models/pet'
+require 'models/toy'
 
 Company.has_many :accounts
 
@@ -10,7 +13,7 @@ class NumericData < ActiveRecord::Base
 end
 
 class CalculationsTest < ActiveRecord::TestCase
-  fixtures :companies, :accounts, :topics
+  fixtures :companies, :accounts, :topics, :owners, :pets, :toys
 
   def test_should_sum_field
     assert_equal 318, Account.sum(:credit_limit)
@@ -264,19 +267,6 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 4, Account.count(:distinct => true, :include => :firm, :select => :credit_limit)
   end
 
-  def test_should_count_scoped_select
-    Account.update_all("credit_limit = NULL")
-    assert_equal 0, Account.scoped(:select => "credit_limit").count
-  end
-
-  def test_should_count_scoped_select_with_options
-    Account.update_all("credit_limit = NULL")
-    Account.last.update_attribute('credit_limit', 49)
-    Account.first.update_attribute('credit_limit', 51)
-
-    assert_equal 1, Account.scoped(:select => "credit_limit").count(:conditions => ['credit_limit >= 50'])
-  end
-
   def test_should_count_manual_select_with_include
     assert_equal 6, Account.count(:select => "DISTINCT accounts.id", :include => :firm)
   end
@@ -297,6 +287,10 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_raise(ArgumentError) { Account.count(1, 2, 3) }
   end
 
+  def test_count_with_scoped_has_many_through_association
+    assert_equal 1, owners(:blackbeard).toys.with_name('Bone').count
+  end
+
   def test_should_sum_expression
     assert_equal '636', Account.sum("2 * credit_limit")
   end

vendor/rails/activerecord/test/cases/copy_table_test_sqlite.rb

@@ -10,7 +10,7 @@ class CopyTableTest < ActiveRecord::TestCase
     end
   end
 
-  def test_copy_table(from = 'companies', to = 'companies2', options = {})
+  def test_copy_table(from = 'customers', to = 'customers2', options = {})
     assert_nothing_raised {copy_table(from, to, options)}
     assert_equal row_count(from), row_count(to)
 
@@ -24,11 +24,11 @@ class CopyTableTest < ActiveRecord::TestCase
   end
 
   def test_copy_table_renaming_column
-    test_copy_table('companies', 'companies2',
-        :rename => {'client_of' => 'fan_of'}) do |from, to, options|
-      expected = column_values(from, 'client_of')
+    test_copy_table('customers', 'customers2',
+        :rename => {'name' => 'person_name'}) do |from, to, options|
+      expected = column_values(from, 'name')
       assert expected.any?, 'only nils in resultset; real values are needed'
-      assert_equal expected, column_values(to, 'fan_of')
+      assert_equal expected, column_values(to, 'person_name')
     end
   end
 

vendor/rails/activerecord/test/cases/finder_test.rb

@@ -119,6 +119,12 @@ class FinderTest < ActiveRecord::TestCase
       Address.new(existing_address.street + "1", existing_address.city, existing_address.country))
   end
 
+  def test_exists_with_scoped_include
+    Developer.with_scope(:find => { :include => :projects, :order => "projects.name" }) do
+      assert Developer.exists?
+    end
+  end
+
   def test_find_by_array_of_one_id
     assert_kind_of(Array, Topic.find([ 1 ]))
     assert_equal(1, Topic.find([ 1 ]).length)

vendor/rails/activerecord/test/cases/fixtures_test.rb

@@ -518,6 +518,11 @@ class FoxyFixturesTest < ActiveRecord::TestCase
     assert_equal(Fixtures.identify(:foo), Fixtures.identify(:foo))
   end
 
+  def test_identifies_consistently
+    assert_equal 1281023246, Fixtures.identify(:ruby)
+    assert_equal 2140105598, Fixtures.identify(:sapphire_2)
+  end
+
   TIMESTAMP_COLUMNS = %w(created_at created_on updated_at updated_on)
 
   def test_populates_timestamp_columns

vendor/rails/activerecord/test/cases/helper.rb

@@ -5,8 +5,7 @@ require 'config'
 
 require 'rubygems'
 require 'test/unit'
-gem 'mocha', '>= 0.9.5'
-require 'mocha'
+require 'stringio'
 
 require 'active_record'
 require 'active_record/test_case'

vendor/rails/activerecord/test/cases/json_serialization_test.rb

@@ -26,19 +26,19 @@ class JsonSerializationTest < ActiveRecord::TestCase
     NamespacedContact.include_root_in_json = true
     @contact = NamespacedContact.new :name => 'whatever'
     json = @contact.to_json
-    assert_match %r{^\{"namespaced_contact": \{}, json
+    assert_match %r{^\{"namespaced_contact":\{}, json
   end
 
   def test_should_include_root_in_json
     Contact.include_root_in_json = true
     json = @contact.to_json
 
-    assert_match %r{^\{"contact": \{}, json
-    assert_match %r{"name": "Konata Izumi"}, json
-    assert_match %r{"age": 16}, json
-    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_match %r{"awesome": true}, json
-    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+    assert_match %r{^\{"contact":\{}, json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome":true}, json
+    assert_match %r{"preferences":\{"shows":"anime"\}}, json
   ensure
     Contact.include_root_in_json = false
   end
@@ -46,31 +46,31 @@ class JsonSerializationTest < ActiveRecord::TestCase
   def test_should_encode_all_encodable_attributes
     json = @contact.to_json
 
-    assert_match %r{"name": "Konata Izumi"}, json
-    assert_match %r{"age": 16}, json
-    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_match %r{"awesome": true}, json
-    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome":true}, json
+    assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
   def test_should_allow_attribute_filtering_with_only
     json = @contact.to_json(:only => [:name, :age])
 
-    assert_match %r{"name": "Konata Izumi"}, json
-    assert_match %r{"age": 16}, json
-    assert_no_match %r{"awesome": true}, json
-    assert !json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_no_match %r{"preferences": \{"shows": "anime"\}}, json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert_no_match %r{"awesome":true}, json
+    assert !json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_no_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
   def test_should_allow_attribute_filtering_with_except
     json = @contact.to_json(:except => [:name, :age])
 
-    assert_no_match %r{"name": "Konata Izumi"}, json
-    assert_no_match %r{"age": 16}, json
-    assert_match %r{"awesome": true}, json
-    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+    assert_no_match %r{"name":"Konata Izumi"}, json
+    assert_no_match %r{"age":16}, json
+    assert_match %r{"awesome":true}, json
+    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
   def test_methods_are_called_on_object
@@ -79,12 +79,12 @@ class JsonSerializationTest < ActiveRecord::TestCase
     def @contact.favorite_quote; "Constraints are liberating"; end
 
     # Single method.
-    assert_match %r{"label": "Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+    assert_match %r{"label":"Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
 
     # Both methods.
     methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
-    assert_match %r{"label": "Has cheezburger"}, methods_json
-    assert_match %r{"favorite_quote": "Constraints are liberating"}, methods_json
+    assert_match %r{"label":"Has cheezburger"}, methods_json
+    assert_match %r{"favorite_quote":"Constraints are liberating"}, methods_json
   end
 end
 
@@ -99,42 +99,42 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
   def test_includes_uses_association_name
     json = @david.to_json(:include => :posts)
 
-    assert_match %r{"posts": \[}, json
+    assert_match %r{"posts":\[}, json
 
-    assert_match %r{"id": 1}, json
-    assert_match %r{"name": "David"}, json
+    assert_match %r{"id":1}, json
+    assert_match %r{"name":"David"}, json
 
-    assert_match %r{"author_id": 1}, json
-    assert_match %r{"title": "Welcome to the weblog"}, json
-    assert_match %r{"body": "Such a lovely day"}, json
+    assert_match %r{"author_id":1}, json
+    assert_match %r{"title":"Welcome to the weblog"}, json
+    assert_match %r{"body":"Such a lovely day"}, json
 
-    assert_match %r{"title": "So I was thinking"}, json
-    assert_match %r{"body": "Like I hopefully always am"}, json
+    assert_match %r{"title":"So I was thinking"}, json
+    assert_match %r{"body":"Like I hopefully always am"}, json
   end
 
   def test_includes_uses_association_name_and_applies_attribute_filters
     json = @david.to_json(:include => { :posts => { :only => :title } })
 
-    assert_match %r{"name": "David"}, json
-    assert_match %r{"posts": \[}, json
+    assert_match %r{"name":"David"}, json
+    assert_match %r{"posts":\[}, json
 
-    assert_match %r{"title": "Welcome to the weblog"}, json
-    assert_no_match %r{"body": "Such a lovely day"}, json
+    assert_match %r{"title":"Welcome to the weblog"}, json
+    assert_no_match %r{"body":"Such a lovely day"}, json
 
-    assert_match %r{"title": "So I was thinking"}, json
-    assert_no_match %r{"body": "Like I hopefully always am"}, json
+    assert_match %r{"title":"So I was thinking"}, json
+    assert_no_match %r{"body":"Like I hopefully always am"}, json
   end
 
   def test_includes_fetches_second_level_associations
     json = @david.to_json(:include => { :posts => { :include => { :comments => { :only => :body } } } })
 
-    assert_match %r{"name": "David"}, json
-    assert_match %r{"posts": \[}, json
+    assert_match %r{"name":"David"}, json
+    assert_match %r{"posts":\[}, json
 
-    assert_match %r{"comments": \[}, json
-    assert_match %r{\{"body": "Thank you again for the welcome"\}}, json
-    assert_match %r{\{"body": "Don't think too hard"\}}, json
-    assert_no_match %r{"post_id": }, json
+    assert_match %r{"comments":\[}, json
+    assert_match %r{\{"body":"Thank you again for the welcome"\}}, json
+    assert_match %r{\{"body":"Don't think too hard"\}}, json
+    assert_no_match %r{"post_id":}, json
   end
 
   def test_includes_fetches_nth_level_associations
@@ -151,11 +151,11 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
         }
     })
 
-    assert_match %r{"name": "David"}, json
-    assert_match %r{"posts": \[}, json
+    assert_match %r{"name":"David"}, json
+    assert_match %r{"posts":\[}, json
 
-    assert_match %r{"taggings": \[}, json
-    assert_match %r{"tag": \{"name": "General"\}}, json
+    assert_match %r{"taggings":\[}, json
+    assert_match %r{"tag":\{"name":"General"\}}, json
   end
 
   def test_should_not_call_methods_on_associations_that_dont_respond
@@ -163,33 +163,33 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
     json = @david.to_json(:include => :posts, :methods => :favorite_quote)
 
     assert !@david.posts.first.respond_to?(:favorite_quote)
-    assert_match %r{"favorite_quote": "Constraints are liberating"}, json
-    assert_equal %r{"favorite_quote": }.match(json).size, 1
+    assert_match %r{"favorite_quote":"Constraints are liberating"}, json
+    assert_equal %r{"favorite_quote":}.match(json).size, 1
   end
 
   def test_should_allow_only_option_for_list_of_authors
     authors = [@david, @mary]
 
-    assert_equal %([{"name": "David"}, {"name": "Mary"}]), authors.to_json(:only => :name)
+    assert_equal %([{"name":"David"},{"name":"Mary"}]), ActiveSupport::JSON.encode(authors, :only => :name)
   end
 
   def test_should_allow_except_option_for_list_of_authors
     authors = [@david, @mary]
 
-    assert_equal %([{"id": 1}, {"id": 2}]), authors.to_json(:except => [:name, :author_address_id, :author_address_extra_id])
+    assert_equal %([{"id":1},{"id":2}]), ActiveSupport::JSON.encode(authors, :except => [:name, :author_address_id, :author_address_extra_id])
   end
 
   def test_should_allow_includes_for_list_of_authors
     authors = [@david, @mary]
-    json = authors.to_json(
+    json = ActiveSupport::JSON.encode(authors,
       :only => :name,
       :include => {
         :posts => { :only => :id }
       }
     )
 
-    ['"name": "David"', '"posts": [', '{"id": 1}', '{"id": 2}', '{"id": 4}',
-     '{"id": 5}', '{"id": 6}', '"name": "Mary"', '"posts": [{"id": 7}]'].each do |fragment|
+    ['"name":"David"', '"posts":[', '{"id":1}', '{"id":2}', '{"id":4}',
+     '{"id":5}', '{"id":6}', '"name":"Mary"', '"posts":[{"id":7}]'].each do |fragment|
       assert json.include?(fragment), json
      end
   end
@@ -200,6 +200,6 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
       2 => @mary
     }
 
-    assert_equal %({"1": {"name": "David"}}), authors_hash.to_json(:only => [1, :name])
+    assert_equal %({"1":{"name":"David"}}), ActiveSupport::JSON.encode(authors_hash, :only => [1, :name])
   end
 end

vendor/rails/activerecord/test/cases/method_scoping_test.rb

@@ -591,6 +591,16 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
+  def test_default_scope_with_conditions_string
+    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.all.map(&:id).sort
+    assert_equal nil, DeveloperCalledDavid.create!.name
+  end
+
+  def test_default_scope_with_conditions_hash
+    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.all.map(&:id).sort
+    assert_equal 'Jamis', DeveloperCalledJamis.create!.name
+  end
+
   def test_default_scoping_with_threads
     scope = [{ :create => {}, :find => { :order => 'salary DESC' } }]
 
@@ -628,9 +638,9 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
-  def test_named_scope
-    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.salary }
+  def test_named_scope_overwrites_default
+    expected = Developer.find(:all, :order => 'name DESC').collect { |dev| dev.name }
+    received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
     assert_equal expected, received
   end
 

vendor/rails/activerecord/test/cases/reflection_test.rb

@@ -21,25 +21,25 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_read_attribute_names
     assert_equal(
-      %w( id title author_name author_email_address bonus_time written_on last_read content approved replies_count parent_id type ).sort,
+      %w( id title author_name author_email_address bonus_time written_on last_read content approved replies_count parent_id parent_title type ).sort,
       @first.attribute_names
     )
   end
 
   def test_columns
-    assert_equal 12, Topic.columns.length
+    assert_equal 13, Topic.columns.length
   end
 
   def test_columns_are_returned_in_the_order_they_were_declared
     column_names = Topic.columns.map { |column| column.name }
-    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id type), column_names
+    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type), column_names
   end
 
   def test_content_columns
     content_columns        = Topic.content_columns
     content_column_names   = content_columns.map {|column| column.name}
-    assert_equal 8, content_columns.length
-    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content approved).sort, content_column_names.sort
+    assert_equal 9, content_columns.length
+    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content approved parent_title).sort, content_column_names.sort
   end
 
   def test_column_string_type_and_limit

vendor/rails/activerecord/test/cases/schema_dumper_test.rb

@@ -22,6 +22,11 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert_no_match %r{create_table "sqlite_sequence"}, output
   end
 
+  def test_schema_dump_includes_camelcase_table_name
+    output = standard_dump
+    assert_match %r{create_table "CamelCase"}, output
+  end
+
   def assert_line_up(lines, pattern, required = false)
     return assert(true) if lines.empty?
     matches = lines.map { |line| line.match(pattern) }
@@ -147,19 +152,24 @@ class SchemaDumperTest < ActiveRecord::TestCase
     end
   end
 
+  def test_schema_dumps_index_columns_in_right_order
+    index_definition = standard_dump.split(/\n/).grep(/add_index.*companies/).first.strip
+    assert_equal 'add_index "companies", ["firm_id", "type", "rating", "ruby_type"], :name => "company_index"', index_definition
+  end
+  
+  def test_schema_dump_should_honor_nonstandard_primary_keys
+    output = standard_dump
+    match = output.match(%r{create_table "movies"(.*)do})
+    assert_not_nil(match, "nonstandardpk table not found")
+    assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
+  end
+
   if current_adapter?(:MysqlAdapter)
     def test_schema_dump_should_not_add_default_value_for_mysql_text_field
       output = standard_dump
       assert_match %r{t.text\s+"body",\s+:null => false$}, output
     end
 
-    def test_mysql_schema_dump_should_honor_nonstandard_primary_keys
-      output = standard_dump
-      match = output.match(%r{create_table "movies"(.*)do})
-      assert_not_nil(match, "nonstandardpk table not found")
-      assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
-    end
-
     def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
       output = standard_dump
       assert_match %r{t.binary\s+"tiny_blob",\s+:limit => 255$}, output

vendor/rails/activerecord/test/cases/schema_test_postgresql.rb

@@ -6,6 +6,7 @@ class SchemaTest < ActiveRecord::TestCase
   SCHEMA_NAME = 'test_schema'
   SCHEMA2_NAME = 'test_schema2'
   TABLE_NAME = 'things'
+  CAPITALIZED_TABLE_NAME = 'Things'
   INDEX_A_NAME = 'a_index_things_on_name'
   INDEX_B_NAME = 'b_index_things_on_different_columns_in_each_schema'
   INDEX_A_COLUMN = 'name'
@@ -18,9 +19,27 @@ class SchemaTest < ActiveRecord::TestCase
     'moment timestamp without time zone default now()'
   ]
 
+  class Thing1 < ActiveRecord::Base
+    set_table_name "test_schema.things"
+  end
+
+  class Thing2 < ActiveRecord::Base
+    set_table_name "test_schema2.things"
+  end
+
+  class Thing3 < ActiveRecord::Base
+    set_table_name 'test_schema."things.table"'
+  end
+
+  class Thing4 < ActiveRecord::Base
+    set_table_name 'test_schema."Things"'
+  end
+
   def setup
     @connection = ActiveRecord::Base.connection
     @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{TABLE_NAME}.table\" (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{CAPITALIZED_TABLE_NAME}\" (#{COLUMNS.join(',')})"
     @connection.execute "CREATE SCHEMA #{SCHEMA2_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
     @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
     @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
@@ -39,6 +58,12 @@ class SchemaTest < ActiveRecord::TestCase
     end
   end
 
+  def test_with_schema_prefixed_capitalized_table_name
+    assert_nothing_raised do
+      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{CAPITALIZED_TABLE_NAME}")
+    end
+  end
+
   def test_with_schema_search_path
     assert_nothing_raised do
       with_schema_search_path(SCHEMA_NAME) do
@@ -47,6 +72,47 @@ class SchemaTest < ActiveRecord::TestCase
     end
   end
 
+
+  def test_proper_encoding_of_table_name
+    assert_equal '"table_name"', @connection.quote_table_name('table_name')
+    assert_equal '"table.name"', @connection.quote_table_name('"table.name"')
+    assert_equal '"schema_name"."table_name"', @connection.quote_table_name('schema_name.table_name')
+    assert_equal '"schema_name"."table.name"', @connection.quote_table_name('schema_name."table.name"')
+    assert_equal '"schema.name"."table_name"', @connection.quote_table_name('"schema.name".table_name')
+    assert_equal '"schema.name"."table.name"', @connection.quote_table_name('"schema.name"."table.name"')
+  end
+
+  def test_classes_with_qualified_schema_name
+    assert_equal 0, Thing1.count
+    assert_equal 0, Thing2.count
+    assert_equal 0, Thing3.count
+    assert_equal 0, Thing4.count
+
+    Thing1.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
+    assert_equal 1, Thing1.count
+    assert_equal 0, Thing2.count
+    assert_equal 0, Thing3.count
+    assert_equal 0, Thing4.count
+
+    Thing2.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
+    assert_equal 1, Thing1.count
+    assert_equal 1, Thing2.count
+    assert_equal 0, Thing3.count
+    assert_equal 0, Thing4.count
+
+    Thing3.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
+    assert_equal 1, Thing1.count
+    assert_equal 1, Thing2.count
+    assert_equal 1, Thing3.count
+    assert_equal 0, Thing4.count
+
+    Thing4.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
+    assert_equal 1, Thing1.count
+    assert_equal 1, Thing2.count
+    assert_equal 1, Thing3.count
+    assert_equal 1, Thing4.count
+  end
+
   def test_raise_on_unquoted_schema_name
     assert_raise(ActiveRecord::StatementInvalid) do
       with_schema_search_path '$user,public'
@@ -69,6 +135,16 @@ class SchemaTest < ActiveRecord::TestCase
     do_dump_index_tests_for_schema(SCHEMA2_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S2)
   end
 
+  def test_with_uppercase_index_name
+    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
+    assert_nothing_raised { ActiveRecord::Base.connection.remove_index :things, :name => "#{SCHEMA_NAME}.things_Index"}
+
+    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
+    ActiveRecord::Base.connection.schema_search_path = SCHEMA_NAME
+    assert_nothing_raised { ActiveRecord::Base.connection.remove_index :things, :name => "things_Index"}
+    ActiveRecord::Base.connection.schema_search_path = "public"
+  end
+
   private
     def columns(table_name)
       @connection.send(:column_definitions, table_name).map do |name, type, default|

vendor/rails/activerecord/test/cases/timestamp_test.rb

@@ -0,0 +1,75 @@
+require 'cases/helper'
+require 'models/developer'
+require 'models/owner'
+require 'models/pet'
+
+class TimestampTest < ActiveRecord::TestCase
+  fixtures :developers, :owners, :pets
+
+  def setup
+    @developer = Developer.first
+    @previously_updated_at = @developer.updated_at
+  end
+
+  def test_saving_a_changed_record_updates_its_timestamp
+    @developer.name = "Jack Bauer"
+    @developer.save!
+    
+    assert @previously_updated_at != @developer.updated_at
+  end
+  
+  def test_saving_a_unchanged_record_doesnt_update_its_timestamp
+    @developer.save!
+    
+    assert @previously_updated_at == @developer.updated_at
+  end
+  
+  def test_touching_a_record_updates_its_timestamp
+    @developer.touch
+    
+    assert @previously_updated_at != @developer.updated_at
+  end
+  
+  def test_touching_a_different_attribute
+    previously_created_at = @developer.created_at
+    @developer.touch(:created_at)
+
+    assert previously_created_at != @developer.created_at
+  end
+  
+  def test_saving_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_update_the_parent_updated_at
+    pet   = Pet.first
+    owner = pet.owner
+    previously_owner_updated_at = owner.updated_at
+    
+    pet.name = "Fluffy the Third"
+    pet.save
+    
+    assert previously_owner_updated_at != pet.owner.updated_at
+  end
+
+  def test_destroying_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_update_the_parent_updated_at
+    pet   = Pet.first
+    owner = pet.owner
+    previously_owner_updated_at = owner.updated_at
+    
+    pet.destroy
+    
+    assert previously_owner_updated_at != pet.owner.updated_at
+  end
+  
+  def test_saving_a_record_with_a_belongs_to_that_specifies_touching_a_specific_attribute_the_parent_should_update_that_attribute
+    Pet.belongs_to :owner, :touch => :happy_at
+
+    pet   = Pet.first
+    owner = pet.owner
+    previously_owner_happy_at = owner.happy_at
+    
+    pet.name = "Fluffy the Third"
+    pet.save
+    
+    assert previously_owner_happy_at != pet.owner.happy_at
+  ensure
+    Pet.belongs_to :owner, :touch => true
+  end
+end

vendor/rails/activerecord/test/models/author.rb

@@ -25,6 +25,8 @@ class Author < ActiveRecord::Base
   has_many :comments_with_order_and_conditions, :through => :posts, :source => :comments, :order => 'comments.body', :conditions => "comments.body like 'Thank%'"
   has_many :comments_with_include, :through => :posts, :source => :comments, :include => :post
 
+  has_many :thinking_posts, :class_name => 'Post', :conditions => { :title => 'So I was thinking' }, :dependent => :delete_all
+  has_many :welcome_posts,  :class_name => 'Post', :conditions => { :title => 'Welcome to the weblog' }
 
   has_many :comments_desc, :through => :posts, :source => :comments, :order => 'comments.id DESC'
   has_many :limited_comments, :through => :posts, :source => :comments, :limit => 1
@@ -85,6 +87,8 @@ class Author < ActiveRecord::Base
   has_many :tags,     :through => :posts # through has_many :through
   has_many :post_categories, :through => :posts, :source => :categories
 
+  has_one :essay, :primary_key => :name, :as => :writer
+
   belongs_to :author_address, :dependent => :destroy
   belongs_to :author_address_extra, :dependent => :delete, :class_name => "AuthorAddress"
 

vendor/rails/activerecord/test/models/company.rb

@@ -78,19 +78,13 @@ class DependentFirm < Company
   has_many :companies, :foreign_key => 'client_of', :order => "id", :dependent => :nullify
 end
 
-class ExclusivelyDependentFirm < Company
-  has_one :account, :foreign_key => "firm_id", :dependent => :delete
-  has_many :dependent_sanitized_conditional_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all, :conditions => "name = 'BigShot Inc.'"
-  has_many :dependent_conditional_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all, :conditions => ["name = ?", 'BigShot Inc.']
-  has_many :dependent_hash_conditional_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all, :conditions => {:name => 'BigShot Inc.'}
-end
-
 class Client < Company
   belongs_to :firm, :foreign_key => "client_of"
   belongs_to :firm_with_basic_id, :class_name => "Firm", :foreign_key => "firm_id"
   belongs_to :firm_with_select, :class_name => "Firm", :foreign_key => "firm_id", :select => "id"
   belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"
   belongs_to :firm_with_condition, :class_name => "Firm", :foreign_key => "client_of", :conditions => ["1 = ?", 1]
+  belongs_to :firm_with_primary_key, :class_name => "Firm", :primary_key => "name", :foreign_key => "firm_name"
   belongs_to :readonly_firm, :class_name => "Firm", :foreign_key => "firm_id", :readonly => true
 
   # Record destruction so we can test whether firm.clients.clear has
@@ -125,6 +119,12 @@ class Client < Company
   end
 end
 
+class ExclusivelyDependentFirm < Company
+  has_one :account, :foreign_key => "firm_id", :dependent => :delete
+  has_many :dependent_sanitized_conditional_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all, :conditions => "name = 'BigShot Inc.'"
+  has_many :dependent_conditional_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all, :conditions => ["name = ?", 'BigShot Inc.']
+  has_many :dependent_hash_conditional_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all, :conditions => {:name => 'BigShot Inc.'}
+end
 
 class SpecialClient < Client
 end

vendor/rails/activerecord/test/models/developer.rb

@@ -89,3 +89,13 @@ class DeveloperOrderedBySalary < ActiveRecord::Base
     end
   end
 end
+
+class DeveloperCalledDavid < ActiveRecord::Base
+  self.table_name = 'developers'
+  default_scope :conditions => "name = 'David'"
+end
+
+class DeveloperCalledJamis < ActiveRecord::Base
+  self.table_name = 'developers'
+  default_scope :conditions => { :name => 'Jamis' }
+end

vendor/rails/activerecord/test/models/essay.rb

@@ -0,0 +1,3 @@
+class Essay < ActiveRecord::Base
+  belongs_to :writer, :primary_key => :name, :polymorphic => true
+end

vendor/rails/activerecord/test/models/pet.rb

@@ -1,5 +1,5 @@
 class Pet < ActiveRecord::Base
   set_primary_key :pet_id
-  belongs_to :owner
+  belongs_to :owner, :touch => true
   has_many :toys
 end

vendor/rails/activerecord/test/models/project.rb

@@ -13,7 +13,7 @@ class Project < ActiveRecord::Base
                             :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
                             :before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
                             :after_remove => Proc.new {|o, r| o.developers_log << "after_removing#{r.id}"}
-  has_and_belongs_to_many :well_payed_salary_groups, :class_name => "Developer", :group => "salary", :having => "SUM(salary) > 10000", :select => "SUM(salary) as salary"
+  has_and_belongs_to_many :well_payed_salary_groups, :class_name => "Developer", :group => "developers.salary", :having => "SUM(salary) > 10000", :select => "SUM(salary) as salary"
 
   attr_accessor :developers_log
 

vendor/rails/activerecord/test/models/reply.rb

@@ -4,12 +4,13 @@ class Reply < Topic
   named_scope :base
 
   belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true
+  belongs_to :topic_with_primary_key, :class_name => "Topic", :primary_key => "title", :foreign_key => "parent_title", :counter_cache => "replies_count"
   has_many :replies, :class_name => "SillyReply", :dependent => :destroy, :foreign_key => "parent_id"
 
   validate :errors_on_empty_content
   validate_on_create :title_is_wrong_create
 
-  attr_accessible :title, :author_name, :author_email_address, :written_on, :content, :last_read
+  attr_accessible :title, :author_name, :author_email_address, :written_on, :content, :last_read, :parent_title
 
   def validate
     errors.add("title", "Empty")   unless attribute_present? "title"

vendor/rails/activerecord/test/models/topic.rb

@@ -39,6 +39,7 @@ class Topic < ActiveRecord::Base
   named_scope :by_rejected_ids, lambda {{ :conditions => { :id => all(:conditions => {:approved => false}).map(&:id) } }}
 
   has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
+  has_many :replies_with_primary_key, :class_name => "Reply", :dependent => :destroy, :primary_key => "title", :foreign_key => "parent_title"
   serialize :content
 
   before_create  :default_written_on

vendor/rails/activerecord/test/models/toy.rb

@@ -1,4 +1,6 @@
 class Toy < ActiveRecord::Base
   set_primary_key :toy_id
   belongs_to :pet
+
+  named_scope :with_name, lambda { |name| {:conditions => {:name => name}} }
 end

vendor/rails/activerecord/test/schema/schema.rb

@@ -68,6 +68,10 @@ ActiveRecord::Schema.define do
     t.boolean :value
   end
 
+  create_table "CamelCase", :force => true do |t|
+    t.string :name
+  end
+
   create_table :categories, :force => true do |t|
     t.string :name, :null => false
     t.string :type
@@ -114,6 +118,8 @@ ActiveRecord::Schema.define do
     t.integer :rating, :default => 1
   end
 
+  add_index :companies, [:firm_id, :type, :rating, :ruby_type], :name => "company_index"
+
   create_table :computers, :force => true do |t|
     t.integer :developer, :null => false
     t.integer :extendedWarranty, :null => false
@@ -155,6 +161,12 @@ ActiveRecord::Schema.define do
     t.integer :course_id, :null => false
   end
 
+  create_table :essays, :force => true do |t|
+    t.string :name
+    t.string :writer_id
+    t.string :writer_type
+  end
+
   create_table :events, :force => true do |t|
     t.string :title, :limit => 5
   end
@@ -281,6 +293,8 @@ ActiveRecord::Schema.define do
 
   create_table :owners, :primary_key => :owner_id ,:force => true do |t|
     t.string :name
+    t.column :updated_at, :datetime
+    t.column :happy_at,   :datetime
   end
 
 
@@ -410,6 +424,7 @@ ActiveRecord::Schema.define do
     t.boolean  :approved, :default => true
     t.integer  :replies_count, :default => 0
     t.integer  :parent_id
+    t.string   :parent_title
     t.string   :type
   end