ibm_db 5.6.1-arm64-darwin-24

data/test/models/admin/user.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Admin::User < ActiveRecord::Base
+  class Coder
+    def initialize(default = {})
+      @default = default
+    end
+
+    def dump(o)
+      ActiveSupport::JSON.encode(o || @default)
+    end
+
+    def load(s)
+      s.present? ? ActiveSupport::JSON.decode(s) : @default.clone
+    end
+  end
+
+  belongs_to :account
+  store :params, accessors: [ :token ], coder: YAML
+  store :settings, accessors: [ :color, :homepage ]
+  store_accessor :settings, :favorite_food
+  store :parent, accessors: [:birthday, :name], prefix: true
+  store :spouse, accessors: [:birthday], prefix: :partner
+  store_accessor :spouse, :name, prefix: :partner
+  store :configs, accessors: [ :secret_question ]
+  store :configs, accessors: [ :two_factor_auth ], suffix: true
+  store_accessor :configs, :login_retry, suffix: :config
+  store :preferences, accessors: [ :remember_login ]
+  store :json_data, accessors: [ :height, :weight ], coder: Coder.new
+  store :json_data_empty, accessors: [ :is_a_good_guy ], coder: Coder.new
+
+  def phone_number
+    read_store_attribute(:settings, :phone_number).gsub(/(\d{3})(\d{3})(\d{4})/, '(\1) \2-\3')
+  end
+
+  def phone_number=(value)
+    write_store_attribute(:settings, :phone_number, value && value.gsub(/[^\d]/, ""))
+  end
+
+  def color
+    super || "red"
+  end
+
+  def color=(value)
+    value = "blue" unless %w(black red green blue).include?(value)
+    super
+  end
+end

data/test/models/admin.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Admin
+  def self.table_name_prefix
+    "admin_"
+  end
+end

data/test/models/aircraft.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Aircraft < ActiveRecord::Base
+  self.pluralize_table_names = false
+  has_many :engines, foreign_key: "car_id"
+  has_many :wheels, as: :wheelable
+end

data/test/models/arunit2_model.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ARUnit2Model < ActiveRecord::Base
+  self.abstract_class = true
+end

data/test/models/author.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+class Author < ActiveRecord::Base
+  has_many :posts
+  has_many :serialized_posts
+  has_one :post
+  has_many :very_special_comments, through: :posts
+  has_many :posts_with_comments, -> { includes(:comments) }, class_name: "Post"
+  has_many :popular_grouped_posts, -> { includes(:comments).group("type").having("SUM(legacy_comments_count) > 1").select("type") }, class_name: "Post"
+  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, class_name: "Post"
+  has_many :posts_sorted_by_id, -> { order(:id) }, class_name: "Post"
+  has_many :posts_sorted_by_id_limited, -> { order("posts.id").limit(1) }, class_name: "Post"
+  has_many :posts_with_categories, -> { includes(:categories) }, class_name: "Post"
+  has_many :posts_with_comments_and_categories, -> { includes(:comments, :categories).order("posts.id") }, class_name: "Post"
+  has_many :posts_with_special_categorizations, class_name: "PostWithSpecialCategorization"
+  has_one  :post_about_thinking, -> { where("posts.title like '%thinking%'") }, class_name: "Post"
+  has_one  :post_about_thinking_with_last_comment, -> { where("posts.title like '%thinking%'").includes(:last_comment) }, class_name: "Post"
+  has_many :comments, through: :posts do
+    def ratings
+      Rating.joins(:comment).merge(self)
+    end
+  end
+  has_many :comments_containing_the_letter_e, through: :posts, source: :comments
+  has_many :comments_with_order_and_conditions, -> { order("comments.body").where("comments.body like 'Thank%'") }, through: :posts, source: :comments
+  has_many :comments_with_include, -> { includes(:post).where(posts: { type: "Post" }) }, through: :posts, source: :comments
+  has_many :comments_for_first_author, -> { for_first_author }, through: :posts, source: :comments
+
+  has_many :first_posts
+  has_many :comments_on_first_posts, -> { order("posts.id desc, comments.id asc") }, through: :first_posts, source: :comments
+
+  has_one :first_post
+  has_one :comment_on_first_post, -> { order("posts.id desc, comments.id asc") }, through: :first_post, source: :comments
+
+  has_many :thinking_posts, -> { where(title: "So I was thinking") }, dependent: :delete_all, class_name: "Post"
+  has_many :welcome_posts, -> { where(title: "Welcome to the weblog") }, class_name: "Post"
+
+  has_many :welcome_posts_with_one_comment,
+           -> { where(title: "Welcome to the weblog").where(comments_count: 1) },
+           class_name: "Post"
+  has_many :welcome_posts_with_comments,
+           -> { where(title: "Welcome to the weblog").where("legacy_comments_count > 0") },
+           class_name: "Post"
+
+  has_many :comments_desc, -> { order("comments.id DESC") }, through: :posts_sorted_by_id, source: :comments
+  has_many :unordered_comments, -> { unscope(:order).distinct }, through: :posts_sorted_by_id_limited, source: :comments
+  has_many :funky_comments, through: :posts, source: :comments
+  has_many :ordered_uniq_comments, -> { distinct.order("comments.id") }, through: :posts, source: :comments
+  has_many :ordered_uniq_comments_desc, -> { distinct.order("comments.id DESC") }, through: :posts, source: :comments
+  has_many :readonly_comments, -> { readonly }, through: :posts, source: :comments
+
+  has_many :special_posts
+  has_many :special_post_comments, through: :special_posts, source: :comments
+  has_many :special_posts_with_default_scope, class_name: "SpecialPostWithDefaultScope"
+
+  has_many :sti_posts, class_name: "StiPost"
+  has_many :sti_post_comments, through: :sti_posts, source: :comments
+
+  has_many :special_nonexistent_posts, -> { where("posts.body = 'nonexistent'") }, class_name: "SpecialPost"
+  has_many :special_nonexistent_post_comments, -> { where("comments.post_id" => 0) }, through: :special_nonexistent_posts, source: :comments
+  has_many :nonexistent_comments, through: :posts
+
+  has_many :hello_posts, -> { where "posts.body = 'hello'" }, class_name: "Post"
+  has_many :hello_post_comments, through: :hello_posts, source: :comments
+  has_many :posts_with_no_comments, -> { where("comments.id" => nil).includes(:comments) }, class_name: "Post"
+  has_many :posts_with_no_comments_2, -> { left_joins(:comments).where("comments.id": nil) }, class_name: "Post"
+
+  has_many :hello_posts_with_hash_conditions, -> { where(body: "hello") }, class_name: "Post"
+  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_thrown_callbacks, class_name: "Post", before_add: :throw_abort,
+           after_add: :ensure_not_called,
+           before_remove: :throw_abort,
+           after_remove: :ensure_not_called
+  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 :unchangeable_posts, class_name: "Post", before_add: :raise_exception, after_add: :log_after_adding
+
+  has_many :categorizations, -> { }
+  has_many :categories, through: :categorizations
+  has_many :named_categories, through: :categorizations
+
+  has_many :special_categorizations
+  has_many :special_categories, through: :special_categorizations, source: :category
+  has_one  :special_category,   through: :special_categorizations, source: :category
+
+  has_many :general_categorizations, -> { joins(:category).where("categories.name": "General") }, class_name: "Categorization"
+  has_many :general_posts, through: :general_categorizations, source: :post
+
+  has_many :special_categories_with_conditions, -> { where(categorizations: { special: true }) }, through: :categorizations, source: :category
+  has_many :nonspecial_categories_with_conditions, -> { where(categorizations: { special: false }) }, through: :categorizations, source: :category
+
+  has_many :categories_like_general, -> { where(name: "General") }, through: :categorizations, source: :category, class_name: "Category"
+
+  has_many :categorized_posts, through: :categorizations, source: :post
+  has_many :unique_categorized_posts, -> { distinct }, through: :categorizations, source: :post
+
+  has_many :nothings, through: :kateggorisatons, class_name: "Category"
+
+  has_many :author_favorites
+  has_many :favorite_authors, -> { order("name") }, through: :author_favorites
+
+  has_many :taggings,        through: :posts, source: :taggings
+  has_many :taggings_2,      through: :posts, source: :tagging
+  has_many :tags,            through: :posts
+  has_many :ordered_tags,    through: :posts
+  has_many :post_categories, through: :posts, source: :categories
+  has_many :tagging_tags,    through: :taggings, source: :tag
+
+  has_many :similar_posts, -> { distinct }, through: :tags, source: :tagged_posts
+  has_many :ordered_posts, -> { distinct }, through: :ordered_tags, source: :tagged_posts
+  has_many :distinct_tags, -> { select("DISTINCT tags.*").order("tags.name") }, through: :posts, source: :tags
+
+  has_many :tags_with_primary_key, through: :posts
+
+  has_many :books
+  has_many :published_books, class_name: "PublishedBook"
+  has_many :unpublished_books, -> { where(status: [:proposed, :written]) }, class_name: "Book"
+  has_many :subscriptions,        through: :books
+  has_many :subscribers, -> { order("subscribers.nick") }, through: :subscriptions
+  has_many :distinct_subscribers, -> { select("DISTINCT subscribers.*").order("subscribers.nick") }, through: :subscriptions, source: :subscriber
+
+  has_one :essay, primary_key: :name, as: :writer
+  has_one :essay_category, through: :essay, source: :category
+  has_one :essay_owner, through: :essay, source: :owner
+
+  has_one :essay_2, primary_key: :name, class_name: "Essay", foreign_key: :author_id
+  has_one :essay_category_2, through: :essay_2, source: :category
+
+  has_many :essays, primary_key: :name, as: :writer
+  has_many :essay_categories, through: :essays, source: :category
+  has_many :essay_owners, through: :essays, source: :owner
+
+  has_many :essays_2, primary_key: :name, class_name: "Essay", foreign_key: :author_id
+  has_many :essay_categories_2, through: :essays_2, source: :category
+
+  belongs_to :owned_essay, primary_key: :name, class_name: "Essay"
+  has_one :owned_essay_category, through: :owned_essay, source: :category
+
+  belongs_to :author_address,       dependent: :destroy
+  belongs_to :author_address_extra, dependent: :delete, class_name: "AuthorAddress"
+
+  has_many :category_post_comments, through: :categories, source: :post_comments
+
+  has_many :misc_posts, -> { where(posts: { title: ["misc post by bob", "misc post by mary"] }) }, class_name: "Post"
+  has_many :misc_post_first_blue_tags, through: :misc_posts, source: :first_blue_tags
+
+  has_many :misc_post_first_blue_tags_2, -> { where(posts: { title: ["misc post by bob", "misc post by mary"] }) },
+           through: :posts, source: :first_blue_tags_2
+
+  has_many :posts_with_default_include, class_name: "PostWithDefaultInclude"
+  has_many :comments_on_posts_with_default_include, through: :posts_with_default_include, source: :comments
+
+  has_many :posts_with_signature, ->(record) { where("posts.title LIKE ?", "%by #{record.name.downcase}%") }, class_name: "Post"
+  has_many :posts_mentioning_author, ->(record = nil) { where("posts.body LIKE ?", "%#{record&.name&.downcase}%") }, class_name: "Post"
+
+  has_one :recent_post, -> { order(id: :desc) }, class_name: "Post"
+  has_one :recent_response, through: :recent_post, source: :comments
+
+  has_many :posts_with_extension, -> { order(:title) }, class_name: "Post" do
+    def extension_method; end
+  end
+
+  has_many :posts_with_extension_and_instance, ->(record) { order(:title) }, class_name: "Post" do
+    def extension_method; end
+  end
+
+  has_many :top_posts, -> { order(id: :asc) }, class_name: "Post"
+  has_many :other_top_posts, -> { order(id: :asc) }, class_name: "Post"
+
+  has_many :topics, primary_key: "name", foreign_key: "author_name"
+  has_many :topics_without_type, -> { select(:id, :title, :author_name) },
+    class_name: "Topic", primary_key: "name", foreign_key: "author_name"
+
+  has_many :lazy_readers_skimmers_or_not, through: :posts
+  has_many :lazy_readers_skimmers_or_not_2, through: :posts_with_no_comments, source: :lazy_readers_skimmers_or_not
+  has_many :lazy_readers_skimmers_or_not_3, through: :posts_with_no_comments_2, source: :lazy_readers_skimmers_or_not
+
+  attr_accessor :post_log
+  after_initialize :set_post_log
+
+  def set_post_log
+    @post_log = []
+  end
+
+  def label
+    "#{id}-#{name}"
+  end
+
+  def social
+    %w(twitter github)
+  end
+
+  validates_presence_of :name
+
+  private
+    def throw_abort(_)
+      throw(:abort)
+    end
+
+    def ensure_not_called(_)
+      raise
+    end
+
+    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 ||= []
+  end
+
+  before_destroy do |author_address|
+    AuthorAddress.destroyed_author_address_ids << author_address.id
+  end
+end
+
+class AuthorFavorite < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :favorite_author, class_name: "Author"
+end
+
+class AuthorFavoriteWithScope < ActiveRecord::Base
+  self.table_name = "author_favorites"
+
+  default_scope { order(id: :asc) }
+
+  belongs_to :author
+  belongs_to :favorite_author, class_name: "Author"
+end

data/test/models/auto_id.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class AutoId < ActiveRecord::Base
+  self.table_name = "auto_id_tests"
+  self.primary_key = "auto_id"
+end

data/test/models/autoloadable/extra_firm.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ExtraFirm < Company
+end

data/test/models/binary.rb

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

data/test/models/binary_field.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class BinaryField < ActiveRecord::Base
+  serialize :normal_blob
+  serialize :normal_text
+end

data/test/models/bird.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Bird < ActiveRecord::Base
+  belongs_to :pirate
+  validates_presence_of :name
+
+  accepts_nested_attributes_for :pirate
+
+  before_save do
+    # force materialize_transactions
+    self.class.connection.materialize_transactions
+  end
+
+  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
+
+  attr_accessor :total_count, :enable_count
+  after_initialize do
+    self.total_count = Bird.count if enable_count
+  end
+end

data/test/models/book.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Book < ActiveRecord::Base
+  belongs_to :author
+
+  has_many :citations, foreign_key: "book1_id", inverse_of: :book
+  has_many :references, -> { distinct }, through: :citations, source: :reference_of
+
+  has_many :subscriptions
+  has_many :subscribers, through: :subscriptions
+
+  enum status: [:proposed, :written, :published]
+  enum last_read: { unread: 0, reading: 2, read: 3, forgotten: nil }
+  enum nullable_status: [:single, :married]
+  enum language: [:english, :spanish, :french], _prefix: :in
+  enum author_visibility: [:visible, :invisible], _prefix: true
+  enum illustrator_visibility: [:visible, :invisible], _prefix: true
+  enum font_size: [:small, :medium, :large], _prefix: :with, _suffix: true
+  enum difficulty: [:easy, :medium, :hard], _suffix: :to_read
+  enum cover: { hard: "hard", soft: "soft" }
+  enum boolean_status: { enabled: true, disabled: false }
+
+  def published!
+    super
+    "do publish work..."
+  end
+end
+
+class PublishedBook < ActiveRecord::Base
+  self.table_name = "books"
+
+  validates_uniqueness_of :isbn
+end

