class Tapioca::Dsl::Compilers::ActiveJob

~~~
end
def self.perform_now(user); end
sig { params(user: User).returns(Mail) }
def self.perform_later(user, &block); end
end
).returns(T.any(NotifyUserJob, FalseClass))
block: T.nilable(T.proc.params(job: NotifyUserJob).void),
user: User,
params(
sig do
class NotifyUserJob
# typed: true
# notify_user_job.rbi
~~~rbi
this compiler will produce the RBI file ‘notify_user_job.rbi` with the following content:
~~~
end
end
# …
def perform(user)
sig { params(user: User).returns(Mail) }
class NotifyUserJob < ActiveJob::Base
~~~rb
For example, with the following `ActiveJob` subclass:<br><br>(api.rubyonrails.org/classes/ActiveJob/Base.html).
`Tapioca::Dsl::Compilers::ActiveJob` generates RBI files for subclasses of

def decorate 

def decorate
  return unless constant.instance_methods(false).include?(:perform)
  root.create_path(constant) do |job|
    method = constant.instance_method(:perform)
    constant_name = name_of(constant)
    parameters = compile_method_parameters_to_rbi(method)
    return_type = compile_method_return_type_to_rbi(method)
    job.create_method(
      "perform_later",
      parameters: perform_later_parameters(parameters, constant_name),
      return_type: "T.any(#{constant_name}, FalseClass)",
      class_method: true,
    )
    job.create_method(
      "perform_now",
      parameters: parameters,
      return_type: return_type,
      class_method: true,
    )
  end
end

def gather_constants 

def gather_constants
  descendants_of(::ActiveJob::Base)
end

def perform_later_parameters(parameters, constant_name) 

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 }
    parameters + [create_block_param(
      "block",
      type: "T.nilable(T.proc.params(job: #{constant_name}).void)",
    )]
  else
    parameters
  end
end