functional-light-service 0.5.4 → 6.0.0

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.0.0"
+end

data/lib/functional-light-service.rb

@@ -1,28 +1,30 @@
-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/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

data/spec/acceptance/before_actions_spec.rb

@@ -1,98 +1,115 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe 'Action before_actions' do
-  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
-  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
+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