tapioca 0.15.1 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12203d783fb506aff6b357dc3dc02fd7f9d9e7147fd2fb715329a5311ff96bf6
-  data.tar.gz: 0ac885bad578baec1701f6b2f46e48ca5f12e4c5d8fd9840d63195291400a430
+  metadata.gz: 02620ac27a54a716743952e003b0c4b3d8cfd8a1fe9ee580068007e570c0814a
+  data.tar.gz: 6901ae216ea51a7a92facf5c64e4de42262f7f86e79ebfa816c7a8b1ca9a5af1
 SHA512:
-  metadata.gz: f42230c7ca6b96bb6ed299faa2b4c8d8f87ae44244a6501006c55b22c6307b9a0b777cdbb8d713f6ee3320d44502428c17ddf86dd85929be842433557d3e3793
-  data.tar.gz: df6f57d7c1446e70bd759bc84c5fa06f5985e01783be8d8f7655e06e3045c5de17cc1e931d4f0b5d78bc19f867de61dc228c77eb2f4df325038e09d908e2efd0
+  metadata.gz: 443333835093464931be7bcbf54e9dfad0e2241f099cc06fbca54c54dca284ab84c246343110dca2e5a64eaeee5d0d006bf22b3d955be9f64160d63ae807aeeb
+  data.tar.gz: 375a7ee0697b44f807161819bbbe6907eb8ee6f5ae76e791c73da4f748bd26bf3a86bfa3b28a6589503020890621c73f27506928c26e6c2078981dfb556cc7a5

data/lib/tapioca/commands/abstract_gem.rb

@@ -119,7 +119,14 @@ module Tapioca
         ) if @file_header
 
         rbi.root = Runtime::Trackers::Autoload.with_disabled_exits do
-          Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc, include_loc: @include_loc).compile
+          Tapioca::Gem::Pipeline.new(
+            gem,
+            include_doc: @include_doc,
+            include_loc: @include_loc,
+            error_handler: ->(error) {
+              say_error(error, :bold, :red)
+            },
+          ).compile
         end
 
         merge_with_exported_rbi(gem, rbi) if @include_exported_rbis

data/lib/tapioca/dsl/compiler.rb

@@ -49,7 +49,7 @@ module Tapioca
         sig { returns(T::Enumerable[T::Class[T.anything]]) }
         def all_classes
           @all_classes ||= T.let(
-            T.cast(ObjectSpace.each_object(Class), T::Enumerable[T::Class[T.anything]]).each,
+            ObjectSpace.each_object(Class),
             T.nilable(T::Enumerable[T::Class[T.anything]]),
           )
         end
@@ -57,7 +57,7 @@ module Tapioca
         sig { returns(T::Enumerable[Module]) }
         def all_modules
           @all_modules ||= T.let(
-            T.cast(ObjectSpace.each_object(Module), T::Enumerable[Module]).each,
+            ObjectSpace.each_object(Module),
             T.nilable(T::Enumerable[Module]),
           )
         end

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

@@ -57,9 +57,7 @@ module Tapioca
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
             # Collect all the classes that include ActiveModel::Validations
-            all_classes.select do |c|
-              c < ActiveModel::Validations
-            end
+            all_classes.select { |c| ActiveModel::Validations > c }
           end
         end
 

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

@@ -188,6 +188,7 @@ module Tapioca
         def populate_single_assoc_getter_setter(klass, association_name, reflection)
           association_class = type_for(reflection)
           association_type = as_nilable_type(association_class)
+          association_methods_module = constant.generated_association_methods
 
           klass.create_method(
             association_name.to_s,
@@ -206,6 +207,18 @@ module Tapioca
             "reset_#{association_name}",
             return_type: "void",
           )
