functional-light-service 0.5.4 → 6.0.0

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

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

@@ -1,114 +1,114 @@
-module FunctionalLightService
-  module Organizer
-    def self.extended(base_class)
-      base_class.extend ClassMethods
-      base_class.extend Macros
-    end
-
-    def self.included(base_class)
-      msg = "DEPRECATION WARNING:\n" \
-            "Including FunctionalLightService::Organizer is deprecated\n" \
-            "Please use `extend FunctionalLightService::Organizer` instead"
-      print msg
-      extended(base_class)
-    end
-
-    # In case this module is included
-    module ClassMethods
-      def with(data = {})
-        VerifyCallMethodExists.run(self, caller(1..1).first)
-        data[:_aliases] = @aliases if @aliases
-
-        if @before_actions
-          data[:_before_actions] = @before_actions.dup
-          @before_actions = nil
-        end
-
-        if @after_actions
-          data[:_after_actions] = @after_actions.dup
-          @after_actions = nil
-        end
-
-        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_until(condition_block, steps)
-        ReduceUntil.run(self, condition_block, steps)
-      end
-
-      def iterate(collection_key, steps)
-        Iterate.run(self, collection_key, steps)
-      end
-
-      def execute(code_block)
-        Execute.run(code_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) { ctx[key.to_sym] = value })
-        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].flatten
-      end
-
-      def append_before_actions(action)
-        @before_actions ||= []
-        @before_actions.push(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].flatten
-      end
-
-      def append_after_actions(action)
-        @after_actions ||= []
-        @after_actions.push(action)
-      end
-    end
-  end
-end
+# 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_until(condition_block, steps)
+        ReduceUntil.run(self, condition_block, steps)
+      end
+
+      def iterate(collection_key, steps)
+        Iterate.run(self, collection_key, steps)
+      end
+
+      def execute(code_block)
+        Execute.run(code_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) { ctx[key.to_sym] = value })
+        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