tapioca 0.16.9 → 0.17.7

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

@@ -32,57 +32,45 @@ module Tapioca
       #   sleeping?, running?, cleaning?
       #   run, run!, run_without_validation!, may_run?
       #
+      #: [ConstantType = (Class[::AASM] & ::AASM::ClassMethods)]
       class AASM < Compiler
         extend T::Sig
 
         # 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],
-          )
-
-        ConstantType = type_member { { fixed: T.all(T::Class[::AASM], ::AASM::ClassMethods) } }
-
-        sig { override.void }
+        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]
+
+        # @override
+        #: -> void
         def decorate
           state_machine_store = ::AASM::StateMachineStore.fetch(constant)
           return unless state_machine_store
@@ -214,7 +202,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

@@ -61,12 +61,12 @@ module Tapioca
       #   def helpers; end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActionController::Base)]
       class ActionControllerHelpers < Compiler
         extend T::Sig
 
-        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 +120,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 +131,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 +139,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 +152,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

@@ -29,12 +29,12 @@ module Tapioca
       #   def self.notify_customer(customer_id); end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActionMailer::Base)]
       class ActionMailer < Compiler
         extend T::Sig
 
-        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 +53,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 +62,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

@@ -43,12 +43,12 @@ module Tapioca
       #  def title?; end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActionText < Compiler
         extend T::Sig
 
-        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 +75,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 +83,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

@@ -38,12 +38,12 @@ module Tapioca
       #   def self.perform_now(user); end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveJob::Base)]
       class ActiveJob < Compiler
         extend T::Sig
 
-        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 +71,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 +87,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

@@ -34,14 +34,12 @@ module Tapioca
       #   def name=(name); end
       # end
       # ~~~
+      #: [ConstantType = (Class[::ActiveModel::Attributes] & ::ActiveModel::Attributes::ClassMethods)]
       class ActiveModelAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          { 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 +54,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 +63,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 +82,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 +98,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 +122,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

@@ -53,14 +53,12 @@ module Tapioca
       #   def token_confirmation=(unencrypted_password); end
       # end
       # ~~~
+      #: [ConstantType = (Class[::ActiveModel::SecurePassword] & ::ActiveModel::SecurePassword::ClassMethods)]
       class ActiveModelSecurePassword < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          { 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 +92,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

@@ -40,28 +40,21 @@ module Tapioca
       #   def password_confirmation=(password_confirmation); end
       # end
       # ~~~
+      #: [ConstantType = (Class[ActiveModel::Validations] & ActiveModel::Validations::HelperMethods & ActiveModel::Validations::ClassMethods)]
       class ActiveModelValidationsConfirmation < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          {
-            fixed: T.all(
-              T::Class[ActiveModel::Validations],
-              ActiveModel::Validations::HelperMethods,
-              ActiveModel::Validations::ClassMethods,
-            ),
-          }
-        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)
 

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

@@ -101,6 +101,7 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(ActiveRecord::Base)]
       class ActiveRecordAssociations < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
@@ -111,19 +112,18 @@ module Tapioca
         class MissingConstantError < StandardError
           extend T::Sig
 
-          sig { returns(String) }
+          #: String
           attr_reader :class_name
 
-          sig { params(class_name: String).void }
+          #: (String class_name) -> void
           def initialize(class_name)
             @class_name = class_name
             super
           end
         end
 
-        ConstantType = type_member { { fixed: T.class_of(ActiveRecord::Base) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.reflections.empty?
 
@@ -140,7 +140,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end
@@ -148,7 +149,7 @@ module Tapioca
 
         private
 
-        sig { params(mod: RBI::Scope).void }
+        #: (RBI::Scope mod) -> void
         def populate_nested_attribute_writers(mod)
           constant.nested_attributes_options.keys.each do |association_name|
             mod.create_method(
@@ -159,7 +160,7 @@ module Tapioca
           end
         end
 
-        sig { params(mod: RBI::Scope).void }
+        #: (RBI::Scope mod) -> void
         def populate_associations(mod)
           constant.reflections.each do |association_name, reflection|
             if reflection.collection?
@@ -178,13 +179,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            association_name: T.any(String, Symbol),
-            reflection: ReflectionType,
-          ).void
-        end
+        #: (RBI::Scope klass, (String | Symbol) association_name, ReflectionType reflection) -> void
         def populate_single_assoc_getter_setter(klass, association_name, reflection)
           association_class = type_for(reflection)
           association_type = as_nilable_type(association_class)
@@ -247,13 +242,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            association_name: T.any(String, Symbol),
-            reflection: ReflectionType,
-          ).void
-        end
+        #: (RBI::Scope klass, (String | Symbol) association_name, ReflectionType reflection) -> void
         def populate_collection_assoc_getter_setter(klass, association_name, reflection)
           association_class = type_for(reflection)
           relation_class = relation_type_for(reflection)
@@ -279,11 +268,7 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            reflection: ReflectionType,
-          ).returns(String)
-        end
+        #: (ReflectionType reflection) -> String
         def type_for(reflection)
           validate_reflection!(reflection)
 
@@ -292,11 +277,7 @@ module Tapioca
           T.must(qualified_name_of(reflection.klass))
         end
 
-        sig do
-          params(
-            reflection: ReflectionType,
-          ).void
-        end
+        #: (ReflectionType reflection) -> void
         def validate_reflection!(reflection)
           # Check existence of source reflection, first, since, calling
           # `.klass` also tries to go through the source reflection
@@ -320,7 +301,7 @@ module Tapioca
           raise MissingConstantError, class_name
         end
 
-        sig { params(reflection: ReflectionType).returns(T.nilable(String)) }
+        #: (ReflectionType reflection) -> String?
         def declaration(reflection)
           case reflection
           when ActiveRecord::Reflection::HasOneReflection
@@ -340,7 +321,7 @@ module Tapioca
           end
         end
 
-        sig { params(reflection: ReflectionType).returns(T::Array[RBI::Comment]) }
+        #: (ReflectionType reflection) -> Array[RBI::Comment]
         def association_comments(reflection)
           anchor_name = case reflection
           when ActiveRecord::Reflection::HasOneReflection
@@ -374,11 +355,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            reflection: ReflectionType,
-          ).returns(String)
-        end
+        #: (ReflectionType reflection) -> String
         def relation_type_for(reflection)
           validate_reflection!(reflection)
 
@@ -398,11 +375,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            reflection: ReflectionType,
-          ).returns(T::Boolean)
-        end
+        #: (ReflectionType reflection) -> bool
         def polymorphic_association?(reflection)
           if reflection.through_reflection?
             polymorphic_association?(reflection.source_reflection)

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

@@ -120,13 +120,13 @@ module Tapioca
       #     sig { returns(T.untyped) }
       #     def title; end
       # ~~~
+      #: [ConstantType = singleton(ActiveRecord::Base)]
       class ActiveRecordColumns < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.class_of(ActiveRecord::Base) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return unless constant.table_exists?
 
@@ -165,7 +165,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end
@@ -175,7 +176,7 @@ module Tapioca
 
         ColumnTypeOption = Helpers::ActiveRecordColumnTypeHelper::ColumnTypeOption
 
-        sig { returns(ColumnTypeOption) }
+        #: -> ColumnTypeOption
         def column_type_option
           @column_type_option ||= T.let(
             ColumnTypeOption.from_options(options) do |value, default_column_type_option|
@@ -188,15 +189,7 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            name: String,
-            methods_to_add: T.nilable(T::Array[String]),
-            return_type: String,
-            parameters: T::Array[RBI::TypedParam],
-          ).void
-        end
+        #: (RBI::Scope klass, String name, Array[String]? methods_to_add, ?return_type: String, ?parameters: Array[RBI::TypedParam]) -> void
         def add_method(klass, name, methods_to_add, return_type: "void", parameters: [])
           klass.create_method(
             name,
@@ -205,14 +198,7 @@ module Tapioca
           ) if methods_to_add.nil? || methods_to_add.include?(name)
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            attribute_name: String,
-            column_name: String,
-            methods_to_add: T.nilable(T::Array[String]),
-          ).void
-        end
+        #: (RBI::Scope klass, String attribute_name, ?String column_name, ?Array[String]? methods_to_add) -> void
         def add_methods_for_attribute(klass, attribute_name, column_name = attribute_name, methods_to_add = nil)
           getter_type, setter_type = Helpers::ActiveRecordColumnTypeHelper
             .new(constant, column_type_option: column_type_option)
@@ -277,12 +263,20 @@ module Tapioca
             "saved_change_to_#{attribute_name}?",
             methods_to_add,
             return_type: "T::Boolean",
+            parameters: [
+              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
+            ],
           )
           add_method(
             klass,
             "will_save_change_to_#{attribute_name}?",
             methods_to_add,
             return_type: "T::Boolean",
+            parameters: [
+              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
+            ],
           )
 
           # Added by ActiveModel::Dirty
@@ -299,8 +293,8 @@ module Tapioca
             methods_to_add,
             return_type: "T::Boolean",
             parameters: [
-              create_kw_opt_param("from", type: setter_type, default: "T.unsafe(nil)"),
-              create_kw_opt_param("to", type: setter_type, default: "T.unsafe(nil)"),
+              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
             ],
           )
           add_method(
@@ -326,8 +320,8 @@ module Tapioca
             methods_to_add,
             return_type: "T::Boolean",
             parameters: [
-              create_kw_opt_param("from", type: setter_type, default: "T.unsafe(nil)"),
-              create_kw_opt_param("to", type: setter_type, default: "T.unsafe(nil)"),
+              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
             ],
           )
           add_method(