feat(steps): allow to redefine original methods by outputs

Author: marian13

lib/convenient_service/service/plugins/can_have_steps/entities/method/commands/define_method_in_container.rb

@@ -51,22 +51,59 @@ def initialize(method:, container:, index:)
                 end
 
                 ##
-                # @return [Boolean]
+                # @return [Boolean] true if method is just defined, false if already defined.
                 #
                 def call
+                  container.mutex.synchronize do
+                    return false if has_defined_method?
+
+                    define_method
+
+                    true
+                  end
+                end
+
+                private
+
+                ##
+                # @return [void]
+                #
+                def define_method
+                  container.klass.alias_method name_before_out_redefinition.to_s, name.to_s if container.has_defined_method?(name)
+
                   <<~RUBY.tap { |code| container.klass.class_eval(code, __FILE__, __LINE__ + 1) }
                     ##
                     # @return [Object] Can be any type.
                     # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted]
                     #
+                    # @internal
+                    #   TODO: Direct specs.
+                    #
                     def #{name}
-                      internals.cache.scope(:step_output_values).fetch(__method__) do
-                        ::ConvenientService.raise ::ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted.new(method_name: __method__)
-                      end
+                      return internals.cache.scope(:step_output_values).read(__method__) if internals.cache.scope(:step_output_values).exist?(__method__)
+
+                      return #{name}_before_out_redefinition if respond_to?(:#{name}_before_out_redefinition)
+
+                      ::ConvenientService.raise ::ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted.new(method_name: __method__)
                     end
                   RUBY
+                end
+
+                ##
+                # @return [String]
+                #
+                def name_before_out_redefinition
+                  "#{name}_before_out_redefinition"
+                end
+
+                ##
+                # @return [Boolean]
+                #
+                def has_defined_method?
+                  return false unless container.has_defined_method?(name)
+                  return true if container.has_defined_method?(name_before_out_redefinition)
 
-                  true
+                  container.klass.instance_method(name.to_s).source_location.first.include?(__FILE__)
                 end
               end
             end

lib/convenient_service/service/plugins/can_have_steps/entities/method/concern/instance_methods.rb

@@ -83,14 +83,15 @@ def has_organizer?
                 ##
                 # @param container [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Service]
                 # @param index [Integer]
-                # @return [void]
+                # @return [Boolean] true if method is just defined, false if already defined.
+                #
+                # @internal
+                #   TODO: Split input and output methods into separate classes.
                 #
                 def define_output_in_container!(container, index:)
                   direction.define_output_in_container!(container, index: index, method: self)
 
                   caller.define_output_in_container!(container, index: index, method: self)
-
-                  true
                 end
 
                 ##

lib/convenient_service/service/plugins/can_have_steps/entities/method/entities/callers/proc.rb

@@ -14,7 +14,7 @@ def calculate_value(method)
                   end
 
                   def define_output_in_container!(container, index:, method:)
-                    true
+                    false
                   end
 
                   private

lib/convenient_service/service/plugins/can_have_steps/entities/method/entities/callers/raw.rb

@@ -14,7 +14,7 @@ def calculate_value(method)
                   end
 
                   def define_output_in_container!(container, index:, method:)
-                    true
+                    false
                   end
 
                   private

lib/convenient_service/service/plugins/can_have_steps/entities/method/entities/directions/output.rb

@@ -10,7 +10,7 @@ module Entities
               module Directions
                 class Output < Base
                   def define_output_in_container!(container, index:, method:)
-                    true
+                    false
                   end
                 end
               end

lib/convenient_service/service/plugins/can_have_steps/entities/service/concern/instance_methods.rb

@@ -33,6 +33,13 @@ def initialize(klass)
                   @klass = klass
                 end
 
+                ##
+                # @return [Mutex]
+                #
+                def mutex
+                  klass.__convenient_service_config__.mutex
+                end
+
                 ##
                 # @param method [String, Symbol]
                 # @return [Boolean]

spec/lib/convenient_service/service/plugins/can_have_steps/entities/method/commands/define_method_in_container_spec.rb

