decouplio 1.0.0alpha7 → 1.0.0rc

data/lib/decouplio/steps/base_octo.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class BaseOcto
+      attr_reader :name,
+                  :hash_case,
+                  :on_success,
+                  :on_failure,
+                  :on_error,
+                  :finish_him,
+                  :on_success_resolver,
+                  :on_failure_resolver,
+                  :on_error_resolver,
+                  :resq
+
+      def _add_octo_next_steps(hash_case)
+        @hash_case = hash_case
+      end
+
+      def _add_resq(resq_step)
+        @resq = resq_step
+      end
+    end
+  end
+end

data/lib/decouplio/steps/base_resq.rb

@@ -1,41 +1,38 @@
 # frozen_string_literal: true
 
-require_relative 'base_step'
-
 module Decouplio
   module Steps
-    class BaseResq < BaseStep
-      def initialize(handler_hash:, step_to_resq:, on_error_type:)
-        super()
-        @handler_hash = handler_hash
-        @step_to_resq = step_to_resq
-        @on_error_type = on_error_type
-      end
-
-      def process(instance:)
-        result = @step_to_resq.process(instance: instance)
-      rescue *@handler_hash.keys => e
-        handler_method = @handler_hash[e.class]
+    class BaseResq
+      attr_reader :name, :step_to_resq, :mappings, :handler_method
 
-        raise e unless handler_method
+      def initialize(name, handler_method)
+        @name = name
+        @handler_method = handler_method
+      end
 
-        instance.append_railway_flow(handler_method)
-        instance.public_send(handler_method, e, **instance.ctx)
+      def process(instance)
+        result = @step_to_resq.process(instance)
+      rescue StandardError => error
+        instance.railway_flow << @handler_method
+        instance.send(@handler_method, error)
 
-        case @on_error_type
-        when Decouplio::Const::Results::PASS, Decouplio::Const::Results::STEP_PASS
-          instance.pass_action
-          Decouplio::Const::Results::ERROR
-        when Decouplio::Const::Results::FINISH_HIM
-          instance.fail_action
-          Decouplio::Const::Results::FINISH_HIM
-        else
-          instance.fail_action
-          Decouplio::Const::Results::ERROR
-        end
+        instance.success = @step_to_resq.on_error_resolver
+        @step_to_resq.on_error
       else
         result
       end
+
+      def _add_on_error(on_error)
+        @on_error = on_error
+      end
+
+      def _add_on_error_resolver(resolver)
+        @on_error_resolver = resolver
+      end
+
+      def _add_step_to_resq(stp)
+        @step_to_resq = stp
+      end
     end
   end
 end

data/lib/decouplio/steps/base_resq_with_mapping.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class BaseResqWithMapping
+      attr_reader :name, :step_to_resq, :mappings
+
+      def initialize(name, mappings)
+        @name = name
+        @mappings = mappings
+      end
+
+      def process(instance)
+        result = @step_to_resq.process(instance)
+      rescue *@mappings.keys => error
+        handler_method = @mappings[error.class]
+
+        raise error unless handler_method
+
+        instance.railway_flow << handler_method
+        instance.send(handler_method, error)
+
+        instance.success = @step_to_resq.on_error_resolver
+        @step_to_resq.on_error
+      else
+        result
+      end
+
+      def _add_step_to_resq(stp)
+        @step_to_resq = stp
+      end
+    end
+  end
+end

data/lib/decouplio/steps/base_service_step.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class BaseServiceStep
+      attr_reader :name, :on_success, :on_failure, :on_error, :finish_him, :on_error_resolver
+
+      def initialize(name, service_class, on_success, on_failure, on_error, finish_him, args)
+        @name = name
+        @service_class = service_class
+        @on_success = on_success
+        @on_failure = on_failure
+        @on_error = on_error
+        @finish_him = finish_him
+        @args = args
+      end
+
+      def process(instance)
+        instance.railway_flow << @name
+
+        if @service_class.call(instance.ctx, instance.ms, **@args)
+          instance.success = @on_success_resolver
+          @on_success
+        else
+          instance.success = @on_failure_resolver
+          @on_failure
+        end
+      end
+
+      def _add_next_steps(steps)
+        @on_success, @on_failure, @on_error = steps
+      end
+
+      def _add_resolvers(resolvers)
+        @on_success_resolver, @on_failure_resolver = resolvers
+      end
+    end
+  end
+end

