functional-light-service 6.1.0 → 6.3.0

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

@@ -1,110 +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?
-      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 +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_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,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.1.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

data/spec/acceptance/custom_log_from_organizer_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe "Log from an organizer with a custom logger" do
-  context "when overriding the global FunctionalLightService organizer" do
-    let(:global_logger_organizer) do
-      Class.new do
-        extend FunctionalLightService::Organizer
-
-        def self.call(number)
-          with(:number => number).reduce(actions)
-        end
-
-        def self.actions
-          [
-            TestDoubles::AddsOneAction,
-            TestDoubles::AddsTwoAction,
-            TestDoubles::AddsThreeAction
-          ]
-        end
-      end
-    end
-
-    let(:global_logger_string) { StringIO.new }
-
-    let(:custom_logger_string) { StringIO.new }
-    let(:custom_logger_organizer) do
-      custom_logger = Logger.new(custom_logger_string)
-
-      Class.new do
-        extend FunctionalLightService::Organizer
-
-        log_with custom_logger
-
-        def self.call(coffee, this_hot = :very_hot)
-          with(:milk => this_hot, :coffee => coffee)
-            .reduce(TestDoubles::MakesLatteAction,
-                    TestDoubles::AddsTwoActionWithFetch)
-        end
-      end
-    end
-
-    before do
-      @original_global_logger = FunctionalLightService::Configuration.logger
-      FunctionalLightService::Configuration.logger = Logger.new(global_logger_string)
-    end
-
-    it "logs in own logger" do
-      global_logger_organizer.call(1)
-      custom_logger_organizer.call(:coffee => "Cappucino")
-
-      expect(custom_logger_string.string).to include("MakesLatteAction")
-      expect(custom_logger_string.string).to_not include("AddsOneAction")
-      expect(global_logger_string.string).to include("AddsOneAction")
-      expect(global_logger_string.string).to_not include("MakesLatteAction")
-    end
-
-    after do
-      FunctionalLightService::Configuration.logger = @original_global_logger
-    end
-  end
-end

data/spec/acceptance/deprecation_warnings_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-# Maybe()/Null e il monkey-patch di Object sono opt-in: non fanno parte
-# del require chain di default della gem
-require 'functional-light-service/functional/maybe'
-
-describe "deprecation warnings" do
-  around do |example|
-    FunctionalLightService::Deprecations.silenced = false
-    FunctionalLightService::Deprecations.reset!
-    example.run
-  ensure
-    FunctionalLightService::Deprecations.silenced = true
-    FunctionalLightService::Deprecations.reset!
-  end
-
-  context "when including FunctionalLightService::Organizer" do
-    it "warns on stderr" do
-      expect do
-        class OrganizerIncludingLS
-          include FunctionalLightService::Organizer
-        end
-      end.to output(/Including FunctionalLightService::Organizer is deprecated/).to_stderr
-    end
-  end
-
-  context "when including FunctionalLightService::Action" do
-    it "warns on stderr" do
-      expect do
-        class ActionIncludingLS
-          include FunctionalLightService::Action
-        end
-      end.to output(/Including FunctionalLightService::Action is deprecated/).to_stderr
-    end
-  end
-
-  context "when using Maybe/Null" do
-    it "warns once per process" do
-      expect { Maybe(nil) }
-        .to output(%r{Maybe\(\)/Null are deprecated}).to_stderr
-      # warn-once: la seconda invocazione non emette nulla
-      expect { Maybe(nil) }.not_to output.to_stderr
-    end
-  end
-
-  context "when using the exotic operators" do
-    include FunctionalLightService::Prelude::Result
-
-    it "Result#>= warns and delegates to #try" do
-      result = nil
-      expect { result = Success(1) >= ->(v) { Success(v + 1) } }
-        .to output(/Result#>= is deprecated/).to_stderr
-      expect(result).to eq(Success(2))
-    end
-
-    it "Result#<< warns and delegates to #pipe" do
-      expect { Success(1) << ->(_v) {} }
-        .to output(/Result#<< is deprecated/).to_stderr
-    end
-
-    it "Result#+ warns and still combines" do
-      result = nil
-      expect { result = Success(1) + Success(2) }
-        .to output(/Result#\+ is deprecated/).to_stderr
-      expect(result).to eq(Success(3))
-    end
-
-    it "Option#+ warns and still combines" do
-      some = FunctionalLightService::Option::Some
-      result = nil
-      expect { result = some.new(1) + some.new(2) }
-        .to output(/Option#\+ is deprecated/).to_stderr
-      expect(result).to eq(some.new(3))
-    end
-  end
-
-  context "when silenced" do
-    it "emits nothing" do
-      FunctionalLightService::Deprecations.silenced = true
-      expect { Maybe(nil) }.not_to output.to_stderr
-    end
-  end
-end