Upgraded to Rails 2.1. This can have wide ranging consequences, so please help track down any issues introduced by the upgrade. Requires environment.rb modifications.

Changes you will need to make:

 * In your environment.rb, you will need to update references to a few files per environment.rb.tmpl
 * In your environment.rb, you will need to specify the local time zone of the computer that is running your Tracks install.

Other notes on my changes:

 * Modified our code to take advantage of Rails 2.1's slick time zone support.
 * Upgraded will_paginate for compatibility
 * Hacked the Selenium on Rails plugin, which has not been updated in some time and does not support Rails 2.1
 * Verified that all tests pass on my machine, including Selenium tests -- I'd like confirmation from others, too.

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

@@ -0,0 +1,133 @@
+class Author < ActiveRecord::Base
+  has_many :posts
+  has_many :posts_with_comments, :include => :comments, :class_name => "Post"
+  has_many :posts_with_categories, :include => :categories, :class_name => "Post"
+  has_many :posts_with_comments_and_categories, :include => [ :comments, :categories ], :order => "posts.id", :class_name => "Post"
+  has_many :posts_containing_the_letter_a, :class_name => "Post"
+  has_many :posts_with_extension, :class_name => "Post" do #, :extend => ProxyTestExtension
+    def testing_proxy_owner
+      proxy_owner
+    end
+    def testing_proxy_reflection
+      proxy_reflection
+    end
+    def testing_proxy_target
+      proxy_target
+    end
+  end
+  has_many :comments, :through => :posts
+  has_many :comments_containing_the_letter_e, :through => :posts, :source => :comments
+  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 :comments_desc, :through => :posts, :source => :comments, :order => 'comments.id DESC'
+  has_many :limited_comments, :through => :posts, :source => :comments, :limit => 1
+  has_many :funky_comments, :through => :posts, :source => :comments
+  has_many :ordered_uniq_comments, :through => :posts, :source => :comments, :uniq => true, :order => 'comments.id'
+  has_many :ordered_uniq_comments_desc, :through => :posts, :source => :comments, :uniq => true, :order => 'comments.id DESC'
+  has_many :readonly_comments, :through => :posts, :source => :comments, :readonly => true
+  
+  has_many :special_posts
+  has_many :special_post_comments, :through => :special_posts, :source => :comments
+
+  has_many :special_nonexistant_posts, :class_name => "SpecialPost", :conditions => "posts.body = 'nonexistant'"
+  has_many :special_nonexistant_post_comments, :through => :special_nonexistant_posts, :source => :comments, :conditions => "comments.post_id = 0"
+  has_many :nonexistant_comments, :through => :posts
+
+  has_many :hello_posts, :class_name => "Post", :conditions => "posts.body = 'hello'"
+  has_many :hello_post_comments, :through => :hello_posts, :source => :comments
+  has_many :posts_with_no_comments, :class_name => 'Post', :conditions => 'comments.id is null', :include => :comments
+
+  has_many :hello_posts_with_hash_conditions, :class_name => "Post",
+:conditions => {:body => 'hello'}
+  has_many :hello_post_comments_with_hash_conditions, :through =>
+:hello_posts_with_hash_conditions, :source => :comments
+
+  has_many :other_posts,          :class_name => "Post"
+  has_many :posts_with_callbacks, :class_name => "Post", :before_add => :log_before_adding,
+           :after_add     => :log_after_adding,
+           :before_remove => :log_before_removing,
+           :after_remove  => :log_after_removing
+  has_many :posts_with_proc_callbacks, :class_name => "Post",
+           :before_add    => Proc.new {|o, r| o.post_log << "before_adding#{r.id || '<new>'}"},
+           :after_add     => Proc.new {|o, r| o.post_log << "after_adding#{r.id || '<new>'}"},
+           :before_remove => Proc.new {|o, r| o.post_log << "before_removing#{r.id}"},
+           :after_remove  => Proc.new {|o, r| o.post_log << "after_removing#{r.id}"}
+  has_many :posts_with_multiple_callbacks, :class_name => "Post",
+           :before_add => [:log_before_adding, Proc.new {|o, r| o.post_log << "before_adding_proc#{r.id || '<new>'}"}],
+           :after_add  => [:log_after_adding,  Proc.new {|o, r| o.post_log << "after_adding_proc#{r.id || '<new>'}"}]
+  has_many :unchangable_posts, :class_name => "Post", :before_add => :raise_exception, :after_add => :log_after_adding
+
+  has_many :categorizations
+  has_many :categories, :through => :categorizations
+
+  has_many :categories_like_general, :through => :categorizations, :source => :category, :class_name => 'Category', :conditions => { :name => 'General' }
+
+  has_many :categorized_posts, :through => :categorizations, :source => :post
+  has_many :unique_categorized_posts, :through => :categorizations, :source => :post, :uniq => true
+
+  has_many :nothings, :through => :kateggorisatons, :class_name => 'Category'
+
+  has_many :author_favorites
+  has_many :favorite_authors, :through => :author_favorites, :order => 'name'
+
+  has_many :tagging,  :through => :posts # through polymorphic has_one
+  has_many :taggings, :through => :posts, :source => :taggings # through polymorphic has_many
+  has_many :tags,     :through => :posts # through has_many :through
+  has_many :post_categories, :through => :posts, :source => :categories
+
+  belongs_to :author_address, :dependent => :destroy
+  belongs_to :author_address_extra, :dependent => :delete, :class_name => "AuthorAddress"
+
+  attr_accessor :post_log
+
+  def after_initialize
+    @post_log = []
+  end
+
+  def label
+    "#{id}-#{name}"
+  end
+
+  private
+    def log_before_adding(object)
+      @post_log << "before_adding#{object.id || '<new>'}"
+    end
+
+    def log_after_adding(object)
+      @post_log << "after_adding#{object.id}"
+    end
+
+    def log_before_removing(object)
+      @post_log << "before_removing#{object.id}"
+    end
+
+    def log_after_removing(object)
+      @post_log << "after_removing#{object.id}"
+    end
+
+    def raise_exception(object)
+      raise Exception.new("You can't add a post")
+    end
+end
+
+class AuthorAddress < ActiveRecord::Base
+  has_one :author
+
+  def self.destroyed_author_address_ids
+    @destroyed_author_address_ids ||= Hash.new { |h,k| h[k] = [] }
+  end
+
+  before_destroy do |author_address|
+    if author_address.author
+      AuthorAddress.destroyed_author_address_ids[author_address.author.id] << author_address.id
+    end
+    true
+  end
+end
+
+class AuthorFavorite < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :favorite_author, :class_name => "Author"
+end

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

@@ -0,0 +1,4 @@
+class AutoId < ActiveRecord::Base
+  def self.table_name () "auto_id_tests" end
+  def self.primary_key () "auto_id" end
+end

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

@@ -0,0 +1,2 @@
+class Binary < ActiveRecord::Base
+end

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

@@ -0,0 +1,4 @@
+class Book < ActiveRecord::Base
+  has_many :citations, :foreign_key => 'book1_id'
+  has_many :references, :through => :citations, :source => :reference_of, :uniq => true
+end

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

@@ -0,0 +1,5 @@
+class Categorization < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :category
+  belongs_to :author
+end

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

@@ -0,0 +1,29 @@
+class Category < ActiveRecord::Base
+  has_and_belongs_to_many :posts
+  has_and_belongs_to_many :special_posts, :class_name => "Post"
+  has_and_belongs_to_many :other_posts, :class_name => "Post"
+
+  has_and_belongs_to_many(:select_testing_posts,
+                          :class_name => 'Post',
+                          :foreign_key => 'category_id',
+                          :association_foreign_key => 'post_id',
+                          :select => 'posts.*, 1 as correctness_marker')
+
+  has_and_belongs_to_many :post_with_conditions,
+                          :class_name => 'Post',
+                          :conditions => { :title => 'Yet Another Testing Title' }
+  def self.what_are_you
+    'a category...'
+  end
+
+  has_many :categorizations
+  has_many :authors, :through => :categorizations, :select => 'authors.*, categorizations.post_id'
+end
+
+class SpecialCategory < Category
+
+  def self.what_are_you
+    'a special category...'
+  end
+
+end

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

@@ -0,0 +1,6 @@
+class Citation < ActiveRecord::Base
+  belongs_to :reference_of, :class_name => "Book", :foreign_key => :book2_id
+
+  belongs_to :book1, :class_name => "Book", :foreign_key => :book1_id
+  belongs_to :book2, :class_name => "Book", :foreign_key => :book2_id
+end

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

@@ -0,0 +1,7 @@
+class Club < ActiveRecord::Base
+  has_many :memberships
+  has_many :members, :through => :memberships
+  has_many :current_memberships
+  has_one :sponsor
+  has_one :sponsored_member, :through => :sponsor, :source => :sponsorable, :source_type => "Member"
+end

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

@@ -0,0 +1,3 @@
+class ColumnName < ActiveRecord::Base
+  def self.table_name () "colnametests" end
+end

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

@@ -0,0 +1,25 @@
+class Comment < ActiveRecord::Base
+  named_scope :containing_the_letter_e, :conditions => "comments.body LIKE '%e%'"
+  
+  belongs_to :post, :counter_cache => true
+
+  def self.what_are_you
+    'a comment...'
+  end
+
+  def self.search_by_type(q)
+    self.find(:all, :conditions => ["#{QUOTED_TYPE} = ?", q])
+  end
+end
+
+class SpecialComment < Comment
+  def self.what_are_you
+    'a special comment...'
+  end
+end
+
+class VerySpecialComment < Comment
+  def self.what_are_you
+    'a very special comment...'
+  end
+end

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

@@ -0,0 +1,123 @@
+class AbstractCompany < ActiveRecord::Base
+  self.abstract_class = true
+end
+
+class Company < AbstractCompany
+  attr_protected :rating
+  set_sequence_name :companies_nonstd_seq
+
+  validates_presence_of :name
+
+  has_one :dummy_account, :foreign_key => "firm_id", :class_name => "Account"
+
+  def arbitrary_method
+    "I am Jack's profound disappointment"
+  end
+end
+
+module Namespaced
+  class Company < ::Company
+  end
+end
+
+class Firm < Company
+  has_many :clients, :order => "id", :dependent => :destroy, :counter_sql =>
+      "SELECT COUNT(*) FROM companies WHERE firm_id = 1 " +
+      "AND (#{QUOTED_TYPE} = 'Client' OR #{QUOTED_TYPE} = 'SpecialClient' OR #{QUOTED_TYPE} = 'VerySpecialClient' )"
+  has_many :clients_sorted_desc, :class_name => "Client", :order => "id DESC"
+  has_many :clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id"
+  has_many :dependent_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :destroy
+  has_many :exclusively_dependent_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all
+  has_many :limited_clients, :class_name => "Client", :order => "id", :limit => 1
+  has_many :clients_like_ms, :conditions => "name = 'Microsoft'", :class_name => "Client", :order => "id"
+  has_many :clients_with_interpolated_conditions, :class_name => "Client", :conditions => 'rating > #{rating}'
+  has_many :clients_like_ms_with_hash_conditions, :conditions => { :name => 'Microsoft' }, :class_name => "Client", :order => "id"
+  has_many :clients_using_sql, :class_name => "Client", :finder_sql => 'SELECT * FROM companies WHERE client_of = #{id}'
+  has_many :clients_using_counter_sql, :class_name => "Client",
+           :finder_sql  => 'SELECT * FROM companies WHERE client_of = #{id}',
+           :counter_sql => 'SELECT COUNT(*) FROM companies WHERE client_of = #{id}'
+  has_many :clients_using_zero_counter_sql, :class_name => "Client",
+           :finder_sql  => 'SELECT * FROM companies WHERE client_of = #{id}',
+           :counter_sql => 'SELECT 0 FROM companies WHERE client_of = #{id}'
+  has_many :no_clients_using_counter_sql, :class_name => "Client",
+           :finder_sql  => 'SELECT * FROM companies WHERE client_of = 1000',
+           :counter_sql => 'SELECT COUNT(*) FROM companies WHERE client_of = 1000'
+  has_many :clients_using_finder_sql, :class_name => "Client", :finder_sql => 'SELECT * FROM companies WHERE 1=1'
+  has_many :plain_clients, :class_name => 'Client'
+  has_many :readonly_clients, :class_name => 'Client', :readonly => true
+
+  has_one :account, :foreign_key => "firm_id", :dependent => :destroy
+  has_one :account_with_select, :foreign_key => "firm_id", :select => "id, firm_id", :class_name=>'Account'
+  has_one :readonly_account, :foreign_key => "firm_id", :class_name => "Account", :readonly => true
+end
+
+class DependentFirm < Company
+  has_one :account, :foreign_key => "firm_id", :dependent => :nullify
+  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.']
+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 :readonly_firm, :class_name => "Firm", :foreign_key => "firm_id", :readonly => true
+
+  # Record destruction so we can test whether firm.clients.clear has
+  # is calling client.destroy, deleting from the database, or setting
+  # foreign keys to NULL.
+  def self.destroyed_client_ids
+    @destroyed_client_ids ||= Hash.new { |h,k| h[k] = [] }
+  end
+
+  before_destroy do |client|
+    if client.firm
+      Client.destroyed_client_ids[client.firm.id] << client.id
+    end
+    true
+  end
+
+  # Used to test that read and question methods are not generated for these attributes
+  def ruby_type
+    read_attribute :ruby_type
+  end
+
+  def rating?
+    query_attribute :rating
+  end
+end
+
+
+class SpecialClient < Client
+end
+
+class VerySpecialClient < SpecialClient
+end
+
+class Account < ActiveRecord::Base
+  belongs_to :firm
+
+  def self.destroyed_account_ids
+    @destroyed_account_ids ||= Hash.new { |h,k| h[k] = [] }
+  end
+
+  before_destroy do |account|
+    if account.firm
+      Account.destroyed_account_ids[account.firm.id] << account.id
+    end
+    true
+  end
+
+
+  protected
+    def validate
+      errors.add_on_empty "credit_limit"
+    end
+end

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