data/lib/decouplio/steps/base_step.rb

@@ -1,15 +1,42 @@
 # frozen_string_literal: true
 
-require_relative '../const/results'
-
 module Decouplio
   module Steps
     class BaseStep
-      attr_reader :name
+      attr_reader :name,
+                  :on_success,
+                  :on_failure,
+                  :on_error,
+                  :finish_him,
+                  :on_success_resolver,
+                  :on_failure_resolver,
+                  :on_error_resolver
+
+      def initialize(name, on_success, on_failure, on_error, finish_him)
+        @name = name
+        @on_success = on_success
+        @on_failure = on_failure
+        @on_error = on_error
+        @finish_him = finish_him
+      end
+
+      def process(instance)
+        instance.railway_flow << @name
+        if instance.send(@name)
+          instance.success = @on_success_resolver
+          @on_success
+        else
+          instance.success = @on_failure_resolver
+          @on_failure
+        end
+      end
+
+      def _add_next_steps(steps)
+        @on_success, @on_failure, @on_error = steps
+      end
 
-      def process(*)
-        raise NotImplementedError,
-              'Please implement process method'
+      def _add_resolvers(resolvers)
+        @on_success_resolver, @on_failure_resolver, @on_error_resolver = resolvers
       end
     end
   end

data/lib/decouplio/steps/base_unless_condition.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class BaseUnlessCondition < Decouplio::Steps::BaseCondition
+      def process(instance)
+        instance.send(@condition_method) ? @skip_condition_step : @perform_condition_step
+      end
+    end
+  end
+end

data/lib/decouplio/steps/base_wrap.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class BaseWrap
+      attr_reader :name,
+                  :on_success,
+                  :on_failure,
+                  :on_error,
+                  :finish_him,
+                  :on_error_resolver,
+                  :wrap_block
+
+      def _add_next_steps(steps)
+        @on_success, @on_failure, @on_error = steps
+      end
+
+      def _add_resolvers(resolvers)
+        @on_success_resolver, @on_failure_resolver, @on_error_resolver = resolvers
+      end
+
+      def _add_wrap_first_step(wrap_first_step)
+        @wrap_first_step = wrap_first_step
+      end
+    end
+  end
+end

data/lib/decouplio/steps/fail.rb

@@ -1,35 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'base_step'
-require_relative 'shared/fail_resolver'
-
 module Decouplio
   module Steps
-    class Fail < BaseStep
-      def initialize(name:, on_success_type:, on_failure_type:)
-        super()
-        @name = name
-        @on_success_type = on_success_type
-        @on_failure_type = on_failure_type
-      end
-
-      def process(instance:)
-        instance.append_railway_flow(@name)
-        result = instance.send(@name, **instance.ctx)
-
-        resolve(result: result, instance: instance)
-      end
-
-      private
-
-      def resolve(result:, instance:)
-        Decouplio::Steps::Shared::FailResolver.call(
-          instance: instance,
-          result: result,
-          on_success_type: @on_success_type,
-          on_failure_type: @on_failure_type
-        )
-      end
+    class Fail < Decouplio::Steps::BaseStep
     end
   end
 end

data/lib/decouplio/steps/if_condition_fail.rb

@@ -1,28 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'base_step'
-
 module Decouplio
   module Steps
-    class IfConditionFail < Decouplio::Steps::BaseStep
-      def initialize(name:)
-        super()
-        @name = name
-      end
-
-      def process(instance:)
-        result = instance.send(@name, **instance.ctx)
-
-        resolve(result: result, instance: instance)
-      end
-
-      private
-
-      def resolve(result:, instance:)
-        instance.fail_action
-
-        result ? Decouplio::Const::Results::PASS : Decouplio::Const::Results::FAIL
-      end
+    class IfConditionFail < Decouplio::Steps::BaseIfCondition
     end
   end
 end

data/lib/decouplio/steps/if_condition_pass.rb

@@ -1,26 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'base_step'
-
 module Decouplio
   module Steps
-    class IfConditionPass < Decouplio::Steps::BaseStep
-      def initialize(name:)
-        super()
-        @name = name
-      end
-
-      def process(instance:)
-        result = instance.send(@name, **instance.ctx)
-
-        resolve(result: result)
-      end
-
-      private
-
-      def resolve(result:)
-        result ? Decouplio::Const::Results::PASS : Decouplio::Const::Results::FAIL
-      end
+    class IfConditionPass < Decouplio::Steps::BaseIfCondition
     end
   end
 end

data/lib/decouplio/steps/inner_action_fail.rb

@@ -1,40 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'base_step'
-require_relative 'shared/fail_resolver'
-
 module Decouplio
   module Steps
-    class InnerActionFail < Decouplio::Steps::BaseStep
-      def initialize(name:, action:, on_success_type:, on_failure_type:)
-        super()
-        @name = name
-        @action = action
-        @on_success_type = on_success_type
-        @on_failure_type = on_failure_type
-      end
-
-      def process(instance:)
-        instance.append_railway_flow(@name)
-        outcome = @action.call(parent_ctx: instance.ctx, parent_railway_flow: instance.railway_flow)
-
-        resolve(outcome: outcome, instance: instance)
-      end
-
-      private
-
-      def resolve(outcome:, instance:)
-        result = outcome.success?
-
-        instance.error_store.merge(outcome.error_store)
-
-        Decouplio::Steps::Shared::FailResolver.call(
-          instance: instance,
-          result: result,
-          on_success_type: @on_success_type,
-          on_failure_type: @on_failure_type
-        )
-      end
+    class InnerActionFail < Decouplio::Steps::BaseInnerAction
     end
   end
 end

data/lib/decouplio/steps/inner_action_pass.rb

@@ -1,37 +1,19 @@
 # frozen_string_literal: true
 
-require_relative 'base_step'
-
 module Decouplio
   module Steps
-    class InnerActionPass < Decouplio::Steps::BaseStep
-      def initialize(name:, action:, on_success_type:, on_failure_type:)
-        super()
-        @name = name
-        @action = action
-        @on_success_type = on_success_type
-        @on_failure_type = on_failure_type
-      end
-
-      def process(instance:)
-        instance.append_railway_flow(@name)
-        outcome = @action.call(parent_ctx: instance.ctx, parent_railway_flow: instance.railway_flow)
-
-        resolve(outcome: outcome, instance: instance)
-      end
-
-      private
-
-      def resolve(outcome:, instance:)
-        instance.error_store.merge(outcome.error_store)
-
-        instance.pass_action
-
-        if @on_success_type == Decouplio::Const::Results::FINISH_HIM
-          Decouplio::Const::Results::FINISH_HIM
-        else
-          Decouplio::Const::Results::PASS
-        end
+    class InnerActionPass < Decouplio::Steps::BaseInnerAction
+      def process(instance)
+        instance.railway_flow << @name
+
+        @action_class.call(
+          _parent_meta_store: instance.ms,
+          _parent_railway_flow: instance.railway_flow,
+          _parent_ctx: instance.ctx
+        )
+
+        instance.success = @on_success_resolver
+        @on_success
       end
     end
   end

data/lib/decouplio/steps/inner_action_step.rb

@@ -1,40 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'base_step'
-require_relative 'shared/step_resolver'
-
 module Decouplio
   module Steps
-    class InnerActionStep < Decouplio::Steps::BaseStep
-      def initialize(name:, action:, on_success_type:, on_failure_type:)
-        super()
-        @name = name
-        @action = action
-        @on_success_type = on_success_type
-        @on_failure_type = on_failure_type
-      end
-
-      def process(instance:)
-        instance.append_railway_flow(@name)
-        outcome = @action.call(parent_ctx: instance.ctx, parent_railway_flow: instance.railway_flow)
-
-        resolve(outcome: outcome, instance: instance)
-      end
-
-      private
-
-      def resolve(outcome:, instance:)
-        result = outcome.success?
-
-        instance.error_store.merge(outcome.error_store)
-
-        Decouplio::Steps::Shared::StepResolver.call(
-          instance: instance,
-          result: result,
-          on_success_type: @on_success_type,
-          on_failure_type: @on_failure_type
-        )
-      end
+    class InnerActionStep < Decouplio::Steps::BaseInnerAction
     end
   end
 end

