orthoses-rails 0.4.0 → 0.7.0

data/examples/rails/Rakefile

@@ -1,68 +1,50 @@
-REPO_ROOT = "#{File.dirname(__FILE__)}/src"
-$:.unshift("#{REPO_ROOT}/actioncable/lib")
-$:.unshift("#{REPO_ROOT}/actionmailbox/lib")
-$:.unshift("#{REPO_ROOT}/actionmailer/lib")
-$:.unshift("#{REPO_ROOT}/actionpack/lib")
-$:.unshift("#{REPO_ROOT}/actiontext/lib")
-$:.unshift("#{REPO_ROOT}/actionview/lib")
-$:.unshift("#{REPO_ROOT}/activejob/lib")
-$:.unshift("#{REPO_ROOT}/activemodel/lib")
-$:.unshift("#{REPO_ROOT}/activerecord/lib")
-$:.unshift("#{REPO_ROOT}/activestorage/lib")
-$:.unshift("#{REPO_ROOT}/activesupport/lib")
-$:.unshift("#{REPO_ROOT}/railties/lib")
-
-require 'orthoses'
-require 'orthoses-rails'
-require 'openssl'
-require 'cgi'
-require 'uri'
-
-Orthoses.logger.level = :error
-
-Orthoses::Utils.unautoload!
-
-def run_child_process
-  pid = fork do
-    yield
-  end
-  Process.wait(pid)
-end
+## run `$ rake`
 
 def switch_branch(name)
-  cd "src" do
+  cd "_src" do
     sh "git switch #{name}"
   end
 end
 
 def generate(out_dir, version)
+  require 'orthoses'
+  require 'orthoses-rails'
+  require 'openssl'
+  require 'cgi'
+  require 'uri'
+
+  Orthoses.logger.level = :error
+
   loader = -> () {
-    # require "rails/all"
-    require "rails/app_updater"
     require "active_support/all"
     require "active_record"
     require "active_job"
     require "active_model"
-    require "active_storage"
+    require "active_storage/engine"
     require "action_dispatch"
-    require "action_mailbox"
+    begin
+      require "action_mailbox"
+      require "action_text"
+    rescue LoadError
+    end
     require "action_mailer"
     require "action_pack"
-    require "action_text"
     require "action_view"
 
-    [
+    roots = [
       ActiveSupport,
       ActiveModel,
       ActiveJob,
       ActiveRecord,
       ActiveStorage,
       ActionDispatch,
-      ActionMailbox,
       ActionMailer,
-      ActionText,
       ActionView,
-    ].each do |rails_mod|
+    ]
+    roots << ActionMailbox if defined?(ActionMailbox)
+    roots << ActionText if defined?(ActionText)
+
+    roots.each do |rails_mod|
       rails_mod.eager_load!
       Orthoses::Utils.each_const_recursive(rails_mod, on_error: -> (e) {
         Orthoses.logger.warn "skip load const by [#{e.root}][#{e.const}](#{e.error.class})#{e.error.message}"
@@ -70,13 +52,21 @@ def generate(out_dir, version)
       v = rails_mod.respond_to?(:version) ? rails_mod.version : nil
       puts "loaded #{rails_mod}: v#{v}"
     end
-    Orthoses::Utils.unautoload!
+    eval(<<~RUBY)
+      module Dummy
+        class Application < Rails::Application
+          config.load_defaults #{version.to_s}
+          config.active_storage.service = :local
+        end
+      end
+    RUBY
+    ENV['RAILS_ENV'] = 'development'
+    Rails.application.initialize!
   }
   Orthoses::Builder.new do
     use Orthoses::CreateFileByName,
       base_dir: "#{out_dir}/#{version}",
-      header: "# !!! GENERATED CODE !!!"
-    use Orthoses::AvoidRecursiveAncestorError
+      header: "# !!! GENERATED CODE !!!\n# Please see generators/rails-generator"
     use Orthoses::Filter,
       if: -> (name, content) {
         # OMG, both ERB and Erb are exist...
@@ -101,18 +91,18 @@ def generate(out_dir, version)
       on_error: -> (e) {
         Orthoses.logger.warn "[Orthoses::Constant] skip load const by #{e.root}[::#{e.const}] (#{e.error.class}) #{e.error.message}"
       }
-    Orthoses::ActiveSupport.each do |middleware, **args|
-      use middleware, **args
-    end
+    use Orthoses::ActiveSupport::ClassAttribute
+    use Orthoses::ActiveSupport::Delegation
+    use Orthoses::ActiveSupport::MattrAccessor
+    use Orthoses::ActiveSupport::TimeWithZone
     use Orthoses::ActiveRecord::QueryMethods
-    use Orthoses::ActiveRecord::KnownSig
-    use Orthoses::ActiveModel::KnownSig
-    use Orthoses::ObjectSpaceAll
     use Orthoses::LoadRBS,
-      paths: Dir.glob('patch/**/*.rbs')
+      paths: -> { Orthoses::PathHelper.best_version_paths(::ActiveRecord::VERSION::STRING, "known_sig/activerecord") }
     use Orthoses::LoadRBS,
-      paths: Dir.glob('known_sig/**/*.rbs')
-    # require in method
+      paths: -> { Orthoses::PathHelper.best_version_paths(::ActiveModel::VERSION::STRING, "known_sig/activemodel") }
+    use Orthoses::LoadRBS,
+      paths: -> { Orthoses::PathHelper.best_version_paths(::ActiveSupport::VERSION::STRING, "known_sig/activesupport") }
+    # # require in method
     use Orthoses::Tap do |store|
       store.delete("DummyERB")
       store.delete("DummyCompiler")
@@ -129,6 +119,9 @@ def generate(out_dir, version)
       elsif defined?(ActiveRecord::Migration::Compatibility::V6_0)
         store["ActiveRecord::Migration::Compatibility::V5_2"].header = nil
         store["ActiveRecord::Migration::Compatibility::V6_0"].header = "class ActiveRecord::Migration::Compatibility::V6_0 < ActiveRecord::Migration::Current"
+      elsif defined?(ActiveRecord::Migration::Compatibility::V5_2)
+        store["ActiveRecord::Migration::Compatibility::V5_1"].header = nil
+        store["ActiveRecord::Migration::Compatibility::V5_2"].header = "class ActiveRecord::Migration::Compatibility::V5_2 < ActiveRecord::Migration::Current"
       end
     end
     # class_eval in #each
@@ -197,177 +190,140 @@ def generate(out_dir, version)
     end
     use Orthoses::DelegateClass
     use Orthoses::Attribute
+    use Orthoses::Railties::Mixin, callback: -> (railties_mixin) {
+      Orthoses::CreateFileByName.new(
+        ->{ railties_mixin },
+        base_dir: "#{out_dir}/#{version}/railties_mixin",
+        header: "# !!! GENERATED CODE !!!\n# Please see generators/rails-generator"
+      ).call
+    }
     use Orthoses::Mixin,
       if: -> (base_mod, how, mod) {
         mod != Enumerable # TODO
       }
     use Orthoses::RBSPrototypeRB,
-      paths: Dir.glob('src/{railties,action{cable,mailbox,mailer,pack,text,view},active{job,model,record,storage,support}}/lib/**/*.rb'),
+      paths: Dir.glob('_src/{railties,action{cable,mailbox,mailer,pack,text,view},active{job,model,record,storage,support}}/{app,lib}/**/*.rb'),
       constant_filter: -> (member) { false },
-      mixin_filter: -> (member) { false }
+      mixin_filter: -> (member) { false },
+      attribute_filter: -> (member) { false }
+    use Orthoses::Autoload
     run loader
   end.call
 
   # $ cat out/7.0/**/*.rbs | wc
-  # 68367  333370 2555378
+  # 69763  339342 2606899
 end
 
-versions = %w[
+def generate_test_script(gem:, version:, export:, stdlib_dependencies:, gem_dependencies:, rails_dependencies:)
+  Pathname(export).join('_scripts').tap(&:mkdir).join('test').write(<<~SHELL)
+    #!/usr/bin/env bash
+
+    # !!! GENERATED CODE !!!
+    # Please see generators/rails-generator
+
+    # set -eou => Exit command with non-zero status code, Output logs of every command executed, Treat unset variables as an error when substituting.
+    set -eou pipefail
+    # Internal Field Separator - Linux shell variable
+    IFS=$'\n\t'
+    # Print shell input lines
+    set -v
+
+    # Set RBS_DIR variable to change directory to execute type checks using `steep check`
+    RBS_DIR=$(cd $(dirname $0)/..; pwd)
+    # Set REPO_DIR variable to validate RBS files added to the corresponding folder
+    REPO_DIR=$(cd $(dirname $0)/../../..; pwd)
+    # Validate RBS files, using the bundler environment present
+    bundle exec rbs --repo=$REPO_DIR #{stdlib_dependencies.map{"-r #{_1}"}.join(" ")} \\
+      #{gem_dependencies.map{"-r #{_1}"}.join(" ")} \\
+      -r #{gem} validate --silent
+
+    cd ${RBS_DIR}/_test
+    # Run type checks
+    bundle exec steep check
+  SHELL
+
+  sh "chmod +x #{Pathname(export).join('_scripts').join('test')}"
+
+  Pathname(export).join('_test').tap(&:mkdir).join('Steepfile').write(<<~RUBY)
+    # !!! GENERATED CODE !!!
+    # Please see generators/rails-generator
+
+    D = Steep::Diagnostic
+
+    target :test do
+      signature "."
+      check "."
+
+      repo_path "../../../"
+
+    #{stdlib_dependencies.map{"  library \"#{_1}\""}.join("\n")}
+    #{gem_dependencies.map{"  library \"#{_1}\""}.join("\n")}
+
+      library "#{gem}:#{version}"
+
+      configure_code_diagnostics(D::Ruby.all_error)
+    end
+  RUBY
+end
+
+def generate_manifest(export:, stdlib_dependencies:)
+  Pathname(export).join('manifest.yaml').write(<<~YAML)
+    dependencies:
+      #{stdlib_dependencies.map{"- name: #{_1}"}.join("\n  ")}
+  YAML
+end
+
+VERSIONS = %w[
   6.0
   6.1
   7.0
 ]
+Object.private_constant :VERSIONS
+
+tasks = Dir["tasks/*"]
+tasks.each do |task|
+  load task
+end
+GEMS = tasks.map { File.basename(_1).sub(/\.rake/, '') }
+Object.private_constant :GEMS
 
 task :clean do
   FileUtils.rm_rf("out")
-  FileUtils.rm_rf("export")
 end
 
-namespace :generate do
-  versions.each do |version|
-    task version do
-      switch_branch("#{version.tr('.', '-')}-stable")
-      run_child_process { generate("out", version) }
-    end
-  end
+VERSIONS.each do |version|
+  namespace version do
+    desc "run all version=#{version}"
+    task :all => [
+      :generate,
+      :export,
+      :validate,
+      # :install,
+    ]
 
-  desc "generate all library"
-  task :all => versions
-end
+    desc "run export version=#{version}"
+    task :export => GEMS.map{"#{version}:#{_1}:export"}
 
-namespace :export do
-  versions.each do |version|
-    task version do |t|
-      export = "export/activesupport/#{version}"
-
-      sh "rm -fr #{export}"
-      sh "mkdir -p #{export}"
-
-      # minimum
-      sh "cp -a out/#{version}/active_support.rbs #{export}"
-      sh "cp -a out/#{version}/active_support #{export}"
-      sh "rm #{export}/active_support/railtie.rbs"
-
-      # core_ext
-      %w[
-        array benchmark big_decimal class date date_and_time date_time digest
-        enumerable file hash integer kernel load_error marshal module name_error numeric
-        object pathname range regexp securerandom string symbol time uri
-      ].each do |lib|
-        out = "out/#{version}/#{lib}"
-        sh "cp -a #{out} #{export}" if File.exist?(out)
-        sh "cp -a #{out}.rbs #{export}" if File.exist?("#{out}.rbs")
-      end
-
-      Pathname(export).join("EXTERNAL_TODO.rbs").write(<<~RBS)
-        module Minitest
-          class Test
-            def name: () -> untyped
-            def assert_raises: () -> untyped
-            def refute_empty: () -> untyped
-            def refute_equal: () -> untyped
-            def refute_in_delta: () -> untyped
-            def refute_in_epsilon: () -> untyped
-            def refute_includes: () -> untyped
-            def refute_instance_of: () -> untyped
-            def refute_kind_of: () -> untyped
-            def refute_match: () -> untyped
-            def refute_nil: () -> untyped
-            def refute_operator: () -> untyped
-            def refute_predicate: () -> untyped
-            def refute_respond_to: () -> untyped
-            def refute_same: () -> untyped
-          end
-        end
-        module DRb
-          module DRbUndumped
-          end
-        end
-        module Concurrent
-          class Map
-          end
-        end
-      RBS
-
-      case version
-      when "6.0", "6.1"
-        sh "rm -fr #{export}/uri"
-      when "7.0"
-        # deprecated
-        sh "rm -fr #{export}/uri{,.rbs}"
-      end
+    desc "run validate version=#{version}"
+    task :validate => GEMS.map{"#{version}:#{_1}:validate"}
 
-      Pathname(export).join('_scripts').tap(&:mkdir).join('test').write(<<~'RUBY')
-        #!/usr/bin/env bash
-
-        # set -eou => Exit command with non-zero status code, Output logs of every command executed, Treat unset variables as an error when substituting.
-        set -eou pipefail
-        # Internal Field Separator - Linux shell variable
-        IFS=$'\n\t'
-        # Print shell input lines
-        set -v
-
-        # Set RBS_DIR variable to change directory to execute type checks using `steep check`
-        RBS_DIR=$(cd $(dirname $0)/..; pwd)
-        # Set REPO_DIR variable to validate RBS files added to the corresponding folder
-        REPO_DIR=$(cd $(dirname $0)/../../..; pwd)
-        # Validate RBS files, using the bundler environment present
-        bundle exec rbs --repo=$REPO_DIR \
-          -r digest -r benchmark -r time -r monitor -r date -r singleton \
-          -r logger -r mutex_m -r pathname -r json \
-          -r nokogiri \
-          -r activesupport validate --silent
-
-        cd ${RBS_DIR}/_test
-        # Run type checks
-        bundle exec steep check
-      RUBY
-      sh "chmod +x #{Pathname(export).join('_scripts').join('test')}"
-      Pathname(export).join('_test').tap(&:mkdir).join('Steepfile').write(<<~RUBY)
-        D = Steep::Diagnostic
-
-        target :test do
-          signature "."
-          check "."
-
-          repo_path "../../../"
-
-          library "benchmark"
-          library "date"
-          library "digest"
-          library "json"
-          library "logger"
-          library "monitor"
-          library "mutex_m"
-          library "pathname"
-          library "singleton"
-          library "time"
-
-          library "nokogiri"
-
-          library "activesupport:#{version}"
-
-          configure_code_diagnostics(D::Ruby.all_error)
-        end
-      RUBY
-      Pathname(export).join('_test').join('test.rb').write(<<~'RUBY')
-        require 'active_support/all'
+    desc "run install version=#{version}"
+    task :install => GEMS.map{"#{version}:#{_1}:install"}
 
-        # Test ActiveSupport::NumericWithFormat
-        42.to_s
-        42.to_s(:phone)
-      RUBY
+    desc "generate version=#{version}"
+    task :generate do |t|
+      switch_branch("#{version.tr('.', '-')}-stable")
+      sh "bundle install"
+      sh "bundle exec rake #{t.name}_exec"
+    end
 
-      sh "rbs --collection ../../rbs_collection.yaml -I #{export} validate --silent"
+    task :generate_exec do
+      generate("out", version)
     end
   end
-
-  desc "export all library"
-  task :all => versions
 end
 
 task default: [
   :clean,
-  'generate:all',
-  'export:all',
+  *(VERSIONS.map {"#{_1}:all"})
 ]

data/examples/rails/config/database.yml

@@ -0,0 +1,8 @@
+development:
+  primary: &primary
+    adapter: sqlite3
+    pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+    timeout: 5000
+    database: ':memory:'
+  replica:
+    <<: *primary

data/examples/rails/config/storage.yml

@@ -0,0 +1,3 @@
+local:
+  service: Disk
+  root: <%= Rails.root.join("storage") %>

data/examples/rails/known_sig/actionpack/7.0/action_controller/metal.rbs

@@ -0,0 +1,4 @@
+module ActionController
+  class Metal < AbstractController::Base
+  end
+end

data/examples/rails/known_sig/activerecord/6.0/_active_record_relation.rbs

@@ -0,0 +1,49 @@
+interface _ActiveRecord_Relation[Model, PrimaryKey]
+  def all: () -> self
+  def ids: () -> Array[PrimaryKey]
+  def none: () -> self
+  def pluck: (Symbol | String column) -> Array[untyped]
+           | (*Symbol | String columns) -> Array[Array[untyped]]
+  def where: (*untyped) -> self
+  def not: (*untyped) -> self
+  def exists?: (*untyped) -> bool
+  def order: (*untyped) -> self
+  def group: (*Symbol | String) -> untyped
+  def distinct: () -> self
+  def or: (self) -> self
+  def merge: (self) -> self
+  def joins: (*String | Symbol) -> self
+           | (Hash[untyped, untyped]) -> self
+  def left_joins: (*String | Symbol) -> self
+           | (Hash[untyped, untyped]) -> self
+  def left_outer_joins: (*String | Symbol) -> self
+                      | (Hash[untyped, untyped]) -> self
+  def includes: (*String | Symbol) -> self
+              | (Hash[untyped, untyped]) -> self
+  def eager_load: (*String | Symbol) -> self
+                | (Hash[untyped, untyped]) -> self
+  def preload: (*String | Symbol) -> self
+             | (Hash[untyped, untyped]) -> self
+  def find_by: (*untyped) -> Model?
+  def find_by!: (*untyped) -> Model
+  def find: (PrimaryKey id) -> Model
+          | (Array[PrimaryKey]) -> Array[Model]
+          | (*PrimaryKey) -> Array[Model]
+          | () { (Model) -> boolish } -> Model?
+  def first: () -> Model?
+           | (Integer count) -> Array[Model]
+  def first!: () -> Model
+  def last: () -> Model?
+           | (Integer count) -> Array[Model]
+  def last!: () -> Model
+  def limit: (Integer | Arel::Nodes::SqlLiteral | nil) -> self
+  def limit!: (Integer | Arel::Nodes::SqlLiteral | nil) -> self
+  def find_each: (?batch_size: Integer, ?start: Integer, ?finish: Integer, ?error_on_ignore: bool) { (Model) -> void } -> nil
+  def find_in_batches: (?batch_size: Integer, ?start: Integer, ?finish: Integer, ?error_on_ignore: bool) { (self) -> void } -> nil
+  def destroy_all: () -> untyped
+  def delete_all: () -> untyped
+  def update_all: (*untyped) -> untyped
+  def each: () { (Model) -> void } -> self
+  def select: (*Symbol | String) -> self
+            | () { (Model) -> boolish } -> Array[Model]
+end

data/examples/rails/known_sig/activerecord/6.0/_active_record_relation_class_methods.rbs

@@ -0,0 +1,45 @@
+interface _ActiveRecord_Relation_ClassMethods[Model, Relation, PrimaryKey]
+  def all: () -> Relation
+  def ids: () -> Array[PrimaryKey]
+  def none: () -> Relation
+  def pluck: (Symbol | String column) -> Array[untyped]
+           | (*Symbol | String columns) -> Array[Array[untyped]]
+  def where: (*untyped) -> Relation
+  def exists?: (*untyped) -> bool
+  def order: (*untyped) -> Relation
+  def group: (*Symbol | String) -> untyped
+  def distinct: () -> self
+  def or: (Relation) -> Relation
+  def merge: (Relation) -> Relation
+  def joins: (*String | Symbol) -> self
+           | (Hash[untyped, untyped]) -> self
+  def left_joins: (*String | Symbol) -> self
+           | (Hash[untyped, untyped]) -> self
+  def left_outer_joins: (*String | Symbol) -> self
+                      | (Hash[untyped, untyped]) -> self
+  def includes: (*String | Symbol) -> self
+              | (Hash[untyped, untyped]) -> self
+  def eager_load: (*String | Symbol) -> self
+                | (Hash[untyped, untyped]) -> self
+  def preload: (*String | Symbol) -> self
+             | (Hash[untyped, untyped]) -> self
+  def find_by: (*untyped) -> Model?
+  def find_by!: (*untyped) -> Model
+  def find: (PrimaryKey id) -> Model
+          | (Array[PrimaryKey]) -> Array[Model]
+          | (*PrimaryKey) -> Array[Model]
+  def first: () -> Model?
+           | (Integer count) -> Array[Model]
+  def first!: () -> Model
+  def last: () -> Model?
+           | (Integer count) -> Array[Model]
+  def last!: () -> Model
+  def limit: (Integer | Arel::Nodes::SqlLiteral | nil) -> Relation
+  def find_each: (?batch_size: Integer, ?start: Integer, ?finish: Integer, ?error_on_ignore: bool) { (Model) -> void } -> nil
+  def find_in_batches: (?batch_size: Integer, ?start: Integer, ?finish: Integer, ?error_on_ignore: bool) { (self) -> void } -> nil
+  def destroy_all: () -> untyped
+  def delete_all: () -> untyped
+  def update_all: (*untyped) -> untyped
+  def select: (*Symbol | String) -> Relation
+            | () { (Model) -> boolish } -> Array[Model]
+end

data/examples/rails/known_sig/activerecord/6.1/_active_record_relation.rbs

@@ -0,0 +1,49 @@
+interface _ActiveRecord_Relation[Model, PrimaryKey]
+  def all: () -> self
+  def ids: () -> Array[PrimaryKey]
+  def none: () -> self
+  def pluck: (Symbol | String column) -> Array[untyped]
+           | (*Symbol | String columns) -> Array[Array[untyped]]
+  def where: (*untyped) -> self
+  def not: (*untyped) -> self
+  def exists?: (*untyped) -> bool
+  def order: (*untyped) -> self
+  def group: (*Symbol | String) -> untyped
+  def distinct: () -> self
+  def or: (self) -> self
+  def merge: (self) -> self
+  def joins: (*String | Symbol) -> self
+           | (Hash[untyped, untyped]) -> self
+  def left_joins: (*String | Symbol) -> self
+           | (Hash[untyped, untyped]) -> self
+  def left_outer_joins: (*String | Symbol) -> self
+                      | (Hash[untyped, untyped]) -> self
+  def includes: (*String | Symbol) -> self
+              | (Hash[untyped, untyped]) -> self
+  def eager_load: (*String | Symbol) -> self
+                | (Hash[untyped, untyped]) -> self
+  def preload: (*String | Symbol) -> self
+             | (Hash[untyped, untyped]) -> self
+  def find_by: (*untyped) -> Model?
+  def find_by!: (*untyped) -> Model
+  def find: (PrimaryKey id) -> Model
+          | (Array[PrimaryKey]) -> Array[Model]
+          | (*PrimaryKey) -> Array[Model]
+          | () { (Model) -> boolish } -> Model?
+  def first: () -> Model?
+           | (Integer count) -> Array[Model]
+  def first!: () -> Model
+  def last: () -> Model?
+           | (Integer count) -> Array[Model]
+  def last!: () -> Model
+  def limit: (Integer | Arel::Nodes::SqlLiteral | nil) -> self
+  def limit!: (Integer | Arel::Nodes::SqlLiteral | nil) -> self
+  def find_each: (?batch_size: Integer, ?start: Integer, ?finish: Integer, ?error_on_ignore: bool) { (Model) -> void } -> nil
+  def find_in_batches: (?batch_size: Integer, ?start: Integer, ?finish: Integer, ?error_on_ignore: bool) { (self) -> void } -> nil
+  def destroy_all: () -> untyped
+  def delete_all: () -> untyped
+  def update_all: (*untyped) -> untyped
+  def each: () { (Model) -> void } -> self
+  def select: (*Symbol | String) -> self
+            | () { (Model) -> boolish } -> Array[Model]
+end

data/examples/rails/known_sig/activerecord/6.1/_active_record_relation_class_methods.rbs

@@ -0,0 +1,45 @@
+interface _ActiveRecord_Relation_ClassMethods[Model, Relation, PrimaryKey]
+  def all: () -> Relation
+  def ids: () -> Array[PrimaryKey]
+  def none: () -> Relation
+  def pluck: (Symbol | String column) -> Array[untyped]
+           | (*Symbol | String columns) -> Array[Array[untyped]]
+  def where: (*untyped) -> Relation
+  def exists?: (*untyped) -> bool
+  def order: (*untyped) -> Relation
+  def group: (*Symbol | String) -> untyped
+  def distinct: () -> self
+  def or: (Relation) -> Relation
+  def merge: (Relation) -> Relation
+  def joins: (*String | Symbol) -> self
+           | (Hash[untyped, untyped]) -> self
+  def left_joins: (*String | Symbol) -> self
+           | (Hash[untyped, untyped]) -> self
+  def left_outer_joins: (*String | Symbol) -> self
+                      | (Hash[untyped, untyped]) -> self
+  def includes: (*String | Symbol) -> self
+              | (Hash[untyped, untyped]) -> self
+  def eager_load: (*String | Symbol) -> self
+                | (Hash[untyped, untyped]) -> self
+  def preload: (*String | Symbol) -> self
+             | (Hash[untyped, untyped]) -> self
+  def find_by: (*untyped) -> Model?
+  def find_by!: (*untyped) -> Model
+  def find: (PrimaryKey id) -> Model
+          | (Array[PrimaryKey]) -> Array[Model]
+          | (*PrimaryKey) -> Array[Model]
+  def first: () -> Model?
+           | (Integer count) -> Array[Model]
+  def first!: () -> Model
+  def last: () -> Model?
+           | (Integer count) -> Array[Model]
+  def last!: () -> Model
+  def limit: (Integer | Arel::Nodes::SqlLiteral | nil) -> Relation
+  def find_each: (?batch_size: Integer, ?start: Integer, ?finish: Integer, ?error_on_ignore: bool) { (Model) -> void } -> nil
+  def find_in_batches: (?batch_size: Integer, ?start: Integer, ?finish: Integer, ?error_on_ignore: bool) { (self) -> void } -> nil
+  def destroy_all: () -> untyped
+  def delete_all: () -> untyped
+  def update_all: (*untyped) -> untyped
+  def select: (*Symbol | String) -> Relation
+            | () { (Model) -> boolish } -> Array[Model]
+end