flows 0.1.0 → 0.5.1

data/lib/flows/node.rb

@@ -1,27 +0,0 @@
-module Flows
-  # Representation of FSM node.
-  class Node
-    attr_reader :name, :meta
-
-    def initialize(name:, body:, router:, meta: {}, preprocessor: nil, postprocessor: nil)
-      @name = name
-      @body = body
-      @router = router
-
-      @meta = meta.freeze
-
-      @preprocessor = preprocessor
-      @postprocessor = postprocessor
-    end
-
-    def call(input, context:)
-      input  = @preprocessor.call(input, context, @meta) if @preprocessor
-      output = @body.call(input)
-      output = @postprocessor.call(output, context, @meta) if @postprocessor
-
-      route = @router.call(output, context: context, meta: @meta)
-
-      [output, route]
-    end
-  end
-end

data/lib/flows/operation.rb

@@ -1,54 +0,0 @@
-require_relative 'operation/errors'
-
-require_relative 'operation/dsl'
-require_relative 'operation/builder'
-require_relative 'operation/executor'
-
-module Flows
-  # Operaion DSL
-  module Operation
-    def self.included(mod)
-      mod.instance_variable_set(:@steps, [])
-      mod.instance_variable_set(:@track_path, [])
-      mod.extend ::Flows::Operation::DSL
-    end
-
-    include ::Flows::Result::Helpers
-
-    def initialize(method_source: nil, deps: {})
-      _flows_do_checks
-
-      flow = _flows_make_flow(method_source || self, deps)
-
-      @_flows_executor = _flows_make_executor(flow)
-    end
-
-    def call(**params)
-      @_flows_executor.call(**params)
-    end
-
-    private
-
-    def _flows_do_checks
-      raise NoStepsError if self.class.steps.empty?
-      raise NoSuccessShapeError, self if self.class.ok_shapes.nil?
-    end
-
-    def _flows_make_flow(method_source, deps)
-      ::Flows::Operation::Builder.new(
-        steps: self.class.steps,
-        method_source: method_source,
-        deps: deps
-      ).call
-    end
-
-    def _flows_make_executor(flow)
-      ::Flows::Operation::Executor.new(
-        flow: flow,
-        ok_shapes: self.class.ok_shapes,
-        err_shapes: self.class.err_shapes,
-        class_name: self.class.name
-      )
-    end
-  end
-end

data/lib/flows/operation/builder.rb

@@ -1,130 +0,0 @@
-require_relative './builder/build_router'
-
-module Flows
-  module Operation
-    # Flow builder
-    class Builder
-      attr_reader :steps, :method_source, :deps
-
-      def initialize(steps:, method_source:, deps:)
-        @method_source = method_source
-        @steps = steps
-        @deps = deps
-
-        @step_names = @steps.map { |s| s[:name] }
-      end
-
-      def call
-        resolve_wiring!
-        resolve_bodies!
-
-        nodes = build_nodes
-        Flows::Flow.new(start_node: nodes.first.name, nodes: nodes)
-      end
-
-      private
-
-      def resolve_wiring! # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        # we have to disable some linters for performance reasons
-        # this method can be simplified using `map.with_index`, but while loops is about
-        # 2x faster for such cases.
-        index = 0
-
-        while index < @steps.length
-          current_step = @steps[index]
-          next_step_name = nil
-
-          inner_index = index + 1
-          while inner_index < @steps.length
-            candidate = @steps[inner_index]
-            candidate_last_track = candidate[:track_path].last
-
-            if candidate[:track_path] == [] || current_step[:track_path].include?(candidate_last_track)
-              next_step_name = candidate[:name]
-              break
-            end
-
-            inner_index += 1
-          end
-
-          current_step[:next_step] = next_step_name || :term
-
-          index += 1
-        end
-      end
-
-      def resolve_bodies!
-        @steps.map! do |step|
-          step.merge(
-            body: step[:custom_body] || resolve_body_from_source(step[:name])
-          )
-        end
-      end
-
-      def resolve_body_from_source(name)
-        return @deps[name] if @deps.key?(name)
-
-        raise(::Flows::Operation::NoStepImplementationError, name) unless @method_source.respond_to?(name)
-
-        @method_source.method(name)
-      end
-
-      def build_nodes
-        @nodes = @steps.map do |step|
-          Flows::Node.new(
-            name: step[:name],
-            body: build_final_body(step),
-            preprocessor: method(:node_preprocessor),
-            postprocessor: method(:node_postprocessor),
-            router: BuildRouter.call(step[:custom_routes], step[:next_step], @step_names),
-            meta: build_meta(step)
-          )
-        end
-      end
-
-      def build_final_body(step)
-        case step[:type]
-        when :step
-          step[:body]
-        when :wrapper
-          build_wrapper_body(step[:body], step[:block])
-        end
-      end
-
-      def build_wrapper_body(wrapper, block)
-        suboperation_class = Class.new do
-          include ::Flows::Operation
-        end
-
-        suboperation_class.instance_exec(&block)
-        suboperation_class.no_shape
-
-        suboperation = suboperation_class.new(method_source: @method_source, deps: @deps)
-
-        lambda do |**options|
-          wrapper.call(**options) { suboperation.call(**options) }
-        end
-      end
-
-      def build_meta(step)
-        {
-          type: step[:type],
-          name: step[:name],
-          track_path: step[:track_path]
-        }
-      end
-
-      def node_preprocessor(_input, context, _meta)
-        context[:data]
-      end
-
-      def node_postprocessor(output, context, meta)
-        output_data = output.ok? ? output.unwrap : output.error
-        context[:data].merge!(output_data)
-        context[:last_step] = meta[:name]
-
-        output
-      end
-    end
-  end
-end