@@ -0,0 +1,61 @@
+module MyApplication
+  module Business
+    class Company < ActiveRecord::Base
+      attr_protected :rating
+    end
+
+    class Firm < Company
+      has_many :clients, :order => "id", :dependent => :destroy
+      has_many :clients_sorted_desc, :class_name => "Client", :order => "id DESC"
+      has_many :clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id"
+      has_many :clients_like_ms, :conditions => "name = 'Microsoft'", :class_name => "Client", :order => "id"
+      has_many :clients_using_sql, :class_name => "Client", :finder_sql => 'SELECT * FROM companies WHERE client_of = #{id}'
+
+      has_one :account, :dependent => :destroy
+    end
+
+    class Client < Company
+      belongs_to :firm, :foreign_key => "client_of"
+      belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"
+
+      class Contact < ActiveRecord::Base; end
+    end
+
+    class Developer < ActiveRecord::Base
+      has_and_belongs_to_many :projects
+      validates_length_of :name, :within => (3..20)
+    end
+
+    class Project < ActiveRecord::Base
+      has_and_belongs_to_many :developers
+    end
+
+  end
+
+  module Billing
+    class Firm < ActiveRecord::Base
+      self.table_name = 'companies'
+    end
+
+    module Nested
+      class Firm < ActiveRecord::Base
+        self.table_name = 'companies'
+      end
+    end
+
+    class Account < ActiveRecord::Base
+      with_options(:foreign_key => :firm_id) do |i|
+        i.belongs_to :firm, :class_name => 'MyApplication::Business::Firm'
+        i.belongs_to :qualified_billing_firm, :class_name => 'MyApplication::Billing::Firm'
+        i.belongs_to :unqualified_billing_firm, :class_name => 'Firm'
+        i.belongs_to :nested_qualified_billing_firm, :class_name => 'MyApplication::Billing::Nested::Firm'
+        i.belongs_to :nested_unqualified_billing_firm, :class_name => 'Nested::Firm'
+      end
+
+      protected
+        def validate
+          errors.add_on_empty "credit_limit"
+        end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+class Computer < ActiveRecord::Base
+  belongs_to :developer, :foreign_key=>'developer'
+end

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

@@ -0,0 +1,16 @@
+class Contact < ActiveRecord::Base
+  # mock out self.columns so no pesky db is needed for these tests
+  def self.column(name, sql_type = nil, options = {})
+    @columns ||= []
+    @columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, options[:default], sql_type.to_s, options[:null])
+  end
+
+  column :name,        :string
+  column :age,         :integer
+  column :avatar,      :binary
+  column :created_at,  :datetime
+  column :awesome,     :boolean
+  column :preferences, :string
+
+  serialize :preferences
+end

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

@@ -0,0 +1,3 @@
+class Course < ActiveRecord::Base
+  has_many :entrants
+end

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

