functional-light-service 6.2.0 → 6.3.0

data/lib/functional-light-service/organizer/with_callback.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  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/functional-light-service/organizer/with_reducer.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Organizer
-    class WithReducer
-      attr_reader :context
-      attr_accessor :organizer
-
-      def initialize(monitored_organizer = nil)
-        @organizer = monitored_organizer
-      end
-
-      def with(data = {})
-        @context = FunctionalLightService::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/functional-light-service/organizer/with_reducer_factory.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Organizer
-    class WithReducerFactory
-      def self.make(monitored_organizer)
-        logger = monitored_organizer.logger || FunctionalLightService::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/functional-light-service/organizer/with_reducer_log_decorator.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  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 { "[FunctionalLightService] - calling organizer <#{organizer}>" }
-
-        decorated.with(data)
-
-        logger.info do
-          "[FunctionalLightService] -     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("[FunctionalLightService] - executing <#{action}>")
-        log_expects(action)
-        log_promises(action)
-        logger.info("[FunctionalLightService] -     keys in context: "\
-                    "#{extract_keys(context.keys)}")
-      end
-
-      def log_expects(action)
-        return unless defined?(action.expects) && action.expects.any?
-
-        logger.info("[FunctionalLightService] -   expects: " \
-                    "#{extract_keys(action.expects)}")
-      end
-
-      def log_promises(action)
-        return unless defined?(action.promises) && action.promises.any?
-
-        logger.info("[FunctionalLightService] -   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("[FunctionalLightService] - :-((( <#{action}> has failed...")
-        logger.warn("[FunctionalLightService] - 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 = "[FunctionalLightService] - ;-) <#{action}> has decided " \
-              "to skip the rest of the actions"
-        logger.info(msg)
-        logger.info("[FunctionalLightService] - context message: #{context.message}")
-        @logged = true
-      end
-    end
-  end
-end

data/lib/functional-light-service/organizer.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Organizer
-    def self.extended(base_class)
-      base_class.extend ClassMethods
-      base_class.extend Macros
-    end
-
-    def self.included(base_class)
-      FunctionalLightService::Deprecations.warn(
-        "Including FunctionalLightService::Organizer is deprecated; " \
-        "use `extend FunctionalLightService::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/functional-light-service/testing/context_factory.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  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/functional-light-service/testing.rb

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

data/lib/functional-light-service/version.rb

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

data/spec/acceptance/add_numbers_spec.rb

@@ -1,11 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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 FunctionalLightService::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

@@ -1,19 +0,0 @@
-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

data/spec/acceptance/before_actions_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe 'Action before_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.before_actions = nil
-    TestDoubles::TestIterate.before_actions = nil
-    TestDoubles::TestWithCallback.before_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.before_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.before_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 BeforeActions
-      class AdditionOrganizer
-        extend FunctionalLightService::Organizer
-
-        before_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 before_actions hook lambdas from organizer' do
-      result = BeforeActions::AdditionOrganizer.call(0)
-
-      expect(result.fetch(:number)).to eq(1)
-    end
-
-    it 'keeps the declarative hooks on every subsequent call' do
-      first = BeforeActions::AdditionOrganizer.call(0)
-      second = BeforeActions::AdditionOrganizer.call(0)
-
-      expect(first.fetch(:number)).to eq(1)
-      expect(second.fetch(:number)).to eq(1)
-    end
-  end
-
-  describe 'works with callbacks' do
-    it 'can interact with actions from the outside' do
-      TestDoubles::TestWithCallback.before_actions = [
-        ->(ctx) { ctx.total -= 1000 if ctx.current_action == TestDoubles::AddToTotalAction }
-      ]
-      result = TestDoubles::TestWithCallback.call
-
-      expect(result.counter).to eq(3)
-      expect(result.total).to eq(-2994)
-    end
-  end
-
-  describe 'can halt all execution with a raised error' do
-    it 'does not call the rest of the callback steps' do
-      class SkipContextError < StandardError
-        attr_reader :ctx
-
-        def initialize(msg, ctx)
-          @ctx = ctx
-          super(msg)
-        end
-      end
-      TestDoubles::TestWithCallback.before_actions = [
-        ->(ctx) do
-          if ctx.current_action == TestDoubles::IncrementCountAction
-            ctx.total -= 1000
-            raise SkipContextError.new("stop context now", ctx)
-          end
-        end
-      ]
-      begin
-        TestDoubles::TestWithCallback.call
-      rescue SkipContextError => e
-        expect(e.ctx).not_to be_empty
-      end
-    end
-  end
-end