tapioca 0.13.3 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: feabe451c23d5c95ab011b2996a0f53daee19e20d7bf7075aeb4da7fa812f9a5
-  data.tar.gz: 1a47b4e7a3942786a0fd064c8c49bb02aae2f79f23bf22a2933a6608ba68ca5e
+  metadata.gz: 469c53709eb6cb5de25abc9526d40c8dff3b852bf218bcbbc966078271754bfd
+  data.tar.gz: fbc47526d02ef8fea90ad262007865ee56ab56a72dc5832c375540f42a3d9e11
 SHA512:
-  metadata.gz: 982979631a9a78a2f6b589be02f2064b94fd6b95675316a2bd2271a21f2366af752c994ade6194d412f5bbabf5666623416e728d2c4d56dd336d5b17d8803f03
-  data.tar.gz: 1fb7b58f1f361a5a05d25a7dfad6b491efc65c084be0c3e293755e81192ac8e25c8477b1f6f75c12fe0740cf8e8ed38921e5e314b63f54efb7189aa9edd03cd3
+  metadata.gz: f64c8009bf0e0d5a4b11595cc0bf9c72c5aca3fee4bcae7da5b036009dc0e27c9c5fc2d921564f9664aef0f2b1a648000e3228902d3d2a8b13338af85773d48e
+  data.tar.gz: b751f2a0618927d616edebad5841333af85cb5c7d773bd8904c119d521ab871a65b3405c72efe56426faccdada8b32204f2e5a56cde3ddc4f067884270f106b4

data/README.md

@@ -500,6 +500,7 @@ Options:
                                                                                                    # 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
+             [--skip-constant=constant [constant ...]]                                             # Do not generate RBI definitions for the given application constant(s)
   -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