+          if association_methods_module.method_defined?("#{association_name}_changed?")
+            klass.create_method(
+              "#{association_name}_changed?",
+              return_type: "T::Boolean",
+            )
+          end
+          if association_methods_module.method_defined?("#{association_name}_previously_changed?")
+            klass.create_method(
+              "#{association_name}_previously_changed?",
+              return_type: "T::Boolean",
+            )
+          end
           unless reflection.polymorphic?
             klass.create_method(
               "build_#{association_name}",

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

@@ -111,7 +111,7 @@ module Tapioca
         sig { params(mod: RBI::Scope, name: String).void }
         def create_fixture_method(mod, name)
           return_type = return_type_for_fixture(name)
-          mod << RBI::Method.new(name) do |node|
+          mod.create_method(name) do |node|
             node.add_opt_param("fixture_name", "nil")
             node.add_rest_param("other_fixtures")
 

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

@@ -155,6 +155,25 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
+        # From ActiveRecord::ConnectionAdapter::Quoting#quote, minus nil
+        ID_TYPES = T.let(
+          [
+            "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.freeze,
+          T::Set[String],
+        )
+
         sig { override.void }
         def decorate
           create_classes_and_includes
@@ -220,7 +239,7 @@ module Tapioca
           [:find_or_create_by, :find_or_create_by!, :find_or_initialize_by, :create_or_find_by, :create_or_find_by!],
           T::Array[Symbol],
         )
-        BUILDER_METHODS = T.let([:new, :build, :create, :create!], T::Array[Symbol])
+        BUILDER_METHODS = T.let([:new, :create, :create!, :build], T::Array[Symbol])
         TO_ARRAY_METHODS = T.let([:to_ary, :to_a], T::Array[Symbol])
 
         private
@@ -663,58 +682,43 @@ module Tapioca
                 return_type: "T::Boolean",
               )
             when :find
-              # From ActiveRecord::ConnectionAdapter::Quoting#quote, minus nil
-              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
+              id_types = ID_TYPES
 
               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"
+
+                id_types = ID_TYPES.union([type]) if type != "T.untyped"
               end
 
               id_types = "T.any(#{id_types.to_a.join(", ")})"
+              if constant.try(:composite_primary_key?)
+                id_types = "T::Array[#{id_types}]"
+              end
 
-              array_type = if constant.try(:composite_primary_key?)
-                "T::Array[T::Array[#{id_types}]]"
-              else
-                "T::Array[#{id_types}]"
+              array_type = "T::Array[#{id_types}]"
+
+              common_relation_methods_module.create_method("find") do |method|
+                method.add_opt_param("args", "nil")
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("args", id_types)
+                  sig.return_type = constant_name
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("args", array_type)
+                  sig.return_type = "T::Enumerable[#{constant_name}]"
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("args", "NilClass")
+                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
+                  sig.return_type = as_nilable_type(constant_name)
+                end
               end
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: { args: id_types },
-                  return_type: constant_name,
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: { args: array_type },
-                  return_type: "T::Enumerable[#{constant_name}]",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: {
-                    args: "NilClass",
-                    block: "T.proc.params(object: #{constant_name}).void",
-                  },
-                  return_type: as_nilable_type(constant_name),
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "find",
-                sigs: sigs,
-                parameters: [RBI::OptParam.new("args", "nil"), RBI::BlockParam.new("block")],
-              )
             when :find_by
               create_common_method(
                 "find_by",
@@ -747,21 +751,18 @@ module Tapioca
                 return_type: constant_name,
               )
             when :first, :last, :take
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: { limit: "NilClass" },
-                  return_type: as_nilable_type(constant_name),
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: { limit: "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")],
-              )
+              common_relation_methods_module.create_method(method_name.to_s) do |method|
+                method.add_opt_param("limit", "nil")
+
+                method.add_sig do |sig|
+                  sig.return_type = as_nilable_type(constant_name)
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("limit", "Integer")
+                  sig.return_type = "T::Array[#{constant_name}]"
+                end
+              end
             when :raise_record_not_found_exception!
               # skip
             else
@@ -821,24 +822,21 @@ module Tapioca
                 return_type: "T.any(Integer, Float, BigDecimal)",
               )
             when :count
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: { column_name: "T.nilable(T.any(String, Symbol))" },
-                  return_type: "Integer",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: { column_name: "NilClass", block: "T.proc.params(object: #{constant_name}).void" },
-                  return_type: "Integer",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "count",
-                sigs: sigs,
-                parameters: [
-                  RBI::OptParam.new("column_name", "nil"),
-                  RBI::BlockParam.new("block"),
-                ],
-              )
+              common_relation_methods_module.create_method(method_name.to_s) do |method|
+                method.add_opt_param("column_name", "nil")
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("column_name", "T.nilable(T.any(String, Symbol))")
+                  sig.return_type = "Integer"
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("column_name", "NilClass")
+                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
+                  sig.return_type = "Integer"
+                end
+              end
             when :ids
               create_common_method("ids", return_type: "Array")
             when :pick, :pluck
