flows 0.3.0 → 0.4.0

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