@@ -10,16 +10,6 @@
 
   include ConvenientService::RSpec::Matchers::DelegateTo
 
-  let(:container) do
-    Class.new.tap do |klass|
-      klass.class_exec(first_step_service) do |first_step_service|
-        include ConvenientService::Standard::Config
-
-        step first_step_service, out: :foo
-      end
-    end
-  end
-
   let(:organizer) { container.new }
 
   let(:first_step_service) do
@@ -39,110 +29,148 @@ def result
     describe ".call" do
       subject(:command_result) { described_class.call(method: method, container: step.container, index: step.index) }
 
-      it "returns `true`" do
-        expect(command_result).to eq(true)
-      end
+      context "when `method` is NOT defined in container" do
+        let(:container) do
+          Class.new.tap do |klass|
+            klass.class_exec(first_step_service) do |first_step_service|
+              include ConvenientService::Standard::Config
 
-      it "defines `method` in `container`" do
-        expect { command_result }.to change { ConvenientService::Utils::Method.defined?(method.name.to_s, step.container.klass, private: true) }.from(false).to(true)
-      end
+              step first_step_service, out: :foo
+            end
+          end
+        end
 
-      example_group "generated method" do
-        before do
-          command_result
+        it "returns `true`" do
+          expect(command_result).to eq(true)
         end
 
-        context "when corresponding step is NOT completed" do
-          let(:exception_message) do
-            <<~TEXT
-              `out` method `#{method}` is called before its corresponding step is completed.
+        it "defines `method` in `container`" do
+          expect { command_result }.to change { ConvenientService::Utils::Method.defined?(method.name.to_s, step.container.klass, private: true) }.from(false).to(true)
+        end
 
-              Maybe it makes sense to change steps order?
-            TEXT
+        example_group "generated method" do
+          before do
+            command_result
           end
 
-          it "raises `ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted`" do
-            expect { organizer.foo }
-              .to raise_error(ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted)
-              .with_message(exception_message)
-          end
+          context "when corresponding step is NOT completed" do
+            let(:exception_message) do
+              <<~TEXT
+                `out` method `#{method}` is called before its corresponding step is completed.
 
-          specify do
-            expect { ignoring_exception(ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted) { organizer.foo } }
-              .to delegate_to(ConvenientService, :raise)
-          end
-        end
+                Maybe it makes sense to change steps order?
+              TEXT
+            end
 
-        context "when corresponding step is completed" do
-          before do
-            ##
-            # NOTE: Completes the step.
-            #
-            organizer.steps[0].save_outputs_in_organizer!
-          end
+            it "raises `ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted`" do
+              expect { organizer.foo }
+                .to raise_error(ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted)
+                .with_message(exception_message)
+            end
 
-          it "returns corresponding step service result data attribute by key" do
-            expect(organizer.foo).to eq(organizer.steps[0].result.unsafe_data[:foo])
+            specify do
+              expect { ignoring_exception(ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Exceptions::OutMethodStepIsNotCompleted) { organizer.foo } }
+                .to delegate_to(ConvenientService, :raise)
+            end
           end
 
-          context "when multiple corresponding steps are completed" do
-            let(:container) do
-              Class.new.tap do |klass|
-                klass.class_exec(first_step_service, second_step_service) do |first_step_service, second_step_service|
-                  include ConvenientService::Standard::Config
+          context "when corresponding step is completed" do
+            before do
+              ##
+              # NOTE: Completes the step.
+              #
+              organizer.steps[0].save_outputs_in_organizer!
+            end
+
+            it "returns corresponding step service result data attribute by key" do
+              expect(organizer.foo).to eq(organizer.steps[0].result.unsafe_data[:foo])
+            end
 
-                  step first_step_service, out: :foo
+            context "when multiple corresponding steps are completed" do
+              let(:container) do
+                Class.new.tap do |klass|
+                  klass.class_exec(first_step_service, second_step_service) do |first_step_service, second_step_service|
+                    include ConvenientService::Standard::Config
 
-                  step second_step_service, out: :foo
+                    step first_step_service, out: :foo
+
+                    step second_step_service, out: :foo
+                  end
                 end
               end
