Andreas/tracks
1
0
Fork 0
mirror of https://github.com/TracksApp/tracks.git synced 2026-02-21 22:54:09 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

unfreeze rails 2.3.9

Browse source
This commit is contained in:
Reinier Balt 2011-02-04 16:35:00 +01:00
parent 6443adac78
commit dea6dbe4da
1916 changed files with 0 additions and 240923 deletions
Download patch file Download diff file Expand all files Collapse all files

151
vendor/rails/activerecord/test/models/author.rb vendored
View file

@ -1,151 +0,0 @@
class Author < ActiveRecord::Base
has_many :posts
has_many :very_special_comments, :through => :posts
has_many :posts_with_comments, :include => :comments, :class_name => "Post"
has_many :popular_grouped_posts, :include => :comments, :class_name => "Post", :group => "type", :having => "SUM(comments_count) > 1", :select => "type"
has_many :posts_with_comments_sorted_by_comment_id, :include => :comments, :class_name => "Post", :order => 'comments.id'
has_many :posts_sorted_by_id_limited, :class_name => "Post", :order => 'posts.id', :limit => 1
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_one :post_about_thinking, :class_name => 'Post', :conditions => "posts.title like '%thinking%'"
has_one :post_about_thinking_with_last_comment, :class_name => 'Post', :conditions => "posts.title like '%thinking%'", :include => :last_comment
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 :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
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 :sti_posts, :class_name => 'StiPost'
has_many :sti_post_comments, :through => :sti_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
has_many :event_authors
has_many :events, :through => :event_authors
has_one :essay, :primary_key => :name, :as => :writer
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
validates_presence_of :name
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

4
vendor/rails/activerecord/test/models/auto_id.rb vendored
View file

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

2
vendor/rails/activerecord/test/models/binary.rb vendored
View file

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

9
vendor/rails/activerecord/test/models/bird.rb vendored
View file

@ -1,9 +0,0 @@
class Bird < ActiveRecord::Base
validates_presence_of :name
attr_accessor :cancel_save_from_callback
before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
def cancel_save_callback_method
false
end
end

4
vendor/rails/activerecord/test/models/book.rb vendored
View file

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

5
vendor/rails/activerecord/test/models/categorization.rb vendored
View file

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

34
vendor/rails/activerecord/test/models/category.rb vendored
View file

@ -1,34 +0,0 @@
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 :posts_with_authors_sorted_by_author_id, :class_name => "Post", :include => :authors, :order => "authors.id"
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' }
has_and_belongs_to_many :popular_grouped_posts, :class_name => "Post", :group => "posts.type", :having => "sum(comments.post_id) > 2", :include => :comments
has_and_belongs_to_many :posts_gruoped_by_title, :class_name => "Post", :group => "title", :select => "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

6
vendor/rails/activerecord/test/models/citation.rb vendored
View file

@ -1,6 +0,0 @@
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

13
vendor/rails/activerecord/test/models/club.rb vendored
View file

@ -1,13 +0,0 @@
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"
private
def private_method
"I'm sorry sir, this is a *private* club, not a *pirate* club"
end
end

3
vendor/rails/activerecord/test/models/column_name.rb vendored
View file

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

29
vendor/rails/activerecord/test/models/comment.rb vendored
View file

@ -1,29 +0,0 @@
class Comment < ActiveRecord::Base
named_scope :containing_the_letter_e, :conditions => "comments.body LIKE '%e%'"
named_scope :for_first_post, :conditions => { :post_id => 1 }
named_scope :for_first_author,
:joins => :post,
:conditions => { "posts.author_id" => 1 }
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

171
vendor/rails/activerecord/test/models/company.rb vendored
View file

@ -1,171 +0,0 @@
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"
has_many :contracts
has_many :developers, :through => :contracts
def arbitrary_method
"I am Jack's profound disappointment"
end
private
def private_method
"I am Jack's innermost fears and aspirations"
end
end
module Namespaced
class Company < ::Company
end
class Firm < ::Company
has_many :clients, :class_name => 'Namespaced::Client'
end
class Client < ::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 :unsorted_clients, :class_name => "Client"
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 :unvalidated_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :validate => false
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_many :clients_using_primary_key, :class_name => 'Client',
:primary_key => 'name', :foreign_key => 'firm_name'
has_many :clients_using_primary_key_with_delete_all, :class_name => 'Client',
:primary_key => 'name', :foreign_key => 'firm_name', :dependent => :delete_all
has_many :clients_grouped_by_firm_id, :class_name => "Client", :group => "firm_id", :select => "firm_id"
has_many :clients_grouped_by_name, :class_name => "Client", :group => "name", :select => "name"
has_one :account, :foreign_key => "firm_id", :dependent => :destroy, :validate => true
has_one :unvalidated_account, :foreign_key => "firm_id", :class_name => 'Account', :validate => false
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
has_one :account_using_primary_key, :primary_key => "firm_id", :class_name => "Account"
has_one :account_using_foreign_and_primary_keys, :foreign_key => "firm_name", :primary_key => "name", :class_name => "Account"
has_one :deletable_account, :foreign_key => "firm_id", :class_name => "Account", :dependent => :delete
has_one :account_limit_500_with_hash_conditions, :foreign_key => "firm_id", :class_name => "Account", :conditions => { :credit_limit => 500 }
has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
has_many :accounts
has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
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 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
# 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
class << self
private
def private_method
"darkness"
end
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
class VerySpecialClient < SpecialClient
end
class Account < ActiveRecord::Base
belongs_to :firm
belongs_to :unautosaved_firm, :foreign_key => "firm_id", :class_name => "Firm", :autosave => false
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
private
def private_method
"Sir, yes sir!"
end
end

78
vendor/rails/activerecord/test/models/company_in_module.rb vendored
View file

@ -1,78 +0,0 @@
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, :class_name => 'MyApplication::Billing::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
module Prefixed
def self.table_name_prefix
'prefixed_'
end
class Company < ActiveRecord::Base
end
class Firm < Company
self.table_name = 'companies'
end
module Nested
class Company < ActiveRecord::Base
end
end
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

3
vendor/rails/activerecord/test/models/computer.rb vendored
View file

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

16
vendor/rails/activerecord/test/models/contact.rb vendored
View file

@ -1,16 +0,0 @@
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

5
vendor/rails/activerecord/test/models/contract.rb vendored
View file

@ -1,5 +0,0 @@
class Contract < ActiveRecord::Base
belongs_to :company
belongs_to :developer
end

3
vendor/rails/activerecord/test/models/course.rb vendored
View file

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

73
vendor/rails/activerecord/test/models/customer.rb vendored
View file

@ -1,73 +0,0 @@
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), :converter => Proc.new { |balance| balance.to_money }
composed_of :gps_location, :allow_nil => true
composed_of :fullname, :mapping => %w(name to_s), :constructor => Proc.new { |name| Fullname.parse(name) }, :converter => :parse
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
class Fullname
attr_reader :first, :last
def self.parse(str)
return nil unless str
new(*str.to_s.split)
end
def initialize(first, last = nil)
@first, @last = first, last
end
def to_s
"#{first} #{last.upcase}"
end
end

2
vendor/rails/activerecord/test/models/default.rb vendored
View file

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

101
vendor/rails/activerecord/test/models/developer.rb vendored
View file

@ -1,101 +0,0 @@
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
named_scope :jamises, :conditions => {:name => 'Jamis'}
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, :validate => true
belongs_to :unvalidated_developer, :class_name => '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
class DeveloperOrderedBySalary < ActiveRecord::Base
self.table_name = 'developers'
default_scope :order => 'salary DESC'
named_scope :by_name, :order => 'name DESC'
def self.all_ordered_by_name
with_scope(:find => { :order => 'name DESC' }) do
find(:all)
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

5
vendor/rails/activerecord/test/models/edge.rb vendored
View file

@ -1,5 +0,0 @@
# 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

3
vendor/rails/activerecord/test/models/entrant.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/essay.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/event.rb vendored
View file

@ -1,3 +0,0 @@
class Event < ActiveRecord::Base
validates_uniqueness_of :title
end

8
vendor/rails/activerecord/test/models/event_author.rb vendored
View file

@ -1,8 +0,0 @@
require 'models/author'
require 'models/event'
class EventAuthor < ActiveRecord::Base
belongs_to :author
belongs_to :event
end

7
vendor/rails/activerecord/test/models/face.rb vendored
View file

@ -1,7 +0,0 @@
class Face < ActiveRecord::Base
belongs_to :man, :inverse_of => :face
belongs_to :polymorphic_man, :polymorphic => true, :inverse_of => :polymorphic_face
# These is a "broken" inverse_of for the purposes of testing
belongs_to :horrible_man, :class_name => 'Man', :inverse_of => :horrible_face
belongs_to :horrible_polymorphic_man, :polymorphic => true, :inverse_of => :horrible_polymorphic_face
end

2
vendor/rails/activerecord/test/models/guid.rb vendored
View file

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

5
vendor/rails/activerecord/test/models/interest.rb vendored
View file

