functional-light-service 0.5.4 → 6.1.0

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

data/lib/functional-light-service/testing/context_factory.rb

@@ -1,42 +1,48 @@
-module FunctionalLightService
-  module Testing
-    class ContextFactory
-      attr_reader :organizer
-
-      def self.make_from(organizer)
-        new(organizer)
-      end
-
-      def for(action)
-        @organizer.append_before_actions(
-          ->(ctx) do
-            if ctx.current_action == action
-              # The last `:_before_actions` hook is for
-              # ContextFactory, remove it, so it won't
-              # be invoked again
-              ctx[:_before_actions].pop
-
-              throw(:return_ctx_from_execution, ctx)
-            end
-          end
-        )
-
-        self
-      end
-
-      # More than one arguments can be passed to the
-      # Organizer's #call method
-      # rubocop:disable Style/ArgumentsForwarding
-      def with(*args, &block)
-        catch(:return_ctx_from_execution) do
-          @organizer.call(*args, &block)
-        end
-      end
-      # rubocop:enable Style/ArgumentsForwarding
-
-      def initialize(organizer)
-        @organizer = organizer
-      end
-    end
-  end
-end
+# 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 +1,3 @@
-require 'functional-light-service/testing/context_factory'
+# frozen_string_literal: true
+
+require 'functional-light-service/testing/context_factory'

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

@@ -1,3 +1,5 @@
-module FunctionalLightService
-  VERSION = "0.5.4".freeze
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  VERSION = "6.1.0"
+end

data/lib/functional-light-service.rb

@@ -1,28 +1,31 @@
-require 'logger'
-
-require 'functional-light-service/version'
-
-module FunctionalLightService; end
-
-require 'functional-light-service/functional/monad'
-require 'functional-light-service/functional/enum'
-require 'functional-light-service/functional/result'
-require 'functional-light-service/functional/option'
-require 'functional-light-service/functional/null'
-require 'functional-light-service/errors'
-require 'functional-light-service/configuration'
-require 'functional-light-service/localization_adapter'
-require 'functional-light-service/context'
-require 'functional-light-service/context/key_verifier'
-require 'functional-light-service/organizer/scoped_reducable'
-require 'functional-light-service/organizer/with_reducer'
-require 'functional-light-service/organizer/with_reducer_log_decorator'
-require 'functional-light-service/organizer/with_reducer_factory'
-require 'functional-light-service/organizer/reduce_if'
-require 'functional-light-service/organizer/reduce_until'
-require 'functional-light-service/organizer/iterate'
-require 'functional-light-service/organizer/execute'
-require 'functional-light-service/organizer/with_callback'
-require 'functional-light-service/organizer/verify_call_method_exists'
-require 'functional-light-service/action'
-require 'functional-light-service/organizer'
+# frozen_string_literal: true
+
+require 'logger'
+
+require 'functional-light-service/version'
+
+module FunctionalLightService; end
+
+require 'functional-light-service/deprecations'
+require 'functional-light-service/functional/monad'
+require 'functional-light-service/functional/enum'
+require 'functional-light-service/functional/result'
+require 'functional-light-service/functional/option'
+require 'functional-light-service/functional/null'
+require 'functional-light-service/functional/sequencer'
+require 'functional-light-service/errors'
+require 'functional-light-service/configuration'
+require 'functional-light-service/localization_adapter'
+require 'functional-light-service/context'
+require 'functional-light-service/context/key_verifier'
+require 'functional-light-service/organizer/scoped_reducable'
+require 'functional-light-service/organizer/with_reducer'
+require 'functional-light-service/organizer/with_reducer_log_decorator'
+require 'functional-light-service/organizer/with_reducer_factory'
+require 'functional-light-service/organizer/reduce_if'
+require 'functional-light-service/organizer/reduce_until'
+require 'functional-light-service/organizer/iterate'
+require 'functional-light-service/organizer/execute'
+require 'functional-light-service/organizer/with_callback'
+require 'functional-light-service/action'
+require 'functional-light-service/organizer'

data/spec/acceptance/after_actions_spec.rb

@@ -1,71 +1,87 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe 'Action after_actions' do
-  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
-  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
+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