@@ -850,29 +848,21 @@ module Tapioca
                 return_type: "T.untyped",
               )
             when :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: [
-                  RBI::OptParam.new("initial_value_or_column", "nil"),
-                  RBI::BlockParam.new("block"),
-                ],
-              )
+              common_relation_methods_module.create_method(method_name.to_s) do |method|
+                method.add_opt_param("initial_value_or_column", "nil")
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("initial_value_or_column", "T.untyped")
+                  sig.return_type = "T.any(Integer, Float, BigDecimal)"
+                end
+
+                method.add_sig(type_params: ["U"]) do |sig|
+                  sig.add_param("initial_value_or_column", "T.nilable(T.type_parameter(:U))")
+                  sig.add_param("block", "T.proc.params(object: #{constant_name}).returns(T.type_parameter(:U))")
+                  sig.return_type = "T.type_parameter(:U)"
+                end
+              end
             end
           end
 
@@ -880,102 +870,100 @@ module Tapioca
             case method_name
             when :find_each
               order = ActiveRecord::Batches.instance_method(:find_each).parameters.include?([:key, :order])
-              parameters = {
-                start: "T.untyped",
-                finish: "T.untyped",
-                batch_size: "Integer",
-                error_on_ignore: "T.untyped",
-                order: ("Symbol" if order),
-              }.compact
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: parameters.merge(block: "T.proc.params(object: #{constant_name}).void"),
-                  return_type: "void",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: parameters,
-                  return_type: "T::Enumerator[#{constant_name}]",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "find_each",
-                sigs: sigs,
-                parameters: [
-                  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"),
-                ],
-              )
+
+              common_relation_methods_module.create_method("find_each") do |method|
+                method.add_kw_opt_param("start", "nil")
+                method.add_kw_opt_param("finish", "nil")
+                method.add_kw_opt_param("batch_size", "1000")
+                method.add_kw_opt_param("error_on_ignore", "nil")
+                method.add_kw_opt_param("order", ":asc") if order
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("start", "T.untyped")
+                  sig.add_param("finish", "T.untyped")
+                  sig.add_param("batch_size", "Integer")
+                  sig.add_param("error_on_ignore", "T.untyped")
+                  sig.add_param("order", "Symbol") if order
+                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
+                  sig.return_type = "void"
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("start", "T.untyped")
+                  sig.add_param("finish", "T.untyped")
+                  sig.add_param("batch_size", "Integer")
+                  sig.add_param("error_on_ignore", "T.untyped")
+                  sig.add_param("order", "Symbol") if order
+                  sig.return_type = "T::Enumerator[#{constant_name}]"
+                end
+              end
             when :find_in_batches
               order = ActiveRecord::Batches.instance_method(:find_in_batches).parameters.include?([:key, :order])
-              parameters = {
-                start: "T.untyped",
-                finish: "T.untyped",
-                batch_size: "Integer",
-                error_on_ignore: "T.untyped",
-                order: ("Symbol" if order),
-              }.compact
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: parameters.merge(block: "T.proc.params(object: T::Array[#{constant_name}]).void"),
-                  return_type: "void",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: parameters,
-                  return_type: "T::Enumerator[T::Enumerator[#{constant_name}]]",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "find_in_batches",
-                sigs: sigs,
-                parameters: [
-                  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"),
-                ],
-              )
+              common_relation_methods_module.create_method("find_in_batches") do |method|
+                method.add_kw_opt_param("start", "nil")
+                method.add_kw_opt_param("finish", "nil")
+                method.add_kw_opt_param("batch_size", "1000")
+                method.add_kw_opt_param("error_on_ignore", "nil")
+                method.add_kw_opt_param("order", ":asc") if order
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("start", "T.untyped")
+                  sig.add_param("finish", "T.untyped")
+                  sig.add_param("batch_size", "Integer")
+                  sig.add_param("error_on_ignore", "T.untyped")
+                  sig.add_param("order", "Symbol") if order
+                  sig.add_param("block", "T.proc.params(object: T::Array[#{constant_name}]).void")
+                  sig.return_type = "void"
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("start", "T.untyped")
+                  sig.add_param("finish", "T.untyped")
+                  sig.add_param("batch_size", "Integer")
+                  sig.add_param("error_on_ignore", "T.untyped")
+                  sig.add_param("order", "Symbol") if order
+                  sig.return_type = "T::Enumerator[T::Enumerator[#{constant_name}]]"
+                end
+              end
             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])
