ibm_db 3.0.0-x86-mingw32 → 3.0.1-x86-mingw32

data/test/models/price_estimate.rb

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

data/test/models/professor.rb

@@ -0,0 +1,5 @@
+require_dependency 'models/arunit2_model'
+
+class Professor < ARUnit2Model
+  has_and_belongs_to_many :courses
+end

data/test/models/project.rb

@@ -0,0 +1,29 @@
+class Project < ActiveRecord::Base
+  has_and_belongs_to_many :developers, -> { distinct.order 'developers.name desc, developers.id desc' }
+  has_and_belongs_to_many :readonly_developers, -> { readonly }, :class_name => "Developer"
+  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, -> { limit 1 }, :class_name => "Developer"
+  has_and_belongs_to_many :developers_named_david, -> { where("name = 'David'").distinct }, :class_name => "Developer"
+  has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(:name => 'David').distinct }, :class_name => "Developer"
+  has_and_belongs_to_many :salaried_developers, -> { where "salary > 0" }, :class_name => "Developer"
+  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, -> { group("developers.salary").having("SUM(salary) > 10000").select("SUM(salary) as salary") }, :class_name => "Developer"
+
+  attr_accessor :developers_log
+  after_initialize :set_developers_log
+
+  def set_developers_log
+    @developers_log = []
+  end
+
+  def self.all_as_method
+    all
+  end
+  scope :all_as_scope, -> { all }
+end
+
+class SpecialProject < Project
+end

data/test/models/publisher.rb

@@ -0,0 +1,2 @@
+module Publisher
+end

data/test/models/publisher/article.rb

@@ -0,0 +1,4 @@
+class Publisher::Article < ActiveRecord::Base
+  has_and_belongs_to_many :magazines
+  has_and_belongs_to_many :tags
+end

data/test/models/publisher/magazine.rb

@@ -0,0 +1,3 @@
+class Publisher::Magazine < ActiveRecord::Base
+  has_and_belongs_to_many :articles
+end

data/test/models/randomly_named_c1.rb

@@ -0,0 +1,3 @@
+class ClassNameThatDoesNotFollowCONVENTIONS < ActiveRecord::Base
+  self.table_name = :randomly_named_table
+end

data/test/models/rating.rb

@@ -0,0 +1,4 @@
+class Rating < ActiveRecord::Base
+  belongs_to :comment
+  has_many :taggings, :as => :taggable
+end

data/test/models/reader.rb

@@ -0,0 +1,23 @@
+class Reader < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :person, :inverse_of => :readers
+  belongs_to :single_person, :class_name => 'Person', :foreign_key => :person_id, :inverse_of => :reader
+  belongs_to :first_post, -> { where(id: [2, 3]) }
+end
+
+class SecureReader < ActiveRecord::Base
+  self.table_name = "readers"
+
+  belongs_to :secure_post, :class_name => "Post", :foreign_key => "post_id"
+  belongs_to :secure_person, :inverse_of => :secure_readers, :class_name => "Person", :foreign_key => "person_id"
+end
+
+class LazyReader < ActiveRecord::Base
+  self.table_name = "readers"
+  default_scope -> { where(skimmer: true) }
+
+  scope :skimmers_or_not, -> { unscope(:where => :skimmer) }
+
+  belongs_to :post
+  belongs_to :person
+end

data/test/models/record.rb

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

data/test/models/reference.rb

@@ -0,0 +1,22 @@
+class Reference < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :job
+
+  has_many :agents_posts_authors, :through => :person
+
+  class << self; attr_accessor :make_comments; end
+  self.make_comments = false
+
+  before_destroy :make_comments
+
+  def make_comments
+    if self.class.make_comments
+      person.update comments: "Reference destroyed"
+    end
+  end
+end
+
+class BadReference < ActiveRecord::Base
+  self.table_name = 'references'
+  default_scope { where(:favourite => false) }
+end

data/test/models/reply.rb

