light-service 0.15.0 → 0.18.0

data/lib/light-service/context.rb

@@ -6,10 +6,12 @@ module LightService
     FAILURE = 1
   end
 
-  # rubocop:disable ClassLength
+  # rubocop:disable Metrics/ClassLength
   class Context < Hash
-    attr_accessor :message, :error_code, :current_action, :organized_by
+    attr_accessor :message, :error_code, :current_action, :around_actions,
+                  :organized_by
 
+    # rubocop:disable Metrics/ParameterLists, Lint/MissingSuper
     def initialize(context = {},
                    outcome = Outcomes::SUCCESS,
                    message = '',
@@ -21,6 +23,7 @@ module LightService
 
       context.to_hash.each { |k, v| self[k] = v }
     end
+    # rubocop:enable Metrics/ParameterLists, Lint/MissingSuper
 
     def self.make(context = {})
       unless context.is_a?(Hash) || context.is_a?(LightService::Context)
@@ -115,9 +118,9 @@ module LightService
     end
 
     def define_accessor_methods_for_keys(keys)
-      return if keys.nil?
+      return if keys.blank?
 
-      keys.each do |key|
+      Array(keys).each do |key|
         next if respond_to?(key.to_sym)
 
         define_singleton_method(key.to_s) { fetch(key) }
@@ -151,13 +154,8 @@ module LightService
     end
 
     def inspect
-      "#{self.class}(#{self}, " \
-      + "success: #{success?}, " \
-      + "message: #{check_nil(message)}, " \
-      + "error_code: #{check_nil(error_code)}, " \
-      + "skip_remaining: #{@skip_remaining}, " \
-      + "aliases: #{@aliases}" \
-      + ")"
+      "#{self.class}(#{self}, success: #{success?}, message: #{check_nil(message)}, error_code: " \
+        "#{check_nil(error_code)}, skip_remaining: #{@skip_remaining}, aliases: #{@aliases})"
     end
 
     private
@@ -168,5 +166,5 @@ module LightService
       "'#{value}'"
     end
   end
-  # rubocop:enable ClassLength
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/light-service/errors.rb

@@ -1,6 +1,11 @@
 module LightService
   class FailWithRollbackError < StandardError; end
+
   class ExpectedKeysNotInContextError < StandardError; end
+
   class PromisedKeysNotInContextError < StandardError; end
+
   class ReservedKeysInContextError < StandardError; end
+
+  class UnusableExpectKeyDefaultError < StandardError; end
 end

data/lib/light-service/orchestrator.rb

@@ -115,7 +115,7 @@ module LightService
 
       def issue_deprecation_warning_for(method_name)
         msg = "`Orchestrator##{method_name}` is DEPRECATED and will be " \
-          "removed, please switch to `Organizer##{method_name} instead. "
+              "removed, please switch to `Organizer##{method_name} instead. "
         ActiveSupport::Deprecation.warn(msg)
       end
     end

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

@@ -0,0 +1,48 @@
+module LightService
+  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)
+
+        lambda do |ctx|
+          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/light-service/organizer/reduce_if_else.rb

@@ -0,0 +1,21 @@
+module LightService
+  module Organizer
+    class ReduceIfElse
+      extend ScopedReducable
+
+      def self.run(organizer, condition_block, if_steps, else_steps)
+        lambda do |ctx|
+          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/light-service/organizer/with_reducer.rb

@@ -30,17 +30,16 @@ module LightService
       def reduce(*actions)
         raise "No action(s) were provided" if actions.empty?
 
+        @context.around_actions ||= around_each_handler
         actions.flatten!
 
         actions.each_with_object(context) do |action, current_context|
-          begin
-            invoke_action(current_context, action)
-          rescue FailWithRollbackError
-            reduce_rollback(actions)
-          ensure
-            # For logging
-            yield(current_context, action) if block_given?
-          end
+          invoke_action(current_context, action)
+        rescue FailWithRollbackError
+          reduce_rollback(actions)
+        ensure
+          # For logging
+          yield(current_context, action) if block_given?
         end
       end
 
@@ -59,12 +58,10 @@ module LightService
       private
 
       def invoke_action(current_context, action)
-        around_each_handler.call(current_context) do
-          if action.respond_to?(:call)
-            action.call(current_context)
-          else
-            action.execute(current_context)
-          end
+        if action.respond_to?(:call)
+          action.call(current_context)
+        else
+          action.execute(current_context)
         end
       end
 

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

@@ -5,7 +5,7 @@ module LightService
 
       alias logged? logged
 
-      def initialize(organizer, decorated: WithReducer.new, logger:)
+      def initialize(organizer, logger:, decorated: WithReducer.new)
         @decorated = decorated
         @organizer = organizer
 
@@ -22,7 +22,7 @@ module LightService
 
         logger.info do
           "[LightService] -     keys in context: " \
-          "#{extract_keys(decorated.context.keys)}"
+            "#{extract_keys(decorated.context.keys)}"
         end
         self
       end

data/lib/light-service/organizer.rb

@@ -41,10 +41,18 @@ module LightService
         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 iterate(collection_key, steps)
         Iterate.run(self, collection_key, steps)
       end
@@ -65,9 +73,18 @@ module LightService
         @logger
       end
 
-      def add_to_context(**args)
-        args.map do |key, value|
-          execute(->(ctx) { ctx[key.to_sym] = value })
+      # Set the value as a key on the context hash
+      # and also create convenience accessors for the keys
+      def add_to_context(args)
+        Context::ReservedKeysViaOrganizerVerifier.new(args).verify
+
+        Hash(args).map do |key, value|
+          context_key = lambda do |ctx|
+            ctx[key.to_sym] = value
+            ctx.define_accessor_methods_for_keys(key)
+          end
+
+          execute(context_key)
         end
       end
 

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

@@ -26,11 +26,13 @@ module LightService
 
       # 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

data/lib/light-service/version.rb

@@ -1,3 +1,3 @@
 module LightService
-  VERSION = "0.15.0".freeze
+  VERSION = "0.18.0".freeze
 end

data/lib/light-service.rb

@@ -13,7 +13,9 @@ require 'light-service/organizer/with_reducer'
 require 'light-service/organizer/with_reducer_log_decorator'
 require 'light-service/organizer/with_reducer_factory'
 require 'light-service/organizer/reduce_if'
+require 'light-service/organizer/reduce_if_else'
 require 'light-service/organizer/reduce_until'
+require 'light-service/organizer/reduce_case'
 require 'light-service/organizer/iterate'
 require 'light-service/organizer/execute'
 require 'light-service/organizer/with_callback'

data/light-service.gemspec

@@ -15,8 +15,9 @@ Gem::Specification.new do |gem|
   gem.name          = "light-service"
   gem.require_paths = ["lib"]
   gem.version       = LightService::VERSION
+  gem.required_ruby_version = '>= 2.6.0'
 
-  gem.add_runtime_dependency("activesupport", ">= 3.0.0")
+  gem.add_runtime_dependency("activesupport", ">= 4.0.0")
 
   gem.add_development_dependency("generator_spec", "~> 0.9.4")
   gem.add_development_dependency("test-unit", "~> 3.0") # Needed for generator specs.
@@ -24,7 +25,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency("rspec", "~> 3.0")
   gem.add_development_dependency("simplecov", "~> 0.17")
   gem.add_development_dependency("codecov", "~> 0.1")
-  gem.add_development_dependency("rubocop", "~> 0.68.0")
+  gem.add_development_dependency("rubocop", "~> 1.26.0")
   gem.add_development_dependency("rubocop-performance", "~> 1.2.0")
   gem.add_development_dependency("pry", "~> 0.12.2")
 end

data/spec/acceptance/after_actions_spec.rb

@@ -34,14 +34,10 @@ RSpec.describe 'Action after_actions' do
       class AdditionOrganizer
         extend LightService::Organizer
         after_actions (lambda do |ctx|
-                         if ctx.current_action == TestDoubles::AddsOneAction
-                           ctx.number -= 2
-                         end
+                         ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction
                        end),
                       (lambda do |ctx|
-                         if ctx.current_action == TestDoubles::AddsThreeAction
-                           ctx.number -= 3
-                         end
+                         ctx.number -= 3 if ctx.current_action == TestDoubles::AddsThreeAction
                        end)
 
         def self.call(number)
@@ -65,6 +61,21 @@ RSpec.describe 'Action after_actions' do
     end
   end
 
+  context 'with callbacks' do
+    it 'ensures the correct :current_action is set' do
+      TestDoubles::TestWithCallback.after_actions = [
+        lambda do |ctx|
+          ctx.total -= 1000 if ctx.current_action == TestDoubles::IterateCollectionAction
+        end
+      ]
+
+      result = TestDoubles::TestWithCallback.call
+
+      expect(result.counter).to eq(3)
+      expect(result.total).to eq(-994)
+    end
+  end
+
   describe 'after_actions can be appended' do
     it 'adds to the :_after_actions collection' do
       TestDoubles::AdditionOrganizer.append_after_actions(

data/spec/acceptance/around_each_spec.rb

@@ -16,4 +16,19 @@ describe 'Executing arbitrary code around each action' do
       }]
     )
   end
+
+  it 'logs data with nested actions' do
+    context = { :number => 1, :logger => TestDoubles::TestLogger.new }
+
+    result = TestDoubles::AroundEachWithReduceIfOrganizer.call(context)
+
+    expect(result.fetch(:number)).to eq(7)
+    expect(result[:logger].logs).to eq(
+      [
+        { :action => TestDoubles::AddsOneAction, :before => 1, :after => 2 },
+        { :action => TestDoubles::AddsTwoAction, :before => 2, :after => 4 },
+        { :action => TestDoubles::AddsThreeAction, :before => 4, :after => 7 }
+      ]
+    )
+  end
 end

data/spec/acceptance/before_actions_spec.rb

@@ -34,14 +34,10 @@ RSpec.describe 'Action before_actions' do
       class AdditionOrganizer
         extend LightService::Organizer
         before_actions (lambda do |ctx|
-                          if ctx.current_action == TestDoubles::AddsOneAction
-                            ctx.number -= 2
-                          end
+                          ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction
                         end),
                        (lambda do |ctx|
-                          if ctx.current_action == TestDoubles::AddsThreeAction
-                            ctx.number -= 3
-                          end
+                          ctx.number -= 3 if ctx.current_action == TestDoubles::AddsThreeAction
                         end)
 
         def self.call(number)
@@ -69,9 +65,7 @@ RSpec.describe 'Action before_actions' do
     it 'can interact with actions from the outside' do
       TestDoubles::TestWithCallback.before_actions = [
         lambda do |ctx|
-          if ctx.current_action == TestDoubles::AddToTotalAction
-            ctx.total -= 1000
-          end
+          ctx.total -= 1000 if ctx.current_action == TestDoubles::AddToTotalAction
         end
       ]
       result = TestDoubles::TestWithCallback.call

data/spec/acceptance/log_from_organizer_spec.rb

@@ -59,7 +59,7 @@ describe "Logs from organizer" do
       expect(log_message).to include(organizer_log_message)
     end
 
-    it "lists the keys in contect after the actions are executed" do
+    it "lists the keys in context after the actions are executed" do
       organizer_log_message = "[LightService] -     keys in context: " \
                               ":tea, :milk, :coffee, :milk_tea, :latte"
       expect(log_message).to include(organizer_log_message)

data/spec/acceptance/organizer/add_to_context_spec.rb

@@ -20,6 +20,20 @@ RSpec.describe LightService::Organizer do
     end
   end
 
+  class TestAddToContextReservedWords
+    extend LightService::Organizer
+
+    def self.call(context = LightService::Context.make)
+      with(context).reduce(steps)
+    end
+
+    def self.steps
+      [
+        add_to_context(:message => "yo", "error_code" => "00P5")
+      ]
+    end
+  end
+
   it 'adds items to the context on the fly' do
     result = TestAddToContext.call
 
@@ -27,4 +41,17 @@ RSpec.describe LightService::Organizer do
     expect(result.number).to eq(1)
     expect(result[:something]).to eq('hello')
   end
+
+  it 'adds items to the context as accessors' do
+    result = TestAddToContext.call
+
+    expect(result).to be_success
+    expect(result.something).to eq('hello')
+  end
+
+  it "will not add items as accessors when they are reserved" do
+    expect { TestAddToContextReservedWords.call }.to \
+      raise_error(LightService::ReservedKeysInContextError)
+      .with_message(/:message, :error_code/)
+  end
 end

data/spec/acceptance/organizer/execute_with_add_to_context_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  class TestExecuteWithAddToContext
+    extend LightService::Organizer
+
+    def self.call
+      with.reduce(steps)
+    end
+
+    def self.steps
+      [
+        add_to_context(:greeting => "hello"),
+        execute(->(ctx) { ctx.greeting.upcase! })
+      ]
+    end
+  end
+
+  context "when using context values created by add_to_context" do
+    it "is expected to reference them as accessors" do
+      result = TestExecuteWithAddToContext.call
+
+      expect(result).to be_a_success
+      expect(result.greeting).to eq "HELLO"
+    end
+  end
+end

data/spec/acceptance/organizer/reduce_case_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  class TestReduceCase
+    extend LightService::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
+end

data/spec/acceptance/organizer/reduce_if_else_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  class TestReduceIfElse
+    extend LightService::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) { LightService::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_if_spec.rb

@@ -63,6 +63,7 @@ RSpec.describe LightService::Organizer do
         reduce(actions)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def self.actions
         [
           reduce_if(
@@ -76,6 +77,7 @@ RSpec.describe LightService::Organizer do
           execute(->(c) { c[:last_outside] = true })
         ]
       end
+      # rubocop:enable Metrics/AbcSize
     end
 
     result = org.call