flows 0.0.2 → 0.1.0

data/bin/profile_10steps

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# rubocop:disable all
+
+require 'bundler/setup'
+require 'json'
+require 'ruby-prof'
+require 'stackprof'
+
+require_relative './examples'
+
+flows_ten_steps = FlowsTenSteps.new
+
+build_output_name = '10steps_build_10k_times'
+exec_output_name = '10steps_execution_10k_times'
+
+#
+# RubyProf
+#
+RubyProf.measure_mode = RubyProf::WALL_TIME
+
+puts 'Build with RubyProf...'
+result = RubyProf.profile do
+  10_000.times do
+    FlowsTenSteps.new
+  end
+end
+printer = RubyProf::MultiPrinter.new(result)
+printer.print(path: 'profile', profile: build_output_name)
+
+puts 'Execution with RubyProf...'
+result = RubyProf.profile do
+  10_000.times {
+    flows_ten_steps.call
+  }
+end
+printer = RubyProf::MultiPrinter.new(result)
+printer.print(path: 'profile', profile: exec_output_name)
+
+#
+# StackProf
+#
+
+puts 'Build with StackProf...'
+result = StackProf.run(mode: :wall, raw: true) do
+  10_000.times do
+    FlowsTenSteps.new
+  end
+end
+File.write("profile/#{build_output_name}.json", JSON.generate(result))
+
+puts 'Execution with StackProf...'
+result = StackProf.run(mode: :wall, raw: true) do
+  10_000.times do
+    flows_ten_steps.call
+  end
+end
+File.write("profile/#{exec_output_name}.json", JSON.generate(result))
+
+puts
+puts 'Install speedscope:'
+puts '  npm i -g speedscope'
+puts
+puts "speedscope profile/#{build_output_name}.json"
+puts "speedscope profile/#{exec_output_name}.json"

data/bin/ruby_benchmarks

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# rubocop:disable all
+
+require 'bundler/setup'
+require 'benchmark/ips'
+
+puts '-' * 50
+puts '- method execution'
+puts '-' * 50
+
+class OneMethod
+  def meth
+    :ok
+  end
+end
+
+one_method = OneMethod.new
+method_obj = one_method.method(:meth)
+
+Benchmark.ips do |b|
+  b.report('native call') { one_method.meth }
+  b.report('send(...)') { one_method.send(:meth) }
+  b.report('Method#call') { method_obj.call }
+
+  b.compare!
+end

data/flows.gemspec

@@ -2,7 +2,7 @@ lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'flows/version'
 
-Gem::Specification.new do |spec|
+Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.name          = 'flows'
   spec.version       = Flows::VERSION
   spec.authors       = ['Roman Kolesnev']
@@ -33,4 +33,13 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'codecov'
   spec.add_development_dependency 'simplecov'
+
+  # benchmarking tools
+  spec.add_development_dependency 'benchmark-ips'
+  spec.add_development_dependency 'ruby-prof'
+  spec.add_development_dependency 'stackprof'
+
+  # alternatives for comparison in benchmarking
+  spec.add_development_dependency 'dry-transaction'
+  spec.add_development_dependency 'trailblazer-operation'
 end

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

@@ -0,0 +1,37 @@
+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/builder.rb

@@ -1,10 +1,17 @@
+require_relative './builder/build_router'
+
 module Flows
   module Operation
     # Flow builder
     class Builder
-      def initialize(steps:, method_source:)
+      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
@@ -17,39 +24,96 @@ module Flows
 
       private
 
-      def resolve_wiring!
-        @steps = @steps.map.with_index do |step, index|
-          step.merge(
-            next_step: @steps.dig(index + 1, :name) || :term
-          )
+      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|
-          unless @method_source.respond_to?(step[:name])
-            raise ::Flows::Operation::NoStepImplementationError, step[:name]
-          end
-
           step.merge(
-            body: @method_source.method(step[:name])
+            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: step[:body],
+            body: build_final_body(step),
             preprocessor: method(:node_preprocessor),
             postprocessor: method(:node_postprocessor),
-            router: make_router(step),
-            meta: { name: step[:name] }
+            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
@@ -61,15 +125,6 @@ module Flows
 
         output
       end
-
-      def make_router(step_definition)
-        routes = step_definition[:custom_routes]
-
-        routes[Flows::Result::Ok] ||= step_definition[:next_step]
-        routes[Flows::Result::Err] ||= :term
-
-        Flows::Router.new(routes)
-      end
     end
   end
 end

data/lib/flows/operation/dsl.rb

@@ -2,31 +2,70 @@ module Flows
   module Operation
     # DSL methods for operation
     module DSL
-      attr_reader :steps, :success_shapes, :failure_shapes
+      attr_reader :steps, :ok_shapes, :err_shapes
 
       include Flows::Result::Helpers
 
-      def step(name, custom_routes = {})
-        @steps << {
-          name: name,
-          custom_routes: custom_routes
-        }
+      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 success(*keys, **code_keys_map)
-        @success_shapes = if keys.empty?
-                            code_keys_map
-                          else
-                            { success: keys }
-                          end
+      def no_shape
+        @ok_shapes = :no_shapes
+        @err_shapes = :no_shapes
       end
 
-      def failure(*keys, **code_keys_map)
-        @failure_shapes = if keys.empty?
-                            code_keys_map
-                          else
-                            { failure: keys }
-                          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

data/lib/flows/operation/errors.rb

@@ -29,6 +29,16 @@ module Flows
       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

data/lib/flows/operation/executor.rb

@@ -4,11 +4,11 @@ module Flows
     class Executor
       include ::Flows::Result::Helpers
 
-      def initialize(flow:, success_shapes:, failure_shapes:, class_name:)
+      def initialize(flow:, ok_shapes:, err_shapes:, class_name:)
         @flow = flow
 
-        @success_shapes = success_shapes
-        @failure_shapes = failure_shapes
+        @ok_shapes = ok_shapes
+        @err_shapes = err_shapes
         @operation_class_name = class_name
       end
 
@@ -31,8 +31,10 @@ module Flows
       end
 
       def build_success_result(status, context)
-        shape = @success_shapes[status]
-        raise ::Flows::Operation::UnexpectedSuccessStatusError.new(status, @success_shapes.keys) if shape.nil?
+        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)
 
@@ -40,13 +42,16 @@ module Flows
       end
 
       def build_failure_result(status, context, last_result)
-        raise ::Flows::Operation::NoFailureShapeError if @failure_shapes.nil?
+        raise ::Flows::Operation::NoFailureShapeError if @err_shapes.nil?
+
+        meta = build_meta(context, last_result)
 
-        shape = @failure_shapes[status]
-        raise ::Flows::Operation::UnexpectedFailureStatusError.new(status, @failure_shapes.keys) if shape.nil?
+        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)
-        meta = build_meta(context, last_result)
 
         Flows::Result::Err.new(data, status: status, meta: meta)
       end

data/lib/flows/operation.rb

@@ -9,15 +9,18 @@ module Flows
   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
+    def initialize(method_source: nil, deps: {})
       _flows_do_checks
 
-      @_flows_executor = _flows_make_executor(_flows_make_flow)
+      flow = _flows_make_flow(method_source || self, deps)
+
+      @_flows_executor = _flows_make_executor(flow)
     end
 
     def call(**params)
@@ -28,21 +31,22 @@ module Flows
 
     def _flows_do_checks
       raise NoStepsError if self.class.steps.empty?
-      raise NoSuccessShapeError, self if self.class.success_shapes.nil?
+      raise NoSuccessShapeError, self if self.class.ok_shapes.nil?
     end
 
-    def _flows_make_flow
+    def _flows_make_flow(method_source, deps)
       ::Flows::Operation::Builder.new(
         steps: self.class.steps,
-        method_source: self
+        method_source: method_source,
+        deps: deps
       ).call
     end
 
     def _flows_make_executor(flow)
       ::Flows::Operation::Executor.new(
         flow: flow,
-        success_shapes: self.class.success_shapes,
-        failure_shapes: self.class.failure_shapes,
+        ok_shapes: self.class.ok_shapes,
+        err_shapes: self.class.err_shapes,
         class_name: self.class.name
       )
     end

data/lib/flows/result/err.rb

@@ -2,8 +2,12 @@ module Flows
   class Result
     # Wrapper for failure results
     class Err < Result
+      attr_reader :error
+
       def initialize(data, status: :failure, meta: {})
-        super
+        @error = data
+        @status = status
+        @meta = meta
       end
 
       def ok?
@@ -17,10 +21,6 @@ module Flows
       def unwrap
         raise UnwrapError.new(@status, @data, @meta)
       end
-
-      def error
-        @data
-      end
     end
   end
 end

data/lib/flows/result/ok.rb

@@ -2,8 +2,12 @@ module Flows
   class Result
     # Wrapper for successful results
     class Ok < Result
+      attr_reader :unwrap
+
       def initialize(data, status: :success, meta: {})
-        super
+        @unwrap = data
+        @status = status
+        @meta = meta
       end
 
       def ok?
@@ -14,10 +18,6 @@ module Flows
         false
       end
 
-      def unwrap
-        @data
-      end
-
       def error
         raise NoErrorError.new(@status, @data)
       end

data/lib/flows/result.rb

@@ -3,12 +3,8 @@ module Flows
   class Result
     attr_reader :status, :meta
 
-    def initialize(data, status:, meta: {})
-      @data = data
-      @status = status
-      @meta = meta
-
-      raise 'Use Flows::Result::Ok or Flows::Result::Err for build result objects' if self.class == Result
+    def initialize(**)
+      raise 'Use Flows::Result::Ok or Flows::Result::Err for build result objects'
     end
   end
 end

data/lib/flows/result_router.rb

@@ -0,0 +1,14 @@
+module Flows
+  # Node router for simple case when result must be a `Flows::Result`
+  # and we don't care about resukt 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

@@ -4,23 +4,19 @@ module Flows
     class Error < Flows::Error; end
     class NoRouteError < Error; end
 
-    DEFAULT_PREPROCESSOR = ->(output, _context, _meta) { output }
-
-    def initialize(route_hash, preprocessor: DEFAULT_PREPROCESSOR)
+    def initialize(route_hash, preprocessor: nil)
       @route_def = route_hash
       @preprocessor = preprocessor
     end
 
     def call(output, context:, meta:)
-      data = @preprocessor.call(output, context, meta)
+      data = @preprocessor ? @preprocessor.call(output, context, meta) : output
 
-      matched_entry = @route_def.find do |predicate, _|
-        predicate === data # rubocop:disable Style/CaseEquality
+      @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}" unless matched_entry
-
-      matched_entry[1]
+      raise NoRouteError, "no route found found for output: #{output.inspect}"
     end
   end
 end

data/lib/flows/version.rb

@@ -1,3 +1,3 @@
 module Flows
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/lib/flows.rb

@@ -5,6 +5,7 @@ end
 require 'flows/version'
 
 require 'flows/router'
+require 'flows/result_router'
 require 'flows/node'
 require 'flows/flow'