data/lib/decouplio/steps/octo_by_key.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class OctoByKey < Decouplio::Steps::BaseOcto
+      def initialize(name, by_key, hash_case, on_success, on_failure, on_error, finish_him)
+        super()
+        @name = name
+        @by_key = by_key
+        @hash_case = hash_case
+        @on_success = on_success
+        @on_failure = on_failure
+        @on_error = on_error
+        @finish_him = finish_him
+      end
+
+      def process(instance)
+        instance.railway_flow << @name
+        @hash_case[instance.ctx[@by_key]]
+      end
+
+      def _add_next_steps(steps)
+        @on_success, @on_failure, @on_error = steps
+      end
+
+      def _add_resolvers(resolvers)
+        @on_success_resolver, @on_failure_resolver, @on_error_resolver = resolvers
+      end
+    end
+  end
+end

data/lib/decouplio/steps/octo_by_method.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class OctoByMethod < Decouplio::Steps::BaseOcto
+      def initialize(name, by_method, hash_case, on_success, on_failure, on_error, finish_him)
+        super()
+        @name = name
+        @by_method = by_method
+        @hash_case = hash_case
+        @on_success = on_success
+        @on_failure = on_failure
+        @on_error = on_error
+        @finish_him = finish_him
+      end
+
+      def process(instance)
+        instance.railway_flow << @name
+        @hash_case[instance.send(@by_method)]
+      end
+
+      def _add_next_steps(steps)
+        @on_success, @on_failure, @on_error = steps
+      end
+
+      def _add_resolvers(resolvers)
+        @on_success_resolver, @on_failure_resolver, @on_error_resolver = resolvers
+      end
+    end
+  end
+end

data/lib/decouplio/steps/pass.rb

@@ -1,34 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'base_step'
-
 module Decouplio
   module Steps
     class Pass < Decouplio::Steps::BaseStep
-      def initialize(name:, on_success_type:)
-        super()
-        @name = name
-        @on_success_type = on_success_type
-      end
-
-      def process(instance:)
-        instance.append_railway_flow(@name)
-        instance.send(@name, **instance.ctx)
-
-        resolve(instance: instance)
-      end
-
-      private
-
-      def resolve(instance:)
-        instance.pass_action
-
-        if @on_success_type == Decouplio::Const::Results::FINISH_HIM
-          Decouplio::Const::Results::FINISH_HIM
-        else
-          instance.pass_action
-          Decouplio::Const::Results::PASS
-        end
+      def process(instance)
+        instance.railway_flow << @name
+        instance.send(@name)
+        instance.success = @on_success_resolver
+        @on_success
       end
     end
   end

data/lib/decouplio/steps/resq_fail.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base_resq'
-
 module Decouplio
   module Steps
     class ResqFail < BaseResq

data/lib/decouplio/steps/resq_pass.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'base_resq'
-
 module Decouplio
   module Steps
-    class ResqPass < Decouplio::Steps::BaseResq
+    class ResqPass < BaseResq
     end
   end
 end

data/lib/decouplio/steps/resq_with_mapping_fail.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class ResqWithMappingFail < BaseResqWithMapping
+    end
+  end
+end

data/lib/decouplio/steps/resq_with_mapping_pass.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class ResqWithMappingPass < BaseResqWithMapping
+    end
+  end
+end

data/lib/decouplio/steps/service_as_fail.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class ServiceAsFail < BaseServiceStep
+    end
+  end
+end

data/lib/decouplio/steps/service_as_pass.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class ServiceAsPass < BaseServiceStep
+      def process(instance)
+        instance.railway_flow << @name
+
+        @service_class.call(instance.ctx, instance.ms, **@args)
+
+        instance.success = @on_success_resolver
+        @on_success
+      end
+    end
+  end
+end

data/lib/decouplio/steps/service_as_step.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class ServiceAsStep < BaseServiceStep
+    end
+  end
+end