switchyard 7.0.0

data/lib/switchyard/organizer/with_callback.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Switchyard
+  module Organizer
+    class WithCallback
+      extend ScopedReducable
+
+      def self.run(organizer, action, steps)
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          # This will only allow 2 level deep nesting of callbacks
+          previous_callback = ctx[:callback]
+
+          ctx[:callback] = ->(context) do
+            ctx = scoped_reduce(organizer, context, steps)
+            ctx
+          end
+
+          ctx = action.execute(ctx)
+          ctx[:callback] = previous_callback
+
+          ctx
+        end
+      end
+    end
+  end
+end

data/lib/switchyard/organizer/with_reducer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Switchyard
+  module Organizer
+    class WithReducer
+      attr_reader :context
+      attr_accessor :organizer
+
+      def initialize(monitored_organizer = nil)
+        @organizer = monitored_organizer
+      end
+
+      def with(data = {})
+        @context = Switchyard::Context.make(data)
+        @context.organized_by = organizer
+        self
+      end
+
+      # Handler di default condiviso: prima veniva creata una classe anonima
+      # per ogni WithReducer senza around_each
+      NOOP_AROUND_EACH_HANDLER = ->(_context, &block) { block.call }
+
+      def around_each(handler)
+        @around_each_handler = handler
+        self
+      end
+
+      def around_each_handler
+        @around_each_handler || NOOP_AROUND_EACH_HANDLER
+      end
+
+      def reduce(*actions)
+        raise "No action(s) were provided" if actions.empty?
+
+        actions.flatten!
+
+        actions.each_with_index.with_object(context) do |(action, index), current_context|
+          invoke_action(current_context, action)
+        rescue FailWithRollbackError
+          reduce_rollback(actions, index)
+        ensure
+          # For logging
+          yield(current_context, action) if block_given?
+        end
+      end
+
+      def reduce_rollback(actions, index_of_failed_action = nil)
+        reversable_actions(actions, index_of_failed_action)
+          .reverse
+          .reduce(context) do |context, action|
+            if action.respond_to?(:rollback)
+              action.rollback(context)
+            else
+              context
+            end
+          end
+      end
+
+      private
+
+      def invoke_action(current_context, action)
+        around_each_handler.call(current_context) do
+          if action.respond_to?(:call)
+            action.call(current_context)
+          else
+            action.execute(current_context)
+          end
+        end
+      end
+
+      def reversable_actions(actions, index_of_failed_action = nil)
+        # L'indice viene tracciato nel reduce: actions.index troverebbe la prima
+        # occorrenza e con azioni duplicate il rollback sarebbe parziale
+        index_of_failed_action ||= actions.index(@context.current_action) || 0
+
+        # Reverse from the point where the fail was triggered
+        actions.take(index_of_failed_action + 1)
+      end
+    end
+  end
+end

data/lib/switchyard/organizer/with_reducer_factory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Switchyard
+  module Organizer
+    class WithReducerFactory
+      def self.make(monitored_organizer)
+        logger = monitored_organizer.logger || Switchyard::Configuration.logger
+        decorated = WithReducer.new(monitored_organizer)
+
+        return decorated if logger.nil?
+
+        WithReducerLogDecorator.new(
+          monitored_organizer,
+          :decorated => decorated,
+          :logger => logger
+        )
+      end
+    end
+  end
+end

data/lib/switchyard/organizer/with_reducer_log_decorator.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Switchyard
+  module Organizer
+    class WithReducerLogDecorator
+      attr_reader :logged, :logger, :decorated, :organizer
+
+      alias logged? logged
+
+      def initialize(organizer, logger:, decorated: WithReducer.new)
+        @decorated = decorated
+        @organizer = organizer
+
+        decorated.organizer = organizer
+
+        @logger = logger
+        @logged = false
+      end
+
+      def with(data = {})
+        logger.info { "[Switchyard] - calling organizer <#{organizer}>" }
+
+        decorated.with(data)
+
+        logger.info do
+          "[Switchyard] -     keys in context: " \
+            "#{extract_keys(decorated.context.keys)}"
+        end
+        self
+      end
+
+      def around_each(handler)
+        decorated.around_each(handler)
+        self
+      end
+
+      def reduce(*actions)
+        decorated.reduce(*actions) do |context, action|
+          next context if logged?
+
+          if has_failure?(context)
+            write_failure_log(context, action)
+            next context
+          end
+
+          if skip_remaining?(context)
+            write_skip_remaining_log(context, action)
+            next context
+          end
+
+          write_log(action, context)
+        end
+      end
+
+      private
+
+      def write_log(action, context)
+        return unless logger.info?
+
+        logger.info("[Switchyard] - executing <#{action}>")
+        log_expects(action)
+        log_promises(action)
+        logger.info("[Switchyard] -     keys in context: "\
+                    "#{extract_keys(context.keys)}")
+      end
+
+      def log_expects(action)
+        return unless defined?(action.expects) && action.expects.any?
+
+        logger.info("[Switchyard] -   expects: " \
+                    "#{extract_keys(action.expects)}")
+      end
+
+      def log_promises(action)
+        return unless defined?(action.promises) && action.promises.any?
+
+        logger.info("[Switchyard] -   promises: " \
+                    "#{extract_keys(action.promises)}")
+      end
+
+      def extract_keys(keys)
+        keys.map { |key| ":#{key}" }.join(', ')
+      end
+
+      def has_failure?(context)
+        context.respond_to?(:failure?) && context.failure?
+      end
+
+      def write_failure_log(context, action)
+        logger.warn("[Switchyard] - :-((( <#{action}> has failed...")
+        logger.warn("[Switchyard] - context message: #{context.message}")
+        @logged = true
+      end
+
+      def skip_remaining?(context)
+        (context.respond_to?(:skip_remaining?) && context.skip_remaining?) ||
+          (context.respond_to?(:skip_all_remaining?) && context.skip_all_remaining?)
+      end
+
+      def write_skip_remaining_log(context, action)
+        return unless logger.info?
+
+        msg = "[Switchyard] - ;-) <#{action}> has decided " \
+              "to skip the rest of the actions"
+        logger.info(msg)
+        logger.info("[Switchyard] - context message: #{context.message}")
+        @logged = true
+      end
+    end
+  end
+end

