flows 0.2.0 → 0.6.0

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,93 +0,0 @@
-module Flows
-  module Operation
-    # DSL methods for operation
-    module DSL
-      attr_reader :steps, :ok_shapes, :err_shapes
-
-      def self.extended(mod, steps = nil, ok_shapes = nil, err_shapes = nil)
-        mod.instance_variable_set(:@steps, steps || [])
-        mod.instance_variable_set(:@track_path, [])
-        mod.instance_variable_set(:@ok_shapes, ok_shapes)
-        mod.instance_variable_set(:@err_shapes, err_shapes)
-
-        mod.class_exec do
-          def self.inherited(subclass)
-            ::Flows::Operation::DSL.extended(subclass, steps.map(&:dup), ok_shapes, err_shapes)
-            super
-          end
-        end
-      end
-
-      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 routes(routes_hash)
-        routes_hash
-      end
-
-      alias when_ok match_ok
-      alias when_err match_err
-
-      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

data/lib/flows/railway/builder.rb

@@ -1,68 +0,0 @@
-module Flows
-  module Railway
-    # Flow builder
-    class Builder
-      attr_reader :steps, :method_source, :deps
-
-      def initialize(steps:, method_source:, deps:)
-        @method_source = method_source
-        @steps = steps
-        @deps = deps
-      end
-
-      def call
-        resolve_bodies_and_wiring!
-
-        nodes = build_nodes
-        Flows::Flow.new(start_node: nodes.first.name, nodes: nodes)
-      end
-
-      private
-
-      def resolve_bodies_and_wiring!
-        index = 0
-
-        while index < @steps.length
-          current_step = @steps[index]
-
-          current_step[:next_step] = @steps[index + 1]&.fetch(:name) || :term
-          current_step[:body] = current_step[:custom_body] || resolve_body_from_source(current_step[:name])
-
-          index += 1
-        end
-      end
-
-      def resolve_body_from_source(name)
-        return @deps[name] if @deps.key?(name)
-
-        raise(::Flows::Railway::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: step[:body],
-            preprocessor: method(:node_preprocessor),
-            postprocessor: method(:node_postprocessor),
-            router: Flows::ResultRouter.new(step[:next_step], :term),
-
-            meta: { name: step[:name] }
-          )
-        end
-      end
-
-      def node_preprocessor(input, _context, _meta)
-        input.unwrap
-      end
-
-      def node_postprocessor(output, context, meta)
-        context[:last_step] = meta[:name]
-
-        output
-      end
-    end
-  end
-end

data/lib/flows/railway/executor.rb

@@ -1,23 +0,0 @@
-module Flows
-  module Railway
-    # Runner for railway steps
-    class Executor
-      include ::Flows::Result::Helpers
-
-      def initialize(flow:, class_name:)
-        @flow = flow
-        @railway_class_name = class_name
-      end
-
-      def call(**params)
-        context = {}
-        last_result = @flow.call(ok(params), context: context)
-
-        last_result.meta[:railway] = @railway_class_name
-        last_result.meta[:last_step] = context[:last_step]
-
-        last_result
-      end
-    end
-  end
-end

data/lib/flows/result_router.rb

@@ -1,14 +0,0 @@
-module Flows
-  # Node router for simple case when result must be a `Flows::Result`
-  # and we don't care about result status key
-  class ResultRouter
-    def initialize(success_route, failure_route)
-      @success_route = success_route
-      @failure_route = failure_route
-    end
-
-    def call(output, **)
-      output.ok? ? @success_route : @failure_route
-    end
-  end
-end

data/lib/flows/router.rb

@@ -1,22 +0,0 @@
-module Flows
-  # Node router: defines predicate rules to calculate next node.
-  class Router
-    class Error < Flows::Error; end
-    class NoRouteError < Error; end
-
-    def initialize(route_hash, preprocessor: nil)
-      @route_def = route_hash
-      @preprocessor = preprocessor
-    end
-
-    def call(output, context:, meta:)
-      data = @preprocessor ? @preprocessor.call(output, context, meta) : output
-
-      @route_def.each_pair do |predicate, route|
-        return route if predicate === data # rubocop:disable Style/CaseEquality
-      end
-
-      raise NoRouteError, "no route found found for output: #{output.inspect}"
-    end
-  end
-end