tapioca 0.16.9 → 0.17.7

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

@@ -63,14 +63,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = (Class[::Kredis::Attributes] & ::Kredis::Attributes::ClassMethods & Extensions::Kredis)]
       class Kredis < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          { fixed: T.all(T::Class[::Kredis::Attributes], ::Kredis::Attributes::ClassMethods, Extensions::Kredis) }
-        end
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.__tapioca_kredis_types.nil?
 
@@ -89,7 +87,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_classes
               .grep(::Kredis::Attributes::ClassMethods)
@@ -99,7 +98,7 @@ module Tapioca
 
         private
 
-        sig { params(mod: RBI::Scope, method: String, data: T::Hash[Symbol, T.untyped]).void }
+        #: (RBI::Scope mod, String method, Hash[Symbol, untyped] data) -> void
         def generate_methods(mod, method, data)
           return_type = data.fetch(:type)
           case return_type
@@ -114,7 +113,7 @@ module Tapioca
           mod.create_method(method, return_type: return_type)
         end
 
-        sig { params(mod: RBI::Scope, klass_name: String, values: T::Array[T.untyped]).void }
+        #: (RBI::Scope mod, String klass_name, Array[untyped] values) -> void
         def create_enum_class(mod, klass_name, values)
           klass = mod.create_class(klass_name, superclass_name: "Kredis::Types::Enum")
           values.each do |value|

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

@@ -44,12 +44,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = Module]
       class MixedInClassAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: Module } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           mixin_compiler = Runtime::DynamicMixinCompiler.new(constant)
           return if mixin_compiler.empty_attributes?
@@ -62,7 +62,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             # Select all non-anonymous modules that have overridden Module.included
             all_modules.select do |mod|

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

@@ -64,6 +64,7 @@ module Tapioca
       # ~~~
       # --ignore=/path/to/proto/cart_pb.rb
       # ~~~
+      #: [ConstantType = Class[top]]
       class Protobuf < Compiler
         class Field < T::Struct
           prop :name, String
@@ -74,11 +75,10 @@ module Tapioca
 
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T::Class[T.anything] } }
-
         FIELD_RE = /^[a-z_][a-zA-Z0-9_]*$/
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           root.create_path(constant) do |klass|
             if constant == Google::Protobuf::RepeatedField
@@ -155,7 +155,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             marker = Google::Protobuf::MessageExts::ClassMethods
 
@@ -178,7 +179,7 @@ module Tapioca
 
         private
 
-        sig { params(desc: Google::Protobuf::FieldDescriptor).returns(T::Boolean) }
+        #: (Google::Protobuf::FieldDescriptor desc) -> bool
         def has_presence?(desc)
           if desc.respond_to?(:has_presence?)
             # This method is only defined in google-protobuf 3.26.0 and later
@@ -190,7 +191,7 @@ module Tapioca
           end
         end
 
-        sig { params(klass: RBI::Scope, names: String).void }
+        #: (RBI::Scope klass, *String names) -> void
         def create_type_members(klass, *names)
           klass.create_extend("T::Generic")
 
@@ -199,11 +200,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            descriptor: Google::Protobuf::FieldDescriptor,
-          ).returns(String)
-        end
+        #: (Google::Protobuf::FieldDescriptor descriptor) -> String
         def type_of(descriptor)
           case descriptor.type
           when :enum
@@ -229,12 +226,12 @@ module Tapioca
           end
         end
 
-        sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(T::Boolean) }
+        #: (Google::Protobuf::FieldDescriptor descriptor) -> bool
         def nilable_descriptor?(descriptor)
           descriptor.label == :optional && descriptor.type == :message
         end
 
-        sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(T::Boolean) }
+        #: (Google::Protobuf::FieldDescriptor descriptor) -> bool
         def map_type?(descriptor)
           # Defensively make sure that we are dealing with a repeated field
           return false unless descriptor.label == :repeated
@@ -248,7 +245,7 @@ module Tapioca
           false
         end
 
-        sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(Field) }
+        #: (Google::Protobuf::FieldDescriptor descriptor) -> Field
         def field_of(descriptor)
           if descriptor.label == :repeated
             if map_type?(descriptor)
@@ -290,12 +287,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            desc: Google::Protobuf::FieldDescriptor,
-          ).returns(Field)
-        end
+        #: (RBI::Scope klass, Google::Protobuf::FieldDescriptor desc) -> Field
         def create_descriptor_method(klass, desc)
           field = field_of(desc)
 
@@ -325,12 +317,7 @@ module Tapioca
           field
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            desc: Google::Protobuf::OneofDescriptor,
-          ).void
-        end
+        #: (RBI::Scope klass, Google::Protobuf::OneofDescriptor desc) -> void
         def create_oneof_method(klass, desc)
           klass.create_method(
             desc.name,

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

@@ -33,17 +33,14 @@ module Tapioca
       #   def skip_comments; end
       # end
       # ~~~
+      #: [ConstantType = singleton(::Rails::Generators::Base)]
       class RailsGenerators < Compiler
         extend T::Sig
 
-        BUILT_IN_MATCHER = T.let(
-          /::(ActionMailbox|ActionText|ActiveRecord|Rails)::Generators/,
-          Regexp,
-        )
+        BUILT_IN_MATCHER = /::(ActionMailbox|ActionText|ActiveRecord|Rails)::Generators/
 
-        ConstantType = type_member { { fixed: T.class_of(::Rails::Generators::Base) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           base_class = base_class_of_constant
           arguments = constant.arguments - base_class.arguments
@@ -62,7 +59,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_classes.select do |const|
               name = qualified_name_of(const)
@@ -76,7 +74,7 @@ module Tapioca
 
         private
 
-        sig { params(klass: RBI::Tree, argument: T.any(Thor::Argument, Thor::Option)).void }
+        #: (RBI::Tree klass, (Thor::Argument | Thor::Option) argument) -> void
         def generate_methods_for_argument(klass, argument)
           klass.create_method(
             argument.name,
@@ -85,7 +83,7 @@ module Tapioca
           )
         end
 
-        sig { returns(T.class_of(::Rails::Generators::Base)) }
+        #: -> singleton(::Rails::Generators::Base)
         def base_class_of_constant
           ancestor = inherited_ancestors_of(constant).find do |klass|
             qualified_name_of(klass)&.match?(BUILT_IN_MATCHER)
@@ -94,7 +92,7 @@ module Tapioca
           T.cast(ancestor, T.class_of(::Rails::Generators::Base))
         end
 
-        sig { params(arg: T.any(Thor::Argument, Thor::Option)).returns(String) }
+        #: ((Thor::Argument | Thor::Option) arg) -> String
         def type_for(arg)
           type =
             case arg.type

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

@@ -36,12 +36,17 @@ module Tapioca
       #   def self.perform_in(interval, customer_id); end
       # end
       # ~~~
+      #
+      # If your project uses `ActiveSupport` as well, then the compiler will automatically add its classes
+      # as accepted values for the `interval` parameter:
+      # * `self.perform_at` will also accept a `ActiveSupport::TimeWithZone` value
+      # * `self.perform_in` will also accept a `ActiveSupport::Duration` value
+      #: [ConstantType = singleton(::Sidekiq::Worker)]
       class SidekiqWorker < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::Sidekiq::Worker) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return unless constant.instance_methods.include?(:perform)
 
@@ -53,12 +58,22 @@ module Tapioca
             # `perform_at` and is just an alias for `perform_in` so both methods technically
             # accept a datetime, time, or numeric but we're typing them differently so they
             # semantically make sense.
+            at_return_type = if defined?(ActiveSupport::TimeWithZone)
+              "T.any(DateTime, Time, ActiveSupport::TimeWithZone)"
+            else
+              "T.any(DateTime, Time)"
+            end
             at_params = [
-              create_param("interval", type: "T.any(DateTime, Time)"),
+              create_param("interval", type: at_return_type),
               *async_params,
             ]
+            in_return_type = if defined?(ActiveSupport::Duration)
+              "T.any(Numeric, ActiveSupport::Duration)"
+            else
+              "Numeric"
+            end
             in_params = [
-              create_param("interval", type: "Numeric"),
+              create_param("interval", type: in_return_type),
               *async_params,
             ]
 
@@ -71,7 +86,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_classes.select { |c| Sidekiq::Worker > c }
           end
@@ -79,13 +95,7 @@ module Tapioca
 
         private
 
-        sig do
-          params(
-            worker: RBI::Scope,
-            method_name: String,
-            parameters: T::Array[RBI::TypedParam],
-          ).void
-        end
+        #: (RBI::Scope worker, String method_name, Array[RBI::TypedParam] parameters) -> void
         def generate_perform_method(worker, method_name, parameters)
           if constant.method(method_name.to_sym).owner == Sidekiq::Worker::ClassMethods
             worker.create_method(method_name, parameters: parameters, return_type: "String", class_method: true)

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

@@ -29,42 +29,43 @@ module Tapioca
       # # post.rbi
       # # typed: true
       # class Post
-      #   sig { returns(T.nilable(::String)) }
-      #   def title; end
+      #   include SmartPropertiesGeneratedMethods
       #
-      #   sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
-      #   def title=(title); end
+      #   module SmartPropertiesGeneratedMethods
+      #     sig { returns(T.nilable(::String)) }
+      #     def title; end
       #
-      #   sig { returns(::String) }
-      #   def description; end
+      #     sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def title=(title); end
       #
-      #   sig { params(description: ::String).returns(::String) }
-      #   def description=(description); end
+      #     sig { returns(::String) }
+      #     def description; end
       #
-      #   sig { returns(T.nilable(T::Boolean)) }
-      #   def published?; end
+      #     sig { params(description: ::String).returns(::String) }
+      #     def description=(description); end
       #
-      #   sig { params(published: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      #   def published=(published); end
+      #     sig { returns(T.nilable(T::Boolean)) }
+      #     def published?; end
       #
-      #   sig { returns(T.nilable(T::Boolean)) }
-      #   def enabled; end
+      #     sig { params(published: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      #     def published=(published); end
       #
-      #   sig { params(enabled: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      #   def enabled=(enabled); end
+      #     sig { returns(T.nilable(T::Boolean)) }
+      #     def enabled; end
+      #
+      #     sig { params(enabled: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      #     def enabled=(enabled); end
+      #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::SmartProperties)]
       class SmartProperties < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::SmartProperties) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
-          properties = T.let(
-            T.unsafe(constant).properties,
-            ::SmartProperties::PropertyCollection,
-          )
+          properties = T.unsafe(constant).properties #: ::SmartProperties::PropertyCollection
           return if properties.keys.empty?
 
           root.create_path(constant) do |k|
@@ -82,7 +83,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_modules.select do |c|
               name_of(c) &&
@@ -95,12 +97,7 @@ module Tapioca
 
         private
 
-        sig do
-          params(
-            mod: RBI::Scope,
-            property: ::SmartProperties::Property,
-          ).void
-        end
+        #: (RBI::Scope mod, ::SmartProperties::Property property) -> void
         def generate_methods_for_property(mod, property)
           type = type_for(property)
 
@@ -114,15 +111,12 @@ module Tapioca
           mod.create_method(property.reader.to_s, return_type: type)
         end
 
-        BOOLEANS = T.let(
-          [
-            [true, false],
-            [false, true],
-          ].freeze,
-          T::Array[[T::Boolean, T::Boolean]],
-        )
+        BOOLEANS = [
+          [true, false],
+          [false, true],
+        ].freeze #: Array[[bool, bool]]
 
-        sig { params(property: ::SmartProperties::Property).returns(String) }
+        #: (::SmartProperties::Property property) -> String
         def type_for(property)
           converter, accepter, required = property.to_h.fetch_values(
             :converter,

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

@@ -109,12 +109,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = (Module & ::StateMachines::ClassMethods)]
       class StateMachines < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.all(Module, ::StateMachines::ClassMethods) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.state_machines.empty?
 
@@ -157,7 +157,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_classes.select { |mod| ::StateMachines::InstanceMethods > mod }
           end
@@ -165,7 +166,7 @@ module Tapioca
 
         private
 
-        sig { params(machine: ::StateMachines::Machine).returns(String) }
+        #: (::StateMachines::Machine machine) -> String
         def state_type_for(machine)
           value_types = machine.states.map { |state| state.value.class.name }.uniq
 
@@ -176,7 +177,7 @@ module Tapioca
           end
         end
 
-        sig { params(instance_module: RBI::Module).void }
+        #: (RBI::Module instance_module) -> void
         def define_activerecord_methods(instance_module)
           instance_module.create_method(
             "changed_for_autosave?",
@@ -184,7 +185,7 @@ module Tapioca
           )
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_state_methods(instance_module, machine)
           machine.states.each do |state|
             instance_module.create_method(
@@ -194,7 +195,7 @@ module Tapioca
           end
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_event_methods(instance_module, machine)
           machine.events.each do |event|
             instance_module.create_method(
@@ -219,13 +220,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            instance_module: RBI::Module,
-            machine: ::StateMachines::Machine,
-            state_type: String,
-          ).void
-        end
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine, String state_type) -> void
         def define_state_accessor(instance_module, machine, state_type)
           attribute = machine.attribute.to_s
           instance_module.create_method(
@@ -239,7 +234,7 @@ module Tapioca
           ) if ::StateMachines::HelperModule === machine.owner_class.instance_method("#{attribute}=").owner
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_state_predicate(instance_module, machine)
           instance_module.create_method(
             "#{machine.name}?",
@@ -248,7 +243,7 @@ module Tapioca
           )
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_event_helpers(instance_module, machine)
           events_attribute = machine.attribute(:events).to_s
           transitions_attribute = machine.attribute(:transitions).to_s
@@ -295,7 +290,7 @@ module Tapioca
           end
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_path_helpers(instance_module, machine)
           paths_attribute = machine.attribute(:paths).to_s
 
@@ -306,13 +301,7 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            instance_module: RBI::Module,
-            class_module: RBI::Module,
-            machine: ::StateMachines::Machine,
-          ).void
-        end
+        #: (RBI::Module instance_module, RBI::Module class_module, ::StateMachines::Machine machine) -> void
         def define_name_helpers(instance_module, class_module, machine)
           name_attribute = machine.attribute(:name).to_s
           event_name_attribute = machine.attribute(:event_name).to_s
@@ -337,7 +326,7 @@ module Tapioca
           )
         end
 
-        sig { params(class_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module class_module, ::StateMachines::Machine machine) -> void
         def define_scopes(class_module, machine)
           helper_modules = machine.instance_variable_get(:@helper_modules)
           class_methods = helper_modules[:class].instance_methods(false)

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

@@ -78,12 +78,12 @@ module Tapioca
       #   include GeneratedUrlHelpersModule
       # end
       # ~~~
+      #: [ConstantType = Module]
       class UrlHelpers < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: Module } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           case constant
           when GeneratedPathHelpersModule.singleton_class, GeneratedUrlHelpersModule.singleton_class
@@ -98,7 +98,8 @@ module Tapioca
 
         class << self
           extend T::Sig
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             return [] unless defined?(Rails.application) && Rails.application
 
@@ -130,7 +131,7 @@ module Tapioca
             constants.concat(NON_DISCOVERABLE_INCLUDERS).push(GeneratedUrlHelpersModule, GeneratedPathHelpersModule)
           end
 
-          sig { returns(T::Array[Module]) }
+          #: -> Array[Module]
           def gather_non_discoverable_includers
             [].tap do |includers|
               if defined?(ActionController::TemplateAssertions) && defined?(ActionDispatch::IntegrationTest)