@@ -885,7 +886,7 @@ Check duplicated definitions in shim RBIs
 ```
 <!-- END_HELP_COMMAND_CHECK_SHIMS -->
 
-Depending on the amount of meta-programming used in your project this can mean an overwhelming amount of manual work. In this case, you should consider [writting a custom DSL compiler](#writing-custom-dsl-compilers).
+Depending on the amount of meta-programming used in your project this can mean an overwhelming amount of manual work. In this case, you should consider [writing a custom DSL compiler](#writing-custom-dsl-compilers).
 
 ### Configuration
 
@@ -933,6 +934,7 @@ dsl:
   list_compilers: false
   app_root: "."
   halt_upon_load_error: true
+  skip_constant: []
 gem:
   outdir: sorbet/rbi/gems
   file_header: true

data/lib/tapioca/cli.rb

@@ -135,6 +135,11 @@ module Tapioca
       type: :boolean,
       desc: "Halt upon a load error while loading the Rails application",
       default: true
+    option :skip_constant,
+      type: :array,
+      banner: "constant [constant ...]",
+      desc: "Do not generate RBI definitions for the given application constant(s)",
+      default: []
     def dsl(*constant_or_paths)
       set_environment(options)
 
@@ -149,6 +154,7 @@ module Tapioca
         exclude: options[:exclude],
         file_header: options[:file_header],
         tapioca_path: TAPIOCA_DIR,
+        skip_constant: options[:skip_constant],
         quiet: options[:quiet],
         verbose: options[:verbose],
         number_of_workers: options[:workers],

data/lib/tapioca/commands/abstract_dsl.rb

@@ -18,6 +18,7 @@ module Tapioca
           exclude: T::Array[String],
           file_header: T::Boolean,
           tapioca_path: String,
+          skip_constant: T::Array[String],
           quiet: T::Boolean,
           verbose: T::Boolean,
           number_of_workers: T.nilable(Integer),
@@ -36,6 +37,7 @@ module Tapioca
         exclude:,
         file_header:,
         tapioca_path:,
+        skip_constant: [],
         quiet: false,
         verbose: false,
         number_of_workers: nil,
@@ -60,6 +62,7 @@ module Tapioca
         @rbi_formatter = rbi_formatter
         @app_root = app_root
         @halt_upon_load_error = halt_upon_load_error
+        @skip_constant = skip_constant
 
         super()
       end
@@ -124,6 +127,7 @@ module Tapioca
           error_handler: ->(error) {
             say_error(error, :bold, :red)
           },
+          skipped_constants: constantize(@skip_constant),
           number_of_workers: @number_of_workers,
         )
       end

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

@@ -81,7 +81,7 @@ module Tapioca
             # Create helper method module
             controller.create_module(helper_methods_name) do |helper_methods|
               # If the controller has no helper defined, then it just inherits
-              # the Action Controlller base helper methods module, so we should
+              # the Action Controller base helper methods module, so we should
               # just add that as an include and stop doing more processing.
               if helpers_module.name == "ActionController::Base::HelperMethods"
                 next helper_methods.create_include(T.must(qualified_name_of(helpers_module)))

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

@@ -66,7 +66,7 @@ module Tapioca
             # pre Rails 6.0, this used to be a single static module
             [ActiveModel::SecurePassword::InstanceMethodsOnActivation]
           else
-            # post Rails 6.0, this is now using a dynmaic module builder pattern
+            # post Rails 6.0, this is now using a dynamic module builder pattern
             # and we can have multiple different ones included into the model
             constant.ancestors.grep(ActiveModel::SecurePassword::InstanceMethodsOnActivation)
           end

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

@@ -92,6 +92,12 @@ module Tapioca
       #
       #     sig { returns(T.nilable(::Category)) }
       #     def reload_category; end
+      #
+      #     sig { void }
+      #     def reset_author; end
+      #
+      #     sig { void }
+      #     def reset_category; end
       #   end
       # end
       # ~~~
@@ -196,6 +202,10 @@ module Tapioca
             "reload_#{association_name}",
             return_type: association_type,
           )
+          klass.create_method(
+            "reset_#{association_name}",
+            return_type: "void",
+          )
           unless reflection.polymorphic?
             klass.create_method(
               "build_#{association_name}",

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

@@ -1,7 +1,9 @@
 # typed: strict
 # frozen_string_literal: true
 
-return unless defined?(Rails) && defined?(ActiveSupport::TestCase) && defined?(ActiveRecord::TestFixtures)
+return unless defined?(Rails) &&
+  defined?(ActiveSupport::TestCase) &&
+  defined?(ActiveRecord::TestFixtures)
 
 module Tapioca
   module Dsl
@@ -24,8 +26,10 @@ module Tapioca
       # # test_case.rbi
       # # typed: true
       # class ActiveSupport::TestCase
-      #   sig { params(fixture_names: T.any(String, Symbol)).returns(T.untyped) }
-      #   def posts(*fixture_names); end
+      #   sig { params(fixture_name: T.any(String, Symbol), other_fixtures: NilClass).returns(Post) }
+      #   sig { params(fixture_name: T.any(String, Symbol), other_fixtures: T.any(String, Symbol))
+      #           .returns(T::Array[Post]) }
+      #   def posts(fixture_name, *other_fixtures); end
       # end
       # ~~~
       class ActiveRecordFixtures < Compiler
@@ -104,10 +108,90 @@ module Tapioca
 
         sig { params(mod: RBI::Scope, name: String).void }
         def create_fixture_method(mod, name)
-          mod.create_method(
-            name,
-            parameters: [create_rest_param("fixture_names", type: "T.any(String, Symbol)")],
-            return_type: "T.untyped",
+          return_type = return_type_for_fixture(name)
+          mod << RBI::Method.new(name) do |node|
+            node.add_param("fixture_name")
+            node.add_rest_param("other_fixtures")
+
+            node.add_sig do |sig|
+              sig.add_param("fixture_name", "T.any(String, Symbol)")
+              sig.add_param("other_fixtures", "NilClass")
+              sig.return_type = return_type
+            end
+
+            node.add_sig do |sig|
+              sig.add_param("fixture_name", "T.any(String, Symbol)")
+              sig.add_param("other_fixtures", "T.any(String, Symbol)")
+              sig.return_type = "T::Array[#{return_type}]"
+            end
+          end
+        end
+
+        sig { params(fixture_name: String).returns(String) }
+        def return_type_for_fixture(fixture_name)
+          fixture_class_mapping_from_fixture_files[fixture_name] ||
+            fixture_class_from_fixture_set(fixture_name) ||
+            fixture_class_from_active_record_base_class_mapping[fixture_name] ||
+            "T.untyped"
+        end
+
+        sig { params(fixture_name: String).returns(T.nilable(String)) }
+        def fixture_class_from_fixture_set(fixture_name)
+          # only rails 7.1+ support fixture sets so this is conditional
+          return unless fixture_loader.respond_to?(:fixture_sets)
+
+          model_name_from_fixture_set = T.unsafe(fixture_loader).fixture_sets[fixture_name]
+          return unless model_name_from_fixture_set
+
+          model_name = ActiveRecord::FixtureSet.default_fixture_model_name(model_name_from_fixture_set)
+          return unless Object.const_defined?(model_name)
+
+          model_name
+        end
+
+        sig { returns(T::Hash[String, String]) }
+        def fixture_class_from_active_record_base_class_mapping
+          @fixture_class_mapping ||= T.let(
+            begin
+              ActiveRecord::Base.descendants.each_with_object({}) do |model_class, mapping|
+                class_name = model_class.name
+
+                fixture_name = class_name.underscore.gsub("/", "_")
+                fixture_name = fixture_name.pluralize if ActiveRecord::Base.pluralize_table_names
+
+                mapping[fixture_name] = class_name
+
+                mapping
+              end
+            end,
+            T.nilable(T::Hash[String, String]),
+          )
+        end
+
+        sig { returns(T::Hash[String, String]) }
+        def fixture_class_mapping_from_fixture_files
+          @fixture_file_class_mapping ||= T.let(
+            begin
+              fixture_paths = if T.unsafe(fixture_loader).respond_to?(:fixture_paths)
+                T.unsafe(fixture_loader).fixture_paths
+              else
+                T.unsafe(fixture_loader).fixture_path
+              end
+
+              Array(fixture_paths).each_with_object({}) do |path, mapping|
+                Dir["#{path}{.yml,/{**,*}/*.yml}"].select do |file|
+                  next unless ::File.file?(file)
+
+                  ActiveRecord::FixtureSet::File.open(file) do |fh|
+                    next unless fh.model_class
+
+                    fixture_name = file.delete_prefix(path.to_s).delete_prefix("/").delete_suffix(".yml")
+                    mapping[fixture_name] = fh.model_class
+                  end
+                end
+              end
+            end,
+            T.nilable(T::Hash[String, String]),
           )
         end
       end

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

@@ -3,6 +3,7 @@
 
 return unless defined?(ActiveRecord::Base)
 
+require "tapioca/dsl/helpers/active_model_type_helper"
 require "tapioca/dsl/helpers/active_record_constants_helper"
 
 module Tapioca
@@ -24,15 +25,15 @@ module Tapioca
       # 1. A `Model::PrivateRelation` that subclasses `ActiveRecord::Relation`. This synthetic class represents
       # a relation on `Model` whose methods which return a relation always return a `Model::PrivateRelation` instance.
       #
-      # 2. `Model::PrivateAssocationRelation` that subclasses `ActiveRecord::AssociationRelation`. This synthetic
+      # 2. `Model::PrivateAssociationRelation` that subclasses `ActiveRecord::AssociationRelation`. This synthetic
       # class represents a relation on a singular association of type `Model` (e.g. `foo.model`) whose methods which
-      # return a relation will always return a `Model::PrivateAssocationRelation` instance. The difference between this
+      # return a relation will always return a `Model::PrivateAssociationRelation` instance. The difference between this
       # class and the previous one is mainly that an association relation also keeps track of the resource association
       # for this relation.
       #
       # 3. `Model::PrivateCollectionProxy` that subclasses from `ActiveRecord::Associations::CollectionProxy`.
       # This synthetic class represents a relation on a plural association of type `Model` (e.g. `foo.models`)
-      # whose methods which return a relation will always return a `Model::PrivateAssocationRelation` instance.
+      # whose methods which return a relation will always return a `Model::PrivateAssociationRelation` instance.
       # This class represents a collection of `Model` instances with some extra methods to `build`, `create`,
       # etc new `Model` instances in the collection.
       #
@@ -364,7 +365,8 @@ module Tapioca
                 parameters: [
                   create_param("column_name", type: "T.any(String, Symbol)"),
                 ],
-                return_type: "T::Hash[T.untyped, #{method_name == :average ? "Numeric" : "T.untyped"}]",
+                return_type: "T::Hash[T.untyped, " \
+                  "#{method_name == :average ? "T.any(Integer, Float, BigDecimal)" : "T.untyped"}]",
               )
             when :calculate
               klass.create_method(
@@ -373,7 +375,7 @@ module Tapioca
                   create_param("operation", type: "Symbol"),
                   create_param("column_name", type: "T.any(String, Symbol)"),
                 ],
-                return_type: "T::Hash[T.untyped, Numeric]",
+                return_type: "T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]",
               )
             when :count
               klass.create_method(
@@ -390,7 +392,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::Hash[T.untyped, Numeric]",
+                return_type: "T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]",
               )
             end
           end
@@ -560,6 +562,11 @@ module Tapioca
 
           QUERY_METHODS.each do |method_name|
             case method_name
+            when :distinct
+              create_relation_method(
+                method_name.to_s,
+                parameters: [create_opt_param("value", type: "T::Boolean", default: "true")],
+              )
             when :extract_associated
               parameters = [create_param("association", type: "Symbol")]
               return_type = "T::Array[T.untyped]"
@@ -657,9 +664,30 @@ module Tapioca
               )
             when :find
               # 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])"
+              id_types = [
+                "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]",
+              ].to_set
+
+              if constant.table_exists?
+                primary_key_type = constant.type_for_attribute(constant.primary_key)
+                type = Tapioca::Dsl::Helpers::ActiveModelTypeHelper.type_for(primary_key_type)
+                type = RBIHelper.as_non_nilable_type(type)
+                id_types << type if type != "T.untyped"
+              end
+
+              id_types = "T.any(#{id_types.to_a.join(", ")})"
+
               array_type = if constant.try(:composite_primary_key?)
                 "T::Array[T::Array[#{id_types}]]"
               else
@@ -781,7 +809,7 @@ module Tapioca
                 parameters: [
                   create_param("column_name", type: "T.any(String, Symbol)"),
                 ],
-                return_type: method_name == :average ? "Numeric" : "T.untyped",
+                return_type: method_name == :average ? "T.any(Integer, Float, BigDecimal)" : "T.untyped",
               )
             when :calculate
               create_common_method(
@@ -790,7 +818,7 @@ module Tapioca
                   create_param("operation", type: "Symbol"),
                   create_param("column_name", type: "T.any(String, Symbol)"),
                 ],
-                return_type: "Numeric",
+                return_type: "T.any(Integer, Float, BigDecimal)",
               )
             when :count
               sigs = [
@@ -822,13 +850,28 @@ module Tapioca
                 return_type: "T.untyped",
               )
             when :sum
-              create_common_method(
-                "sum",
+              sigs = [
+                common_relation_methods_module.create_sig(
+                  parameters: { initial_value_or_column: "T.untyped" },
+                  return_type: "T.any(Integer, Float, BigDecimal)",
+                ),
+                common_relation_methods_module.create_sig(
+                  type_parameters: ["U"],
+                  parameters:
+                  {
+                    initial_value_or_column: "T.nilable(T.type_parameter(:U))",
+                    block: "T.proc.params(object: #{constant_name}).returns(T.type_parameter(:U))",
+                  },
+                  return_type: "T.type_parameter(:U)",
+                ),
+              ]
+              common_relation_methods_module.create_method_with_sigs(
+                method_name.to_s,
+                sigs: sigs,
                 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))"),
+                  RBI::OptParam.new("initial_value_or_column", "nil"),
+                  RBI::BlockParam.new("block"),
                 ],
-                return_type: "Numeric",
               )
             end
           end

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

@@ -55,7 +55,7 @@ module Tapioca
       #     sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
       #     def saved_change_to_review_date; end
       #
-      #     sig { params(reviewd: T::Boolean).returns(T::Boolean) }
+      #     sig { params(reviewed: T::Boolean).returns(T::Boolean) }
       #     def reviewed=(reviewed); end
       #
       #     sig { returns(T::Boolean) }

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

@@ -66,7 +66,7 @@ module Tapioca
           root.create_constant(config_constant_name, value: "T.let(T.unsafe(nil), #{option_class_name})")
 
           root.create_class(option_class_name, superclass_name: "::Config::Options") do |mod|
-            # We need this to be generic only becuase `Config::Options` is an
+            # We need this to be generic only because `Config::Options` is an
             # enumerable and, thus, needs to redeclare the `Elem` type member.
             #
             # We declare it as a fixed member of `T.untyped` so that if anyone

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

@@ -239,7 +239,7 @@ module Tapioca
           return false unless descriptor.label == :repeated
 
           # Try to create a new instance with the field that maps to the descriptor name
-          # being assinged a hash value. If this goes through, then it's a map type.
+          # being assigned a hash value. If this goes through, then it's a map type.
           constant.new(**{ descriptor.name => {} })
           true
         rescue ArgumentError

data/lib/tapioca/dsl/pipeline.rb

@@ -15,6 +15,9 @@ module Tapioca
       sig { returns(T::Array[Pathname]) }
       attr_reader :requested_paths
 
+      sig { returns(T::Array[Module]) }
+      attr_reader :skipped_constants
+
       sig { returns(T.proc.params(error: String).void) }
       attr_reader :error_handler
 
@@ -28,6 +31,7 @@ module Tapioca
           requested_compilers: T::Array[T.class_of(Compiler)],
           excluded_compilers: T::Array[T.class_of(Compiler)],
           error_handler: T.proc.params(error: String).void,
+          skipped_constants: T::Array[Module],
           number_of_workers: T.nilable(Integer),
         ).void
       end
@@ -37,6 +41,7 @@ module Tapioca
         requested_compilers: [],
         excluded_compilers: [],
         error_handler: $stderr.method(:puts).to_proc,
+        skipped_constants: [],
         number_of_workers: nil
       )
         @active_compilers = T.let(
@@ -46,6 +51,7 @@ module Tapioca
         @requested_constants = requested_constants
         @requested_paths = requested_paths
         @error_handler = error_handler
+        @skipped_constants = skipped_constants
         @number_of_workers = number_of_workers
         @errors = T.let([], T::Array[String])
       end
@@ -56,7 +62,7 @@ module Tapioca
         ).returns(T::Array[T.type_parameter(:T)])
       end
       def run(&blk)
-        constants_to_process = gather_constants(requested_constants, requested_paths)
+        constants_to_process = gather_constants(requested_constants, requested_paths, skipped_constants)
           .select { |c| Module === c } # Filter value constants out
           .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
@@ -128,15 +134,30 @@ module Tapioca
         active_compilers
       end
 
-      sig { params(requested_constants: T::Array[Module], requested_paths: T::Array[Pathname]).returns(T::Set[Module]) }
-      def gather_constants(requested_constants, requested_paths)
+      sig do
+        params(
+          requested_constants: T::Array[Module],
+          requested_paths: T::Array[Pathname],
+          skipped_constants: T::Array[Module],
+        ).returns(T::Set[Module])
+      end
+      def gather_constants(requested_constants, requested_paths, skipped_constants)
         constants = Set.new.compare_by_identity
         active_compilers.each do |compiler|
           constants.merge(compiler.processable_constants)
         end
         constants = filter_anonymous_and_reloaded_constants(constants)
+        constants -= skipped_constants
 
-        constants &= requested_constants unless requested_constants.empty? && requested_paths.empty?
+        unless requested_constants.empty? && requested_paths.empty?
+          constants &= requested_constants
+
+          requested_and_skipped = requested_constants & skipped_constants
+          if requested_and_skipped.any?
+            $stderr.puts("WARNING: Requested constants are being skipped due to configuration:" \
+              "#{requested_and_skipped}. Check the supplied arguments and your `sorbet/tapioca/config.yml` file.")
+          end
+        end
         constants
       end
 

data/lib/tapioca/helpers/rbi_helper.rb

@@ -96,6 +96,15 @@ module Tapioca
       end
     end
 
+    sig { params(type: String).returns(String) }
+    def as_non_nilable_type(type)
+      if type.match(/\A(?:::)?T.nilable\((.+)\)\z/)
+        T.must(::Regexp.last_match(1))
+      else
+        type
+      end
+    end
+
     sig { params(name: String).returns(T::Boolean) }
     def valid_method_name?(name)
       # try to parse a method definition with this name

data/lib/tapioca/helpers/test/dsl_compiler.rb

@@ -4,6 +4,7 @@
 require "tapioca/helpers/test/content"
 require "tapioca/helpers/test/isolation"
 require "tapioca/helpers/test/template"
+require "tapioca/helpers/sorbet_helper"
 
 module Tapioca
   module Helpers
@@ -53,6 +54,8 @@ module Tapioca
         class CompilerContext
           extend T::Sig
 
+          include SorbetHelper
+
           sig { returns(T.class_of(Tapioca::Dsl::Compiler)) }
           attr_reader :compiler_class
 
@@ -95,7 +98,26 @@ module Tapioca
             compiler = compiler_class.new(pipeline, file.root, constant)
             compiler.decorate
 
-            Tapioca::DEFAULT_RBI_FORMATTER.print_file(file)
+            rbi = Tapioca::DEFAULT_RBI_FORMATTER.print_file(file)
+            result = sorbet(
+              "--no-config",
+              "--stop-after",
+              "parser",
+              "-e",
+              "\"#{rbi}\"",
+            )
+
+            unless result.status
+              raise(SyntaxError, <<~MSG)
+                Expected generated RBI file for `#{constant_name}` to not have any parsing errors.
+
+                Got these parsing errors:
+
+                #{result.err}
+              MSG
+            end
+
+            rbi
           end
 
           sig { returns(T::Array[String]) }