-              parameters = {
-                of: "Integer",
-                start: "T.untyped",
-                finish: "T.untyped",
-                load: "T.untyped",
-                error_on_ignore: "T.untyped",
-                order: ("Symbol" if order),
-                use_ranges: ("T.untyped" if use_ranges),
-              }.compact
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: parameters.merge(block: "T.proc.params(object: #{RelationClassName}).void"),
-                  return_type: "void",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: parameters,
-                  return_type: "::ActiveRecord::Batches::BatchEnumerator",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "in_batches",
-                sigs: sigs,
-                parameters: [
-                  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"),
-                ],
-              )
+
+              common_relation_methods_module.create_method("in_batches") do |method|
+                method.add_kw_opt_param("of", "1000")
+                method.add_kw_opt_param("start", "nil")
+                method.add_kw_opt_param("finish", "nil")
+                method.add_kw_opt_param("load", "false")
+                method.add_kw_opt_param("error_on_ignore", "nil")
+                method.add_kw_opt_param("order", ":asc") if order
+                method.add_kw_opt_param("use_ranges", "nil") if use_ranges
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("of", "Integer")
+                  sig.add_param("start", "T.untyped")
+                  sig.add_param("finish", "T.untyped")
+                  sig.add_param("load", "T.untyped")
+                  sig.add_param("error_on_ignore", "T.untyped")
+                  sig.add_param("order", "Symbol") if order
+                  sig.add_param("use_ranges", "T.untyped") if use_ranges
+                  sig.add_param("block", "T.proc.params(object: #{RelationClassName}).void")
+                  sig.return_type = "void"
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("of", "Integer")
+                  sig.add_param("start", "T.untyped")
+                  sig.add_param("finish", "T.untyped")
+                  sig.add_param("load", "T.untyped")
+                  sig.add_param("error_on_ignore", "T.untyped")
+                  sig.add_param("order", "Symbol") if order
+                  sig.add_param("use_ranges", "T.untyped") if use_ranges
+                  sig.return_type = "::ActiveRecord::Batches::BatchEnumerator"
+                end
+              end
             end
           end
 
@@ -991,26 +979,65 @@ module Tapioca
           end
 
           FIND_OR_CREATE_METHODS.each do |method_name|
-            block_type = "T.nilable(T.proc.params(object: #{constant_name}).void)"
-            create_common_method(
-              method_name,
-              parameters: [
-                create_param("attributes", type: "T.untyped"),
-                create_block_param("block", type: block_type),
-              ],
-              return_type: constant_name,
-            )
+            common_relation_methods_module.create_method(method_name.to_s) do |method|
+              method.add_param("attributes")
+              method.add_block_param("block")
+
+              # `T.untyped` matches `T::Array[T.untyped]` so the array signature
+              # must be defined first for Sorbet to pick it, if valid.
+              method.add_sig do |sig|
+                sig.add_param("attributes", "T::Array[T.untyped]")
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = "T::Array[#{constant_name}]"
+              end
+
+              method.add_sig do |sig|
+                sig.add_param("attributes", "T.untyped")
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = constant_name
+              end
+            end
           end
 
           BUILDER_METHODS.each do |method_name|
-            create_common_method(
-              method_name,
-              parameters: [
-                create_opt_param("attributes", type: "T.untyped", default: "nil"),
-                create_block_param("block", type: "T.nilable(T.proc.params(object: #{constant_name}).void)"),
-              ],
-              return_type: constant_name,
-            )
+            common_relation_methods_module.create_method(method_name.to_s) do |method|
+              method.add_opt_param("attributes", "nil")
+              method.add_block_param("block")
+
+              method.add_sig do |sig|
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = constant_name
+              end
+
+              # `T.untyped` matches `T::Array[T.untyped]` so the array signature
+              # must be defined first for Sorbet to pick it, if valid.
+              method.add_sig do |sig|
+                sig.add_param("attributes", "T::Array[T.untyped]")
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = "T::Array[#{constant_name}]"
+              end
+
+              method.add_sig do |sig|
+                sig.add_param("attributes", "T.untyped")
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = constant_name
+              end
+            end
+          end
+
+          # We are creating `#new` on the class itself since when called as `Model.new`
+          # it doesn't allow for an array to be passed. If we kept it as a blanket it
+          # would mean the passing any `T.untyped` value to the method would assume
+          # the result is `T::Array` which is not the case majority of the time.
+          model.create_method("new", class_method: true) do |method|
+            method.add_opt_param("attributes", "nil")
+            method.add_block_param("block")
+
+            method.add_sig do |sig|
+              sig.add_param("attributes", "T.untyped")
+              sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+              sig.return_type = constant_name
+            end
           end
         end
 

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

