decouplio 1.0.0alpha8 → 1.0.0rc

data/lib/decouplio/composer.rb

@@ -1,615 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'action'
-require_relative 'const/types'
-require_relative 'const/results'
-require_relative 'steps/step'
-require_relative 'steps/fail'
-require_relative 'steps/pass'
-require_relative 'steps/wrap'
-require_relative 'steps/octo'
-require_relative 'steps/resq_pass'
-require_relative 'steps/resq_fail'
-require_relative 'steps/if_condition_pass'
-require_relative 'steps/if_condition_fail'
-require_relative 'steps/unless_condition_pass'
-require_relative 'steps/unless_condition_fail'
-require_relative 'steps/inner_action_step'
-require_relative 'steps/inner_action_fail'
-require_relative 'steps/inner_action_pass'
-require_relative 'steps/service_step'
-require_relative 'steps/service_fail'
-require_relative 'steps/service_pass'
-require_relative 'options_validator'
-require_relative 'validators/condition'
-
-module Decouplio
-  class Composer
-    class << self
-      def compose(logic_container_raw_data:, action_class:, palp_prefix: :root, parent_flow: {}, next_steps: nil)
-        flow = logic_container_raw_data.steps
-        palps = logic_container_raw_data.palps
-
-        steps_pool = {}
-        steps_flow = {}
-
-        flow = prepare_raw_data(flow, palp_prefix, action_class)
-        validate_flow(flow, palps, next_steps, action_class)
-        flow = compose_flow(flow, palps, next_steps, action_class, parent_flow)
-
-        flow.each do |step_id, stp|
-          steps_flow[step_id] = stp[:flow]
-          steps_flow.merge!(extract_palp_flow(stp))
-          steps_pool[step_id] = create_step_instance(stp, flow)
-          steps_pool.merge!(extract_palp_pool(stp))
-        end
-
-        {
-          first_step: steps_pool.keys.first,
-          steps_pool: steps_pool.freeze,
-          steps_flow: steps_flow.freeze
-        }
-      end
-
-      private
-
-      def prepare_raw_data(flow, palp_prefix, action_class)
-        flow = flow.map do |stp|
-          stp[:step_id] = random_id(name: stp[:name], palp_prefix: palp_prefix, flow: flow)
-          stp[:flow] = {}
-          stp = compose_resq(stp, palp_prefix, flow)
-          stp = compose_action(stp)
-          stp = compose_wrap(stp, action_class)
-          condition = compose_condition(stp, palp_prefix, flow)
-
-          [condition, stp].compact
-        end.flatten
-
-        flow.to_h do |stp|
-          [stp[:step_id], stp]
-        end
-      end
-
-      def validate_flow(flow, palps, next_steps, action_class)
-        OptionsValidator.new(
-          flow: flow,
-          palps: palps,
-          next_steps: next_steps,
-          action_class: action_class
-        ).call
-      end
-
-      def extract_palp_flow(stp)
-        return {} unless stp[:type] == Decouplio::Const::Types::OCTO_TYPE
-
-        stp[:hash_case].values.map { |composer_output| composer_output[:steps_flow] }.reduce({}, :merge)
-      end
-
-      def extract_palp_pool(stp)
-        return {} unless stp[:type] == Decouplio::Const::Types::OCTO_TYPE
-
-        stp[:hash_case].values.map { |composer_output| composer_output[:steps_pool] }.reduce({}, :merge)
-      end
-
-      def create_step_instance(stp, flow)
-        case stp[:type]
-        when Decouplio::Const::Types::STEP_TYPE
-          create_step(stp, flow)
-        when Decouplio::Const::Types::FAIL_TYPE
-          create_fail(stp, flow)
-        when Decouplio::Const::Types::PASS_TYPE
-          create_pass(stp, flow)
-        when Decouplio::Const::Types::IF_TYPE_PASS
-          create_if_condition_pass(stp)
-        when Decouplio::Const::Types::IF_TYPE_FAIL
-          create_if_condition_fail(stp)
-        when Decouplio::Const::Types::UNLESS_TYPE_PASS
-          create_unless_condition_pass(stp)
-        when Decouplio::Const::Types::UNLESS_TYPE_FAIL
-          create_unless_condition_fail(stp)
-        when Decouplio::Const::Types::OCTO_TYPE
-          create_octo(stp)
-        when Decouplio::Const::Types::WRAP_TYPE
-          create_wrap(flow, stp)
-        when Decouplio::Const::Types::RESQ_TYPE_STEP, Decouplio::Const::Types::RESQ_TYPE_PASS
-          create_resq_pass(stp, flow)
-        when Decouplio::Const::Types::RESQ_TYPE_FAIL
-          create_resq_fail(stp, flow)
-        when Decouplio::Const::Types::ACTION_TYPE_STEP
-          create_inner_action_step(stp, flow)
-        when Decouplio::Const::Types::ACTION_TYPE_FAIL
-          create_inner_action_fail(stp, flow)
-        when Decouplio::Const::Types::ACTION_TYPE_PASS
-          create_inner_action_pass(stp, flow)
-        when Decouplio::Const::Types::SERVICE_TYPE_STEP
-          create_inner_service_step(stp, flow)
-        when Decouplio::Const::Types::SERVICE_TYPE_FAIL
-          create_inner_service_fail(stp, flow)
-        when Decouplio::Const::Types::SERVICE_TYPE_PASS
-          create_inner_service_pass(stp, flow)
-        end
-      end
-
-      def create_step(stp, flow)
-        Decouplio::Steps::Step.new(
-          name: stp[:name],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def create_fail(stp, flow)
-        Decouplio::Steps::Fail.new(
-          name: stp[:name],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def create_pass(stp, flow)
-        Decouplio::Steps::Pass.new(
-          name: stp[:name],
-          on_success_type: success_type(flow, stp)
-        )
-      end
-
-      def create_if_condition_pass(stp)
-        Decouplio::Steps::IfConditionPass.new(
-          name: stp[:name]
-        )
-      end
-
-      def create_if_condition_fail(stp)
-        Decouplio::Steps::IfConditionFail.new(
-          name: stp[:name]
-        )
-      end
-
-      def create_unless_condition_pass(stp)
-        Decouplio::Steps::UnlessConditionPass.new(
-          name: stp[:name]
-        )
-      end
-
-      def create_unless_condition_fail(stp)
-        Decouplio::Steps::UnlessConditionFail.new(
-          name: stp[:name]
-        )
-      end
-
-      def create_octo(stp)
-        Decouplio::Steps::Octo.new(
-          name: stp[:name],
-          ctx_key: stp[:ctx_key],
-          method: stp[:method]
-        )
-      end
-
-      def create_wrap(flow, stp)
-        Decouplio::Steps::Wrap.new(
-          name: stp[:name],
-          klass: stp[:klass],
-          method: stp[:method],
-          wrap_flow: stp[:wrap_flow],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def create_resq_pass(stp, flow)
-        Decouplio::Steps::ResqPass.new(
-          handler_hash: stp[:handler_hash],
-          step_to_resq: create_step_instance(stp[:step_to_resq], flow),
-          on_error_type: error_type(flow, stp)
-        )
-      end
-
-      def create_resq_fail(stp, flow)
-        Decouplio::Steps::ResqFail.new(
-          handler_hash: stp[:handler_hash],
-          step_to_resq: create_step_instance(stp[:step_to_resq], flow),
-          on_error_type: error_type(flow, stp)
-        )
-      end
-
-      def create_inner_action_step(stp, flow)
-        Decouplio::Steps::InnerActionStep.new(
-          name: stp[:name],
-          action: stp[:action],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def create_inner_action_fail(stp, flow)
-        Decouplio::Steps::InnerActionFail.new(
-          name: stp[:name],
-          action: stp[:action],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def create_inner_action_pass(stp, flow)
-        Decouplio::Steps::InnerActionPass.new(
-          name: stp[:name],
-          action: stp[:action],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def create_inner_service_step(stp, flow)
-        Decouplio::Steps::ServiceStep.new(
-          name: stp[:name],
-          service: stp[:service],
-          args: stp[:_args],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def create_inner_service_fail(stp, flow)
-        Decouplio::Steps::ServiceFail.new(
-          name: stp[:name],
-          service: stp[:service],
-          args: stp[:_args],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def create_inner_service_pass(stp, flow)
-        Decouplio::Steps::ServicePass.new(
-          name: stp[:name],
-          service: stp[:service],
-          args: stp[:_args],
-          on_success_type: success_type(flow, stp),
-          on_failure_type: failure_type(flow, stp)
-        )
-      end
-
-      def compose_flow(flow, palps, next_steps, action_class, flow_hash = {})
-        flow.each_with_index do |(step_id, stp), idx|
-          case stp[:type]
-          when Decouplio::Const::Types::STEP_TYPE,
-               Decouplio::Const::Types::PASS_TYPE,
-               Decouplio::Const::Types::WRAP_TYPE,
-               Decouplio::Const::Types::ACTION_TYPE_STEP,
-               Decouplio::Const::Types::ACTION_TYPE_PASS,
-               Decouplio::Const::Types::SERVICE_TYPE_STEP,
-               Decouplio::Const::Types::SERVICE_TYPE_PASS,
-               Decouplio::Const::Types::RESQ_TYPE_STEP,
-               Decouplio::Const::Types::RESQ_TYPE_PASS
-            compose_step_flow(stp, step_id, flow, idx, flow_hash, next_steps)
-          when Decouplio::Const::Types::FAIL_TYPE,
-               Decouplio::Const::Types::RESQ_TYPE_FAIL,
-               Decouplio::Const::Types::ACTION_TYPE_FAIL,
-               Decouplio::Const::Types::SERVICE_TYPE_FAIL
-            compose_fail_flow(stp, step_id, flow, idx, flow_hash, next_steps)
-          when Decouplio::Const::Types::IF_TYPE_PASS, Decouplio::Const::Types::UNLESS_TYPE_PASS
-            compose_pass_condition_flow(stp, flow, idx, flow_hash)
-          when Decouplio::Const::Types::IF_TYPE_FAIL, Decouplio::Const::Types::UNLESS_TYPE_FAIL
-            compose_fail_condition_flow(stp, flow, idx, flow_hash)
-          when Decouplio::Const::Types::OCTO_TYPE
-            compose_octo_flow(stp, step_id, idx, flow, palps, flow_hash, action_class)
-          end
-        end
-      end
-
-      def compose_step_flow(stp, step_id, flow, idx, flow_hash, next_steps)
-        flow_values = flow.values + (next_steps&.values || [])
-        stp[:flow][Decouplio::Const::Results::PASS] = next_success_step(
-          flow_values,
-          idx,
-          flow[step_id][:on_success]
-        )
-        stp[:flow][Decouplio::Const::Results::FAIL] = next_failure_step(
-          flow_values,
-          idx,
-          flow[step_id][:on_failure]
-        )
-        stp[:flow][Decouplio::Const::Results::ERROR] = next_failure_step(
-          flow_values,
-          idx,
-          flow[step_id][:on_error]
-        )
-        stp[:flow][Decouplio::Const::Results::PASS] ||= flow_hash[Decouplio::Const::Results::PASS]
-        stp[:flow][Decouplio::Const::Results::FAIL] ||= flow_hash[Decouplio::Const::Results::FAIL]
-        stp[:flow][Decouplio::Const::Results::ERROR] ||= flow_hash[Decouplio::Const::Results::ERROR]
-        stp[:flow][Decouplio::Const::Results::FINISH_HIM] = Decouplio::Const::Results::NO_STEP
-      end
-
-      def compose_fail_flow(stp, step_id, flow, idx, flow_hash, next_steps)
-        flow_values = flow.values + (next_steps&.values || [])
-        stp[:flow][Decouplio::Const::Results::PASS] = next_failure_step(
-          flow_values,
-          idx,
-          flow[step_id][:on_success]
-        )
-        stp[:flow][Decouplio::Const::Results::FAIL] = next_failure_step(
-          flow_values,
-          idx,
-          flow[step_id][:on_failure]
-        )
-        stp[:flow][Decouplio::Const::Results::ERROR] = next_failure_step(
-          flow_values,
-          idx,
-          flow[step_id][:on_error]
-        )
-        stp[:flow][Decouplio::Const::Results::PASS] ||= flow_hash[Decouplio::Const::Results::FAIL]
-        stp[:flow][Decouplio::Const::Results::FAIL] ||= flow_hash[Decouplio::Const::Results::FAIL]
-        stp[:flow][Decouplio::Const::Results::ERROR] ||= flow_hash[Decouplio::Const::Results::ERROR]
-        stp[:flow][Decouplio::Const::Results::FINISH_HIM] = Decouplio::Const::Results::NO_STEP
-      end
-
-      def compose_pass_condition_flow(stp, flow, idx, flow_hash)
-        stp[:flow][Decouplio::Const::Results::PASS] = next_success_step(flow.values, idx, nil)
-        stp[:flow][Decouplio::Const::Results::FAIL] = next_success_step(flow.values, idx + 1, nil)
-        stp[:flow][Decouplio::Const::Results::FAIL] ||= flow_hash[Decouplio::Const::Results::PASS]
-      end
-
-      def compose_fail_condition_flow(stp, flow, idx, flow_hash)
-        stp[:flow][Decouplio::Const::Results::PASS] = next_failure_step(flow.values, idx, nil)
-        stp[:flow][Decouplio::Const::Results::FAIL] = next_failure_step(flow.values, idx + 1, nil)
-        stp[:flow][Decouplio::Const::Results::FAIL] ||= flow_hash[Decouplio::Const::Results::FAIL]
-      end
-
-      def compose_octo_flow(stp, step_id, idx, flow, palps, flow_hash, action_class)
-        stp[:flow][Decouplio::Const::Results::PASS] = next_success_step(
-          flow.values,
-          idx,
-          flow[step_id][:on_success]
-        )
-        stp[:flow][Decouplio::Const::Results::FAIL] = next_failure_step(
-          flow.values,
-          idx,
-          flow[step_id][:on_failure]
-        )
-        stp[:flow][Decouplio::Const::Results::PASS] ||= flow_hash[Decouplio::Const::Results::PASS]
-        stp[:flow][Decouplio::Const::Results::FAIL] ||= flow_hash[Decouplio::Const::Results::FAIL]
-        stp[:flow][Decouplio::Const::Results::FINISH_HIM] = Decouplio::Const::Results::NO_STEP
-        stp = compose_strategy(stp, palps, flow.to_a[(idx + 1)..].to_h, action_class)
-        stp[:hash_case].each do |strategy_key, strategy_raw_data|
-          stp[:flow][strategy_key] = strategy_raw_data[:first_step]
-        end
-      end
-
-      def success_type(flow, stp)
-        return :finish_him if [:on_success, true].include?(finish_him(stp))
-
-        step_id = stp.dig(:flow, Decouplio::Const::Results::PASS)
-        if step_id.nil? && Decouplio::Const::Results::STEP_PASS == stp[:on_success]
-          Decouplio::Const::Results::STEP_PASS
-        elsif step_id.nil? && Decouplio::Const::Results::STEP_FAIL == stp[:on_success]
-          Decouplio::Const::Results::STEP_FAIL
-        else
-          Decouplio::Const::Types::PASS_FLOW.include?(
-            flow[step_id]&.[](:type)
-          )
-        end
-      end
-
-      def failure_type(flow, stp)
-        return :finish_him if [:on_failure, true].include?(finish_him(stp))
-
-        step_id = stp.dig(:flow, Decouplio::Const::Results::FAIL)
-        if step_id.nil? && Decouplio::Const::Results::STEP_PASS == stp[:on_failure]
-          Decouplio::Const::Results::STEP_PASS
-        elsif step_id.nil? && Decouplio::Const::Results::STEP_FAIL == stp[:on_failure]
-          Decouplio::Const::Results::STEP_FAIL
-        else
-          Decouplio::Const::Types::FAIL_FLOW.include?(
-            flow[step_id]&.[](:type)
-          )
-        end
-      end
-
-      def error_type(flow, stp)
-        return :finish_him if [:on_error].include?(finish_him(stp))
-
-        step_id = stp.dig(:flow, Decouplio::Const::Results::ERROR)
-        if step_id.nil? && Decouplio::Const::Results::STEP_PASS == stp[:on_error]
-          Decouplio::Const::Results::STEP_PASS
-        elsif step_id.nil? && Decouplio::Const::Results::STEP_FAIL == stp[:on_error]
-          Decouplio::Const::Results::STEP_FAIL
-        else
-          Decouplio::Const::Types::FAIL_FLOW.include?(
-            flow[step_id]&.[](:type)
-          )
-        end
-      end
-
-      def finish_him(stp)
-        if stp[:on_success] == :finish_him
-          :on_success
-        elsif stp[:on_failure] == :finish_him
-          :on_failure
-        elsif stp.key?(:finish_him)
-          stp[:finish_him]
-        end
-      end
-
-      def compose_wrap(stp, action_class)
-        if Decouplio::Const::Types::WRAP_TYPE == stp[:type]
-          stp[:wrap_flow] = Flow.call(logic: stp[:wrap_flow], action_class: action_class)
-        elsif Decouplio::Const::Types::WRAP_TYPE == stp.dig(:step_to_resq, :type)
-          stp[:step_to_resq][:wrap_flow] = Flow.call(logic: stp[:step_to_resq][:wrap_flow], action_class: action_class)
-        end
-
-        stp
-      end
-
-      def compose_condition(stp, palp_prefix, flow)
-        condition_options = stp.slice(:if, :unless)
-
-        return if condition_options.empty?
-
-        Decouplio::Validators::Condition.validate(
-          condition_options: condition_options,
-          type: stp[:type]
-        )
-
-        condition = ([%i[name type]] + condition_options.invert.to_a).transpose.to_h
-        condition[:step_id] = random_id(name: condition[:name], palp_prefix: palp_prefix, flow: flow)
-        condition[:type] = Decouplio::Const::Types::STEP_TYPE_TO_CONDITION_TYPE.dig(stp[:type], condition[:type])
-        condition[:flow] = {}
-        condition
-      end
-
-      def compose_action(stp)
-        return stp if Decouplio::Const::Types::ACTION_NOT_ALLOWED_STEPS.include?(stp[:type])
-
-        if !stp[:name].is_a?(Symbol) && stp[:name] < Decouplio::Action
-          stp[:action] = stp[:name]
-          stp[:name] = stp[:name].name.to_sym
-        elsif stp[:name].is_a?(Class) && stp[:name].respond_to?(:call)
-          stp[:service] = stp[:name]
-          stp[:name] = stp[:name].name.to_sym
-        elsif stp.dig(:step_to_resq, :name) &&
-              !stp.dig(:step_to_resq, :name).is_a?(Symbol) &&
-              stp.dig(:step_to_resq, :name) < Decouplio::Action
-          stp[:step_to_resq][:action] = stp[:step_to_resq][:name]
-          stp[:step_to_resq][:name] = stp[:step_to_resq][:name].name.to_sym
-        elsif stp.dig(:step_to_resq, :name).is_a?(Class) && stp.dig(:step_to_resq, :name).respond_to?(:call)
-          stp[:step_to_resq][:service] = stp[:step_to_resq][:name]
-          stp[:step_to_resq][:name] = stp[:step_to_resq][:name].name.to_sym
-        elsif stp[:name].is_a?(Class)
-          stp[:action] = stp[:name]
-        elsif stp.dig(:step_to_resq, :name).is_a?(Class)
-          stp[:step_to_resq][:action] = stp.dig(:step_to_resq, :name)
-        end
-
-        if stp.key?(:action)
-          stp[:type] = Decouplio::Const::Types::STEP_TYPE_TO_INNER_TYPE[stp[:type]]
-        elsif stp.dig(:step_to_resq, :action)
-          stp[:step_to_resq][:type] = Decouplio::Const::Types::STEP_TYPE_TO_INNER_TYPE[stp[:type]]
-        end
-
-        if stp.key?(:service)
-          stp[:type] = Decouplio::Const::Types::STEP_TYPE_TO_SERVICE_TYPE[stp[:type]]
-        elsif stp.dig(:step_to_resq, :service)
-          stp[:step_to_resq][:type] = Decouplio::Const::Types::STEP_TYPE_TO_SERVICE_TYPE[stp[:type]]
-        end
-
-        stp
-      end
-
-      def compose_strategy(stp, palps, next_steps, action_class)
-        return stp unless stp[:type] == Decouplio::Const::Types::OCTO_TYPE
-
-        stp[:hash_case] = stp[:hash_case].to_h do |strategy_key, options|
-          strategy_flow = compose(
-            logic_container_raw_data: palps[options[:palp]],
-            action_class: action_class,
-            palp_prefix: options[:palp],
-            parent_flow: stp[:flow],
-            next_steps: next_steps
-          )
-          [
-            strategy_key,
-            strategy_flow
-          ]
-        end
-        stp
-      end
-
-      def compose_resq(stp, palp_prefix, flow)
-        return stp unless stp[:type] == Decouplio::Const::Types::RESQ_TYPE
-
-        options_for_resq = stp[:step_to_resq].slice(
-          :on_success,
-          :on_failure,
-          :on_error,
-          :finish_him,
-          :if,
-          :unless
-        )
-        stp[:step_id] = random_id(name: stp[:name], palp_prefix: palp_prefix, flow: flow)
-        stp[:flow] = {}
-        handler_hash = {}
-        stp[:handler_hash].each do |handler_method, error_classes|
-          [error_classes].flatten.each do |error_class|
-            handler_hash[error_class] = handler_method
-          end
-        end
-        stp[:handler_hash] = handler_hash
-        stp[:type] = Decouplio::Const::Types::STEP_TYPE_TO_RESQ_TYPE[stp[:step_to_resq][:type]]
-        stp.merge(options_for_resq)
-      end
-
-      def next_success_step(steps, idx, value)
-        steps_slice = steps[(idx + 1)..]
-        steps_slice.each_with_index do |stp, index|
-          if (
-            Decouplio::Const::Results::STEP_PASS == value &&
-            Decouplio::Const::Types::SUCCESS_TRACK_STEP_TYPES.include?(stp[:type])
-          ) || (
-            Decouplio::Const::Results::STEP_FAIL == value &&
-            Decouplio::Const::Types::FAILURE_TRACK_STEP_TYPES.include?(stp[:type])
-          ) || (
-            !value &&
-            Decouplio::Const::Types::SUCCESS_TRACK_STEP_TYPES.include?(stp[:type])
-          )
-            return stp[:step_id]
-          elsif value == stp[:name]
-            prev_step = steps_slice[index - 1]
-            if [
-              Decouplio::Const::Types::IF_TYPE_PASS,
-              Decouplio::Const::Types::UNLESS_TYPE_PASS
-            ].include?(prev_step[:type])
-              return prev_step[:step_id]
-            else
-              return stp[:step_id]
-            end
-          end
-        end
-
-        Decouplio::Const::Results::NO_STEP
-      end
-
-      def next_failure_step(steps, idx, value)
-        steps_slice = steps[(idx + 1)..]
-        steps_slice.each_with_index do |stp, index|
-          if (
-            Decouplio::Const::Results::STEP_PASS == value &&
-            Decouplio::Const::Types::SUCCESS_TRACK_STEP_TYPES.include?(stp[:type])
-          ) || (
-            Decouplio::Const::Results::STEP_FAIL == value &&
-            Decouplio::Const::Types::FAILURE_TRACK_STEP_TYPES.include?(stp[:type])
-          ) || (
-            !value &&
-            Decouplio::Const::Types::FAILURE_TRACK_STEP_TYPES.include?(stp[:type])
-          )
-            return stp[:step_id]
-          elsif value == stp[:name]
-            prev_step = steps_slice[index - 1]
-            if [
-              Decouplio::Const::Types::IF_TYPE_FAIL,
-              Decouplio::Const::Types::UNLESS_TYPE_FAIL
-            ].include?(prev_step[:type])
-              return prev_step[:step_id]
-            else
-              return stp[:step_id]
-            end
-          end
-        end
-
-        Decouplio::Const::Results::NO_STEP
-      end
-
-      def random_id(name:, palp_prefix:, flow:)
-        loop do
-          random_step_id =
-            "#{palp_prefix}_#{name}_#{random_value}#{random_value}#{random_value}#{random_value}#{random_value}".to_sym
-
-          break random_step_id if flow.select { |stp| stp[:step_id] == random_step_id }.empty?
-        end
-      end
-
-      def random_value
-        (10..99).to_a.sample
-      end
-    end
-  end
-end

data/lib/decouplio/const/colors.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Decouplio
-  module Const
-    module Colors
-      BLACK = "\033[0;30m"
-      DARK_GRAY = "\033[1;30m"
-      RED = "\033[0;31m"
-      LIGHT_RED = "\033[1;31m"
-      GREEN = "\033[0;32m"
-      LIGHT_GREEN = "\033[1;32m"
-      BROWN_ORANGE = "\033[0;33m"
-      YELLOW = "\033[1;33m"
-      BLUE = "\033[0;34m"
-      LIGHT_BLUE = "\033[1;34m"
-      PURPLE = "\033[0;35m"
-      LIGHT_PURPLE = "\033[1;35m"
-      CYAN = "\033[0;36m"
-      LIGHT_CYAN = "\033[1;36m"
-      LIGHT_GRAY = "\033[0;37m"
-      WHITE = "\033[1;37m"
-      NO_COLOR = "\033[0m"
-    end
-  end
-end

data/lib/decouplio/const/results.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Decouplio
-  module Const
-    module Results
-      PASS = true
-      FAIL = false
-      ERROR = :error
-      FINISH_HIM = :finish_him
-      NO_STEP = nil
-      STEP_PASS = :PASS
-      STEP_FAIL = :FAIL
-    end
-  end
-end

data/lib/decouplio/const/step_options.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Decouplio
-  module Const
-    module StepOptions
-      ALLOWED = %i[
-        on_success
-        on_failure
-        on_error
-        finish_him
-        if
-        unless
-      ].freeze
-    end
-  end
-end

data/lib/decouplio/errors/extra_key_for_fail_error.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_error'
-require_relative '../const/validations/fail'
-
-module Decouplio
-  module Errors
-    class ExtraKeyForFailError < Decouplio::Errors::BaseError
-      def template
-        Decouplio::Const::Validations::Fail::VALIDATION_ERROR_MESSAGE
-      end
-
-      def interpolation_values
-        [
-          @errored_option,
-          format(
-            Decouplio::Const::Validations::Fail::OPTIONS_IS_NOT_ALLOWED,
-            @details
-          ),
-          Decouplio::Const::Validations::Fail::ALLOWED_OPTIONS_MESSAGE,
-          Decouplio::Const::Validations::Fail::MANUAL_URL
-        ]
-      end
-    end
-  end
-end