@ -1,5 +0,0 @@
class Interest < ActiveRecord::Base
belongs_to :man, :inverse_of => :interests
belongs_to :polymorphic_man, :polymorphic => true, :inverse_of => :polymorphic_interests
belongs_to :zine, :inverse_of => :interests
end

4
vendor/rails/activerecord/test/models/invoice.rb vendored
View file

@ -1,4 +0,0 @@
class Invoice < ActiveRecord::Base
has_many :line_items, :autosave => true
before_save {|record| record.balance = record.line_items.map(&:amount).sum }
end

7
vendor/rails/activerecord/test/models/item.rb vendored
View file

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

5
vendor/rails/activerecord/test/models/job.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/joke.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/keyboard.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/legacy_thing.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/line_item.rb vendored
View file

@ -1,3 +0,0 @@
class LineItem < ActiveRecord::Base
belongs_to :invoice, :touch => true
end

9
vendor/rails/activerecord/test/models/man.rb vendored
View file

@ -1,9 +0,0 @@
class Man < ActiveRecord::Base
has_one :face, :inverse_of => :man
has_one :polymorphic_face, :class_name => 'Face', :as => :polymorphic_man, :inverse_of => :polymorphic_man
has_many :interests, :inverse_of => :man
has_many :polymorphic_interests, :class_name => 'Interest', :as => :polymorphic_man, :inverse_of => :polymorphic_man
# These are "broken" inverse_of associations for the purposes of testing
has_one :dirty_face, :class_name => 'Face', :inverse_of => :dirty_man
has_many :secret_interests, :class_name => 'Interest', :inverse_of => :secret_man
end

4
vendor/rails/activerecord/test/models/matey.rb vendored
View file

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

12
vendor/rails/activerecord/test/models/member.rb vendored
View file

@ -1,12 +0,0 @@
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
has_one :member_detail
has_one :organization, :through => :member_detail
belongs_to :member_type
end

5
vendor/rails/activerecord/test/models/member_detail.rb vendored
View file

@ -1,5 +0,0 @@
class MemberDetail < ActiveRecord::Base
belongs_to :member
belongs_to :organization
has_one :member_type, :through => :member
end

3
vendor/rails/activerecord/test/models/member_type.rb vendored
View file

@ -1,3 +0,0 @@
class MemberType < ActiveRecord::Base
has_many :members
end

9
vendor/rails/activerecord/test/models/membership.rb vendored
View file

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

2
vendor/rails/activerecord/test/models/minimalistic.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/mixed_case_monkey.rb vendored
View file

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

5
vendor/rails/activerecord/test/models/movie.rb vendored
View file

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

4
vendor/rails/activerecord/test/models/order.rb vendored
View file

@ -1,4 +0,0 @@
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

6
vendor/rails/activerecord/test/models/organization.rb vendored
View file

@ -1,6 +0,0 @@
class Organization < ActiveRecord::Base
has_many :member_details
has_many :members, :through => :member_details
named_scope :clubs, { :from => 'clubs' }
end

5
vendor/rails/activerecord/test/models/owner.rb vendored
View file

@ -1,5 +0,0 @@
class Owner < ActiveRecord::Base
set_primary_key :owner_id
has_many :pets
has_many :toys, :through => :pets
end

22
vendor/rails/activerecord/test/models/parrot.rb vendored
View file

@ -1,22 +0,0 @@
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
alias_attribute :title, :name
validates_presence_of :name
attr_accessor :cancel_save_from_callback
before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
def cancel_save_callback_method
false
end
end
class LiveParrot < Parrot
end
class DeadParrot < Parrot
belongs_to :killer, :class_name => 'Pirate'
end

16
vendor/rails/activerecord/test/models/person.rb vendored
View file

@ -1,16 +0,0 @@
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]
has_many :posts_with_comments_sorted_by_comment_id, :through => :readers, :source => :post, :include => :comments, :order => 'comments.id'
belongs_to :primary_contact, :class_name => 'Person'
has_many :agents, :class_name => 'Person', :foreign_key => 'primary_contact_id'
named_scope :males, :conditions => { :gender => 'M' }
named_scope :females, :conditions => { :gender => 'F' }
end

5
vendor/rails/activerecord/test/models/pet.rb vendored
View file

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

80
vendor/rails/activerecord/test/models/pirate.rb vendored
View file

@ -1,80 +0,0 @@
class Pirate < ActiveRecord::Base
belongs_to :parrot, :validate => true
belongs_to :non_validated_parrot, :class_name => 'Parrot'
has_and_belongs_to_many :parrots, :validate => true, :order => 'parrots.id ASC'
has_and_belongs_to_many :non_validated_parrots, :class_name => 'Parrot'
has_and_belongs_to_many :parrots_with_method_callbacks, :class_name => "Parrot",
:before_add => :log_before_add,
:after_add => :log_after_add,
:before_remove => :log_before_remove,
:after_remove => :log_after_remove
has_and_belongs_to_many :parrots_with_proc_callbacks, :class_name => "Parrot",
:before_add => proc {|p,pa| p.ship_log << "before_adding_proc_parrot_#{pa.id || '<new>'}"},
:after_add => proc {|p,pa| p.ship_log << "after_adding_proc_parrot_#{pa.id || '<new>'}"},
:before_remove => proc {|p,pa| p.ship_log << "before_removing_proc_parrot_#{pa.id}"},
:after_remove => proc {|p,pa| p.ship_log << "after_removing_proc_parrot_#{pa.id}"}
has_many :treasures, :as => :looter
has_many :treasure_estimates, :through => :treasures, :source => :price_estimates
# These both have :autosave enabled because accepts_nested_attributes_for is used on them.
has_one :ship
has_one :update_only_ship, :class_name => 'Ship'
has_one :non_validated_ship, :class_name => 'Ship'
has_many :birds, :order => 'birds.id ASC'
has_many :birds_with_method_callbacks, :class_name => "Bird",
:before_add => :log_before_add,
:after_add => :log_after_add,
:before_remove => :log_before_remove,
:after_remove => :log_after_remove
has_many :birds_with_proc_callbacks, :class_name => "Bird",
:before_add => proc {|p,b| p.ship_log << "before_adding_proc_bird_#{b.id || '<new>'}"},
:after_add => proc {|p,b| p.ship_log << "after_adding_proc_bird_#{b.id || '<new>'}"},
:before_remove => proc {|p,b| p.ship_log << "before_removing_proc_bird_#{b.id}"},
:after_remove => proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
has_many :birds_with_reject_all_blank, :class_name => "Bird"
accepts_nested_attributes_for :parrots, :birds, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
accepts_nested_attributes_for :update_only_ship, :update_only => true
accepts_nested_attributes_for :parrots_with_method_callbacks, :parrots_with_proc_callbacks,
:birds_with_method_callbacks, :birds_with_proc_callbacks, :allow_destroy => true
accepts_nested_attributes_for :birds_with_reject_all_blank, :reject_if => :all_blank
validates_presence_of :catchphrase
def ship_log
@ship_log ||= []
end
def reject_empty_ships_on_create(attributes)
attributes.delete('_reject_me_if_new').present? && new_record?
end
attr_accessor :cancel_save_from_callback
before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
def cancel_save_callback_method
false
end
private
def log_before_add(record)
log(record, "before_adding_method")
end
def log_after_add(record)
log(record, "after_adding_method")
end
def log_before_remove(record)
log(record, "before_removing_method")
end
def log_after_remove(record)
log(record, "after_removing_method")
end
def log(record, callback)
ship_log << "#{callback}_#{record.class.name.downcase}_#{record.id || '<new>'}"
end
end

3
vendor/rails/activerecord/test/models/polymorphic_design.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/polymorphic_price.rb vendored
View file

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

102
vendor/rails/activerecord/test/models/post.rb vendored
View file

@ -1,102 +0,0 @@
class Post < ActiveRecord::Base
named_scope :with_type_self, lambda{{:conditions => ["type=?", self.name]}}
named_scope :containing_the_letter_a, :conditions => "body LIKE '%a%'"
named_scope :ranked_by_comments, :order => "comments_count DESC"
named_scope :limit, lambda {|limit| {:limit => limit} }
named_scope :with_authors_at_address, lambda { |address| {
:conditions => [ 'authors.author_address_id = ?', address.id ],
:joins => 'JOIN authors ON authors.id = posts.author_id'
}
}
belongs_to :author do
def greeting
"hello"
end
end
belongs_to :author_with_posts, :class_name => "Author", :foreign_key => :author_id, :include => :posts
belongs_to :author_with_address, :class_name => "Author", :foreign_key => :author_id, :include => :author_address
has_one :last_comment, :class_name => 'Comment', :order => 'id desc'
named_scope :with_special_comments, :joins => :comments, :conditions => {:comments => {:type => 'SpecialComment'} }
named_scope :with_very_special_comments, :joins => :comments, :conditions => {:comments => {:type => 'VerySpecialComment'} }
named_scope :with_post, lambda {|post_id|
{ :joins => :comments, :conditions => {:comments => {:post_id => post_id} } }
}
has_many :comments, :order => "body" do
def find_most_recent
find(:first, :order => "id DESC")
end
end
has_many :author_favorites, :through => :author
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 :misc_tags, :through => :taggings, :source => :tag, :conditions => "tags.name = 'Misc'"
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.top(limit)
ranked_by_comments.limit(limit)
end
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

3
vendor/rails/activerecord/test/models/price_estimate.rb vendored
View file

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

30
vendor/rails/activerecord/test/models/project.rb vendored
View file

@ -1,30 +0,0 @@
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} ORDER BY t.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}"}
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
def after_initialize
@developers_log = []
end
end
class SpecialProject < Project
def hello_world
"hello there!"
end
end

4
vendor/rails/activerecord/test/models/reader.rb vendored
View file

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

4
vendor/rails/activerecord/test/models/reference.rb vendored
View file

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

46
vendor/rails/activerecord/test/models/reply.rb vendored
View file

@ -1,46 +0,0 @@
require 'models/topic'
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, :parent_title
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
module Web
class Reply < Web::Topic
belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true, :class_name => 'Web::Topic'
end
end

19
vendor/rails/activerecord/test/models/ship.rb vendored
View file

@ -1,19 +0,0 @@
class Ship < ActiveRecord::Base
self.record_timestamps = false
belongs_to :pirate
belongs_to :update_only_pirate, :class_name => 'Pirate'
has_many :parts, :class_name => 'ShipPart'
accepts_nested_attributes_for :parts, :allow_destroy => true
accepts_nested_attributes_for :pirate, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
accepts_nested_attributes_for :update_only_pirate, :update_only => true
validates_presence_of :name
attr_accessor :cancel_save_from_callback
before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
def cancel_save_callback_method
false
end
end

7
vendor/rails/activerecord/test/models/ship_part.rb vendored
View file

@ -1,7 +0,0 @@
class ShipPart < ActiveRecord::Base
belongs_to :ship
has_many :trinkets, :class_name => "Treasure", :as => :looter
accepts_nested_attributes_for :trinkets, :allow_destroy => true
validates_presence_of :name
end

4
vendor/rails/activerecord/test/models/sponsor.rb vendored
View file

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

4
vendor/rails/activerecord/test/models/subject.rb vendored
View file

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

8
vendor/rails/activerecord/test/models/subscriber.rb vendored
View file

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

4
vendor/rails/activerecord/test/models/subscription.rb vendored
View file

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

7
vendor/rails/activerecord/test/models/tag.rb vendored
View file

@ -1,7 +0,0 @@
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

10
vendor/rails/activerecord/test/models/tagging.rb vendored
View file

@ -1,10 +0,0 @@
# 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

3
vendor/rails/activerecord/test/models/task.rb vendored
View file

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

4
vendor/rails/activerecord/test/models/tee.rb vendored
View file

@ -1,4 +0,0 @@
class Tee < ActiveRecord::Base
has_one :polymorphic_design, :as => :designable
has_one :polymorphic_price, :as => :sellable
end

4
vendor/rails/activerecord/test/models/tie.rb vendored
View file

@ -1,4 +0,0 @@
class Tie < ActiveRecord::Base
has_one :polymorphic_design, :as => :designable
has_one :polymorphic_price, :as => :sellable
end

80
vendor/rails/activerecord/test/models/topic.rb vendored
View file

@ -1,80 +0,0 @@
class Topic < ActiveRecord::Base
named_scope :base
named_scope :written_before, lambda { |time|
if time
{ :conditions => ['written_on < ?', time] }
end
}
named_scope :approved, :conditions => {:approved => true}
named_scope :rejected, :conditions => {:approved => false}
named_scope :by_lifo, :conditions => {:author_name => 'lifo'}
named_scope :approved_as_hash_condition, :conditions => {:topics => {:approved => true}}
named_scope 'approved_as_string', :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"
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
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
module Web
class Topic < ActiveRecord::Base
has_many :replies, :dependent => :destroy, :foreign_key => "parent_id", :class_name => 'Web::Reply'
end
end

6
vendor/rails/activerecord/test/models/toy.rb vendored
View file

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

8
vendor/rails/activerecord/test/models/treasure.rb vendored
View file

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

9
vendor/rails/activerecord/test/models/vertex.rb vendored
View file

@ -1,9 +0,0 @@
# 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

5
vendor/rails/activerecord/test/models/warehouse_thing.rb vendored
View file

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

3
vendor/rails/activerecord/test/models/zine.rb vendored
View file

@ -1,3 +0,0 @@
class Zine < ActiveRecord::Base
has_many :interests, :inverse_of => :zine
end