data/lib/switchyard/organizer.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Switchyard
+  module Organizer
+    def self.extended(base_class)
+      base_class.extend ClassMethods
+      base_class.extend Macros
+    end
+
+    def self.included(base_class)
+      Switchyard::Deprecations.warn(
+        "Including Switchyard::Organizer is deprecated; " \
+        "use `extend Switchyard::Organizer` instead"
+      )
+      extended(base_class)
+    end
+
+    # In case this module is included
+    module ClassMethods
+      def with(data = {})
+        data[:_aliases] = @aliases if @aliases
+
+        # Gli hook di classe vengono solo letti (mai azzerati): devono valere
+        # per ogni chiamata, anche concorrente
+        data[:_before_actions] = @before_actions.dup if @before_actions
+        data[:_after_actions] = @after_actions.dup if @after_actions
+
+        WithReducerFactory.make(self).with(data)
+      end
+
+      def reduce(*actions)
+        with({}).reduce(actions)
+      end
+
+      def reduce_if(condition_block, steps)
+        ReduceIf.run(self, condition_block, steps)
+      end
+
+      def reduce_if_else(condition_block, if_steps, else_steps)
+        ReduceIfElse.run(self, condition_block, if_steps, else_steps)
+      end
+
+      def reduce_until(condition_block, steps)
+        ReduceUntil.run(self, condition_block, steps)
+      end
+
+      def reduce_case(**args)
+        ReduceCase.run(self, **args)
+      end
+
+      def reduce_while(condition_block, steps)
+        ReduceWhile.run(self, condition_block, steps)
+      end
+
+      def iterate(collection_key, steps)
+        Iterate.run(self, collection_key, steps)
+      end
+
+      def execute(code_block = nil, &block)
+        Execute.run(code_block || block)
+      end
+
+      def with_callback(action, steps)
+        WithCallback.run(self, action, steps)
+      end
+
+      def log_with(logger)
+        @logger = logger
+      end
+
+      def logger
+        @logger
+      end
+
+      def add_to_context(**args)
+        args.map do |key, value|
+          execute(->(ctx) do
+            ctx[key.to_sym] = value
+            ctx.define_accessor_methods_for_keys([key])
+          end)
+        end
+      end
+
+      def add_aliases(args)
+        execute(->(ctx) { ctx.assign_aliases(ctx.aliases.merge(args)) })
+      end
+    end
+
+    module Macros
+      def aliases(key_hash)
+        @aliases = key_hash
+      end
+
+      # This looks like an accessor,
+      # but it's used as a macro in the Organizer
+      def before_actions(*logic)
+        self.before_actions = logic
+      end
+
+      def before_actions=(logic)
+        @before_actions = logic.nil? ? nil : [logic].flatten
+      end
+
+      def append_before_actions(action)
+        @before_actions ||= []
+        @before_actions.push(action)
+      end
+
+      def remove_before_actions(action)
+        @before_actions&.delete(action)
+      end
+
+      # This looks like an accessor,
+      # but it's used as a macro in the Organizer
+      def after_actions(*logic)
+        self.after_actions = logic
+      end
+
+      def after_actions=(logic)
+        @after_actions = logic.nil? ? nil : [logic].flatten
+      end
+
+      def append_after_actions(action)
+        @after_actions ||= []
+        @after_actions.push(action)
+      end
+    end
+  end
+end

data/lib/switchyard/testing/context_factory.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Switchyard
+  module Testing
+    class ContextFactory
+      attr_reader :organizer
+
+      def self.make_from(organizer)
+        new(organizer)
+      end
+
+      def for(action)
+        @target_action = action
+        self
+      end
+
+      # More than one arguments can be passed to the
+      # Organizer's #call method
+      def with(...)
+        hook = nil
+        hook = ->(ctx) do
+          if ctx.current_action == @target_action
+            # L'hook non deve essere re-invocato quando il context
+            # verra' usato con Action#execute nel test
+            ctx[:_before_actions].delete(hook)
+
+            throw(:return_ctx_from_execution, ctx)
+          end
+        end
+
+        @organizer.append_before_actions(hook)
+
+        begin
+          catch(:return_ctx_from_execution) do
+            @organizer.call(...)
+          end
+        ensure
+          # L'hook e' per-chiamata: la classe organizer non deve conservarlo
+          @organizer.remove_before_actions(hook)
+        end
+      end
+
+      def initialize(organizer)
+        @organizer = organizer
+      end
+    end
+  end
+end

data/lib/switchyard/testing.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'switchyard/testing/context_factory'

data/lib/switchyard/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Switchyard
+  VERSION = "7.0.0"
+end

data/lib/switchyard.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require 'switchyard/version'
+
+module Switchyard; end
+
+require 'switchyard/deprecations'
+require 'switchyard/functional/monad'
+require 'switchyard/functional/enum'
+require 'switchyard/functional/result'
+require 'switchyard/functional/option'
+require 'switchyard/functional/null'
+require 'switchyard/functional/sequencer'
+require 'switchyard/errors'
+require 'switchyard/configuration'
+require 'switchyard/i18n/localization_adapter'
+require 'switchyard/localization_adapter'
+require 'switchyard/localization_map'
+require 'switchyard/context'
+require 'switchyard/context/key_verifier'
+require 'switchyard/organizer/scoped_reducable'
+require 'switchyard/organizer/with_reducer'
+require 'switchyard/organizer/with_reducer_log_decorator'
+require 'switchyard/organizer/with_reducer_factory'
+require 'switchyard/organizer/reduce_if'
+require 'switchyard/organizer/reduce_if_else'
+require 'switchyard/organizer/reduce_case'
+require 'switchyard/organizer/reduce_until'
+require 'switchyard/organizer/reduce_while'
+require 'switchyard/organizer/iterate'
+require 'switchyard/organizer/execute'
+require 'switchyard/organizer/with_callback'
+require 'switchyard/action'
+require 'switchyard/organizer'

data/spec/acceptance/add_numbers_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe TestDoubles::AdditionOrganizer do
+  it 'Adds 1, 2 and 3 to the initial value of 1' do
+    result = TestDoubles::AdditionOrganizer.call(1)
+    number = result.fetch(:number)
+
+    expect(number).to eq(7)
+  end
+end

data/spec/acceptance/after_actions_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe 'Action after_actions' do
+  # Gli hook restano sulla classe (non vengono piu consumati da #with):
+  # i test double sono condivisi, quindi vanno ripuliti dopo ogni esempio
+  after do
+    TestDoubles::AdditionOrganizer.after_actions = nil
+    TestDoubles::TestIterate.after_actions = nil
+  end
+
+  describe 'works with simple organizers - from outside' do
+    it 'can be used to inject code block before each action' do
+      TestDoubles::AdditionOrganizer.after_actions = ->(ctx) do
+        ctx.number -= 2 if ctx.current_action == TestDoubles::AddsThreeAction
+      end
+
+      result = TestDoubles::AdditionOrganizer.call(0)
+
+      expect(result.fetch(:number)).to eq(4)
+    end
+
+    it 'works with iterator' do
+      TestDoubles::TestIterate.after_actions = [
+        ->(ctx) { ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction }
+      ]
+
+      result = TestDoubles::TestIterate.call(:number => 0,
+                                             :counters => [1, 2, 3, 4])
+
+      expect(result).to be_success
+      expect(result.number).to eq(-4)
+    end
+  end
+
+  describe 'can be added to organizers declaratively' do
+    module AfterActions
+      class AdditionOrganizer
+        extend Switchyard::Organizer
+
+        after_actions ->(ctx) do
+          ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction
+        end,
+                      ->(ctx) do
+                        ctx.number -= 3 if ctx.current_action == TestDoubles::AddsThreeAction
+                      end
+
+        def self.call(number)
+          with(:number => number).reduce(actions)
+        end
+
+        def self.actions
+          [
+            TestDoubles::AddsOneAction,
+            TestDoubles::AddsTwoAction,
+            TestDoubles::AddsThreeAction
+          ]
+        end
+      end
+    end
+
+    it 'accepts after_actions hook lambdas from organizer' do
+      result = AfterActions::AdditionOrganizer.call(0)
+
+      expect(result.fetch(:number)).to eq(1)
+    end
+
+    it 'keeps the declarative hooks on every subsequent call' do
+      first = AfterActions::AdditionOrganizer.call(0)
+      second = AfterActions::AdditionOrganizer.call(0)
+
+      expect(first.fetch(:number)).to eq(1)
+      expect(second.fetch(:number)).to eq(1)
+    end
+  end
+
+  describe 'after_actions can be appended' do
+    it 'adds to the :_after_actions collection' do
+      TestDoubles::AdditionOrganizer.append_after_actions(
+        ->(ctx) { ctx.number -= 3 if ctx.current_action == TestDoubles::AddsThreeAction }
+      )
+
+      result = TestDoubles::AdditionOrganizer.call(0)
+      expect(result.fetch(:number)).to eq(3)
+    end
+  end
+end

data/spec/acceptance/around_each_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe 'Executing arbitrary code around each action' do
+  it 'can be used to log data' do
+    context = { :number => 0, :logger => TestDoubles::TestLogger.new }
+
+    result = TestDoubles::AroundEachOrganizer.call(context)
+
+    expect(result.fetch(:number)).to eq(2)
+    expect(result[:logger].logs).to eq(
+      [{
+        :action => TestDoubles::AddsTwoActionWithFetch,
+        :before => 0,
+        :after => 2
+      }]
+    )
+  end
+end