data/lib/tapioca/loaders/loader.rb

@@ -49,8 +49,6 @@ module Tapioca
       def load_rails_application(environment_load: false, eager_load: false, app_root: ".", halt_upon_load_error: true)
         return unless File.exist?("#{app_root}/config/application.rb")
 
-        silence_deprecations
-
         if environment_load
           require "./#{app_root}/config/environment"
         else
@@ -186,14 +184,6 @@ module Tapioca
         nil
       end
 
-      sig { void }
-      def silence_deprecations
-        # Stop any ActiveSupport Deprecations from being reported
-        if defined?(ActiveSupport::Deprecation)
-          ActiveSupport::Deprecation.silenced = true
-        end
-      end
-
       sig { void }
       def eager_load_rails_app
         application = Rails.application

data/lib/tapioca/rbi_ext/model.rb

@@ -128,14 +128,15 @@ module RBI
     sig do
       params(
         parameters: T::Hash[T.any(String, Symbol), String],
+        type_parameters: T::Array[String],
         return_type: String,
       ).returns(RBI::Sig)
     end
-    def create_sig(parameters:, return_type: "T.untyped")
+    def create_sig(parameters:, type_parameters: [], return_type: "T.untyped")
       params = parameters.map do |name, type|
         RBI::SigParam.new(name.to_s, type)
       end