data/test/models/book_destroy_async.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class BookDestroyAsync < ActiveRecord::Base
+  self.table_name = "books"
+
+  has_many :taggings, as: :taggable, class_name: "Tagging"
+  has_many :tags, through: :taggings, dependent: :destroy_async
+  has_many :essays, dependent: :destroy_async, class_name: "EssayDestroyAsync", foreign_key: "book_id"
+  has_one :content, dependent: :destroy_async
+
+  enum status: [:proposed, :written, :published]
+
+  def published!
+    super
+    "do publish work..."
+  end
+end
+
+class BookDestroyAsyncWithScopedTags < ActiveRecord::Base
+  self.table_name = "books"
+
+  has_many :taggings, as: :taggable, class_name: "Tagging"
+  has_many :tags, -> { where name: "Der be rum" }, through: :taggings, dependent: :destroy_async
+end

data/test/models/boolean.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Boolean < ActiveRecord::Base
+  def has_fun
+    super
+  end
+end

data/test/models/bulb.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Bulb < ActiveRecord::Base
+  default_scope { where(name: "defaulty") }
+  belongs_to :car, touch: true
+  scope :awesome, -> { where(frickinawesome: true) }
+
+  attr_reader :scope_after_initialize, :attributes_after_initialize, :count_after_create
+
+  after_initialize :record_scope_after_initialize
+  def record_scope_after_initialize
+    @scope_after_initialize = self.class.all
+  end
+
+  after_initialize :record_attributes_after_initialize
+  def record_attributes_after_initialize
+    @attributes_after_initialize = attributes.dup
+  end
+
+  after_create :record_count_after_create
+  def record_count_after_create
+    @count_after_create = Bulb.unscoped do
+      car&.bulbs&.count
+    end
+  end
+
+  def color=(color)
+    self[:color] = color.upcase + "!"
+  end
+
+  def self.new(attributes = {}, &block)
+    bulb_type = (attributes || {}).delete(:bulb_type)
+
+    if bulb_type.present?
+      bulb_class = "#{bulb_type.to_s.camelize}Bulb".constantize
+      bulb_class.new(attributes, &block)
+    else
+      super
+    end
+  end
+end
+
+class CustomBulb < Bulb
+  after_initialize :set_awesomeness
+
+  def set_awesomeness
+    self.frickinawesome = true if name == "Dude"
+  end
+end
+
+class FunkyBulb < Bulb
+  before_destroy do
+    raise "before_destroy was called"
+  end
+end
+
+class FailedBulb < Bulb
+  before_destroy do
+    throw(:abort)
+  end
+end