@@ -0,0 +1,55 @@
+class Customer < ActiveRecord::Base
+  composed_of :address, :mapping => [ %w(address_street street), %w(address_city city), %w(address_country country) ], :allow_nil => true
+  composed_of(:balance, :class_name => "Money", :mapping => %w(balance amount)) { |balance| balance.to_money }
+  composed_of :gps_location, :allow_nil => true
+end
+
+class Address
+  attr_reader :street, :city, :country
+
+  def initialize(street, city, country)
+    @street, @city, @country = street, city, country
+  end
+
+  def close_to?(other_address)
+    city == other_address.city && country == other_address.country
+  end
+
+  def ==(other)
+    other.is_a?(self.class) && other.street == street && other.city == city && other.country == country
+  end
+end
+
+class Money
+  attr_reader :amount, :currency
+
+  EXCHANGE_RATES = { "USD_TO_DKK" => 6, "DKK_TO_USD" => 0.6 }
+
+  def initialize(amount, currency = "USD")
+    @amount, @currency = amount, currency
+  end
+
+  def exchange_to(other_currency)
+    Money.new((amount * EXCHANGE_RATES["#{currency}_TO_#{other_currency}"]).floor, other_currency)
+  end
+end
+
+class GpsLocation
+  attr_reader :gps_location
+
+  def initialize(gps_location)
+    @gps_location = gps_location
+  end
+
+  def latitude
+    gps_location.split("x").first
+  end
+
+  def longitude
+    gps_location.split("x").last
+  end
+
+  def ==(other)
+    self.latitude == other.latitude && self.longitude == other.longitude
+  end
+end

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

@@ -0,0 +1,2 @@
+class Default < ActiveRecord::Base
+end

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

@@ -0,0 +1,76 @@
+module DeveloperProjectsAssociationExtension
+  def find_most_recent
+    find(:first, :order => "id DESC")
+  end
+end
+
+module DeveloperProjectsAssociationExtension2
+  def find_least_recent
+    find(:first, :order => "id ASC")
+  end
+end
+
+class Developer < ActiveRecord::Base
+  has_and_belongs_to_many :projects do
+    def find_most_recent
+      find(:first, :order => "id DESC")
+    end
+  end
+
+  has_and_belongs_to_many :projects_extended_by_name,
+      :class_name => "Project",
+      :join_table => "developers_projects",
+      :association_foreign_key => "project_id",
+      :extend => DeveloperProjectsAssociationExtension
+
+  has_and_belongs_to_many :projects_extended_by_name_twice,
+      :class_name => "Project",
+      :join_table => "developers_projects",
+      :association_foreign_key => "project_id",
+      :extend => [DeveloperProjectsAssociationExtension, DeveloperProjectsAssociationExtension2]
+
+  has_and_belongs_to_many :projects_extended_by_name_and_block,
+      :class_name => "Project",
+      :join_table => "developers_projects",
+      :association_foreign_key => "project_id",
+      :extend => DeveloperProjectsAssociationExtension do
+        def find_least_recent
+          find(:first, :order => "id ASC")
+        end
+      end
+
+  has_and_belongs_to_many :special_projects, :join_table => 'developers_projects', :association_foreign_key => 'project_id'
+
+  has_many :audit_logs
+
+  validates_inclusion_of :salary, :in => 50000..200000
+  validates_length_of    :name, :within => 3..20
+
+  before_create do |developer|
+    developer.audit_logs.build :message => "Computer created"
+  end
+
+  def log=(message)
+    audit_logs.build :message => message
+  end
+end
+
+class AuditLog < ActiveRecord::Base
+  belongs_to :developer
+end
+
+DeveloperSalary = Struct.new(:amount)
+class DeveloperWithAggregate < ActiveRecord::Base
+  self.table_name = 'developers'
+  composed_of :salary, :class_name => 'DeveloperSalary', :mapping => [%w(salary amount)]
+end
+
+class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
+  self.table_name = 'developers'
+  has_and_belongs_to_many :projects, :join_table => 'developers_projects', :foreign_key => 'developer_id'
+  before_destroy :raise_if_projects_empty!
+
+  def raise_if_projects_empty!
+    raise if projects.empty?
+  end
+end

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

@@ -0,0 +1,5 @@
+# This class models an edge in a directed graph.
+class Edge < ActiveRecord::Base
+  belongs_to :source, :class_name => 'Vertex', :foreign_key => 'source_id'
+  belongs_to :sink,   :class_name => 'Vertex', :foreign_key => 'sink_id'
+end

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

@@ -0,0 +1,3 @@
+class Entrant < ActiveRecord::Base
+  belongs_to :course
+end

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

@@ -0,0 +1,2 @@
+class Guid < ActiveRecord::Base
+end

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

@@ -0,0 +1,7 @@
+class AbstractItem < ActiveRecord::Base
+  self.abstract_class = true
+  has_one :tagging, :as => :taggable
+end
+
+class Item < AbstractItem
+end

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

@@ -0,0 +1,5 @@
+class Job < ActiveRecord::Base
+  has_many :references
+  has_many :people, :through => :references
+  belongs_to :ideal_reference, :class_name => 'Reference'
+end

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

@@ -0,0 +1,3 @@
+class Joke < ActiveRecord::Base
+  set_table_name 'funny_jokes'
+end

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