+
+              let(:second_step_service) do
+                Class.new do
+                  include ConvenientService::Standard::Config
+
+                  def result
+                    success(data: {foo: "foo from second step"})
+                  end
+                end
+              end
+
+              before do
+                ##
+                # NOTE: Completes the steps.
+                #
+                organizer.steps[0].save_outputs_in_organizer!
+                organizer.steps[1].save_outputs_in_organizer!
+              end
+
+              it "returns last corresponding step service result data attribute by key" do
+                expect(organizer.foo).to eq(organizer.steps[1].result.unsafe_data[:foo])
+              end
             end
+          end
 
-            let(:second_step_service) do
-              Class.new do
-                include ConvenientService::Standard::Config
+          context "when method has alias" do
+            let(:container) do
+              Class.new.tap do |klass|
+                klass.class_exec(first_step_service) do |first_step_service|
+                  include ConvenientService::Standard::Config
 
-                def result
-                  success(data: {foo: "foo from second step"})
+                  step first_step_service, out: {foo: :bar}
                 end
               end
             end
 
             before do
               ##
-              # NOTE: Completes the steps.
+              # NOTE: Completes the step.
               #
               organizer.steps[0].save_outputs_in_organizer!
-              organizer.steps[1].save_outputs_in_organizer!
             end
 
-            it "returns last corresponding step service result data attribute by key" do
-              expect(organizer.foo).to eq(organizer.steps[1].result.unsafe_data[:foo])
+            it "returns corresponding step service result data attribute by key" do
+              expect(organizer.bar).to eq(organizer.steps[0].result.unsafe_data[:bar])
             end
           end
         end
+      end
+
+      context "when `method` is defined in container" do
+        let(:container) do
+          Class.new.tap do |klass|
+            klass.class_exec(first_step_service) do |first_step_service|
+              include ConvenientService::Standard::Config
 
-        context "when method has alias" do
-          let(:container) do
-            Class.new.tap do |klass|
-              klass.class_exec(first_step_service) do |first_step_service|
-                include ConvenientService::Standard::Config
+              step first_step_service, out: :foo
 
-                step first_step_service, out: {foo: :bar}
+              def foo
+                :foo
               end
             end
           end
+        end
 
-          before do
-            ##
-            # NOTE: Completes the step.
-            #
-            organizer.steps[0].save_outputs_in_organizer!
-          end
+        it "returns `false`" do
+          described_class.call(method: method, container: step.container, index: step.index)
 
-          it "returns corresponding step service result data attribute by key" do
-            expect(organizer.bar).to eq(organizer.steps[0].result.unsafe_data[:bar])
-          end
+          expect(command_result).to eq(false)
+        end
+
+        it "does NOT define `method` in `container`" do
+          expect { command_result }.not_to change { ConvenientService::Utils::Method.defined?(method.name.to_s, step.container.klass, private: true) }
         end
       end
     end

spec/lib/convenient_service/service/plugins/can_have_steps/entities/method/concern/instance_methods_spec.rb

@@ -23,6 +23,8 @@
   let(:service_class) do
     Class.new.tap do |klass|
       klass.class_exec(method_other, method_return_value) do |method_other, method_return_value|
+        include ConvenientService::Core
+
         define_method(method_other) { method_return_value }
       end
     end
@@ -159,7 +161,13 @@
 
     describe "#define_output_in_container!" do
       let(:method_options) { {direction: :output} }
-      let(:service_class) { Class.new }
+
+      let(:service_class) do
+        Class.new do
+          include ConvenientService::Core
+        end
+      end
+
       let(:index) { 0 }
 
       it "returns `true`" do
@@ -170,14 +178,12 @@
         expect { method.define_output_in_container!(container, index: index) }
           .to delegate_to(direction, :define_output_in_container!)
           .with_arguments(container, index: index, method: method)
-          .and_return_its_value
       end
 
       specify do
         expect { method.define_output_in_container!(container, index: index) }
           .to delegate_to(caller, :define_output_in_container!)
           .with_arguments(container, index: index, method: method)
-          .and_return_its_value
       end
     end