tapioca 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a3ddc2c5d6e123488c0c4f2d0aad9a5de62a8145f2c3eb2d6b73de6f814afc0
-  data.tar.gz: 908740542e026711e9ee85d46ce3828533f965c302039b645213adc016d74258
+  metadata.gz: f655f69697a5c375a3e04eef733d55213d2ea83b7392f35e3f81ed61ef4f93e4
+  data.tar.gz: 1ba60b67539a5034080dd9247f2f005593f25bcb2f01d72b72bccfb9a1f77f73
 SHA512:
-  metadata.gz: 0622e47a67918e24c8ec4434892265039b38c0de522b3e2ad1ca156d62b1487317384a7dcc928249c7d5cec62493bee5e36d0cbd2342b97a39011056485d6f30
-  data.tar.gz: 3082afd8096436fee4ecf4cb46b3a4232f77e34fa53bfb60b3182d12a7fcb5b3df58fe8ce67d1c8dcfb9b4a68dd859429bb6f0cf65eb8708991dfb2ff018720b
+  metadata.gz: 99e5157e6d3b82922fb321d9eed18813bd8964cd02a9e253653c73ae6fff56529638e129532bf165dae9ec43e191e9186b4e6a7e4481ea0e4f11d5e2675b2f37
+  data.tar.gz: 22e178bf5afe57e2fa348606bf3cdbc8085cb4e8f735cdf1ad06665e27e6b5e08085d1eef74bba823eab87b3e1f76f12c02df5455a4fd182f11455744a5ce27c

data/README.md

@@ -40,6 +40,7 @@ Tapioca makes it easy to work with [Sorbet](https://sorbet.org) in your codebase
     * [Excluding a gem from RBI generation](#excluding-a-gem-from-rbi-generation)
     * [Changing the strictness level of the RBI for a gem](#changing-the-strictness-level-of-the-rbi-for-a-gem)
     * [Keeping RBI files for gems up-to-date](#keeping-rbi-files-for-gems-up-to-date)
+    * [Importing hand written signatures from gem's `rbi/` folder](#importing-hand-written-signatures-from-gems-rbi-folder)
   * [Pulling RBI annotations from remote sources](#pulling-rbi-annotations-from-remote-sources)
     * [Basic authentication](#basic-authentication)
     * [Using a .netrc file](#using-a-netrc-file)
@@ -83,10 +84,10 @@ Commands:
   tapioca todo               # Generate the list of unresolved constants
 
 Options:
-  -c, [--config=<config file path>]  # Path to the Tapioca configuration file
-                                     # Default: sorbet/tapioca/config.yml
-  -V, [--verbose], [--no-verbose]    # Verbose output for debugging purposes
-                                     # Default: false
+  -c, [--config=<config file path>]                  # Path to the Tapioca configuration file
+                                                     # Default: sorbet/tapioca/config.yml
+  -V, [--verbose], [--no-verbose], [--skip-verbose]  # Verbose output for debugging purposes
+                                                     # Default: false
 
 ```
 <!-- END_HELP -->
@@ -117,10 +118,10 @@ Usage:
   tapioca init
 
 Options:
-  -c, [--config=<config file path>]  # Path to the Tapioca configuration file
-                                     # Default: sorbet/tapioca/config.yml
-  -V, [--verbose], [--no-verbose]    # Verbose output for debugging purposes
-                                     # Default: false
+  -c, [--config=<config file path>]                  # Path to the Tapioca configuration file
+                                                     # Default: sorbet/tapioca/config.yml
+  -V, [--verbose], [--no-verbose], [--skip-verbose]  # Verbose output for debugging purposes
+                                                     # Default: false
 
 Get project ready for type checking
 ```
@@ -164,43 +165,43 @@ Usage:
   tapioca gem [gem...]
 
 Options:
-  --out, -o,   [--outdir=directory]                                   # The output directory for generated gem RBI files
-                                                                      # Default: sorbet/rbi/gems
-               [--file-header], [--no-file-header]                    # Add a "This file is generated" header on top of each generated RBI file
-                                                                      # Default: true
-               [--all], [--no-all]                                    # Regenerate RBI files for all gems
-                                                                      # Default: false
-  --pre, -b,   [--prerequire=file]                                    # A file to be required before Bundler.require is called
-  --post, -a,  [--postrequire=file]                                   # A file to be required after Bundler.require is called
-                                                                      # Default: sorbet/tapioca/require.rb
-  -x,          [--exclude=gem [gem ...]]                              # Exclude the given gem(s) from RBI generation
-               [--include-dependencies], [--no-include-dependencies]  # Generate RBI files for dependencies of the given gem(s)
-                                                                      # Default: false
-  --typed, -t, [--typed-overrides=gem:level [gem:level ...]]          # Override for typed sigils for generated gem RBIs
-                                                                      # Default: {"activesupport"=>"false"}
-               [--verify], [--no-verify]                              # Verify RBIs are up-to-date
-                                                                      # Default: false
-               [--doc], [--no-doc]                                    # Include YARD documentation from sources when generating RBIs. Warning: this might be slow
-                                                                      # Default: true
-               [--loc], [--no-loc]                                    # Include comments with source location when generating RBIs
-                                                                      # Default: true
-               [--exported-gem-rbis], [--no-exported-gem-rbis]        # Include RBIs found in the `rbi/` directory of the gem
-                                                                      # Default: true
-  -w,          [--workers=N]                                          # Number of parallel workers to use when generating RBIs (default: auto)
-               [--auto-strictness], [--no-auto-strictness]            # Autocorrect strictness in gem RBIs in case of conflict with the DSL RBIs
-                                                                      # Default: true
-  --dsl-dir,   [--dsl-dir=directory]                                  # The DSL directory used to correct gems strictnesses
-                                                                      # Default: sorbet/rbi/dsl
-               [--rbi-max-line-length=N]                              # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
-                                                                      # Default: 120
-  -e,          [--environment=ENVIRONMENT]                            # The Rack/Rails environment to use when generating RBIs
-                                                                      # Default: development
-               [--halt-upon-load-error], [--no-halt-upon-load-error]  # Halt upon a load error while loading the Rails application
-                                                                      # Default: true
-  -c,          [--config=<config file path>]                          # Path to the Tapioca configuration file
-                                                                      # Default: sorbet/tapioca/config.yml
-  -V,          [--verbose], [--no-verbose]                            # Verbose output for debugging purposes
-                                                                      # Default: false
+  --out, -o,   [--outdir=directory]                                                                  # The output directory for generated gem RBI files
+                                                                                                     # Default: sorbet/rbi/gems
+               [--file-header], [--no-file-header], [--skip-file-header]                             # Add a "This file is generated" header on top of each generated RBI file
+                                                                                                     # Default: true
+               [--all], [--no-all], [--skip-all]                                                     # Regenerate RBI files for all gems
+                                                                                                     # Default: false
+  --pre, -b,   [--prerequire=file]                                                                   # A file to be required before Bundler.require is called
+  --post, -a,  [--postrequire=file]                                                                  # A file to be required after Bundler.require is called
+                                                                                                     # Default: sorbet/tapioca/require.rb
+  -x,          [--exclude=gem [gem ...]]                                                             # Exclude the given gem(s) from RBI generation
+               [--include-dependencies], [--no-include-dependencies], [--skip-include-dependencies]  # Generate RBI files for dependencies of the given gem(s)
+                                                                                                     # Default: false
+  --typed, -t, [--typed-overrides=gem:level [gem:level ...]]                                         # Override for typed sigils for generated gem RBIs
+                                                                                                     # Default: {"activesupport"=>"false"}
+               [--verify], [--no-verify], [--skip-verify]                                            # Verify RBIs are up-to-date
+                                                                                                     # Default: false
+               [--doc], [--no-doc], [--skip-doc]                                                     # Include YARD documentation from sources when generating RBIs. Warning: this might be slow
+                                                                                                     # Default: true
+               [--loc], [--no-loc], [--skip-loc]                                                     # Include comments with source location when generating RBIs
+                                                                                                     # Default: true
+               [--exported-gem-rbis], [--no-exported-gem-rbis], [--skip-exported-gem-rbis]           # Include RBIs found in the `rbi/` directory of the gem
+                                                                                                     # Default: true
+  -w,          [--workers=N]                                                                         # Number of parallel workers to use when generating RBIs (default: auto)
+               [--auto-strictness], [--no-auto-strictness], [--skip-auto-strictness]                 # Autocorrect strictness in gem RBIs in case of conflict with the DSL RBIs
+                                                                                                     # Default: true
+  --dsl-dir,   [--dsl-dir=directory]                                                                 # The DSL directory used to correct gems strictnesses
+                                                                                                     # Default: sorbet/rbi/dsl
+               [--rbi-max-line-length=N]                                                             # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
+                                                                                                     # Default: 120
+  -e,          [--environment=ENVIRONMENT]                                                           # The Rack/Rails environment to use when generating RBIs
+                                                                                                     # Default: development
+               [--halt-upon-load-error], [--no-halt-upon-load-error], [--skip-halt-upon-load-error]  # Halt upon a load error while loading the Rails application
+                                                                                                     # Default: true
+  -c,          [--config=<config file path>]                                                         # Path to the Tapioca configuration file
+                                                                                                     # Default: sorbet/tapioca/config.yml
+  -V,          [--verbose], [--no-verbose], [--skip-verbose]                                         # Verbose output for debugging purposes
+                                                                                                     # Default: false
 
 Generate RBIs from gems
 ```
@@ -223,18 +224,18 @@ For gems that have a normal default `require` and that load all of their constan
 For example, suppose you are using the class `BetterHtml::Parser` exported from the `better_html` gem. Just doing a `require "better_html"` (which is the default require) does not load that type:
 
 ```shell
-$ bundle exec pry
+$ bundle exec irb
 
-[1] pry(main)> require 'better_html'
+irb(main):001> require 'better_html'
 => true
-[2] pry(main)> BetterHtml
+irb(main):002> BetterHtml
 => BetterHtml
-[3] pry(main)> BetterHtml::Parser
-NameError: uninitialized constant BetterHtml::Parser
-from (pry):3:in `__pry__`
-[4] pry(main)> require 'better_html/parser'
+irb(main):003> BetterHtml::Parser
+(irb):3:in '<main>': uninitialized constant BetterHtml::Parser (NameError)
+Did you mean?  BetterHtml::ParserError
+irb(main):004> require 'better_html/parser'
 => true
-[5] pry(main)> BetterHtml::Parser
+irb(main):005> BetterHtml::Parser
 => BetterHtml::Parser
 ```
 
@@ -315,7 +316,7 @@ gem:
 
 #### Keeping RBI files for gems up-to-date
 
-To ensure all RBI files for gems are up-to-date with the latest changes in your `Gemfile.lock`, Tapioca provides a `--verify` option:
+To ensure all RBI files for gems are present and have the correct version based on your `Gemfile.lock`, Tapioca provides a `--verify` option:
 
 ```shell
 $ bin/tapioca gems --verify
@@ -325,7 +326,16 @@ Checking for out-of-date RBIs...
 Nothing to do, all RBIs are up-to-date.
 ```
 
-This option can be used on CI to make sure the RBI files are always up-to-date and ensure accurate type checking. **Warning**: doing so will break your normal Dependabot workflow as every pull-request opened to bump a gem version will fail CI since the RBI will be out-of-date and will require you to manually run `bin/tapioca gems` to update them.
+This option can be used in CI to make sure the RBI files are *up-to-date* and ensure accurate type checking.
+
+**Warning**: doing so will break your normal automated dependency update workflow as every pull request opened to bump a gem version will fail CI since the RBI will be out-of-date. You will need to either set up additional automation (eg [Dependabot](https://github.com/dependabot/dependabot-core/issues/5962#issuecomment-1303781931)), or manually run `bin/tapioca gems` and commit the results.
+
+**Warning**: Verification ONLY ensures the RBI files are present, used and have the correct version based on the gem version in your `Gemfile.lock`. It's possible for your RBIs to be out-of-date if RBIs were not regenerated following an update to tapioca itself or if a another gem that injects functionality (e.g. `turbo-rails`) was installed/updated/removed. To ensure RBIs are completely up-to-date, you must run `bin/tapioca gems --all` but it's not recommended to do this in CI as it's an expensive operation.
+
+
+#### Importing hand written signatures from gem's `rbi/` folder
+
+Tapioca will import any signatures found in the `rbi/` folder of a given gem and combine them with the RBIs it generates. This is useful when a gem doesn't want to depend on `sorbet-runtime` but still wants to provide type safety to users during static checks. Note that the `rbi/` folder needs to be included in the gem release using the `.gemspec` file. Applications can choose not to import these signatures using the `--no-exported-gem-rbis` flag.
 
 ### Pulling RBI annotations from remote sources
 
@@ -357,14 +367,14 @@ Usage:
 Options:
                [--sources=one two three]                      # URIs of the sources to pull gem RBI annotations from
                                                               # Default: "https://raw.githubusercontent.com/Shopify/rbi-central/main"
-               [--netrc], [--no-netrc]                        # Use .netrc to authenticate to private sources
+               [--netrc], [--no-netrc], [--skip-netrc]        # Use .netrc to authenticate to private sources
                                                               # Default: true
                [--netrc-file=NETRC_FILE]                      # Path to .netrc file
                [--auth=AUTH]                                  # HTTP authorization header for private sources
   --typed, -t, [--typed-overrides=gem:level [gem:level ...]]  # Override for typed sigils for pulled annotations
   -c,          [--config=<config file path>]                  # Path to the Tapioca configuration file
                                                               # Default: sorbet/tapioca/config.yml
-  -V,          [--verbose], [--no-verbose]                    # Verbose output for debugging purposes
+  -V,          [--verbose], [--no-verbose], [--skip-verbose]  # Verbose output for debugging purposes
                                                               # Default: false
 
 Pull gem RBI annotations from remote sources
@@ -467,32 +477,32 @@ Usage:
   tapioca dsl [constant...]
 
 Options:
-  --out, -o, [--outdir=directory]                                   # The output directory for generated DSL RBI files
-                                                                    # Default: sorbet/rbi/dsl
-             [--file-header], [--no-file-header]                    # Add a "This file is generated" header on top of each generated RBI file
-                                                                    # Default: true
-             [--only=compiler [compiler ...]]                       # Only run supplied DSL compiler(s)
-             [--exclude=compiler [compiler ...]]                    # Exclude supplied DSL compiler(s)
-             [--verify], [--no-verify]                              # Verifies RBIs are up-to-date
-                                                                    # Default: false
-  -q,        [--quiet], [--no-quiet]                                # Suppresses file creation output
-                                                                    # Default: false
-  -w,        [--workers=N]                                          # Number of parallel workers to use when generating RBIs (default: 2)
-                                                                    # Default: 2
-             [--rbi-max-line-length=N]                              # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
-                                                                    # Default: 120
-  -e,        [--environment=ENVIRONMENT]                            # The Rack/Rails environment to use when generating RBIs
-                                                                    # Default: development
-  -l,        [--list-compilers], [--no-list-compilers]              # List all loaded compilers
-                                                                    # Default: false
-             [--app-root=APP_ROOT]                                  # The path to the Rails application
-                                                                    # Default: .
-             [--halt-upon-load-error], [--no-halt-upon-load-error]  # Halt upon a load error while loading the Rails application
-                                                                    # Default: true
-  -c,        [--config=<config file path>]                          # Path to the Tapioca configuration file
-                                                                    # Default: sorbet/tapioca/config.yml
-  -V,        [--verbose], [--no-verbose]                            # Verbose output for debugging purposes
-                                                                    # Default: false
+  --out, -o, [--outdir=directory]                                                                  # The output directory for generated DSL RBI files
+                                                                                                   # Default: sorbet/rbi/dsl
+             [--file-header], [--no-file-header], [--skip-file-header]                             # Add a "This file is generated" header on top of each generated RBI file
+                                                                                                   # Default: true
+             [--only=compiler [compiler ...]]                                                      # Only run supplied DSL compiler(s)
+             [--exclude=compiler [compiler ...]]                                                   # Exclude supplied DSL compiler(s)
+             [--verify], [--no-verify], [--skip-verify]                                            # Verifies RBIs are up-to-date
+                                                                                                   # Default: false
+  -q,        [--quiet], [--no-quiet], [--skip-quiet]                                               # Suppresses file creation output
+                                                                                                   # Default: false
+  -w,        [--workers=N]                                                                         # Number of parallel workers to use when generating RBIs (default: 2)
+                                                                                                   # Default: 2
+             [--rbi-max-line-length=N]                                                             # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
+                                                                                                   # Default: 120
+  -e,        [--environment=ENVIRONMENT]                                                           # The Rack/Rails environment to use when generating RBIs
+                                                                                                   # Default: development
+  -l,        [--list-compilers], [--no-list-compilers], [--skip-list-compilers]                    # List all loaded compilers
+                                                                                                   # Default: false
+             [--app-root=APP_ROOT]                                                                 # The path to the Rails application
+                                                                                                   # Default: .
+             [--halt-upon-load-error], [--no-halt-upon-load-error], [--skip-halt-upon-load-error]  # Halt upon a load error while loading the Rails application
+                                                                                                   # Default: true
+  -c,        [--config=<config file path>]                                                         # Path to the Tapioca configuration file
+                                                                                                   # Default: sorbet/tapioca/config.yml
+  -V,        [--verbose], [--no-verbose], [--skip-verbose]                                         # Verbose output for debugging purposes
+                                                                                                   # Default: false
 
 Generate RBIs for dynamic methods
 ```
@@ -521,6 +531,18 @@ Reason:
 
 This option can be used on CI to make sure the RBI files are always up-to-date and ensure accurate type checking.
 
+If you are using Rails, you can configure `tapioca dsl` to run after each migration:
+
+```ruby
+# Rakefile
+if Rails.env.development?
+  namespace :db do
+    task :migrate do # Appends to the existing `db:migrate` task
+      system("bundle exec tapioca dsl", exception: true)
+    end
+  end
+```
+
 #### Writing custom DSL compilers
 
 It is possible to create your own compilers for DSLs not supported by Tapioca out of the box.
@@ -840,23 +862,23 @@ Usage:
   tapioca check-shims
 
 Options:
-      [--gem-rbi-dir=GEM_RBI_DIR]                  # Path to gem RBIs
-                                                   # Default: sorbet/rbi/gems
-      [--dsl-rbi-dir=DSL_RBI_DIR]                  # Path to DSL RBIs
-                                                   # Default: sorbet/rbi/dsl
-      [--shim-rbi-dir=SHIM_RBI_DIR]                # Path to shim RBIs
-                                                   # Default: sorbet/rbi/shims
-      [--annotations-rbi-dir=ANNOTATIONS_RBI_DIR]  # Path to annotations RBIs
-                                                   # Default: sorbet/rbi/annotations
-      [--todo-rbi-file=TODO_RBI_FILE]              # Path to the generated todo RBI file
-                                                   # Default: sorbet/rbi/todo.rbi
-      [--payload], [--no-payload]                  # Check shims against Sorbet's payload
-                                                   # Default: true
-  -w, [--workers=N]                                # Number of parallel workers (default: auto)
-  -c, [--config=<config file path>]                # Path to the Tapioca configuration file
-                                                   # Default: sorbet/tapioca/config.yml
-  -V, [--verbose], [--no-verbose]                  # Verbose output for debugging purposes
-                                                   # Default: false
+      [--gem-rbi-dir=GEM_RBI_DIR]                    # Path to gem RBIs
+                                                     # Default: sorbet/rbi/gems
+      [--dsl-rbi-dir=DSL_RBI_DIR]                    # Path to DSL RBIs
+                                                     # Default: sorbet/rbi/dsl
+      [--shim-rbi-dir=SHIM_RBI_DIR]                  # Path to shim RBIs
+                                                     # Default: sorbet/rbi/shims
+      [--annotations-rbi-dir=ANNOTATIONS_RBI_DIR]    # Path to annotations RBIs
+                                                     # Default: sorbet/rbi/annotations
+      [--todo-rbi-file=TODO_RBI_FILE]                # Path to the generated todo RBI file
+                                                     # Default: sorbet/rbi/todo.rbi
+      [--payload], [--no-payload], [--skip-payload]  # Check shims against Sorbet's payload
+                                                     # Default: true
+  -w, [--workers=N]                                  # Number of parallel workers (default: auto)
+  -c, [--config=<config file path>]                  # Path to the Tapioca configuration file
+                                                     # Default: sorbet/tapioca/config.yml
+  -V, [--verbose], [--no-verbose], [--skip-verbose]  # Verbose output for debugging purposes
+                                                     # Default: false
 
 Check duplicated definitions in shim RBIs
 ```

data/lib/tapioca/commands/abstract_dsl.rb

@@ -175,10 +175,11 @@ module Tapioca
 
         unless unprocessable_compilers.empty?
           message = unprocessable_compilers.map do |name, _|
-            set_color("Error: Cannot find compiler '#{name}'", :red)
+            set_color("Warning: Cannot find compiler '#{name}'", :yellow)
           end.join("\n")
 
-          raise Thor::Error, message
+          say(message)
+          say("")
         end
 
         T.cast(compiler_map.values, T::Array[T.class_of(Tapioca::Dsl::Compiler)])

data/lib/tapioca/commands/abstract_gem.rb

@@ -118,7 +118,9 @@ module Tapioca
           reason: "types exported from the `#{gem.name}` gem",
         ) if @file_header
 
-        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc, include_loc: @include_loc).compile
+        rbi.root = Runtime::Trackers::Autoload.with_disabled_exits do
+          Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc, include_loc: @include_loc).compile
+        end
 
         merge_with_exported_rbi(gem, rbi) if @include_exported_rbis
 

data/lib/tapioca/dsl/compilers/active_model_attributes.rb

@@ -3,6 +3,8 @@
 
 return unless defined?(ActiveModel::Attributes)
 
+require "tapioca/dsl/helpers/active_model_type_helper"
+
 module Tapioca
   module Dsl
     module Compilers
@@ -99,11 +101,6 @@ module Tapioca
 
         sig { params(attribute_type_value: T.untyped).returns(::String) }
         def type_for(attribute_type_value)
-          # This guarantees that the type will remain as T.untyped for attributes in the following form:
-          # attribute :name
-          # This is because for a generic attribute with no specified type, ActiveModel::Type::Value.new is returned
-          return "T.untyped" if attribute_type_value.instance_of?(ActiveModel::Type::Value)
-
           type = case attribute_type_value
           when ActiveModel::Type::Boolean
             "T::Boolean"
@@ -120,7 +117,7 @@ module Tapioca
           when ActiveModel::Type::String
             "::String"
           else
-            attribute_type_value.class.name.to_s
+            Helpers::ActiveModelTypeHelper.type_for(attribute_type_value)
           end
 
           as_nilable_type(type)

data/lib/tapioca/dsl/compilers/active_model_secure_password.rb

@@ -78,7 +78,15 @@ module Tapioca
 
           root.create_path(constant) do |klass|
             methods.each do |method|
-              create_method_from_def(klass, constant.instance_method(method))
+              if method == :authenticate || method.start_with?("authenticate_")
+                klass.create_method(
+                  method.to_s,
+                  parameters: [create_param("unencrypted_password", type: "T.untyped")],
+                  return_type: "T.any(#{constant}, FalseClass)",
+                )
+              else
+                create_method_from_def(klass, constant.instance_method(method))
+              end
             end
           end
         end

data/lib/tapioca/dsl/compilers/active_record_relations.rb

@@ -58,16 +58,6 @@ module Tapioca
       # `Model::PrivateRelation` modules, so that, for example, `find_by` and `all` can be chained off of the
       # `Model` class.
       #
-      # **A note on find**: `find` is typed as `T.untyped` by default.
-      #
-      # While it is often used in the manner of `Model.find(id)`, Rails does support pasing in an array to find, which
-      # would then return a `T::Enumerable[Model]`. This would force a static cast everywhere find is used to avoid type
-      # errors. This is not ideal considering very few users of find use the array syntax over a where. With untyped,
-      # this cast is optional and so it was decided to avoid typing it. If you need runtime guarentees when using `find`
-      # the best method of doing so is by casting the return value to the model: `T.cast(Model.find(id), Model)`.
-      # `find_by` does guarentee a return value of `Model`, so find can can be refactored accordingly:
-      # `Model.find_by!(id: id)`. This will avoid the cast requirement at runtime.
-      #
       # **CAUTION**: The generated relation classes are named `PrivateXXX` intentionally to reflect the fact
       # that they represent private subconstants of the Active Record model. As such, these types do not
       # exist at runtime, and their counterparts that do exist at runtime are marked `private_constant` anyway.
@@ -200,6 +190,8 @@ module Tapioca
             query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
             # Remove the ones we know are private API
             query_methods -= [:arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
+            # Remove "group" which needs a custom return type for GroupChains
+            query_methods -= [:group]
             # Remove "where" which needs a custom return type for WhereChains
             query_methods -= [:where]
             # Remove the methods that ...
@@ -304,6 +296,7 @@ module Tapioca
             end
           end
 
+          create_relation_group_chain_class
           create_relation_where_chain_class
         end
 
@@ -322,9 +315,87 @@ module Tapioca
             end
           end
 
+          create_association_relation_group_chain_class
           create_association_relation_where_chain_class
         end
 
+        sig { void }
+        def create_relation_group_chain_class
+          model.create_class(RelationGroupChainClassName, superclass_name: RelationClassName) do |klass|
+            create_group_chain_methods(klass)
+            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+          end
+        end
+
+        sig { void }
+        def create_association_relation_group_chain_class
+          model.create_class(
+            AssociationRelationGroupChainClassName,
+            superclass_name: AssociationRelationClassName,
+          ) do |klass|
+            create_group_chain_methods(klass)
+            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+          end
+        end
+
+        sig { params(klass: RBI::Scope).void }
+        def create_group_chain_methods(klass)
+          # Calculation methods used with `group` return a hash where the keys cannot be typed
+          # but the values can. Technically a `group` anywhere in the query chain produces
+          # this behavior but to avoid needing to re-type every query method inside this module
+          # we make a simplifying assumption that the calculation method is called immediately
+          # after the group (e.g. `group().count` and not `group().where().count`). The one
+          # exception is `group().having().count` which is fairly idiomatic so that gets handled
+          # without breaking the chain.
+          klass.create_method(
+            "having",
+            parameters: [
+              create_rest_param("args", type: "T.untyped"),
+              create_block_param("blk", type: "T.untyped"),
+            ],
+            return_type: "T.self_type",
+          )
+
+          CALCULATION_METHODS.each do |method_name|
+            case method_name
+            when :average, :maximum, :minimum
+              klass.create_method(
+                method_name.to_s,
+                parameters: [
+                  create_param("column_name", type: "T.any(String, Symbol)"),
+                ],
+                return_type: "T::Hash[T.untyped, #{method_name == :average ? "Numeric" : "T.untyped"}]",
+              )
+            when :calculate
+              klass.create_method(
+                "calculate",
+                parameters: [
+                  create_param("operation", type: "Symbol"),
+                  create_param("column_name", type: "T.any(String, Symbol)"),
+                ],
+                return_type: "T::Hash[T.untyped, Numeric]",
+              )
+            when :count
+              klass.create_method(
+                "count",
+                parameters: [
+                  create_opt_param("column_name", type: "T.untyped", default: "nil"),
+                ],
+                return_type: "T::Hash[T.untyped, Integer]",
+              )
+            when :sum
+              klass.create_method(
+                "sum",
+                parameters: [
+                  create_opt_param("column_name", type: "T.nilable(T.any(String, Symbol))", default: "nil"),
+                  create_block_param("block", type: "T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))"),
+                ],
+                return_type: "T::Hash[T.untyped, Numeric]",
+              )
+            end
+          end
+        end
+
         sig { void }
         def create_relation_where_chain_class
           model.create_class(RelationWhereChainClassName, superclass_name: RelationClassName) do |klass|
@@ -468,6 +539,15 @@ module Tapioca
         sig { void }
         def create_relation_methods
           create_relation_method("all")
+          create_relation_method(
+            "group",
+            parameters: [
+              create_rest_param("args", type: "T.untyped"),
+              create_block_param("blk", type: "T.untyped"),
+            ],
+            relation_return_type: RelationGroupChainClassName,
+            association_return_type: AssociationRelationGroupChainClassName,
+          )
           create_relation_method(
             "where",
             parameters: [
@@ -479,13 +559,29 @@ module Tapioca
           )
 
           QUERY_METHODS.each do |method_name|
-            create_relation_method(
-              method_name,
-              parameters: [
-                create_rest_param("args", type: "T.untyped"),
-                create_block_param("blk", type: "T.untyped"),
-              ],
-            )
+            case method_name
+            when :extract_associated
+              parameters = [create_param("association", type: "Symbol")]
+              return_type = "T::Array[T.untyped]"
+              relation_methods_module.create_method(
+                method_name.to_s,
+                parameters: parameters,
+                return_type: return_type,
+              )
+              association_relation_methods_module.create_method(
+                method_name.to_s,
+                parameters: parameters,
+                return_type: return_type,
+              )
+            else
+              create_relation_method(
+                method_name,
+                parameters: [
+                  create_rest_param("args", type: "T.untyped"),
+                  create_block_param("blk", type: "T.untyped"),
+                ],
+              )
+            end
           end
         end
 
@@ -560,12 +656,29 @@ module Tapioca
                 return_type: "T::Boolean",
               )
             when :find
-              create_common_method(
+              # From ActiveRecord::ConnectionAdapter::Quoting#quote, minus nil
+              id_types = "T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, " \
+                "::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, " \
+                "::ActiveSupport::Duration, T::Class[T.anything])"
+              array_type = if constant.try(:composite_primary_key?)
+                "T::Array[T::Array[#{id_types}]"
+              else
+                "T::Array[#{id_types}]"
+              end
+              sigs = [
+                common_relation_methods_module.create_sig(
+                  parameters: [create_param("args", type: id_types)],
+                  return_type: constant_name,
+                ),
+                common_relation_methods_module.create_sig(
+                  parameters: [create_param("args", type: array_type)],
+                  return_type: "T::Enumerable[#{constant_name}]",
+                ),
+              ]
+              common_relation_methods_module.create_method_with_sigs(
                 "find",
-                parameters: [
-                  create_rest_param("args", type: "T.untyped"),
-                ],
-                return_type: "T.untyped",
+                sigs: sigs,
+                parameters: [RBI::ReqParam.new("args")],
               )
             when :find_by
               create_common_method(
@@ -599,12 +712,20 @@ module Tapioca
                 return_type: constant_name,
               )
             when :first, :last, :take
-              create_common_method(
-                method_name,
-                parameters: [
-                  create_opt_param("limit", type: "T.untyped", default: "nil"),
-                ],
-                return_type: "T.untyped",
+              sigs = [
+                common_relation_methods_module.create_sig(
+                  parameters: [create_opt_param("limit", type: "NilClass", default: "nil")],
+                  return_type: as_nilable_type(constant_name),
+                ),
+                common_relation_methods_module.create_sig(
+                  parameters: [create_param("limit", type: "Integer")],
+                  return_type: "T::Array[#{constant_name}]",
+                ),
+              ]
+              common_relation_methods_module.create_method_with_sigs(
+                method_name.to_s,
+                sigs: sigs,
+                parameters: [RBI::OptParam.new("limit", "nil")],
               )
             when :raise_record_not_found_exception!
               # skip
@@ -653,7 +774,7 @@ module Tapioca
                 parameters: [
                   create_param("column_name", type: "T.any(String, Symbol)"),
                 ],
-                return_type: "T.untyped",
+                return_type: method_name == :average ? "Numeric" : "T.untyped",
               )
             when :calculate
               create_common_method(
@@ -662,7 +783,7 @@ module Tapioca
                   create_param("operation", type: "Symbol"),
                   create_param("column_name", type: "T.any(String, Symbol)"),
                 ],
-                return_type: "T.untyped",
+                return_type: "Numeric",
               )
             when :count
               create_common_method(
@@ -670,7 +791,7 @@ module Tapioca
                 parameters: [
                   create_opt_param("column_name", type: "T.untyped", default: "nil"),
                 ],
-                return_type: "T.untyped",
+                return_type: "Integer",
               )
             when :ids
               create_common_method("ids", return_type: "Array")
@@ -689,7 +810,7 @@ module Tapioca
                   create_opt_param("column_name", type: "T.nilable(T.any(String, Symbol))", default: "nil"),
                   create_block_param("block", type: "T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))"),
                 ],
-                return_type: "T.untyped",
+                return_type: "Numeric",
               )
             end
           end
@@ -698,51 +819,121 @@ module Tapioca
             case method_name
             when :find_each
               order = ActiveRecord::Batches.instance_method(:find_each).parameters.include?([:key, :order])
-              create_common_method(
+              sigs = [
+                common_relation_methods_module.create_sig(
+                  parameters: [
+                    create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("batch_size", type: "Integer", default: "1000"),
+                    create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                    *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                    create_block_param("block", type: "T.proc.params(object: #{constant_name}).void"),
+                  ],
+                  return_type: "void",
+                ),
+                common_relation_methods_module.create_sig(
+                  parameters: [
+                    create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("batch_size", type: "Integer", default: "1000"),
+                    create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                    *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                  ],
+                  return_type: "T::Enumerator[#{constant_name}]",
+                ),
+              ]
+              common_relation_methods_module.create_method_with_sigs(
                 "find_each",
+                sigs: sigs,
                 parameters: [
-                  create_kw_opt_param("start", type: "T.untyped", default: "nil"),
-                  create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
-                  create_kw_opt_param("batch_size", type: "Integer", default: "1000"),
-                  create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
-                  *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
-                  create_block_param("block", type: "T.nilable(T.proc.params(object: #{constant_name}).void)"),
+                  RBI::KwOptParam.new("start", "nil"),
+                  RBI::KwOptParam.new("finish", "nil"),
+                  RBI::KwOptParam.new("batch_size", "1000"),
+                  RBI::KwOptParam.new("error_on_ignore", "nil"),
+                  *(RBI::KwOptParam.new("order", ":asc") if order),
+                  RBI::BlockParam.new("block"),
                 ],
-                return_type: "T.nilable(T::Enumerator[#{constant_name}])",
               )
             when :find_in_batches
               order = ActiveRecord::Batches.instance_method(:find_in_batches).parameters.include?([:key, :order])
-              create_common_method(
+              sigs = [
+                common_relation_methods_module.create_sig(
+                  parameters: [
+                    create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("batch_size", type: "Integer", default: "1000"),
+                    create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                    *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                    create_block_param("block", type: "T.proc.params(object: T::Array[#{constant_name}]).void"),
+                  ],
+                  return_type: "void",
+                ),
+                common_relation_methods_module.create_sig(
+                  parameters: [
+                    create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("batch_size", type: "Integer", default: "1000"),
+                    create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                    *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                  ],
+                  return_type: "T::Enumerator[T::Enumerator[#{constant_name}]]",
+                ),
+              ]
+              common_relation_methods_module.create_method_with_sigs(
                 "find_in_batches",
+                sigs: sigs,
                 parameters: [
-                  create_kw_opt_param("start", type: "T.untyped", default: "nil"),
-                  create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
-                  create_kw_opt_param("batch_size", type: "Integer", default: "1000"),
-                  create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
-                  *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
-                  create_block_param(
-                    "block",
-                    type: "T.nilable(T.proc.params(object: T::Array[#{constant_name}]).void)",
-                  ),
+                  RBI::KwOptParam.new("start", "nil"),
+                  RBI::KwOptParam.new("finish", "nil"),
+                  RBI::KwOptParam.new("batch_size", "1000"),
+                  RBI::KwOptParam.new("error_on_ignore", "nil"),
+                  *(RBI::KwOptParam.new("order", ":asc") if order),
+                  RBI::BlockParam.new("block"),
                 ],
-                return_type: "T.nilable(T::Enumerator[T::Enumerator[#{constant_name}]])",
               )
             when :in_batches
               order = ActiveRecord::Batches.instance_method(:in_batches).parameters.include?([:key, :order])
               use_ranges = ActiveRecord::Batches.instance_method(:in_batches).parameters.include?([:key, :use_ranges])
-              create_common_method(
+              sigs = [
+                common_relation_methods_module.create_sig(
+                  parameters: [
+                    create_kw_opt_param("of", type: "Integer", default: "1000"),
+                    create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("load", type: "T.untyped", default: "false"),
+                    create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                    *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                    *(create_kw_opt_param("use_ranges", type: "T.untyped", default: "nil") if use_ranges),
+                    create_block_param("block", type: "T.proc.params(object: #{RelationClassName}).void"),
+                  ],
+                  return_type: "void",
+                ),
+                common_relation_methods_module.create_sig(
+                  parameters: [
+                    create_kw_opt_param("of", type: "Integer", default: "1000"),
+                    create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                    create_kw_opt_param("load", type: "T.untyped", default: "false"),
+                    create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                    *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                    *(create_kw_opt_param("use_ranges", type: "T.untyped", default: "nil") if use_ranges),
+                  ],
+                  return_type: "::ActiveRecord::Batches::BatchEnumerator",
+                ),
+              ]
+              common_relation_methods_module.create_method_with_sigs(
                 "in_batches",
+                sigs: sigs,
                 parameters: [
-                  create_kw_opt_param("of", type: "Integer", default: "1000"),
-                  create_kw_opt_param("start", type: "T.untyped", default: "nil"),
-                  create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
-                  create_kw_opt_param("load", type: "T.untyped", default: "false"),
-                  create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
-                  *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
-                  *(create_kw_opt_param("use_ranges", type: "T.untyped", default: "nil") if use_ranges),
-                  create_block_param("block", type: "T.nilable(T.proc.params(object: #{RelationClassName}).void)"),
+                  RBI::KwOptParam.new("of", "1000"),
+                  RBI::KwOptParam.new("start", "nil"),
+                  RBI::KwOptParam.new("finish", "nil"),
+                  RBI::KwOptParam.new("load", "false"),
+                  RBI::KwOptParam.new("error_on_ignore", "nil"),
+                  *(RBI::KwOptParam.new("order", ":asc") if order),
+                  *(RBI::KwOptParam.new("use_ranges", "nil") if use_ranges),
+                  RBI::BlockParam.new("block"),
                 ],
-                return_type: "T.nilable(::ActiveRecord::Batches::BatchEnumerator)",
               )
             end
           end

data/lib/tapioca/dsl/compilers/config.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-return unless defined?(Config)
+return unless defined?(Config) && defined?(Config::VERSION) && defined?(Config.const_name)
 
 module Tapioca
   module Dsl

data/lib/tapioca/dsl/compilers/protobuf.rb

@@ -302,6 +302,13 @@ module Tapioca
             return_type: "void",
           )
 
+          if desc.has_presence?
+            klass.create_method(
+              "has_#{field.name}?",
+              return_type: "Object",
+            )
+          end
+
           field
         end
 

data/lib/tapioca/dsl/helpers/active_model_type_helper.rb

@@ -0,0 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Dsl
+    module Helpers
+      module ActiveModelTypeHelper
+        class << self
+          extend T::Sig
+
+          # Returns the type indicated by the custom ActiveModel::Type::Value.
+          # Accepts subclasses of ActiveModel::Type::Value as well as classes that implement similar methods.
+          sig { params(type_value: T.untyped).returns(String) }
+          def type_for(type_value)
+            return "T.untyped" if Runtime::GenericTypeRegistry.generic_type_instance?(type_value)
+
+            type = lookup_return_type_of_method(type_value, :deserialize) ||
+              lookup_return_type_of_method(type_value, :cast) ||
+              lookup_return_type_of_method(type_value, :cast_value) ||
+              lookup_arg_type_of_method(type_value, :serialize) ||
+              T.untyped
+            type.to_s
+          end
+
+          private
+
+          MEANINGLESS_TYPES = T.let(
+            [
+              T.untyped,
+              T.noreturn,
+              T::Private::Types::Void,
+              T::Private::Types::NotTyped,
+            ].freeze,
+            T::Array[Object],
+          )
+
+          sig { params(type: T.untyped).returns(T::Boolean) }
+          def meaningful_type?(type)
+            !MEANINGLESS_TYPES.include?(type)
+          end
+
+          sig { params(obj: T.untyped, method: Symbol).returns(T.nilable(T::Types::Base)) }
+          def lookup_return_type_of_method(obj, method)
+            return_type = lookup_signature_of_method(obj, method)&.return_type
+            return unless return_type && meaningful_type?(return_type)
+
+            return_type
+          end
+
+          sig { params(obj: T.untyped, method: Symbol).returns(T.nilable(T::Types::Base)) }
+          def lookup_arg_type_of_method(obj, method)
+            # Arg types is an array of [name, type] entries, so we dig into first entry (index 0)
+            # and then into the type which is the last element (index 1)
+            first_arg_type = lookup_signature_of_method(obj, method)&.arg_types&.dig(0, 1)
+            return unless first_arg_type && meaningful_type?(first_arg_type)
+
+            first_arg_type
+          end
+
+          sig { params(obj: T.untyped, method: Symbol).returns(T.untyped) }
+          def lookup_signature_of_method(obj, method)
+            Runtime::Reflection.signature_of(obj.method(method))
+          rescue NameError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "tapioca/dsl/helpers/active_model_type_helper"
+
 module Tapioca
   module Dsl
     module Helpers
@@ -98,7 +100,7 @@ module Tapioca
             ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
             "T::Array[#{type_for_activerecord_value(column_type.subtype)}]"
           else
-            handle_unknown_type(column_type)
+            ActiveModelTypeHelper.type_for(column_type)
           end
         end
 
@@ -108,40 +110,6 @@ module Tapioca
             !(constant.singleton_class < Object.const_get(:StrongTypeGeneration))
         end
 
-        sig { params(column_type: BasicObject).returns(String) }
-        def handle_unknown_type(column_type)
-          return "T.untyped" unless ActiveModel::Type::Value === column_type
-          return "T.untyped" if Runtime::GenericTypeRegistry.generic_type_instance?(column_type)
-
-          lookup_return_type_of_method(column_type, :deserialize) ||
-            lookup_return_type_of_method(column_type, :cast) ||
-            lookup_arg_type_of_method(column_type, :serialize) ||
-            "T.untyped"
-        end
-
-        sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
-        def lookup_return_type_of_method(column_type, method)
-          signature = Runtime::Reflection.signature_of(column_type.method(method))
-          return unless signature
-
-          return_type = signature.return_type
-          return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
-
-          return_type.to_s
-        end
-
-        sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
-        def lookup_arg_type_of_method(column_type, method)
-          signature = Runtime::Reflection.signature_of(column_type.method(method))
-          return unless signature
-
-          # Arg types is an array [name, type] entries, so we desctructure the type of
-          # first argument to get the first argument type
-          _, first_argument_type = signature.arg_types.first
-
-          first_argument_type.to_s
-        end
-
         sig { params(column_type: ActiveRecord::Enum::EnumType).returns(String) }
         def enum_setter_type(column_type)
           # In Rails < 7 this method is private. When support for that is dropped we can call the method directly

data/lib/tapioca/dsl/helpers/active_record_constants_helper.rb

@@ -22,8 +22,10 @@ module Tapioca
         CommonRelationMethodsModuleName = T.let("CommonRelationMethods", String)
 
         RelationClassName = T.let("PrivateRelation", String)
+        RelationGroupChainClassName = T.let("PrivateRelationGroupChain", String)
         RelationWhereChainClassName = T.let("PrivateRelationWhereChain", String)
         AssociationRelationClassName = T.let("PrivateAssociationRelation", String)
+        AssociationRelationGroupChainClassName = T.let("PrivateAssociationRelationGroupChain", String)
         AssociationRelationWhereChainClassName = T.let("PrivateAssociationRelationWhereChain", String)
         AssociationsCollectionProxyClassName = T.let("PrivateCollectionProxy", String)
       end

data/lib/tapioca/dsl/pipeline.rb

@@ -61,7 +61,7 @@ module Tapioca
           .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
         # It's OK if there are no constants to process if we received a valid file/path.
-        if constants_to_process.empty? && requested_paths.select { |p| File.exist?(p) }.empty?
+        if constants_to_process.empty? && requested_paths.none? { |p| File.exist?(p) }
           report_error(<<~ERROR)
             No classes/modules can be matched for RBI generation.
             Please check that the requested classes/modules include processable DSL methods.

data/lib/tapioca/gemfile.rb

@@ -178,7 +178,18 @@ module Tapioca
 
       sig { void }
       def parse_yard_docs
-        files.each { |path| YARD.parse(path.to_s, [], Logger::Severity::FATAL) }
+        files.each do |path|
+          YARD.parse(path.to_s, [], Logger::Severity::FATAL)
+        rescue RangeError
+          # In some circumstances, YARD will raise an error when parsing a file
+          # that is actually valid Ruby. We don't want tapioca to halt in these
+          # cases, so we'll rescue the error, pretend like there was no
+          # documentation, and move on.
+          #
+          # This can be removed when https://github.com/lsegal/yard/issues/1536
+          # is resolved and released.
+          []
+        end
       end
 
       sig { returns(T::Array[String]) }

data/lib/tapioca/rbi_ext/model.rb

@@ -87,24 +87,56 @@ module RBI
       ).void
     end
     def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new,
+      comments: [])
+      sig = create_sig(parameters: parameters, return_type: return_type)
+      create_method_with_sigs(
+        name,
+        sigs: [sig],
+        parameters: parameters.map(&:param),
+        class_method: class_method,
+        visibility: visibility,
+        comments: comments,
+      )
+    end
+
+    sig do
+      params(
+        name: String,
+        sigs: T::Array[RBI::Sig],
+        parameters: T::Array[RBI::Param],
+        class_method: T::Boolean,
+        visibility: RBI::Visibility,
+        comments: T::Array[RBI::Comment],
+      ).void
+    end
+    def create_method_with_sigs(name, sigs:, parameters: [], class_method: false, visibility: RBI::Public.new,
       comments: [])
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
-      sig = RBI::Sig.new(return_type: return_type)
       method = RBI::Method.new(
         name,
-        sigs: [sig],
+        sigs: sigs,
+        params: parameters,
         is_singleton: class_method,
         visibility: visibility,
         comments: comments,
       )
-      parameters.each do |param|
-        method << param.param
-        sig << RBI::SigParam.new(param.param.name, param.type)
-      end
       self << method
     end
 
+    sig do
+      params(
+        parameters: T::Array[RBI::TypedParam],
+        return_type: String,
+      ).returns(RBI::Sig)
+    end
+    def create_sig(parameters: [], return_type: "T.untyped")
+      params = parameters.map do |param|
+        RBI::SigParam.new(param.param.name, param.type)
+      end
+      RBI::Sig.new(params: params, return_type: return_type)
+    end
+
     private
 
     sig { returns(T::Hash[String, RBI::Node]) }

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-25 00:00:00.000000000 Z
+date: 2024-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,21 +81,18 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.10820
+        version: 0.5.11087
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.10820
+        version: 0.5.11087
 - !ruby/object:Gem::Dependency
   name: spoom
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.2.0
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.0
@@ -103,9 +100,6 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.2.0
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.0
@@ -209,6 +203,7 @@ files:
 - lib/tapioca/dsl/extensions/active_record.rb
 - lib/tapioca/dsl/extensions/frozen_record.rb
 - lib/tapioca/dsl/extensions/kredis.rb
+- lib/tapioca/dsl/helpers/active_model_type_helper.rb
 - lib/tapioca/dsl/helpers/active_record_column_type_helper.rb
 - lib/tapioca/dsl/helpers/active_record_constants_helper.rb
 - lib/tapioca/dsl/helpers/graphql_type_helper.rb
@@ -293,7 +288,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
+rubygems_version: 3.5.6
 signing_key: 
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard