functional-light-service 6.1.0 → 6.2.0

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.1.0"
+  VERSION = "6.2.0"
 end

data/lib/functional-light-service.rb

@@ -15,7 +15,9 @@ 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'
@@ -23,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

data/spec/acceptance/skip_all_remaining_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+RSpec.describe "skip_all_remaining!" do
+  context "with regular organizer" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            execute(->(c) { c[:first] = true }),
+            execute(lambda(&:skip_all_remaining!)),
+            execute(->(c) { c[:second] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions" do
+      result = organizer.call(FunctionalLightService::Context.make)
+
+      expect(result[:first]).to be true
+      expect(result[:second]).to be_nil
+    end
+  end
+
+  context "with an organizer with a reducer" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                execute(->(c) { c[:first_inside] = true }),
+                execute(lambda(&:skip_all_remaining!)),
+                execute(->(c) { c[:second_inside] = true })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions inside and outside the reducer" do
+      result = organizer.call(FunctionalLightService::Context.make)
+
+      expect(result[:first_inside]).to be true
+      expect(result[:second_inside]).to be_nil
+      expect(result[:outside]).to be_nil
+    end
+  end
+
+  context "with a message" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                execute(->(c) { c.skip_all_remaining!("Skipping with message") })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "preserves the message when exiting scoped reducers" do
+      result = organizer.call(FunctionalLightService::Context.make)
+
+      expect(result.message).to eq("Skipping with message")
+      expect(result[:outside]).to be_nil
+    end
+  end
+
+  context "with an organizer with nested reducers" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                iterate(:items, [
+                          execute(->(c) {
+                            c[:executed_items] ||= []
+                            c[:executed_items] << c[:item]
+                          }),
+                          execute(->(c) { c.skip_all_remaining! if c[:item] == 2 }),
+                          execute(->(c) {
+                            c[:skipped_in_iterate] ||= []
+                            c[:skipped_in_iterate] << c[:item]
+                          })
+                        ]),
+                execute(->(c) { c[:after_iterate_inside_if] = true })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions across all nested scopes" do
+      result = organizer.call(FunctionalLightService::Context.make(:items => [1, 2, 3]))
+
+      expect(result[:executed_items]).to eq([1, 2])
+      expect(result[:skipped_in_iterate]).to eq([1])
+      expect(result[:after_iterate_inside_if]).to be_nil
+      expect(result[:outside]).to be_nil
+    end
+  end
+end

data/spec/action_optional_expected_keys_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe ":expects macro using defaults" do
+  context "when all expected keys are supplied" do
+    it "is expected to ignore default values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :second_number => 5,
+        :third_number => 7
+      )
+
+      expect(outcome.total).to eq 15
+    end
+  end
+
+  context "when defaults are supplied" do
+    it "is expected to use static values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :second_number => 7
+      )
+
+      expect(outcome.total).to eq 20
+    end
+
+    it "is expected to use dynamic values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :third_number => 5
+      )
+
+      expect(outcome.total).to eq 18
+    end
+
+    it "is expected to process defaults in their defined order" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :third_number => 5,
+        :first_number => 3
+      )
+
+      expect(outcome.total).to eq 18
+    end
+
+    it "is expected to use all defaults if required" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3
+      )
+
+      expect(outcome.total).to eq 23
+    end
+  end
+
+  context "when used within an organizer" do
+    it "is expected to process required defaults" do
+      outcome = TestDoubles::OrganizerWithActionsUsingDefaults.call
+
+      expect(outcome.total).to eq 20
+    end
+  end
+
+  context "when the expected key is satisfied through an alias" do
+    it "is expected to not apply the default" do
+      action = Class.new do
+        extend FunctionalLightService::Action
+
+        expects  :greeting, :default => "hello"
+        promises :greeted
+
+        executed do |ctx|
+          ctx.greeted = ctx.greeting
+        end
+      end
+
+      organizer = Class.new do
+        extend FunctionalLightService::Organizer
+
+        aliases :salutation => :greeting
+      end
+
+      outcome = organizer.with(:salutation => "ciao").reduce([action])
+
+      expect(outcome.greeted).to eq "ciao"
+    end
+  end
+
+  context "when defaults are misconfigured" do
+    it "is expected to raise an exception" do
+      expect do
+        # Needs to be specified in the block
+        # as error is raised at define time
+        class AddsNumbersWithIncorrectDefaults
+          extend FunctionalLightService::Action
+
+          expects  :first,  :default => 10 # This one is fine. Other two arent
+          expects  :second, :defalut => ->(ctx) { ctx[:first] + 7 }
+          expects  :third,  :deafult => 10
+          promises :total
+
+          executed do |ctx|
+            ctx.total = ctx.first + ctx.second + ctx.third
+          end
+        end
+      end.to raise_error(FunctionalLightService::UnusableExpectKeyDefaultError)
+    end
+  end
+end

data/spec/context/inspect_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe FunctionalLightService::Context do
     it 'inspects the hash with all the fields' do
       inspected_context =
         "FunctionalLightService::Context({}, success: true, message: '', error_code: nil, " \
-        "skip_remaining: false, aliases: {})"
+        "skip_remaining: false, skip_all_remaining: false, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end
@@ -24,7 +24,7 @@ RSpec.describe FunctionalLightService::Context do
 
       inspected_context =
         "FunctionalLightService::Context({}, success: false, message: 'There was an error', " \
-        "error_code: nil, skip_remaining: false, aliases: {})"
+        "error_code: nil, skip_remaining: false, skip_all_remaining: false, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end
@@ -34,7 +34,17 @@ RSpec.describe FunctionalLightService::Context do
 
       inspected_context =
         "FunctionalLightService::Context({}, success: true, message: 'No need to process', " \
-        "error_code: nil, skip_remaining: true, aliases: {})"
+        "error_code: nil, skip_remaining: true, skip_all_remaining: false, aliases: {})"
+
+      expect(context.inspect).to eq(inspected_context)
+    end
+
+    it 'prints skip_all_remaining' do
+      context.skip_all_remaining!('Nothing else to process')
+
+      inspected_context =
+        "FunctionalLightService::Context({}, success: true, message: 'Nothing else to process', " \
+        "error_code: nil, skip_remaining: false, skip_all_remaining: true, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end

data/spec/context_spec.rb

@@ -198,6 +198,18 @@ RSpec.describe FunctionalLightService::Context do
       expect { action.execute(:_before_actions => []) }
         .to raise_error(FunctionalLightService::ReservedKeysInContextError)
     end
+
+    it "rejects :organized_by in expects/promises" do
+      action = Class.new do
+        extend FunctionalLightService::Action
+
+        expects :organized_by
+        executed { |_ctx| } # rubocop:disable Lint/EmptyBlock
+      end
+
+      expect { action.execute(:organized_by => Object) }
+        .to raise_error(FunctionalLightService::ReservedKeysInContextError)
+    end
   end
 
   describe "#fail! does not mutate the caller's options hash" do