Rescue can call :instance_method for old and new signature.

Author: apotonick

lib/trailblazer/macro/rescue.rb

@@ -7,27 +7,25 @@ def self.Rescue(*exceptions, handler: NoopHandler, id: Macro.id_for(nil, macro:
 
       # In Rescue(), for whatever reason we support a circuit interface handler
       # where we ignore the result set?
-      # handler    = Trailblazer::Activity::Circuit.Step(handler)
 
       is_instance_method = false
       handler = Activity::Option.build(handler) do |instance_method|
         # this is for :instance_methods
         is_instance_method = true
-        callable = Rescue::InstanceMethodWithCircuitInterfaceAndKwargs.new(instance_method)
 
         # assuming we have to deprecate everything.
-        Rescue::Deprecate::InstanceMethodAtRuntime.new(callable, instance_method) # TODO: remove in 2.3.
+        Rescue::Deprecate::InstanceMethodAtRuntime.new(nil, instance_method)
       end
 
       if is_instance_method
         # deprecate at runtime :D
       else
-        # deprecate now!
-        if handler.method(:call).arity == -3
-          # raise handler.inspect
-          puts "@@@@@ xxx #{handler.inspect}"
+        # This only catches the documented signature:
+        #   def(exception, (ctx), *)
+        if Rescue::Deprecate.old_signature?(handler.method(:call))
           Rescue::Deprecate.warning_for_deprecated_callable
-# raise "why are we not hitting this from line 291?"
+
+          # deprecate now!
           handler = Rescue::Deprecate::Callable.new(handler)
         end
       end
@@ -59,21 +57,38 @@ def self.Rescue(*exceptions, handler: NoopHandler, id: Macro.id_for(nil, macro:
 
     module Rescue
       module Deprecate
+        def self.old_signature?(method)
+          # this doesn't catch all, but we ignore that.
+          method.arity == -3 && method.parameters[1] == [:req] # (ctx)
+        end
+
+          # This is kind of specific to Rescue, but might be useful elsewhere. We want to run a circuit interface
+      # *instance method* with keyword arguments. in a normal CI-conform callable, this doesn't need any
+      # wrapping, but instance_methods are different.
+      # TODO: this is not Deprecate specific!!!!!!!!!!!!!!!!!!!!
+        def self.translate_from_circuit_interface_to_instance_method_option(instance_method_option, ctx, flow_options, circuit_options, **kwargs)
+          instance_method_option.(ctx, flow_options, circuit_options, keyword_arguments: kwargs, **circuit_options)
+        end
+
         class InstanceMethodAtRuntime < Struct.new(:filter, :instance_method_option)
           def call(ctx, flow_options, circuit_options, exception:)
-            exec_context = circuit_options.fetch(:exec_context)
+            # Try to retrieve the method instance of the handler method.
             # hacky, but hey, it's deprecation code!
+            exec_context    = circuit_options.fetch(:exec_context)
             instance_method = exec_context.method(instance_method_option.instance_variable_get(:@filter))
 
-            if instance_method.arity == -3 # this doesn't catch all, but we ignore that.
+            if Deprecate.old_signature?(instance_method)
               # Activity::Deprecate.warn(
                 # Activity::DSL::Linear::Deprecate.dsl_caller_location(after: /forwardable.+Rescue/),
               warning =  "#{exec_context.class}##{instance_method.name} " + Deprecate.message_for_deprecation_warning
 
               Kernel.warn %([Trailblazer] #{warning}\n) # TODO: allow that in Activity::Deprecate.
+
+              # this is a bit hacky but we can call old signature with the "correct" arguments.
+              return Deprecate.translate_from_circuit_interface_to_instance_method_option(instance_method_option, exception, [ctx, flow_options], circuit_options)
             end
 
-            filter.(ctx, flow_options, circuit_options, exception: exception)
+            Deprecate.translate_from_circuit_interface_to_instance_method_option(instance_method_option, ctx, flow_options, circuit_options, exception: exception)
           end
         end
 
@@ -95,17 +110,7 @@ def self.warning_for_deprecated_callable
             message_for_deprecation_warning
           )
         end
-      end
-      # This is kind of specific to Rescue, but might be useful elsewhere. We want to run a circuit interface
-      # *instance method* with keyword arguments. in a normal CI-conform callable, this doesn't need any
-      # wrapping, but instance_methods are different.
-      class InstanceMethodWithCircuitInterfaceAndKwargs < Struct.new(:instance_method_option) # DISCUSS: move somewhere else?
-        def call(ctx, flow_options, circuit_options, exception:, **kwargs)
-          # Call the method the old, weird style with exception as a positional argument
-          # followed by the composite circuit interface.
-          instance_method_option.(exception, [ctx, flow_options], keyword_arguments: kwargs, **circuit_options)
-        end
-      end
+      end # Deprecate
     end
   end
 end

test/docs/rescue_test.rb

@@ -13,11 +13,11 @@ class NestedInsanity < Trailblazer::Operation
       step :a
       step Rescue {
         step :y
-        pass ->(options, **) { raise Y if options["raise-y"] }
+        pass ->(ctx, **) { raise Y if ctx["raise-y"] }
         step :z
       }
       step :b
-      pass ->(options, **) { raise A if options["raise-a"] }
+      pass ->(ctx, **) { raise A if ctx["raise-a"] }
       step :c
       left :inner_err
     }
@@ -79,7 +79,7 @@ module Song::Activity; end
 
     #:rescue-handler
     class MyHandler
-      def self.call(exception, (ctx), *)
+      def self.call(ctx, flow_options, circuit_options, exception:)
         ctx[:exception_class] = exception.class
       end
     end
@@ -115,7 +115,7 @@ class RescueWithModuleHandlerTest < Minitest::Spec
     Memo = Class.new
 
     module MyHandler
-      def self.call(exception, (ctx), *)
+      def self.call(ctx, *, exception:)
         ctx[:exception_class] = exception.class
       end
     end
@@ -145,7 +145,7 @@ class RescueWithMethodHandlerTest < Minitest::Spec
     #:rescue-method
     class Memo::Create < Trailblazer::Operation
       step :find_model
-      step Rescue( RuntimeError, handler: :my_handler ) {
+      step Rescue(RuntimeError, handler: :my_handler) {
         step :update
         step :rehash
       }
@@ -156,7 +156,7 @@ class Memo::Create < Trailblazer::Operation
       include Rehash
       #~methods end
 
-      def my_handler(exception, (ctx), *)
+      def my_handler(ctx, *, exception:)
         ctx[:exception_class] = exception.class
       end
     end
@@ -297,9 +297,9 @@ class Song::Operation::Create < Trailblazer::Activity::Railway
     end
     assert_equal warnings, ""
 
-    # _, warnings = capture_io do
+    _, warnings = capture_io do
       assert_invoke activity, rehash_raise: RuntimeError, terminus: :failure, seq: "[:rehash, :MyHandler]", expected_ctx_variables: {exception_class: RuntimeError}
-    # end
+    end
     assert_equal warnings, ""
   end
 end