-      RBI::Sig.new(params: params, return_type: return_type)
+      RBI::Sig.new(type_params: type_parameters, params: params, return_type: return_type)
     end
 
     private

data/lib/tapioca/rbi_formatter.rb

@@ -16,6 +16,8 @@ module Tapioca
       file.comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
       file.comments << RBI::Comment.new("This is an autogenerated file for #{reason}.") unless reason.nil?
       file.comments << RBI::Comment.new("Please instead update this file by running `#{command}`.")
+      # Prevent the header from being attached to the top-level node when generating YARD docs
+      file.comments << RBI::BlankLine.new
     end
 
     sig { params(file: RBI::File).void }

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -158,7 +158,7 @@ module Tapioca
           # and the module that defines it
           owner = inherited_method.owner
 
-          # If no one has overriden the inherited method yet, just subclass
+          # If no one has overridden the inherited method yet, just subclass
           return Class.new(constant) if Class == owner
 
           begin

data/lib/tapioca/static/requires_compiler.rb

@@ -60,7 +60,7 @@ module Tapioca
           #
           # Strings beginning with / match against the
           # prefix of these relative paths; others are
-          # substring matchs.
+          # substring matches.
 
           # Matches must be against whole folder and file
           # names, so `foo` matches `/foo/bar.rb` and

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.13.3
+  version: 0.14.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-15 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -281,14 +281,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.10
 signing_key: 
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard