tapioca 0.16.10 → 0.17.0

data/lib/tapioca/commands/todo.rb

@@ -17,12 +17,7 @@ module Tapioca
         4. Manually create an RBI shim defining the missing constants
       DEPRECATION
 
-      sig do
-        params(
-          todo_file: String,
-          file_header: T::Boolean,
-        ).void
-      end
+      #: (todo_file: String, file_header: bool) -> void
       def initialize(todo_file:, file_header:)
         @todo_file = todo_file
         @file_header = file_header
@@ -30,7 +25,7 @@ module Tapioca
         super()
       end
 
-      sig { void }
+      #: -> void
       def run_with_deprecation
         say(DEPRECATION_MESSAGE, :red)
         say("")
@@ -40,7 +35,8 @@ module Tapioca
 
       private
 
-      sig { override.void }
+      # @override
+      #: -> void
       def execute
         say("Finding all unresolved constants, this may take a few seconds... ")
 
@@ -64,7 +60,7 @@ module Tapioca
         say("Please review changes and commit them.", [:green, :bold])
       end
 
-      sig { params(constants: T::Array[String], command: String).returns(RBI::File) }
+      #: (Array[String] constants, command: String) -> RBI::File
       def rbi(constants, command:)
         file = RBI::File.new
 
@@ -84,7 +80,7 @@ module Tapioca
         file
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def unresolved_constants
         # Taken from https://github.com/sorbet/sorbet/blob/master/gems/sorbet/lib/todo-rbi.rb
         sorbet("--print=missing-constants", "--quiet", "--stdout-hup-hack", "--no-error-count")

data/lib/tapioca/dsl/compiler.rb

@@ -16,21 +16,21 @@ module Tapioca
 
       abstract!
 
-      sig { returns(ConstantType) }
+      #: ConstantType
       attr_reader :constant
 
-      sig { returns(RBI::Tree) }
+      #: RBI::Tree
       attr_reader :root
 
-      sig { returns(T::Hash[String, T.untyped]) }
+      #: Hash[String, untyped]
       attr_reader :options
 
-      @@requested_constants = T.let([], T::Array[Module]) # rubocop:disable Style/ClassVars
+      @@requested_constants = [] #: Array[Module] # rubocop:disable Style/ClassVars
 
       class << self
         extend T::Sig
 
-        sig { params(constant: Module).returns(T::Boolean) }
+        #: (Module constant) -> bool
         def handles?(constant)
           processable_constants.include?(constant)
         end
@@ -38,20 +38,17 @@ module Tapioca
         sig { abstract.returns(T::Enumerable[Module]) }
         def gather_constants; end
 
-        sig { returns(T::Set[Module]) }
+        #: -> Set[Module]
         def processable_constants
-          @processable_constants ||= T.let(
-            T::Set[Module].new.compare_by_identity.merge(gather_constants),
-            T.nilable(T::Set[Module]),
-          )
+          @processable_constants ||= T::Set[Module].new.compare_by_identity.merge(gather_constants) #: Set[Module]?
         end
 
-        sig { params(constants: T::Array[Module]).void }
+        #: (Array[Module] constants) -> void
         def requested_constants=(constants)
           @@requested_constants = constants # rubocop:disable Style/ClassVars
         end
 
-        sig { void }
+        #: -> void
         def reset_state
           @processable_constants = nil
           @all_classes = nil
@@ -60,11 +57,7 @@ module Tapioca
 
         private
 
-        sig do
-          type_parameters(:U)
-            .params(klass: T.all(T::Class[T.anything], T.type_parameter(:U)))
-            .returns(T::Array[T.type_parameter(:U)])
-        end
+        #: [U] ((Class[top] & U) klass) -> Array[U]
         def descendants_of(klass)
           if @@requested_constants.any?
             T.cast(
@@ -78,44 +71,31 @@ module Tapioca
           end
         end
 
-        sig { returns(T::Enumerable[T::Class[T.anything]]) }
+        #: -> T::Enumerable[Class[top]]
         def all_classes
-          @all_classes ||= T.let(
-            all_modules.grep(Class).freeze,
-            T.nilable(T::Enumerable[T::Class[T.anything]]),
-          )
+          @all_classes ||= all_modules.grep(Class).freeze #: T::Enumerable[Class[top]]?
         end
 
-        sig { returns(T::Enumerable[Module]) }
+        #: -> T::Enumerable[Module]
         def all_modules
-          @all_modules ||= T.let(
-            if @@requested_constants.any?
-              @@requested_constants.grep(Module)
-            else
-              ObjectSpace.each_object(Module).to_a
-            end.freeze,
-            T.nilable(T::Enumerable[Module]),
-          )
+          @all_modules ||= if @@requested_constants.any?
+            @@requested_constants.grep(Module)
+          else
+            ObjectSpace.each_object(Module).to_a
+          end.freeze #: T::Enumerable[Module]?
         end
       end
 
-      sig do
-        params(
-          pipeline: Tapioca::Dsl::Pipeline,
-          root: RBI::Tree,
-          constant: ConstantType,
-          options: T::Hash[String, T.untyped],
-        ).void
-      end
+      #: (Tapioca::Dsl::Pipeline pipeline, RBI::Tree root, ConstantType constant, ?Hash[String, untyped] options) -> void
       def initialize(pipeline, root, constant, options = {})
         @pipeline = pipeline
         @root = root
         @constant = constant
         @options = options
-        @errors = T.let([], T::Array[String])
+        @errors = [] #: Array[String]
       end
 
-      sig { params(compiler_name: String).returns(T::Boolean) }
+      #: (String compiler_name) -> bool
       def compiler_enabled?(compiler_name)
         @pipeline.compiler_enabled?(compiler_name)
       end
@@ -124,7 +104,7 @@ module Tapioca
       def decorate; end
 
       # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
-      sig { params(error: String).void }
+      #: (String error) -> void
       def add_error(error)
         @pipeline.add_error(error)
       end
@@ -132,14 +112,9 @@ module Tapioca
       private
 
       # Get the types of each parameter from a method signature
-      sig do
-        params(
-          method_def: T.any(Method, UnboundMethod),
-          signature: T.untyped, # as `T::Private::Methods::Signature` is private
-        ).returns(T::Array[String])
-      end
+      #: ((Method | UnboundMethod) method_def, untyped signature) -> Array[String]
       def parameters_types_from_signature(method_def, signature)
-        params = T.let([], T::Array[String])
+        params = [] #: Array[String]
 
         return method_def.parameters.map { "T.untyped" } unless signature
 
@@ -163,7 +138,7 @@ module Tapioca
         params
       end
 
-      sig { params(scope: RBI::Scope, method_def: T.any(Method, UnboundMethod), class_method: T::Boolean).void }
+      #: (RBI::Scope scope, (Method | UnboundMethod) method_def, ?class_method: bool) -> void
       def create_method_from_def(scope, method_def, class_method: false)
         scope.create_method(
           method_def.name.to_s,
@@ -173,13 +148,13 @@ module Tapioca
         )
       end
 
-      sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[RBI::TypedParam]) }
+      #: ((Method | UnboundMethod) method_def) -> Array[RBI::TypedParam]
       def compile_method_parameters_to_rbi(method_def)
         signature = signature_of(method_def)
         method_def = signature.nil? ? method_def : signature.method
         method_types = parameters_types_from_signature(method_def, signature)
 
-        parameters = T.let(method_def.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+        parameters = method_def.parameters #: Array[[Symbol, Symbol?]]
 
         parameters.each_with_index.map do |(type, name), index|
           fallback_arg_name = "_arg#{index}"
@@ -209,7 +184,7 @@ module Tapioca
         end
       end
 
-      sig { params(method_def: T.any(Method, UnboundMethod)).returns(String) }
+      #: ((Method | UnboundMethod) method_def) -> String
       def compile_method_return_type_to_rbi(method_def)
         signature = signature_of(method_def)
         return_type = signature.nil? ? "T.untyped" : name_of_type(signature.return_type)

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

@@ -37,52 +37,41 @@ module Tapioca
 
         # Taken directly from the AASM::Core::Event class, here:
         # https://github.com/aasm/aasm/blob/0e03746/lib/aasm/core/event.rb#L21-L29
-        EVENT_CALLBACKS =
-          T.let(
-            [
-              "after",
-              "after_commit",
-              "after_transaction",
-              "before",
-              "before_transaction",
-              "ensure",
-              "error",
-              "before_success",
-              "success",
-            ].freeze,
-            T::Array[String],
-          )
+        EVENT_CALLBACKS = [
+          "after",
+          "after_commit",
+          "after_transaction",
+          "before",
+          "before_transaction",
+          "ensure",
+          "error",
+          "before_success",
+          "success",
+        ].freeze #: Array[String]
 
         # Taken directly from the AASM::Base class, here:
         # https://github.com/aasm/aasm/blob/0e03746a2b86558ee1bf7bd7db873938cbb3b29b/lib/aasm/base.rb#L145-L171
-        GLOBAL_CALLBACKS =
-          T.let(
-            [
-              "after_all_transitions",
-              "after_all_transactions",
-              "before_all_transactions",
-              "before_all_events",
-              "after_all_events",
-              "error_on_all_events",
-              "ensure_on_all_events",
-            ].freeze,
-            T::Array[String],
-          )
-
-        TRANSITION_CALLBACKS =
-          T.let(
-            [
-              "on_transition",
-              "guard",
-              "after",
-              "success",
-            ].freeze,
-            T::Array[String],
-          )
+        GLOBAL_CALLBACKS = [
+          "after_all_transitions",
+          "after_all_transactions",
+          "before_all_transactions",
+          "before_all_events",
+          "after_all_events",
+          "error_on_all_events",
+          "ensure_on_all_events",
+        ].freeze #: Array[String]
+
+        TRANSITION_CALLBACKS = [
+          "on_transition",
+          "guard",
+          "after",
+          "success",
+        ].freeze #: Array[String]
 
         ConstantType = type_member { { fixed: T.all(T::Class[::AASM], ::AASM::ClassMethods) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           state_machine_store = ::AASM::StateMachineStore.fetch(constant)
           return unless state_machine_store
@@ -214,7 +203,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             T.cast(ObjectSpace.each_object(::AASM::ClassMethods), T::Enumerable[Module])
           end

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

@@ -66,7 +66,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActionController::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           helpers_module = constant._helpers
           proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
@@ -120,7 +121,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActionController::Base).select(&:name).select do |klass|
               klass.const_defined?(:HelperMethods, false)
@@ -130,7 +132,7 @@ module Tapioca
 
         private
 
-        sig { params(method_name: Symbol).returns(T.nilable(UnboundMethod)) }
+        #: (Symbol method_name) -> UnboundMethod?
         def helper_method_proxy_target(method_name)
           # Lookup the proxy target method only if it is defined as a public/protected or private method.
           if constant.method_defined?(method_name) || constant.private_method_defined?(method_name)
@@ -138,7 +140,7 @@ module Tapioca
           end
         end
 
-        sig { params(helper_methods: RBI::Scope, method_name: Symbol).void }
+        #: (RBI::Scope helper_methods, Symbol method_name) -> void
         def create_unknown_proxy_method(helper_methods, method_name)
           helper_methods.create_method(
             method_name.to_s,
@@ -151,7 +153,7 @@ module Tapioca
           )
         end
 
-        sig { params(mod: Module).returns(T::Array[String]) }
+        #: (Module mod) -> Array[String]
         def gather_includes(mod)
           mod.ancestors
             .reject { |ancestor| ancestor.is_a?(Class) || ancestor == mod || name_of(ancestor).nil? }

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

@@ -34,7 +34,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActionMailer::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           root.create_path(constant) do |mailer|
             action_methods_for_constant.each do |mailer_method|
@@ -53,7 +54,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActionMailer::Base).reject(&:abstract?)
           end
@@ -61,7 +63,7 @@ module Tapioca
 
         private
 
-        sig { returns(T::Array[String]) }
+        #: -> Array[String]
         def action_methods_for_constant
           constant.action_methods.to_a
         end

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

@@ -48,7 +48,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           root.create_path(constant) do |scope|
             self.class.action_text_associations(constant).each do |name|
@@ -75,7 +76,7 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { params(constant: T.class_of(::ActiveRecord::Base)).returns(T::Array[String]) }
+          #: (singleton(::ActiveRecord::Base) constant) -> Array[String]
           def action_text_associations(constant)
             # Implementation copied from https://github.com/rails/rails/blob/31052d0e518b9da103eea2f79d250242ed1e3705/actiontext/lib/action_text/attribute.rb#L66
             constant.reflect_on_all_associations(:has_one)
@@ -83,7 +84,8 @@ module Tapioca
               .select { |n| n.start_with?("rich_text_") }
           end
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base)
               .reject(&:abstract_class?)

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

@@ -43,7 +43,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActiveJob::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return unless constant.instance_methods(false).include?(:perform)
 
@@ -71,12 +72,7 @@ module Tapioca
 
         private
 
-        sig do
-          params(
-            parameters: T::Array[RBI::TypedParam],
-            constant_name: T.nilable(String),
-          ).returns(T::Array[RBI::TypedParam])
-        end
+        #: (Array[RBI::TypedParam] parameters, String? constant_name) -> Array[RBI::TypedParam]
         def perform_later_parameters(parameters, constant_name)
           if ::Gem::Requirement.new(">= 7.0").satisfied_by?(::ActiveJob.gem_version)
             parameters.reject! { |typed_param| RBI::BlockParam === typed_param.param }
@@ -92,7 +88,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveJob::Base)
           end

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

@@ -41,7 +41,8 @@ module Tapioca
           { fixed: T.all(T::Class[::ActiveModel::Attributes], ::ActiveModel::Attributes::ClassMethods) }
         end
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           attribute_methods = attribute_methods_for_constant
           return if attribute_methods.empty?
@@ -56,7 +57,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_classes.grep(::ActiveModel::Attributes::ClassMethods)
           end
@@ -64,9 +66,9 @@ module Tapioca
 
         private
 
-        HANDLED_METHOD_TARGETS = T.let(["attribute", "attribute="], T::Array[String])
+        HANDLED_METHOD_TARGETS = ["attribute", "attribute="] #: Array[String]
 
-        sig { returns(T::Array[[::String, ::String]]) }
+        #: -> Array[[::String, ::String]]
         def attribute_methods_for_constant
           patterns = if constant.respond_to?(:attribute_method_patterns)
             # https://github.com/rails/rails/pull/44367
@@ -83,7 +85,7 @@ module Tapioca
           end
         end
 
-        sig { params(pattern: T.untyped).returns(T::Boolean) }
+        #: (untyped pattern) -> bool
         def handle_method_pattern?(pattern)
           target = if pattern.respond_to?(:method_missing_target)
             # Pre-Rails 6.0, the field is named "method_missing_target"
@@ -99,7 +101,7 @@ module Tapioca
           HANDLED_METHOD_TARGETS.include?(target.to_s)
         end
 
-        sig { params(attribute_type_value: T.untyped).returns(::String) }
+        #: (untyped attribute_type_value) -> ::String
         def type_for(attribute_type_value)
           case attribute_type_value
           when ActiveModel::Type::Boolean
@@ -123,7 +125,7 @@ module Tapioca
           end
         end
 
-        sig { params(klass: RBI::Scope, method: String, type: String).void }
+        #: (RBI::Scope klass, String method, String type) -> void
         def generate_method(klass, method, type)
           if method.end_with?("=")
             parameter = create_param("value", type: type)

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

@@ -60,7 +60,8 @@ module Tapioca
           { fixed: T.all(T::Class[::ActiveModel::SecurePassword], ::ActiveModel::SecurePassword::ClassMethods) }
         end
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           instance_methods_modules = if constant < ActiveModel::SecurePassword::InstanceMethodsOnActivation
             # pre Rails 6.0, this used to be a single static module
@@ -94,7 +95,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             # This selects all classes that are `ActiveModel::SecurePassword::ClassMethods === klass`.
             # In other words, we select all classes that have `ActiveModel::SecurePassword::ClassMethods`

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

@@ -54,14 +54,16 @@ module Tapioca
         end
 
         class << self
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             # Collect all the classes that include ActiveModel::Validations
             all_classes.select { |c| ActiveModel::Validations > c }
           end
         end
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           confirmation_validators = constant.validators.grep(ActiveModel::Validations::ConfirmationValidator)