@@ -145,7 +146,7 @@ module Tapioca
 
           # 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) }
+          #: (Module mod, Module helper) -> bool
           private def includes_helper?(mod, helper)
             ancestors = ancestors_of(mod)
 
@@ -160,11 +161,11 @@ module Tapioca
           end
         end
 
-        NON_DISCOVERABLE_INCLUDERS = T.let(gather_non_discoverable_includers, T::Array[Module])
+        NON_DISCOVERABLE_INCLUDERS = gather_non_discoverable_includers #: Array[Module]
 
         private
 
-        sig { params(root: RBI::Tree, constant: Module).void }
+        #: (RBI::Tree root, Module constant) -> void
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
             mod.create_include("::ActionDispatch::Routing::UrlFor")
@@ -180,7 +181,7 @@ module Tapioca
           end
         end
 
-        sig { params(mod: RBI::Scope, helper_module: Module).void }
+        #: (RBI::Scope mod, Module helper_module) -> void
         def create_mixins_for(mod, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)

data/lib/tapioca/dsl/compilers.rb

@@ -10,13 +10,10 @@ module Tapioca
       # a different namespace and can only be referred to using their fully
       # qualified name. This constant encapsulates that dual lookup when
       # a compiler needs to be resolved by name.
-      NAMESPACES = T.let(
-        [
-          "#{name}::", # compilers in this namespace
-          "::", # compilers that need to be fully namespaced
-        ],
-        T::Array[String],
-      )
+      NAMESPACES = [
+        "#{name}::", # compilers in this namespace
+        "::", # compilers that need to be fully namespaced
+      ] #: Array[String]
     end
   end
 end