usher 0.7.0 → 0.7.1

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/migrations/valid/3_innocent_jointable.rb

@@ -1,12 +0,0 @@
-class InnocentJointable < ActiveRecord::Migration
-  def self.up
-    create_table("people_reminders", :id => false) do |t|
-      t.column :reminder_id, :integer
-      t.column :person_id, :integer
-    end
-  end
-
-  def self.down
-    drop_table "people_reminders"
-  end
-end

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/author.rb

@@ -1,145 +0,0 @@
-class Author < ActiveRecord::Base
-  has_many :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_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
-
-  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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/auto_id.rb

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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/binary.rb

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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/bird.rb

@@ -1,3 +0,0 @@
-class Bird < ActiveRecord::Base
-  validates_presence_of :name
-end

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/book.rb

@@ -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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/categorization.rb

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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/category.rb

@@ -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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/citation.rb

@@ -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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/club.rb

@@ -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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/column_name.rb

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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/comment.rb

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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/company.rb

@@ -1,159 +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"
-
-  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_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 :deletable_account, :foreign_key => "firm_id", :class_name => "Account", :dependent => :delete
-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
-
-  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

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/test/models/company_in_module.rb

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