@@ -0,0 +1,61 @@
+require 'models/topic'
+
+class Reply < Topic
+  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"
+end
+
+class UniqueReply < Reply
+  belongs_to :topic, :foreign_key => 'parent_id', :counter_cache => true
+  validates_uniqueness_of :content, :scope => 'parent_id'
+end
+
+class SillyUniqueReply < UniqueReply
+end
+
+class WrongReply < Reply
+  validate :errors_on_empty_content
+  validate :title_is_wrong_create, :on => :create
+
+  validate :check_empty_title
+  validate :check_content_mismatch, :on => :create
+  validate :check_wrong_update, :on => :update
+  validate :check_author_name_is_secret, :on => :special_case
+
+  def check_empty_title
+    errors[:title] << "Empty" unless attribute_present?("title")
+  end
+
+  def errors_on_empty_content
+    errors[:content] << "Empty" unless attribute_present?("content")
+  end
+
+  def check_content_mismatch
+    if attribute_present?("title") && attribute_present?("content") && content == "Mismatch"
+      errors[:title] << "is Content Mismatch"
+    end
+  end
+
+  def title_is_wrong_create
+    errors[:title] << "is Wrong Create" if attribute_present?("title") && title == "Wrong Create"
+  end
+
+  def check_wrong_update
+    errors[:title] << "is Wrong Update" if attribute_present?("title") && title == "Wrong Update"
+  end
+
+  def check_author_name_is_secret
+    errors[:author_name] << "Invalid" unless author_name == "secret"
+  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

data/test/models/ship.rb

@@ -0,0 +1,33 @@
+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'
+  has_many :treasures
+
+  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
+
+class ShipWithoutNestedAttributes < ActiveRecord::Base
+  self.table_name = "ships"
+  has_many :parts, class_name: "ShipPart", foreign_key: :ship_id
+
+  validates :name, presence: true
+end
+
+class FamousShip < ActiveRecord::Base
+  self.table_name = 'ships'
+  belongs_to :famous_pirate
+  validates_presence_of :name, on: :conference
+end

data/test/models/ship_part.rb

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

data/test/models/shop.rb

@@ -0,0 +1,17 @@
+module Shop
+  class Collection < ActiveRecord::Base
+    has_many :products, :dependent => :nullify
+  end
+
+  class Product < ActiveRecord::Base
+    has_many :variants, :dependent => :delete_all
+    belongs_to :type
+
+    class Type < ActiveRecord::Base
+      has_many :products
+    end
+  end
+
+  class Variant < ActiveRecord::Base
+  end
+end

data/test/models/shop_account.rb

@@ -0,0 +1,6 @@
+class ShopAccount < ActiveRecord::Base
+  belongs_to :customer
+  belongs_to :customer_carrier
+
+  has_one :carrier, through: :customer_carrier
+end

data/test/models/speedometer.rb

@@ -0,0 +1,6 @@
+class Speedometer < ActiveRecord::Base
+  self.primary_key = :speedometer_id
+  belongs_to :dashboard
+
+  has_many :minivans
+end

data/test/models/sponsor.rb

@@ -0,0 +1,7 @@
+class Sponsor < ActiveRecord::Base
+  belongs_to :sponsor_club, :class_name => "Club", :foreign_key => "club_id"
+  belongs_to :sponsorable, :polymorphic => true
+  belongs_to :thing, :polymorphic => true, :foreign_type => :sponsorable_type, :foreign_key => :sponsorable_id
+  belongs_to :sponsorable_with_conditions, -> { where :name => 'Ernie'}, :polymorphic => true,
+             :foreign_type => 'sponsorable_type', :foreign_key => 'sponsorable_id'
+end

data/test/models/string_key_object.rb

@@ -0,0 +1,3 @@
+class StringKeyObject < ActiveRecord::Base
+  self.primary_key = :id
+end

data/test/models/student.rb

@@ -0,0 +1,4 @@
+class Student < ActiveRecord::Base
+  has_and_belongs_to_many :lessons
+  belongs_to :college
+end

data/test/models/subject.rb

@@ -0,0 +1,16 @@
+# used for OracleSynonymTest, see test/synonym_test_oracle.rb
+#
+class Subject < ActiveRecord::Base
+
+  # added initialization of author_email_address in the same way as in Topic class
+  # as otherwise synonym test was failing
+  after_initialize :set_email_address
+
+  protected
+    def set_email_address
+      unless self.persisted?
+        self.author_email_address = 'test@test.com'
+      end
+    end
+
+end

data/test/models/subscriber.rb

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

data/test/models/subscription.rb

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

data/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

data/test/models/tagging.rb

@@ -0,0 +1,13 @@
+# test that attr_readonly isn't called on the :taggable polymorphic association
+module Taggable
+end
+
+class Tagging < ActiveRecord::Base
+  belongs_to :tag, -> { includes(: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 :blue_tag, -> { where :tags => { :name => 'Blue' } }, :class_name => 'Tag', :foreign_key => :tag_id
+  belongs_to :tag_with_primary_key, :class_name => 'Tag', :foreign_key => :tag_id, :primary_key => :custom_primary_key
+  belongs_to :taggable, :polymorphic => true, :counter_cache => :tags_count
+  has_many :things, :through => :taggable
+end

data/test/models/task.rb

@@ -0,0 +1,5 @@
+class Task < ActiveRecord::Base
+  def updated_at
+    ending
+  end
+end

data/test/models/topic.rb

@@ -0,0 +1,124 @@
+class Topic < ActiveRecord::Base
+  scope :base, -> { all }
+  scope :written_before, lambda { |time|
+    if time
+      where 'written_on < ?', time
+    end
+  }
+  scope :approved, -> { where(:approved => true) }
+  scope :rejected, -> { where(:approved => false) }
+
+  scope :scope_with_lambda, lambda { all }
+
+  scope :by_lifo, -> { where(:author_name => 'lifo') }
+  scope :replied, -> { where 'replies_count > 0' }
+
+  scope 'approved_as_string', -> { where(:approved => true) }
+  scope :anonymous_extension, -> { all } do
+    def one
+      1
+    end
+  end
+
+  scope :with_object, Class.new(Struct.new(:klass)) {
+    def call
+      klass.where(:approved => true)
+    end
+  }.new(self)
+
+  module NamedExtension
+    def two
+      2
+    end
+  end
+
+  has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
+  has_many :approved_replies, -> { approved }, class_name: 'Reply', foreign_key: "parent_id", counter_cache: 'replies_count'
+
+  has_many :unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
+  has_many :silly_unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
+
+  serialize :content
+
+  before_create  :default_written_on
+  before_destroy :destroy_children
+
+  # Explicitly define as :date column so that returned Oracle DATE values would be typecasted to Date and not Time.
+  # Some tests depend on assumption that this attribute will have Date values.
+  if current_adapter?(:OracleEnhancedAdapter)
+    set_date_columns :last_read
+  end
+
+  def parent
+    Topic.find(parent_id)
+  end
+
+  # trivial method for testing Array#to_xml with :methods
+  def topic_id
+    id
+  end
+
+  alias_attribute :heading, :title
+
+  before_validation :before_validation_for_transaction
+  before_save :before_save_for_transaction
+  before_destroy :before_destroy_for_transaction
+
+  after_save :after_save_for_transaction
+  after_create :after_create_for_transaction
+
+  after_initialize :set_email_address
+
+  class_attribute :after_initialize_called
+  after_initialize do
+    self.class.after_initialize_called = true
+  end
+
+  def approved=(val)
+    @custom_approved = val
+    write_attribute(:approved, val)
+  end
+
+  protected
+
+    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 set_email_address
+      unless self.persisted?
+        self.author_email_address = 'test@test.com'
+      end
+    end
+
+    def before_validation_for_transaction; end
+    def before_save_for_transaction; end
+    def before_destroy_for_transaction; end
+    def after_save_for_transaction; end
+    def after_create_for_transaction; end
+end
+
+class ImportantTopic < Topic
+  serialize :important, Hash
+end
+
+class DefaultRejectedTopic < Topic
+  default_scope -> { where(approved: false) }
+end
+
+class BlankTopic < Topic
+  # declared here to make sure that dynamic finder with a bang can find a model that responds to `blank?`
+  def blank?
+    true
+  end
+end
+
+module Web
+  class Topic < ActiveRecord::Base
+    has_many :replies, :dependent => :destroy, :foreign_key => "parent_id", :class_name => 'Web::Reply'
+  end
+end