@@ -66,19 +66,18 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            # Find all Modules that are:
             all_modules.select do |mod|
-              # named (i.e. not anonymous)
-              name_of(mod) &&
-                # not singleton classes
+              name_of(mod) && # i.e. not anonymous
                 !mod.singleton_class? &&
-                # extend ActiveSupport::Concern, and
-                mod.singleton_class < ActiveSupport::Concern &&
-                # have dependencies (i.e. include another concern)
-                !dependencies_of(mod).empty?
+                ActiveSupport::Concern > mod.singleton_class &&
+                has_dependencies?(mod)
             end
           end
 
+          # Returns true when `mod` includes other concerns
+          sig { params(mod: Module).returns(T::Boolean) }
+          def has_dependencies?(mod) = dependencies_of(mod).any?
+
           sig { params(concern: Module).returns(T::Array[Module]) }
           def dependencies_of(concern)
             concern.instance_variable_get(:@_dependencies) || []

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

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Time.current) && defined?(ActiveSupport::TimeWithZone)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveSupportTimeExt` generates an RBI file for the `Time#current` method
+      # defined by [Active Support's Time extensions](https://api.rubyonrails.org/classes/Time.html).
+      #
+      # If `Time.zone` or `config.time_zone` are set, then the `Time.current` method will be defined as returning
+      # an instance of `ActiveSupport::TimeWithZone`, otherwise it will return an instance of `Time`.
+      #
+      # For an application that is configured with:
+      # ```ruby
+      # config.time_zone = "UTC"
+      # ```
+      # this compiler will produce the following RBI file:
+      # ```rbi
+      # class Time
+      #   class << self
+      #     sig { returns(::ActiveSupport::TimeWithZone) }
+      #     def current; end
+      #   end
+      # end
+      # ```
+      # whereas if `Time.zone` and `config.time_zone` are not set, it will produce:
+      # ```rbi
+      # class Time
+      #   class << self
+      #     sig { returns(::Time) }
+      #     def current; end
+      #   end
+      # end
+      # ```
+      class ActiveSupportTimeExt < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(::Time) } }
+
+        sig { override.void }
+        def decorate
+          return unless constant.respond_to?(:zone)
+
+          root.create_path(constant) do |mod|
+            return_type = if ::Time.zone
+              "::ActiveSupport::TimeWithZone"
+            else
+              "::Time"
+            end
+
+            mod.create_method("current", return_type: return_type, class_method: true)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            [::Time]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -80,7 +80,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            all_classes.select { |c| c < GraphQL::Schema::InputObject }
+            all_classes.select { |c| GraphQL::Schema::InputObject > c }
           end
         end
       end

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

@@ -80,7 +80,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            all_classes.select { |c| c < GraphQL::Schema::Mutation && c != GraphQL::Schema::RelayClassicMutation }
+            all_classes.select { |c| GraphQL::Schema::Mutation > c && GraphQL::Schema::RelayClassicMutation != c }
           end
         end
       end

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

@@ -100,7 +100,7 @@ module Tapioca
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
             descendants_of(::ActiveRecord::Base).select do |klass|
-              klass < ::IdentityCache::WithoutPrimaryIndex
+              ::IdentityCache::WithoutPrimaryIndex > klass
             end
           end
         end

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

@@ -111,7 +111,7 @@ module Tapioca
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
             all_modules.select do |c|
-              name_of(c) && c < ::JsonApiClient::Resource
+              name_of(c) && ::JsonApiClient::Resource > c
             end
           end
         end

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

@@ -159,9 +159,7 @@ module Tapioca
           def gather_constants
             marker = Google::Protobuf::MessageExts::ClassMethods
 
-            enum_modules = ObjectSpace.each_object(Google::Protobuf::EnumDescriptor).map do |desc|
-              T.cast(desc, Google::Protobuf::EnumDescriptor).enummodule
-            end
+            enum_modules = ObjectSpace.each_object(Google::Protobuf::EnumDescriptor).map(&:enummodule)
 
             results = if Google::Protobuf.const_defined?(:AbstractMessage)
               abstract_message_const = ::Google::Protobuf.const_get(:AbstractMessage)

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