@@ -0,0 +1,3 @@
+class Keyboard < ActiveRecord::Base
+  set_primary_key 'key_number'
+end

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

@@ -0,0 +1,3 @@
+class LegacyThing < ActiveRecord::Base
+  set_locking_column :version
+end

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

@@ -0,0 +1,4 @@
+class Matey < ActiveRecord::Base
+  belongs_to :pirate
+  belongs_to :target, :class_name => 'Pirate'
+end

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

@@ -0,0 +1,9 @@
+class Member < ActiveRecord::Base
+  has_one :current_membership
+  has_many :memberships
+  has_many :fellow_members, :through => :club, :source => :members
+  has_one :club, :through => :current_membership
+  has_one :favourite_club, :through => :memberships, :conditions => ["memberships.favourite = ?", true], :source => :club
+  has_one :sponsor, :as => :sponsorable
+  has_one :sponsor_club, :through => :sponsor
+end

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

@@ -0,0 +1,9 @@
+class Membership < ActiveRecord::Base
+  belongs_to :member
+  belongs_to :club
+end
+
+class CurrentMembership < Membership
+  belongs_to :member
+  belongs_to :club
+end

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

@@ -0,0 +1,2 @@
+class Minimalistic < ActiveRecord::Base
+end

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

@@ -0,0 +1,3 @@
+class MixedCaseMonkey < ActiveRecord::Base
+  set_primary_key 'monkeyID'
+end

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

@@ -0,0 +1,5 @@
+class Movie < ActiveRecord::Base
+  def self.primary_key
+    "movieid"
+  end
+end

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

@@ -0,0 +1,4 @@
+class Order < ActiveRecord::Base
+  belongs_to :billing, :class_name => 'Customer', :foreign_key => 'billing_customer_id'
+  belongs_to :shipping, :class_name => 'Customer', :foreign_key => 'shipping_customer_id'
+end

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

@@ -0,0 +1,4 @@
+class Owner < ActiveRecord::Base
+  set_primary_key :owner_id
+  has_many :pets
+end

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

@@ -0,0 +1,13 @@
+class Parrot < ActiveRecord::Base
+  set_inheritance_column :parrot_sti_class
+  has_and_belongs_to_many :pirates
+  has_and_belongs_to_many :treasures
+  has_many :loots, :as => :looter
+end
+
+class LiveParrot < Parrot
+end
+
+class DeadParrot < Parrot
+  belongs_to :killer, :class_name => 'Pirate'
+end

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

@@ -0,0 +1,10 @@
+class Person < ActiveRecord::Base
+  has_many :readers
+  has_many :posts, :through => :readers
+  has_many :posts_with_no_comments, :through => :readers, :source => :post, :include => :comments, :conditions => 'comments.id is null'
+
+  has_many :references
+  has_many :jobs, :through => :references
+  has_one :favourite_reference, :class_name => 'Reference', :conditions => ['favourite=?', true]
+
+end

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

@@ -0,0 +1,4 @@
+class Pet < ActiveRecord::Base
+  set_primary_key :pet_id
+  belongs_to :owner
+end

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

@@ -0,0 +1,9 @@
+class Pirate < ActiveRecord::Base
+  belongs_to :parrot
+  has_and_belongs_to_many :parrots
+  has_many :treasures, :as => :looter
+
+  has_many :treasure_estimates, :through => :treasures, :source => :price_estimates
+
+  validates_presence_of :catchphrase
+end

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

@@ -0,0 +1,80 @@
+class Post < ActiveRecord::Base
+  named_scope :containing_the_letter_a, :conditions => "body LIKE '%a%'"
+  
+  belongs_to :author do
+    def greeting
+      "hello"
+    end
+  end
+
+  belongs_to :author_with_posts, :class_name => "Author", :foreign_key => :author_id, :include => :posts
+
+  has_one :last_comment, :class_name => 'Comment', :order => 'id desc'
+
+  has_many   :comments, :order => "body" do
+    def find_most_recent
+      find(:first, :order => "id DESC")
+    end
+  end
+
+  has_many :comments_with_interpolated_conditions, :class_name => 'Comment',
+      :conditions => ['#{"#{aliased_table_name}." rescue ""}body = ?', 'Thank you for the welcome']
+
+  has_one  :very_special_comment
+  has_one  :very_special_comment_with_post, :class_name => "VerySpecialComment", :include => :post
+  has_many :special_comments
+  has_many :nonexistant_comments, :class_name => 'Comment', :conditions => 'comments.id < 0'
+
+  has_and_belongs_to_many :categories
+  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'
+
+  has_many :taggings, :as => :taggable
+  has_many :tags, :through => :taggings do
+    def add_joins_and_select
+      find :all, :select => 'tags.*, authors.id as author_id', :include => false,
+        :joins => 'left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id'
+    end
+  end
+
+  has_many :funky_tags, :through => :taggings, :source => :tag
+  has_many :super_tags, :through => :taggings
+  has_one :tagging, :as => :taggable
+
+  has_many :invalid_taggings, :as => :taggable, :class_name => "Tagging", :conditions => 'taggings.id < 0'
+  has_many :invalid_tags, :through => :invalid_taggings, :source => :tag
+
+  has_many :categorizations, :foreign_key => :category_id
+  has_many :authors, :through => :categorizations
+
+  has_many :readers
+  has_many :people, :through => :readers
+  has_many :people_with_callbacks, :source=>:person, :through => :readers,
+              :before_add    => lambda {|owner, reader| log(:added,   :before, reader.first_name) },
+              :after_add     => lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
+              :before_remove => lambda {|owner, reader| log(:removed, :before, reader.first_name) },
+              :after_remove  => lambda {|owner, reader| log(:removed, :after,  reader.first_name) }
+
+  def self.reset_log
+    @log = []
+  end
+  
+  def self.log(message=nil, side=nil, new_record=nil)
+    return @log if message.nil?
+    @log << [message, side, new_record]
+  end
+
+  def self.what_are_you
+    'a post...'
+  end
+end
+
+class SpecialPost < Post; end
+
+class StiPost < Post
+  self.abstract_class = true
+  has_one :special_comment, :class_name => "SpecialComment"
+end
+
+class SubStiPost < StiPost
+  self.table_name = Post.table_name
+end

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

@@ -0,0 +1,3 @@
+class PriceEstimate < ActiveRecord::Base
+  belongs_to :estimate_of, :polymorphic => true
+end

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

@@ -0,0 +1,29 @@
+class Project < ActiveRecord::Base
+  has_and_belongs_to_many :developers, :uniq => true, :order => 'developers.name desc, developers.id desc'
+  has_and_belongs_to_many :readonly_developers, :class_name => "Developer", :readonly => true
+  has_and_belongs_to_many :selected_developers, :class_name => "Developer", :select => "developers.*", :uniq => true
+  has_and_belongs_to_many :non_unique_developers, :order => 'developers.name desc, developers.id desc', :class_name => 'Developer'
+  has_and_belongs_to_many :limited_developers, :class_name => "Developer", :limit => 1
+  has_and_belongs_to_many :developers_named_david, :class_name => "Developer", :conditions => "name = 'David'", :uniq => true
+  has_and_belongs_to_many :developers_named_david_with_hash_conditions, :class_name => "Developer", :conditions => { :name => 'David' }, :uniq => true
+  has_and_belongs_to_many :salaried_developers, :class_name => "Developer", :conditions => "salary > 0"
+  has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => 'SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id}'
+  has_and_belongs_to_many :developers_by_sql, :class_name => "Developer", :delete_sql => "DELETE FROM developers_projects WHERE project_id = \#{id} AND developer_id = \#{record.id}"
+  has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
+                            :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}"}
+
+  attr_accessor :developers_log
+
+  def after_initialize
+    @developers_log = []
+  end
+
+end
+
+class SpecialProject < Project
+  def hello_world
+    "hello there!"
+  end
+end

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

@@ -0,0 +1,4 @@
+class Reader < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :person
+end

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

@@ -0,0 +1,4 @@
+class Reference < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :job
+end

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

@@ -0,0 +1,39 @@
+require 'models/topic'
+
+class Reply < Topic
+  named_scope :base
+
+  belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true
+  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
+
+  def validate
+    errors.add("title", "Empty")   unless attribute_present? "title"
+  end
+
+  def errors_on_empty_content
+    errors.add("content", "Empty") unless attribute_present? "content"
+  end
+
+  def validate_on_create
+    if attribute_present?("title") && attribute_present?("content") && content == "Mismatch"
+      errors.add("title", "is Content Mismatch")
+    end
+  end
+
+  def title_is_wrong_create
+    errors.add("title", "is Wrong Create") if attribute_present?("title") && title == "Wrong Create"
+  end
+
+  def validate_on_update
+    errors.add("title", "is Wrong Update") if attribute_present?("title") && title == "Wrong Update"
+  end
+end
+
+class SillyReply < Reply
+  belongs_to :reply, :foreign_key => "parent_id", :counter_cache => :replies_count
+end

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

