ibm_db 5.6.1-arm64-darwin-24

data/test/models/professor.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "models/arunit2_model"
+
+class Professor < ARUnit2Model
+  has_and_belongs_to_many :courses
+end

data/test/models/project.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Project < ActiveRecord::Base
+  belongs_to :mentor
+  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_paid_salary_groups, -> { group("developers.salary").having("SUM(salary) > 10000").select("SUM(salary) as salary") }, class_name: "Developer"
+  belongs_to :firm
+  has_one :lead_developer, through: :firm, inverse_of: :contracted_projects
+
+  begin
+    previous_value, ActiveRecord::Base.belongs_to_required_by_default =
+      ActiveRecord::Base.belongs_to_required_by_default, true
+    has_and_belongs_to_many :developers_required_by_default, class_name: "Developer"
+  ensure
+    ActiveRecord::Base.belongs_to_required_by_default = previous_value
+  end
+
+  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/article.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+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,5 @@
+# frozen_string_literal: true
+
+class Publisher::Magazine < ActiveRecord::Base
+  has_and_belongs_to_many :articles
+end

data/test/models/publisher.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Publisher
+end

data/test/models/randomly_named_c1.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ClassNameThatDoesNotFollowCONVENTIONS < ActiveRecord::Base
+  self.table_name = :randomly_named_table1
+end

data/test/models/rating.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Rating < ActiveRecord::Base
+  belongs_to :comment
+  has_many :taggings, as: :taggable
+  has_many :taggings_without_tag, -> { left_joins(:tag).where("tags.id": [nil, 0]) }, as: :taggable, class_name: "Tagging"
+  has_many :taggings_with_no_tag, -> { joins("LEFT OUTER JOIN tags ON tags.id = taggings.tag_id").where("tags.id": nil) }, as: :taggable, class_name: "Tagging"
+end

data/test/models/reader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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/recipe.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Recipe < ActiveRecord::Base
+  belongs_to :chef
+end

data/test/models/record.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Record < ActiveRecord::Base
+end

data/test/models/reference.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Reference < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :job
+
+  has_many :ideal_jobs, class_name: "Job", foreign_key: :ideal_reference_id
+  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,79 @@
+# frozen_string_literal: true
+
+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", touch: true
+  has_many :replies, class_name: "SillyReply", dependent: :destroy, foreign_key: "parent_id"
+  has_many :silly_unique_replies, dependent: :destroy, foreign_key: "parent_id"
+
+  scope :ordered, -> { Reply.order(:id) }
+
+  alias_attribute :new_content, :content
+  alias_attribute :new_parent_id, :parent_id
+
+  # Method on Kernel
+  def self.open
+    approved
+  end
+
+  # Methods both on Kernel and Relation
+  def self.load(data:); end
+  def self.select(data:); end
+end
+
+class SillyReply < Topic
+  belongs_to :reply, foreign_key: "parent_id", counter_cache: :replies_count
+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
+  validates :content, uniqueness: true
+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.add(:title, "Empty") unless attribute_present?("title")
+  end
+
+  def errors_on_empty_content
+    errors.add(:content, "Empty") unless attribute_present?("content")
+  end
+
+  def check_content_mismatch
+    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 check_wrong_update
+    errors.add(:title, "is Wrong Update") if attribute_present?("title") && title == "Wrong Update"
+  end
+
+  def check_author_name_is_secret
+    errors.add(:author_name, "Invalid") unless author_name == "secret"
+  end
+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/room.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Room < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :owner, class_name: "User"
+end

data/test/models/section.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Section < ActiveRecord::Base
+  belongs_to :session, inverse_of: :sections, autosave: true
+  belongs_to :seminar, inverse_of: :sections, autosave: true
+end

data/test/models/seminar.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Seminar < ActiveRecord::Base
+  has_many :sections, inverse_of: :seminar, autosave: true, dependent: :destroy
+  has_many :sessions, through: :sections
+end

data/test/models/session.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Session < ActiveRecord::Base
+  has_many :sections, inverse_of: :session, autosave: true, dependent: :destroy
+  has_many :seminars, through: :sections
+end

data/test/models/ship.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Ship < ActiveRecord::Base
+  self.record_timestamps = false
+
+  belongs_to :pirate
+  belongs_to :update_only_pirate, class_name: "Pirate"
+  belongs_to :developer, dependent: :destroy
+  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(&: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
+    throw(:abort)
+  end
+end
+
+class ShipWithoutNestedAttributes < ActiveRecord::Base
+  self.table_name = "ships"
+  has_many :prisoners, inverse_of: :ship, foreign_key: :ship_id
+  has_many :parts, class_name: "ShipPart", foreign_key: :ship_id
+
+  validates :name, presence: true, if: -> { true }
+  validates :name, presence: true, if: -> { true }
+end
+
+class Prisoner < ActiveRecord::Base
+  belongs_to :ship, autosave: true, class_name: "ShipWithoutNestedAttributes", inverse_of: :prisoners
+end
+
+class FamousShip < ActiveRecord::Base
+  self.table_name = "ships"
+  belongs_to :famous_pirate, foreign_key: :pirate_id
+  validates_presence_of :name, on: :conference
+end

data/test/models/ship_part.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+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,19 @@
+# frozen_string_literal: true
+
+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,8 @@
+# frozen_string_literal: true
+
+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,8 @@
+# frozen_string_literal: true
+
+class Speedometer < ActiveRecord::Base
+  self.primary_key = :speedometer_id
+  belongs_to :dashboard
+
+  has_many :minivans
+end

data/test/models/sponsor.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Sponsor < ActiveRecord::Base
+  belongs_to :sponsor_club, class_name: "Club", foreign_key: "club_id"
+  belongs_to :sponsorable, polymorphic: true
+  belongs_to :sponsor, 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/squeak.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Squeak < ActiveRecord::Base
+  belongs_to :mouse
+  accepts_nested_attributes_for :mouse
+end

data/test/models/strict_zine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "models/zine"
+
+class StrictZine < Zine
+  self.strict_loading_by_default = true
+end

data/test/models/string_key_object.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class StringKeyObject < ActiveRecord::Base
+  self.primary_key = :id
+end

data/test/models/student.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+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,10 @@
+# frozen_string_literal: true
+
+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,8 @@
+# frozen_string_literal: true
+
+class Subscription < ActiveRecord::Base
+  belongs_to :subscriber, counter_cache: :books_count
+  belongs_to :book
+
+  validates_presence_of :subscriber_id, :book_id
+end

data/test/models/tag.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+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
+
+class OrderedTag < Tag
+  self.table_name = "tags"
+
+  has_many :ordered_taggings, -> { order("taggings.id DESC") }, foreign_key: "tag_id", class_name: "Tagging"
+  has_many :tagged_posts, through: :ordered_taggings, source: "taggable", source_type: "Post"
+end

data/test/models/tagging.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# 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 :ordered_tag, class_name: "OrderedTag", 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
+
+class IndestructibleTagging < Tagging
+  before_destroy { throw :abort }
+end

data/test/models/task.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Task < ActiveRecord::Base
+  def updated_at
+    ending
+  end
+end

data/test/models/topic.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+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 :true, -> { where(approved: true) }
+  scope :false, -> { where(approved: false) }
+
+  scope :children, -> { where.not(parent_id: nil) }
+  scope :has_children, -> { where(id: Topic.children.select(:parent_id)) }
+
+  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, -> { } do
+    def one
+      1
+    end
+  end
+
+  scope :scope_stats, -> stats { stats[:count] = count; self }
+
+  def self.klass_stats(stats); stats[:count] = count; self; end
+
+  scope :with_object, Class.new(Struct.new(:klass)) {
+    def call
+      klass.where(approved: true)
+    end
+  }.new(self)
+
+  scope :with_kwargs, ->(approved: false) { where(approved: approved) }
+
+  module NamedExtension
+    def two
+      2
+    end
+  end
+
+  has_many :replies, dependent: :destroy, foreign_key: "parent_id", autosave: true
+  has_many :approved_replies, -> { approved }, class_name: "Reply", foreign_key: "parent_id", counter_cache: "replies_count"
+  has_many :open_replies, -> { open }, class_name: "Reply", foreign_key: "parent_id"
+
+  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
+
+  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
+
+  attr_accessor :change_approved_before_save
+  before_save :change_approved_callback
+
+  class_attribute :after_initialize_called
+  after_initialize do
+    self.class.after_initialize_called = true
+  end
+
+  attr_accessor :after_touch_called
+
+  after_initialize do
+    self.after_touch_called = 0
+  end
+
+  after_touch do
+    self.after_touch_called += 1
+  end
+
+  def approved=(val)
+    @custom_approved = val
+    write_attribute(:approved, val)
+  end
+
+  def self.nested_scoping(scope)
+    scope.base
+  end
+
+  private
+    def default_written_on
+      self.written_on = Time.now unless attribute_present?("written_on")
+    end
+
+    def destroy_children
+      self.class.delete_by(parent_id: id)
+    end
+
+    def set_email_address
+      unless persisted? || will_save_change_to_author_email_address?
+        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
+
+    def change_approved_callback
+      self.approved = change_approved_before_save unless change_approved_before_save.nil?
+    end
+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
+
+class TitlePrimaryKeyTopic < Topic
+  self.primary_key = :title
+end
+
+module Web
+  class Topic < ActiveRecord::Base
+    has_many :replies, dependent: :destroy, foreign_key: "parent_id", class_name: "Web::Reply"
+  end
+end

data/test/models/toy.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Toy < ActiveRecord::Base
+  self.primary_key = :toy_id
+  belongs_to :pet
+
+  has_many :sponsors, as: :sponsorable, inverse_of: :sponsorable
+
+  scope :with_pet, -> { joins(:pet) }
+end

data/test/models/traffic_light.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class TrafficLight < ActiveRecord::Base
+  serialize :state, Array
+  serialize :long_state, Array
+end