functional-light-service 6.0.0 → 6.2.0

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

@@ -1,48 +1,39 @@
 # frozen_string_literal: true
 
-require 'i18n'
+require 'dry/inflector'
 
 module FunctionalLightService
+  # Adapter built-in basato su LocalizationMap: nessuna dipendenza da I18n.
+  # Viene selezionato da Configuration quando la costante ::I18n non esiste
   class LocalizationAdapter
-    def failure(message_or_key, action_class, i18n_options = {})
+    INFLECTOR = Dry::Inflector.new
+
+    def failure(message_or_key, action_class, options = {})
       find_translated_message(message_or_key,
-                              action_class,
-                              i18n_options,
-                              :type => :failure)
+                              INFLECTOR.underscore(action_class.to_s),
+                              options.merge(:type => :failures))
     end
 
-    def success(message_or_key, action_class, i18n_options = {})
+    def success(message_or_key, action_class, options = {})
       find_translated_message(message_or_key,
-                              action_class,
-                              i18n_options,
-                              :type => :success)
+                              INFLECTOR.underscore(action_class.to_s),
+                              options.merge(:type => :successes))
     end
 
     private
 
-    def find_translated_message(message_or_key,
-                                action_class,
-                                i18n_options,
-                                type)
+    def find_translated_message(message_or_key, action_class, options)
       if message_or_key.is_a?(Symbol)
-        translate(message_or_key, action_class, i18n_options.merge(type))
+        FunctionalLightService::LocalizationMap.instance.dig(
+          FunctionalLightService::Configuration.locale,
+          action_class.to_sym,
+          :light_service,
+          options[:type],
+          message_or_key
+        )
       else
         message_or_key
       end
     end
-
-    def translate(key, action_class, options = {})
-      type = options.delete(:type)
-
-      scope = i18n_scope_from_class(action_class, type)
-      options[:scope] = scope
-
-      I18n.t(key, **options)
-    end
-
-    def i18n_scope_from_class(action_class, type)
-      inflector = Dry::Inflector.new
-      "#{inflector.underscore(action_class.name)}.light_service.#{inflector.pluralize(type)}"
-    end
   end
 end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module FunctionalLightService
+  class LocalizationMap < Hash
+    include ::Singleton
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Organizer
+    class ReduceCase
+      extend ScopedReducable
+
+      class Arguments
+        attr_reader :value, :when, :else
+
+        def initialize(**args)
+          validate_arguments(**args)
+          @value = args[:value]
+          @when = args[:when]
+          @else = args[:else]
+        end
+
+        private
+
+        # rubocop:disable Style/MultilineIfModifier
+        def validate_arguments(**args)
+          raise(
+            ArgumentError,
+            "Expected keyword arguments: [:value, :when, :else]. Given: #{args.keys}"
+          ) unless args.keys.intersection(mandatory_arguments).count == mandatory_arguments.count
+        end
+        # rubocop:enable Style/MultilineIfModifier
+
+        def mandatory_arguments
+          %i[value when else]
+        end
+      end
+
+      def self.run(organizer, **args)
+        arguments = Arguments.new(**args)
+
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          matched_case = arguments.when.keys.find { |k| k.eql?(ctx[arguments.value]) }
+          steps = arguments.when[matched_case] || arguments.else
+
+          ctx = scoped_reduce(organizer, ctx, steps)
+
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Organizer
+    class ReduceIfElse
+      extend ScopedReducable
+
+      def self.run(organizer, condition_block, if_steps, else_steps)
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          ctx = if condition_block.call(ctx)
+                  scoped_reduce(organizer, ctx, if_steps)
+                else
+                  scoped_reduce(organizer, ctx, else_steps)
+                end
+
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module FunctionalLightService
 
           loop do
             ctx = scoped_reduce(organizer, ctx, steps)
-            break if condition_block.call(ctx) || ctx.failure?
+            break if condition_block.call(ctx) || ctx.stop_processing?
           end
 
           ctx

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Organizer
+    class ReduceWhile
+      def self.run(organizer, condition_block, steps)
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          reset_skip(ctx)
+
+          Array(steps).each do |step|
+            break unless condition_block.call(ctx)
+
+            ctx = organizer.with(ctx).reduce([step])
+            break if ctx.stop_processing?
+          end
+
+          reset_skip(ctx)
+
+          ctx
+        end
+      end
+
+      def self.reset_skip(ctx)
+        ctx.reset_skip_remaining! unless ctx.failure? || ctx.skip_all_remaining?
+      end
+      private_class_method :reset_skip
+    end
+  end
+end

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

@@ -4,9 +4,9 @@ module FunctionalLightService
   module Organizer
     module ScopedReducable
       def scoped_reduce(organizer, ctx, steps)
-        ctx.reset_skip_remaining! unless ctx.failure?
+        ctx.reset_skip_remaining! unless ctx.failure? || ctx.skip_all_remaining?
         ctx = organizer.with(ctx).reduce([steps])
-        ctx.reset_skip_remaining! unless ctx.failure?
+        ctx.reset_skip_remaining! unless ctx.failure? || ctx.skip_all_remaining?
 
         ctx
       end

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

@@ -93,7 +93,8 @@ module FunctionalLightService
       end
 
       def skip_remaining?(context)
-        context.respond_to?(:skip_remaining?) && context.skip_remaining?
+        (context.respond_to?(:skip_remaining?) && context.skip_remaining?) ||
+          (context.respond_to?(:skip_all_remaining?) && context.skip_all_remaining?)
       end
 
       def write_skip_remaining_log(context, action)

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

@@ -36,16 +36,28 @@ module FunctionalLightService
         ReduceIf.run(self, condition_block, steps)
       end
 
+      def reduce_if_else(condition_block, if_steps, else_steps)
+        ReduceIfElse.run(self, condition_block, if_steps, else_steps)
+      end
+
       def reduce_until(condition_block, steps)
         ReduceUntil.run(self, condition_block, steps)
       end
 
+      def reduce_case(**args)
+        ReduceCase.run(self, **args)
+      end
+
+      def reduce_while(condition_block, steps)
+        ReduceWhile.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)
+      def execute(code_block = nil, &block)
+        Execute.run(code_block || block)
       end
 
       def with_callback(action, steps)
@@ -62,7 +74,10 @@ module FunctionalLightService
 
       def add_to_context(**args)
         args.map do |key, value|
-          execute(->(ctx) { ctx[key.to_sym] = value })
+          execute(->(ctx) do
+            ctx[key.to_sym] = value
+            ctx.define_accessor_methods_for_keys([key])
+          end)
         end
       end
 

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FunctionalLightService
-  VERSION = "6.0.0"
+  VERSION = "6.2.0"
 end

data/lib/functional-light-service.rb

@@ -12,9 +12,12 @@ 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/i18n/localization_adapter'
 require 'functional-light-service/localization_adapter'
+require 'functional-light-service/localization_map'
 require 'functional-light-service/context'
 require 'functional-light-service/context/key_verifier'
 require 'functional-light-service/organizer/scoped_reducable'
@@ -22,7 +25,10 @@ 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_if_else'
+require 'functional-light-service/organizer/reduce_case'
 require 'functional-light-service/organizer/reduce_until'
+require 'functional-light-service/organizer/reduce_while'
 require 'functional-light-service/organizer/iterate'
 require 'functional-light-service/organizer/execute'
 require 'functional-light-service/organizer/with_callback'

data/spec/acceptance/organizer/add_to_context_spec.rb

@@ -27,4 +27,28 @@ RSpec.describe FunctionalLightService::Organizer do
     expect(result.number).to eq(1)
     expect(result[:something]).to eq("hello")
   end
+
+  it "defines accessors for the added keys" do
+    result = TestAddToContext.call
+
+    expect(result.something).to eq("hello")
+  end
+
+  it "raises when the added key conflicts with a Context method" do
+    organizer = Class.new do
+      extend FunctionalLightService::Organizer
+
+      def self.call
+        reduce(steps)
+      end
+
+      def self.steps
+        [add_to_context(:message => "boom")]
+      end
+    end
+
+    expect { organizer.call }
+      .to raise_error(FunctionalLightService::ReservedKeysInContextError,
+                      /:message conflicts/)
+  end
 end

data/spec/acceptance/organizer/context_failure_and_skipping_spec.rb

@@ -31,6 +31,21 @@ RSpec.describe FunctionalLightService::Organizer do
     end
   end
 
+  class TestSkipAllFromNestedScope
+    extend FunctionalLightService::Organizer
+
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  reduce_if(->(_ctx) { true }, [
+                              TestDoubles::AddsOneAction,
+                              execute(lambda(&:skip_all_remaining!))
+                            ]),
+                  TestDoubles::AddsOneAction
+                ])
+    end
+  end
+
   class TestContextFailure
     extend FunctionalLightService::Organizer
 
@@ -59,6 +74,13 @@ RSpec.describe FunctionalLightService::Organizer do
     expect(result[:number]).to eq(3)
   end
 
+  it 'does not reset skip_all_remaining at the end of a nested scope' do
+    result = TestSkipAllFromNestedScope.call
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
+
   it 'respects failure across all nestings' do
     result = TestContextFailure.call
 

data/spec/acceptance/organizer/execute_spec.rb

@@ -43,4 +43,25 @@ RSpec.describe FunctionalLightService::Organizer do
     result = TestExecute.call(empty_context)
     expect(result).to be_success
   end
+
+  it 'accepts a block instead of a lambda' do
+    organizer = Class.new do
+      extend FunctionalLightService::Organizer
+
+      def self.call(context)
+        with(context).reduce(steps)
+      end
+
+      def self.steps
+        [
+          execute { |ctx| ctx[:number] += 1 }
+        ]
+      end
+    end
+
+    result = organizer.call(:number => 1)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
 end

data/spec/acceptance/organizer/reduce_case_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::Organizer do
+  class TestReduceCase
+    extend FunctionalLightService::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        reduce_case(
+          :value => :incr_num,
+          :when => {
+            :one => [TestDoubles::AddsOneAction],
+            :two => [TestDoubles::AddsTwoAction],
+            :three => [TestDoubles::AddsThreeAction]
+          },
+          :else => [TestDoubles::FailureAction]
+        )
+      ]
+    end
+  end
+
+  it 'adds one if the incr_num is one' do
+    result = TestReduceCase.call(:number => 0, :incr_num => :one)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(1)
+  end
+
+  it 'adds two if the incr_num is two' do
+    result = TestReduceCase.call(:number => 0, :incr_num => :two)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
+
+  it 'adds three if the incr_num is three' do
+    result = TestReduceCase.call(:number => 0, :incr_num => :three)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'will fail if the incr_num is neither one, two, or three' do
+    result = TestReduceCase.call(:number => 0, :incr_num => :four)
+
+    expect(result).to be_failure
+  end
+
+  it 'raises ArgumentError when a mandatory keyword argument is missing' do
+    expect do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.actions
+          [reduce_case(:value => :incr_num, :when => {})]
+        end
+      end.actions
+    end.to raise_error(ArgumentError, /Expected keyword arguments/)
+  end
+end

data/spec/acceptance/organizer/reduce_if_else_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::Organizer do
+  class TestReduceIfElse
+    extend FunctionalLightService::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        TestDoubles::AddsOneAction,
+        reduce_if_else(
+          ->(ctx) { ctx.number == 1 },
+          [TestDoubles::AddsOneAction],
+          [TestDoubles::AddsTwoAction]
+        )
+      ]
+    end
+  end
+
+  let(:empty_context) { FunctionalLightService::Context.make }
+
+  it 'reduces the if_steps if the condition is true' do
+    result = TestReduceIfElse.call(:number => 0)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
+
+  it 'reduces the else_steps if the condition is false' do
+    result = TestReduceIfElse.call(:number => 2)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(5)
+  end
+
+  it 'will not reduce over a failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestReduceIfElse.call(empty_context)
+
+    expect(result).to be_failure
+  end
+
+  it 'does not reduce over a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestReduceIfElse.call(empty_context)
+    expect(result).to be_success
+  end
+
+  it "knows that it's being conditionally reduced from within an organizer" do
+    result = TestReduceIfElse.call(:number => 2)
+
+    expect(result.organized_by).to eq TestReduceIfElse
+  end
+end

data/spec/acceptance/organizer/reduce_while_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::Organizer do
+  class TestReduceWhile
+    extend FunctionalLightService::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        reduce_while(->(ctx) { ctx[:number] < 3 }, [
+                       TestDoubles::AddsOneAction,
+                       TestDoubles::AddsTwoAction
+                     ])
+      ]
+    end
+  end
+
+  let(:empty_context) { FunctionalLightService::Context.make }
+
+  it 'reduces while the block evaluates to true' do
+    result = TestReduceWhile.call(:number => 0)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'checks the condition before each action' do
+    result = TestReduceWhile.call(:number => 2)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'does not execute any steps when the condition is false from the start' do
+    result = TestReduceWhile.call(:number => 5)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(5)
+  end
+
+  it 'does not execute on failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestReduceWhile.call(empty_context)
+    expect(result).to be_failure
+  end
+
+  it 'does not execute a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestReduceWhile.call(empty_context)
+    expect(result).to be_success
+  end
+
+  it "is expected to know its organizer when reducing while a condition" do
+    result = TestReduceWhile.call(:number => 0)
+
+    expect(result.organized_by).to eq TestReduceWhile
+  end
+
+  it 'skips actions within its own scope' do
+    org = Class.new do
+      extend FunctionalLightService::Organizer
+
+      def self.call
+        reduce(actions)
+      end
+
+      def self.actions
+        [
+          reduce_while(
+            ->(c) { !c.nil? },
+            [
+              execute(->(c) { c[:first_reduce_while] = true }),
+              execute(lambda(&:skip_remaining!)),
+              execute(->(c) { c[:second_reduce_while] = true })
+            ]
+          ),
+          execute(->(c) { c[:last_outside] = true })
+        ]
+      end
+    end
+
+    result = org.call
+
+    aggregate_failures do
+      expect(result[:first_reduce_while]).to be true
+      expect(result[:second_reduce_while]).to be_nil
+      expect(result[:last_outside]).to be true
+    end
+  end
+end