@@ -0,0 +1,3 @@
+class Ship < ActiveRecord::Base
+  self.record_timestamps = false
+end

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

@@ -0,0 +1,4 @@
+class Sponsor < ActiveRecord::Base
+  belongs_to :sponsor_club, :class_name => "Club", :foreign_key => "club_id"
+  belongs_to :sponsorable, :polymorphic => true
+end

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

@@ -0,0 +1,4 @@
+# used for OracleSynonymTest, see test/synonym_test_oci.rb
+#
+class Subject < ActiveRecord::Base
+end

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

@@ -0,0 +1,8 @@
+class Subscriber < ActiveRecord::Base
+  set_primary_key 'nick'
+  has_many :subscriptions
+  has_many :books, :through => :subscriptions
+end
+
+class SpecialSubscriber < Subscriber
+end

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

@@ -0,0 +1,4 @@
+class Subscription < ActiveRecord::Base
+  belongs_to :subscriber
+  belongs_to :book
+end

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

@@ -0,0 +1,7 @@
+class Tag < ActiveRecord::Base
+  has_many :taggings
+  has_many :taggables, :through => :taggings
+  has_one  :tagging
+
+  has_many :tagged_posts, :through => :taggings, :source => :taggable, :source_type => 'Post'
+end

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

@@ -0,0 +1,10 @@
+# test that attr_readonly isn't called on the :taggable polymorphic association
+module Taggable
+end
+
+class Tagging < ActiveRecord::Base
+  belongs_to :tag, :include => :tagging
+  belongs_to :super_tag,   :class_name => 'Tag', :foreign_key => 'super_tag_id'
+  belongs_to :invalid_tag, :class_name => 'Tag', :foreign_key => 'tag_id'
+  belongs_to :taggable, :polymorphic => true, :counter_cache => true
+end

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

@@ -0,0 +1,3 @@
+class Task < ActiveRecord::Base
+
+end

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

@@ -0,0 +1,65 @@
+class Topic < ActiveRecord::Base
+  named_scope :base
+  named_scope :written_before, lambda { |time|
+    { :conditions => ['written_on < ?', time] }
+  }
+  named_scope :approved, :conditions => {:approved => true}
+  named_scope :replied, :conditions => ['replies_count > 0']
+  named_scope :anonymous_extension do
+    def one
+      1
+    end
+  end
+  module NamedExtension
+    def two
+      2
+    end
+  end
+  module MultipleExtensionOne
+    def extension_one
+      1
+    end
+  end
+  module MultipleExtensionTwo
+    def extension_two
+      2
+    end
+  end
+  named_scope :named_extension, :extend => NamedExtension
+  named_scope :multiple_extensions, :extend => [MultipleExtensionTwo, MultipleExtensionOne]
+
+  has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
+  serialize :content
+
+  before_create  :default_written_on
+  before_destroy :destroy_children
+
+  def parent
+    Topic.find(parent_id)
+  end
+
+  # trivial method for testing Array#to_xml with :methods
+  def topic_id
+    id
+  end
+
+  protected
+    def approved=(val)
+      @custom_approved = val
+      write_attribute(:approved, val)
+    end
+
+    def default_written_on
+      self.written_on = Time.now unless attribute_present?("written_on")
+    end
+
+    def destroy_children
+      self.class.delete_all "parent_id = #{id}"
+    end
+
+    def after_initialize
+      if self.new_record?
+        self.author_email_address = 'test@test.com'
+      end
+    end
+end

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

@@ -0,0 +1,6 @@
+class Treasure < ActiveRecord::Base
+  has_and_belongs_to_many :parrots
+  belongs_to :looter, :polymorphic => true
+
+  has_many :price_estimates, :as => :estimate_of
+end

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

@@ -0,0 +1,9 @@
+# This class models a vertex in a directed graph.
+class Vertex < ActiveRecord::Base
+  has_many :sink_edges, :class_name => 'Edge', :foreign_key => 'source_id'
+  has_many :sinks, :through => :sink_edges
+
+  has_and_belongs_to_many :sources,
+    :class_name => 'Vertex', :join_table => 'edges',
+    :foreign_key => 'sink_id', :association_foreign_key => 'source_id'
+end

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

@@ -0,0 +1,5 @@
+class WarehouseThing < ActiveRecord::Base
+  set_table_name "warehouse-things"
+
+  validates_uniqueness_of :value
+end