data/lib/flows/operation/builder/build_router.rb

@@ -1,37 +0,0 @@
-module Flows
-  module Operation
-    class Builder
-      # Router builder
-      module BuildRouter
-        class << self
-          def call(custom_routes, next_step, step_names)
-            if custom_routes
-              custom_router(custom_routes, next_step, step_names)
-            else
-              Flows::ResultRouter.new(next_step, :term)
-            end
-          end
-
-          private
-
-          def custom_router(custom_routes, next_step, step_names)
-            check_custom_routes(custom_routes, step_names)
-
-            custom_routes[Flows::Result::Ok] ||= next_step
-            custom_routes[Flows::Result::Err] ||= :term
-
-            Flows::Router.new(custom_routes)
-          end
-
-          def check_custom_routes(custom_routes, step_names)
-            custom_routes.values.each do |target|
-              next if step_names.include?(target) || target == :term
-
-              raise(::Flows::Operation::NoStepDefinedError, target)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/flows/operation/dsl.rb

@@ -1,72 +0,0 @@
-module Flows
-  module Operation
-    # DSL methods for operation
-    module DSL
-      attr_reader :steps, :ok_shapes, :err_shapes
-
-      include Flows::Result::Helpers
-
-      def step(name, custom_body_or_routes = nil, custom_routes = nil)
-        if custom_routes
-          custom_body = custom_body_or_routes
-        elsif custom_body_or_routes.is_a? Hash
-          custom_routes = custom_body_or_routes
-          custom_body = nil
-        else
-          custom_routes = nil
-          custom_body = custom_body_or_routes
-        end
-
-        @steps << make_step(name, custom_routes: custom_routes, custom_body: custom_body)
-      end
-
-      def track(name, &block)
-        track_path_before = @track_path
-        @track_path += [name]
-
-        @steps << make_step(name, custom_body: ->(**) { ok })
-        instance_exec(&block)
-
-        @track_path = track_path_before
-      end
-
-      def wrap(name, custom_body = nil, &block)
-        @steps << make_step(name, type: :wrapper, custom_body: custom_body, block: block)
-      end
-
-      def ok_shape(*keys, **code_keys_map)
-        @ok_shapes = if keys.empty?
-                       code_keys_map
-                     else
-                       { success: keys }
-                     end
-      end
-
-      def err_shape(*keys, **code_keys_map)
-        @err_shapes = if keys.empty?
-                        code_keys_map
-                      else
-                        { failure: keys }
-                      end
-      end
-
-      def no_shape
-        @ok_shapes = :no_shapes
-        @err_shapes = :no_shapes
-      end
-
-      private
-
-      def make_step(name, type: :step, custom_routes: {}, custom_body: nil, block: nil)
-        {
-          type: type,
-          name: name,
-          custom_routes: custom_routes,
-          custom_body: custom_body,
-          block: block,
-          track_path: @track_path
-        }
-      end
-    end
-  end
-end

data/lib/flows/operation/errors.rb

@@ -1,75 +0,0 @@
-module Flows
-  module Operation
-    # rubocop:disable Style/Documentation
-    class NoSuccessShapeError < ::Flows::Error
-      def message
-        'Missing success output shapes'
-      end
-    end
-
-    class NoFailureShapeError < ::Flows::Error
-      def message
-        'Missing failure output shape'
-      end
-    end
-
-    class NoStepsError < ::Flows::Error
-      def message
-        'No steps defined'
-      end
-    end
-
-    class NoStepImplementationError < ::Flows::Error
-      def initialize(step_name)
-        @step_name = step_name
-      end
-
-      def message
-        "Missing step implementation for #{@step_name}"
-      end
-    end
-
-    class NoStepDefinedError < ::Flows::Error
-      def initialize(step_name)
-        @step_name = step_name
-      end
-
-      def message
-        "Missing step or track definition: #{@step_name}"
-      end
-    end
-
-    class MissingOutputError < ::Flows::Error
-      def initialize(required_keys, actual_keys)
-        @missing_keys = required_keys - actual_keys
-      end
-
-      def message
-        "Missing keys in output: #{@missing_keys.join(', ')}"
-      end
-    end
-
-    class UnexpectedSuccessStatusError < ::Flows::Error
-      def initialize(actual_status, supported_statuses)
-        @actual_status = actual_status.inspect
-        @supported_statuses = supported_statuses.map(&:inspect).join(', ')
-      end
-
-      def message
-        "Unexpeted success result status: `#{@actual_status}`, supported statuses: `#{@supported_statuses}`"
-      end
-    end
-
-    class UnexpectedFailureStatusError < ::Flows::Error
-      def initialize(actual_status, supported_statuses)
-        @actual_status = actual_status.inspect
-        @supported_statuses = supported_statuses.map(&:inspect).join(', ')
-      end
-
-      def message
-        "Unexpeted failure result status: `#{@actual_status}`, supported statuses: `#{@supported_statuses}`"
-      end
-    end
-    # rubocop:enable Style/Documentation
-  end
-end

data/lib/flows/operation/executor.rb

@@ -1,78 +0,0 @@
-module Flows
-  module Operation
-    # Runner for operation steps
-    class Executor
-      include ::Flows::Result::Helpers
-
-      def initialize(flow:, ok_shapes:, err_shapes:, class_name:)
-        @flow = flow
-
-        @ok_shapes = ok_shapes
-        @err_shapes = err_shapes
-        @operation_class_name = class_name
-      end
-
-      def call(**params)
-        context = { data: params }
-        last_result = @flow.call(nil, context: context)
-
-        build_result(last_result, context)
-      end
-
-      private
-
-      def build_result(last_result, context)
-        status = last_result.status
-
-        case last_result
-        when Flows::Result::Ok then build_success_result(status, context)
-        when Flows::Result::Err then build_failure_result(status, context, last_result)
-        end
-      end
-
-      def build_success_result(status, context)
-        return ok(status, context[:data]) if @ok_shapes == :no_shapes
-
-        shape = @ok_shapes[status]
-        raise ::Flows::Operation::UnexpectedSuccessStatusError.new(status, @ok_shapes.keys) if shape.nil?
-
-        data = extract_data(context[:data], shape)
-
-        ok(status, data)
-      end
-
-      def build_failure_result(status, context, last_result)
-        raise ::Flows::Operation::NoFailureShapeError if @err_shapes.nil?
-
-        meta = build_meta(context, last_result)
-
-        return Flows::Result::Err.new(context[:data], status: status, meta: meta) if @err_shapes == :no_shapes
-
-        shape = @err_shapes[status]
-        raise ::Flows::Operation::UnexpectedFailureStatusError.new(status, @err_shapes.keys) if shape.nil?
-
-        data = extract_data(context[:data], shape)
-
-        Flows::Result::Err.new(data, status: status, meta: meta)
-      end
-
-      def extract_data(output, keys)
-        raise ::Flows::Operation::MissingOutputError.new(keys, output.keys) unless keys.all? { |key| output.key?(key) }
-
-        output.slice(*keys)
-      end
-
-      def build_meta(context, last_result)
-        meta = {
-          operation: @operation_class_name,
-          step: context[:last_step],
-          context_data: context[:data]
-        }
-
-        meta[:nested_metadata] = last_result.meta if last_result.meta.any?
-
-        meta
-      end
-    end
-  end
-end