@@ -73,7 +73,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            all_classes.select { |c| c < Sidekiq::Worker }
+            all_classes.select { |c| Sidekiq::Worker > c }
           end
         end
 

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

@@ -86,8 +86,9 @@ module Tapioca
           def gather_constants
             all_modules.select do |c|
               name_of(c) &&
-                c != ::SmartProperties::Validations::Ancestor &&
-                c < ::SmartProperties && ::SmartProperties::ClassMethods === c
+                ::SmartProperties > c &&
+                ::SmartProperties::Validations::Ancestor != c &&
+                ::SmartProperties::ClassMethods === c
             end
           end
         end

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

@@ -159,7 +159,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            all_classes.select { |mod| mod < ::StateMachines::InstanceMethods }
+            all_classes.select { |mod| ::StateMachines::InstanceMethods > mod }
           end
         end
 
@@ -231,12 +231,12 @@ module Tapioca
           instance_module.create_method(
             attribute,
             return_type: state_type,
-          )
+          ) if ::StateMachines::HelperModule === machine.owner_class.instance_method(attribute).owner
           instance_module.create_method(
             "#{attribute}=",
             parameters: [create_param("value", type: state_type)],
             return_type: state_type,
-          )
+          ) if ::StateMachines::HelperModule === machine.owner_class.instance_method("#{attribute}=").owner
         end
 
         sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }

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

@@ -106,19 +106,28 @@ module Tapioca
             routes_reloader = Rails.application.routes_reloader
             routes_reloader.execute_unless_loaded if routes_reloader&.respond_to?(:execute_unless_loaded)
 
-            Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
-            Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
+            url_helpers_module = Rails.application.routes.named_routes.url_helpers_module
+            path_helpers_module = Rails.application.routes.named_routes.path_helpers_module
+
+            Object.const_set(:GeneratedUrlHelpersModule, url_helpers_module)
+            Object.const_set(:GeneratedPathHelpersModule, path_helpers_module)
 
             constants = all_modules.select do |mod|
               next unless name_of(mod)
 
-              includes_helper?(mod, GeneratedUrlHelpersModule) ||
-                includes_helper?(mod, GeneratedPathHelpersModule) ||
-                includes_helper?(mod.singleton_class, GeneratedUrlHelpersModule) ||
-                includes_helper?(mod.singleton_class, GeneratedPathHelpersModule)
+              # Fast-path to quickly disqualify most cases
+              next false unless url_helpers_module > mod || # rubocop:disable Style/InvertibleUnlessCondition
+                path_helpers_module > mod ||
+                url_helpers_module > mod.singleton_class ||
+                path_helpers_module > mod.singleton_class
+
+              includes_helper?(mod, url_helpers_module) ||
+                includes_helper?(mod, path_helpers_module) ||
+                includes_helper?(mod.singleton_class, url_helpers_module) ||
+                includes_helper?(mod.singleton_class, path_helpers_module)
             end
 
-            constants.concat(NON_DISCOVERABLE_INCLUDERS)
+            constants.concat(NON_DISCOVERABLE_INCLUDERS).push(GeneratedUrlHelpersModule, GeneratedPathHelpersModule)
           end
 
           sig { returns(T::Array[Module]) }
@@ -134,17 +143,20 @@ module Tapioca
             end.freeze
           end
 
+          # Returns `true` if `mod` "directly" includes `helper`.
+          # For classes, this method will return false if the `helper` is included only by a superclass
           sig { params(mod: Module, helper: Module).returns(T::Boolean) }
           private def includes_helper?(mod, helper)
-            superclass_ancestors = []
+            ancestors = ancestors_of(mod)
 
-            if Class === mod
-              superclass = superclass_of(mod)
-              superclass_ancestors = ancestors_of(superclass) if superclass
+            own_ancestors = if Class === mod && (superclass = superclass_of(mod))
+              # These ancestors are unique to `mod`, and exclude those in common with `superclass`.
+              ancestors.take(ancestors.count - ancestors_of(superclass).size)
+            else
+              ancestors
             end
 
-            ancestors = Set.new.compare_by_identity.merge(ancestors_of(mod)).subtract(superclass_ancestors)
-            ancestors.any? { |ancestor| helper == ancestor }
+            own_ancestors.include?(helper)
           end
         end
 

data/lib/tapioca/gem/listeners/methods.rb

@@ -73,7 +73,7 @@ module Tapioca
           return unless method_owned_by_constant?(method, constant)
           return if @pipeline.symbol_in_payload?(symbol_name) && !@pipeline.method_in_gem?(method)
 