data/test/models/cake_designer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class CakeDesigner < ActiveRecord::Base
+  has_one :chef, as: :employable
+end

data/test/models/car.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Car < ActiveRecord::Base
+  has_many :bulbs
+  has_many :all_bulbs, -> { unscope(where: :name) }, class_name: "Bulb"
+  has_many :all_bulbs2, -> { unscope(:where) }, class_name: "Bulb"
+  has_many :other_bulbs, -> { unscope(where: :name).where(name: "other") }, class_name: "Bulb"
+  has_many :old_bulbs, -> { rewhere(name: "old") }, class_name: "Bulb"
+  has_many :funky_bulbs, class_name: "FunkyBulb", dependent: :destroy
+  has_many :failed_bulbs, class_name: "FailedBulb", dependent: :destroy
+  has_many :foo_bulbs, -> { where(name: "foo") }, class_name: "Bulb"
+  has_many :awesome_bulbs, -> { awesome }, class_name: "Bulb"
+
+  has_one :bulb
+
+  has_many :tyres
+  has_many :engines, dependent: :destroy, inverse_of: :my_car
+  has_many :wheels, as: :wheelable, dependent: :destroy
+
+  has_many :price_estimates, as: :estimate_of
+
+  scope :incl_tyres, -> { includes(:tyres) }
+  scope :incl_engines, -> { includes(:engines) }
+
+  scope :order_using_new_style,  -> { order("name asc") }
+
+  attribute :wheels_owned_at, :datetime, default: -> { Time.now }
+end
+
+class CoolCar < Car
+  default_scope { order("name desc") }
+end
+
+class FastCar < Car
+  default_scope { order("name desc") }
+end

data/test/models/carrier.rb

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

data/test/models/cart.rb

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

data/test/models/cat.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Cat < ActiveRecord::Base
+  self.abstract_class = true
+
+  enum gender: [:female, :male]
+
+  default_scope -> { where(is_vegetarian: false) }
+end
+
+class Lion < Cat
+end

data/test/models/categorization.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Categorization < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :category, counter_cache: true
+  belongs_to :named_category, class_name: "Category", foreign_key: :named_category_name, primary_key: :name
+  belongs_to :author
+
+  has_many :post_taggings, through: :author, source: :taggings
+
+  belongs_to :author_using_custom_pk,  class_name: "Author", foreign_key: :author_id, primary_key: :author_address_extra_id
+  has_many   :authors_using_custom_pk, class_name: "Author", foreign_key: :id,        primary_key: :category_id
+end
+
+class SpecialCategorization < ActiveRecord::Base
+  self.table_name = "categorizations"
+  default_scope { where(special: true) }
+
+  belongs_to :author
+  belongs_to :category
+end

data/test/models/category.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+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, -> { includes(:authors).order("authors.id") }, class_name: "Post"
+
+  has_and_belongs_to_many :select_testing_posts,
+                          -> { select "posts.*, 1 as correctness_marker" },
+                          class_name: "Post",
+                          foreign_key: "category_id",
+                          association_foreign_key: "post_id"
+
+  has_and_belongs_to_many :post_with_conditions,
+                          -> { where title: "Yet Another Testing Title" },
+                          class_name: "Post"
+
+  has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, class_name: "Post"
+  has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, class_name: "Post"
+
+  def self.what_are_you
+    "a category..."
+  end
+
+  has_many :categorizations
+  has_many :special_categorizations
+  has_many :post_comments, through: :posts, source: :comments
+  has_many :ordered_post_comments, -> { order(id: :desc) }, through: :posts, source: :comments
+
+  has_many :authors, through: :categorizations
+  has_many :authors_with_select, -> { select "authors.*, categorizations.post_id" }, through: :categorizations, source: :author
+
+  scope :general, -> { where(name: "General") }
+
+  # Should be delegated `ast` and `locked` to `arel`.
+  def self.ast
+    raise
+  end
+
+  def self.locked
+    raise
+  end
+end
+
+class SpecialCategory < Category
+end

data/test/models/chef.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Chef < ActiveRecord::Base
+  belongs_to :employable, polymorphic: true
+  has_many :recipes
+end
+
+class ChefList < Chef
+  belongs_to :employable_list, polymorphic: true
+end

data/test/models/citation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Citation < ActiveRecord::Base
+  belongs_to :book, foreign_key: :book1_id, inverse_of: :citations, touch: true
+  belongs_to :reference_of, class_name: "Book", foreign_key: :book2_id
+  has_many :citations
+end