functional-light-service 0.5.4 → 6.1.0

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

@@ -1,13 +1,15 @@
-module FunctionalLightService
-  module Organizer
-    module ScopedReducable
-      def scoped_reduce(organizer, ctx, steps)
-        ctx.reset_skip_remaining! unless ctx.failure?
-        ctx = organizer.with(ctx).reduce([steps])
-        ctx.reset_skip_remaining! unless ctx.failure?
-
-        ctx
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Organizer
+    module ScopedReducable
+      def scoped_reduce(organizer, ctx, steps)
+        ctx.reset_skip_remaining! unless ctx.failure?
+        ctx = organizer.with(ctx).reduce([steps])
+        ctx.reset_skip_remaining! unless ctx.failure?
+
+        ctx
+      end
+    end
+  end
+end

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

@@ -1,26 +1,28 @@
-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
+# 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,77 +1,81 @@
-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
-
-      def around_each(handler)
-        @around_each_handler = handler
-        self
-      end
-
-      def around_each_handler
-        @around_each_handler ||= Class.new do
-          def self.call(_context)
-            yield
-          end
-        end
-      end
-
-      def reduce(*actions)
-        raise "No action(s) were provided" if actions.empty?
-
-        actions.flatten!
-
-        actions.each_with_object(context) do |action, current_context|
-          invoke_action(current_context, action)
-        rescue FailWithRollbackError
-          reduce_rollback(actions)
-        ensure
-          # For logging
-          yield(current_context, action) if block_given?
-        end
-      end
-
-      def reduce_rollback(actions)
-        reversable_actions(actions)
-          .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_current_action = actions.index(@context.current_action) || 0
-
-        # Reverse from the point where the fail was triggered
-        actions.take(index_of_current_action + 1)
-      end
-    end
-  end
-end
+# 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,18 +1,20 @@
-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
+# 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,108 +1,110 @@
-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?
-      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
+# 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?
+      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