sidekiq_worker.rb in tapioca-0.5.0

- old
+ new

@@ -1,10 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "sidekiq"
 rescue LoadError
   return
 end
@@ -43,40 +41,55 @@
       # end
       # ~~~
       class SidekiqWorker < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::Sidekiq::Worker)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::Sidekiq::Worker)).void }
         def decorate(root, constant)
           return unless constant.instance_methods.include?(:perform)
 
-          root.path(constant) do |worker|
+          root.create_path(constant) do |worker|
             method_def = constant.instance_method(:perform)
 
-            async_params = compile_method_parameters_to_parlour(method_def)
+            async_params = compile_method_parameters_to_rbi(method_def)
 
             # `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_params = [
-              Parlour::RbiGenerator::Parameter.new('interval', type: 'T.any(DateTime, Time)'),
+              create_param("interval", type: "T.any(DateTime, Time)"),
               *async_params,
             ]
             in_params = [
-              Parlour::RbiGenerator::Parameter.new('interval', type: 'Numeric'),
+              create_param("interval", type: "Numeric"),
               *async_params,
             ]
 
-            create_method(worker, 'perform_async', parameters: async_params, return_type: 'String', class_method: true)
-            create_method(worker, 'perform_at', parameters: at_params, return_type: 'String', class_method: true)
-            create_method(worker, 'perform_in', parameters: in_params, return_type: 'String', class_method: true)
+            generate_perform_method(constant, worker, "perform_async", async_params)
+            generate_perform_method(constant, worker, "perform_at", at_params)
+            generate_perform_method(constant, worker, "perform_in", in_params)
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          classes = T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class])
-          classes.select { |c| c < Sidekiq::Worker }
+          all_classes.select { |c| c < Sidekiq::Worker }
+        end
+
+        private
+
+        sig do
+          params(
+            constant: T.class_of(::Sidekiq::Worker),
+            worker: RBI::Scope,
+            method_name: String,
+            parameters: T::Array[RBI::TypedParam]
+          ).void
+        end
+        def generate_perform_method(constant, 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)
+          end
         end
       end
     end
   end
 end