-          signature = signature_of(method)
+          signature = lookup_signature_of(method)
           method = T.let(signature.method, UnboundMethod) if signature
 
           method_name = method.name.to_s
@@ -211,6 +211,18 @@ module Tapioca
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
         end
+
+        sig { params(method: UnboundMethod).returns(T.untyped) }
+        def lookup_signature_of(method)
+          signature_of!(method)
+        rescue LoadError, StandardError => error
+          @pipeline.error_handler.call(<<~MSG)
+            Unable to compile signature for method: #{method.owner}##{method.name}
+              Exception raised when loading signature: #{error.inspect}
+          MSG
+
+          nil
+        end
       end
     end
   end

data/lib/tapioca/gem/pipeline.rb

@@ -13,12 +13,28 @@ module Tapioca
       sig { returns(Gemfile::GemSpec) }
       attr_reader :gem
 
-      sig { params(gem: Gemfile::GemSpec, include_doc: T::Boolean, include_loc: T::Boolean).void }
-      def initialize(gem, include_doc: false, include_loc: false)
+      sig { returns(T.proc.params(error: String).void) }
+      attr_reader :error_handler
+
+      sig do
+        params(
+          gem: Gemfile::GemSpec,
+          error_handler: T.proc.params(error: String).void,
+          include_doc: T::Boolean,
+          include_loc: T::Boolean,
+        ).void
+      end
+      def initialize(
+        gem,
+        error_handler:,
+        include_doc: false,
+        include_loc: false
+      )
         @root = T.let(RBI::Tree.new, RBI::Tree)
         @gem = gem
         @seen = T.let(Set.new, T::Set[String])
         @alias_namespace = T.let(Set.new, T::Set[String])
+        @error_handler = error_handler
 
         @events = T.let([], T::Array[Gem::Event])
 

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

@@ -1,6 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "tapioca/dsl"
 require "tapioca/helpers/test/content"
 require "tapioca/helpers/test/isolation"
 require "tapioca/helpers/test/template"

data/lib/tapioca/loaders/dsl.rb

@@ -63,10 +63,17 @@ module Tapioca
       def load_dsl_compilers
         say("Loading DSL compiler classes... ")
 
+        # Load all built-in compilers
+        Dir.glob("#{Tapioca::LIB_ROOT_DIR}/tapioca/dsl/compilers/*.rb").each do |compiler|
+          require File.expand_path(compiler)
+        end
+
+        # Load all custom compilers exported from gems
         ::Gem.find_files("tapioca/dsl/compilers/*.rb").each do |compiler|
           require File.expand_path(compiler)
         end
 
+        # Load all custom compilers from the project
         Dir.glob([
           "#{@tapioca_path}/generators/**/*.rb", # TODO: Here for backcompat, remove later
           "#{@tapioca_path}/compilers/**/*.rb",

data/lib/tapioca/loaders/loader.rb

@@ -47,12 +47,23 @@ module Tapioca
         ).void
       end
       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")
+        return unless File.exist?(File.expand_path("config/application.rb", app_root))
 
-        if environment_load
-          require "./#{app_root}/config/environment"
+        load_path = if environment_load
+          "config/environment"
         else
-          require "./#{app_root}/config/application"
+          "config/application"
+        end
+
+        require File.expand_path(load_path, app_root)
+
+        unless defined?(Rails)
+          say(
+            "\nTried to load the app from `#{load_path}` as a Rails application " \
+              "but the `Rails` constant wasn't defined after loading the file.",
+            :yellow,
+          )
+          return
         end
 
         eager_load_rails_app if eager_load
@@ -219,7 +230,7 @@ module Tapioca
       # The `eager_load_paths` method still exists, but doesn't return all paths anymore and causes Tapioca to miss some
       # engine paths. The following commit is the change:
       # https://github.com/rails/rails/commit/ebfca905db14020589c22e6937382e6f8f687664
-      sig { params(engine: T.class_of(Rails::Engine)).returns(T::Array[String]) }
+      T::Sig::WithoutRuntime.sig { params(engine: T.class_of(Rails::Engine)).returns(T::Array[String]) }
       def eager_load_paths(engine)
         config = engine.config
 

data/lib/tapioca/rbi_ext/model.rb

@@ -80,65 +80,38 @@ module RBI
       params(
         name: String,
         parameters: T::Array[TypedParam],
-        return_type: String,
+        return_type: T.nilable(String),
         class_method: T::Boolean,
         visibility: RBI::Visibility,
         comments: T::Array[RBI::Comment],
+        block: T.nilable(T.proc.params(node: RBI::Method).void),
       ).void
     end
-    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new,
-      comments: [])
-      sig_params = parameters.to_h { |param| [param.param.name, param.type] }
-      sig = create_sig(parameters: sig_params, 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: [])
+    def create_method(name, parameters: [], return_type: nil, class_method: false, visibility: RBI::Public.new,
+      comments: [], &block)
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
+      sigs = []
+
+      if !block || !parameters.empty? || return_type
+        # If there is no block, and the params and return type have not been supplied, then
+        # we create a single signature with the given parameters and return type
+        params = parameters.map { |param| RBI::SigParam.new(param.param.name.to_s, param.type) }
+        sigs << RBI::Sig.new(params: params, return_type: return_type || "T.untyped")
+      end
+
       method = RBI::Method.new(
         name,
         sigs: sigs,
-        params: parameters,
+        params: parameters.map(&:param),
         is_singleton: class_method,
         visibility: visibility,
         comments: comments,
+        &block
       )
       self << method
     end
 
-    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:, type_parameters: [], return_type: "T.untyped")
-      params = parameters.map do |name, type|
-        RBI::SigParam.new(name.to_s, type)
-      end
-      RBI::Sig.new(type_params: type_parameters, params: params, return_type: return_type)
-    end
-
     private
 
     sig { returns(T::Hash[String, RBI::Node]) }

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -41,7 +41,7 @@ module Tapioca
           @underlying_type = T.let(underlying_type, Module)
         end
 
-        sig { params(obj: T.untyped).returns(T::Boolean) }
+        sig { override.params(obj: T.untyped).returns(T::Boolean) }
         def valid?(obj)
           obj.is_a?(@underlying_type)
         end

data/lib/tapioca/runtime/reflection.rb

@@ -130,8 +130,13 @@ module Tapioca
       end
 
       sig { params(method: T.any(UnboundMethod, Method)).returns(T.untyped) }
-      def signature_of(method)
+      def signature_of!(method)
         T::Utils.signature_for_method(method)
+      end
+
+      sig { params(method: T.any(UnboundMethod, Method)).returns(T.untyped) }
+      def signature_of(method)
+        signature_of!(method)
       rescue LoadError, StandardError
         nil
       end
@@ -166,7 +171,7 @@ module Tapioca
       end
       def descendants_of(klass)
         result = ObjectSpace.each_object(klass.singleton_class).reject do |k|
-          T.cast(k, Module).singleton_class? || T.unsafe(k) == klass
+          k.singleton_class? || k == klass
         end
 
         T.unsafe(result)

data/lib/tapioca/static/symbol_loader.rb

@@ -65,7 +65,7 @@ module Tapioca
 
         private
 
-        sig { returns(T::Array[T.class_of(Rails::Engine)]) }
+        T::Sig::WithoutRuntime.sig { returns(T::Array[T.class_of(Rails::Engine)]) }
         def engines
           @engines ||= T.let(
             if Object.const_defined?("Rails::Engine")

data/lib/tapioca/version.rb

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

data/lib/tapioca.rb

@@ -30,6 +30,7 @@ module Tapioca
 
   class Error < StandardError; end
 
+  LIB_ROOT_DIR = T.let(T.must(__dir__), String)
   SORBET_DIR = T.let("sorbet", String)
   SORBET_CONFIG_FILE = T.let("#{SORBET_DIR}/config", String)
   TAPIOCA_DIR = T.let("#{SORBET_DIR}/tapioca", String)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.16.1
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 2024-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,7 +61,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: 0.1.14
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.2'
@@ -71,7 +71,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: 0.1.14
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.2'
@@ -186,6 +186,7 @@ files:
 - lib/tapioca/dsl/compilers/active_storage.rb
 - lib/tapioca/dsl/compilers/active_support_concern.rb
 - lib/tapioca/dsl/compilers/active_support_current_attributes.rb
+- lib/tapioca/dsl/compilers/active_support_time_ext.rb
 - lib/tapioca/dsl/compilers/config.rb
 - lib/tapioca/dsl/compilers/frozen_record.rb
 - lib/tapioca/dsl/compilers/graphql_input_object.rb
@@ -289,7 +290,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.14
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard