light-service 0.8.4 → 0.10.0

data/lib/light-service/organizer.rb

@@ -17,8 +17,19 @@ module LightService
     # In case this module is included
     module ClassMethods
       def with(data = {})
-        VerifyCallMethodExists.call(self, caller(1..1).first)
+        VerifyCallMethodExists.run(self, caller(1..1).first)
         data[:_aliases] = @aliases if @aliases
+
+        if @before_actions
+          data[:_before_actions] = @before_actions.dup
+          @before_actions = nil
+        end
+
+        if @after_actions
+          data[:_after_actions] = @after_actions.dup
+          @after_actions = nil
+        end
+
         WithReducerFactory.make(self).with(data)
       end
 
@@ -26,29 +37,24 @@ module LightService
         with({}).reduce(actions)
       end
 
-      # We need to make sure existing users will
-      # use `call` method name going forward.
-      # This should be removed eventually.
-      class VerifyCallMethodExists
-        def self.call(klass, first_caller = '')
-          invoker_method = caller_method(first_caller)
-          return if invoker_method == 'call'
+      def reduce_if(condition_block, steps)
+        ReduceIf.run(self, condition_block, steps)
+      end
 
-          call_method_exists = klass.methods.include?(:call)
-          return if call_method_exists
+      def reduce_until(condition_block, steps)
+        ReduceUntil.run(self, condition_block, steps)
+      end
 
-          warning_msg = "The <#{klass.name}> class is an organizer, " \
-                        "its entry method (the one that calls with & reduce) " \
-                        "should be named `call`. " \
-                        "Please use #{klass}.call going forward."
-          ActiveSupport::Deprecation.warn(warning_msg)
-        end
+      def iterate(collection_key, steps)
+        Iterate.run(self, collection_key, steps)
+      end
 
-        def self.caller_method(first_caller)
-          return nil unless first_caller =~ /`(.*)'/
+      def execute(code_block)
+        Execute.run(code_block)
+      end
 
-          Regexp.last_match[1]
-        end
+      def with_callback(action, steps)
+        WithCallback.run(self, action, steps)
       end
     end
 
@@ -56,6 +62,22 @@ module LightService
       def aliases(key_hash)
         @aliases = key_hash
       end
+
+      def before_actions(*logic)
+        self.before_actions = logic
+      end
+
+      def before_actions=(logic)
+        @before_actions = [logic].flatten
+      end
+
+      def after_actions(*logic)
+        self.after_actions = logic
+      end
+
+      def after_actions=(logic)
+        @after_actions = [logic].flatten
+      end
     end
   end
 end

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

@@ -0,0 +1,14 @@
+module LightService
+  module Organizer
+    class Execute
+      def self.run(code_block)
+        lambda do |ctx|
+          return ctx if ctx.stop_processing?
+
+          code_block.call(ctx)
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module LightService
+  module Organizer
+    class Iterate
+      extend ScopedReducable
+
+      def self.run(organizer, collection_key, steps)
+        lambda do |ctx|
+          return ctx if ctx.stop_processing?
+
+          collection = ctx[collection_key]
+          item_key = collection_key.to_s.singularize.to_sym
+          collection.each do |item|
+            ctx[item_key] = item
+            ctx = scoped_reduce(organizer, ctx, steps)
+          end
+
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module LightService
+  module Organizer
+    class ReduceIf
+      extend ScopedReducable
+
+      def self.run(organizer, condition_block, steps)
+        lambda do |ctx|
+          return ctx if ctx.stop_processing?
+
+          ctx = scoped_reduce(organizer, ctx, steps) \
+                  if condition_block.call(ctx)
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module LightService
+  module Organizer
+    class ReduceUntil
+      extend ScopedReducable
+
+      def self.run(organizer, condition_block, steps)
+        lambda do |ctx|
+          return ctx if ctx.stop_processing?
+
+          loop do
+            ctx = scoped_reduce(organizer, ctx, steps)
+            break if condition_block.call(ctx) || ctx.failure?
+          end
+
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module LightService
+  module Organizer
+    module ScopedReducable
+      def scoped_reduce(organizer, ctx, steps)
+        ctx.reset_skip_remaining! unless ctx.failure?
+        ctx = organizer.with(ctx).reduce([steps])
+        ctx.reset_skip_remaining! unless ctx.failure?
+
+        ctx
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module LightService
+  module Organizer
+    # We need to make sure existing users will
+    # use `call` method name going forward.
+    # This should be removed eventually.
+    class VerifyCallMethodExists
+      def self.run(klass, first_caller = '')
+        invoker_method = caller_method(first_caller)
+        return if invoker_method == 'call'
+
+        call_method_exists = klass.methods.include?(:call)
+        return if call_method_exists
+
+        warning_msg = "The <#{klass.name}> class is an organizer, " \
+                      "its entry method (the one that calls with & reduce) " \
+                      "should be named `call`. " \
+                      "Please use #{klass}.call going forward."
+        ActiveSupport::Deprecation.warn(warning_msg)
+      end
+
+      def self.caller_method(first_caller)
+        return nil unless first_caller =~ /`(.*)'/
+
+        Regexp.last_match[1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module LightService
+  module Organizer
+    class WithCallback
+      extend ScopedReducable
+
+      def self.run(organizer, action, steps)
+        lambda do |ctx|
+          return ctx if ctx.stop_processing?
+
+          # This will only allow 2 level deep nesting of callbacks
+          previous_callback = ctx[:callback]
+
+          ctx[:callback] = lambda do |context|
+            ctx = scoped_reduce(organizer, context, steps)
+            ctx
+          end
+
+          ctx = action.execute(ctx)
+          ctx[:callback] = previous_callback
+
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 module LightService
   module Organizer
     class WithReducer
-      attr_reader :context, :around_each_handler
+      attr_reader :context
 
       def with(data = {})
         @context = LightService::Context.make(data)
@@ -13,6 +13,14 @@ module LightService
         self
       end
 
+      def around_each_handler
+        @around_each_handler ||= Class.new do
+          def self.call(_context)
+            yield
+          end
+        end
+      end
+
       def reduce(*actions)
         raise "No action(s) were provided" if actions.empty?
         actions.flatten!
@@ -46,10 +54,12 @@ module LightService
       private
 
       def invoke_action(current_context, action)
-        return action.execute(current_context) unless around_each_handler
-
         around_each_handler.call(current_context) do
-          action.execute(current_context)
+          if action.respond_to?(:call)
+            action.call(current_context)
+          else
+            action.execute(current_context)
+          end
         end
       end
 

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

@@ -3,7 +3,9 @@ module LightService
     class WithReducerFactory
       def self.make(monitored_organizer)
         if LightService::Configuration.logger.nil?
+          # :nocov:
           WithReducer.new
+          # :nocov:
         else
           WithReducerLogDecorator.new(monitored_organizer, WithReducer.new)
         end

data/lib/light-service/version.rb

@@ -1,3 +1,3 @@
 module LightService
-  VERSION = "0.8.4".freeze
+  VERSION = "0.10.0".freeze
 end

data/light-service.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency("activesupport", ">= 3.0")
 
   gem.add_development_dependency("rspec", "~> 3.0")
-  gem.add_development_dependency("simplecov", "~> 0.14.1")
-  gem.add_development_dependency("rubocop", "~> 0.51")
+  gem.add_development_dependency("simplecov", "~> 0.16.1")
+  gem.add_development_dependency("rubocop", "~> 0.53")
   gem.add_development_dependency("pry", "~> 0.10")
 end

data/resources/orchestrators_deprecated.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" 
+     xmlns="http://www.w3.org/2000/svg"
+     xmlns:xlink="http://www.w3.org/1999/xlink"
+     width="350" height="20"
+>
+  <text font-size="20" x="0" y="20" font-family="Verdana">
+    <tspan fill="red">Orchestrators are DEPRECATED!</tspan>
+  </text>
+</svg>

data/spec/acceptance/add_numbers_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 require 'test_doubles'
 
-describe TestDoubles::AdditionOrganizer do
-  it "Adds 1, 2 and 3 to the initial value of 1" do
+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(:product)
+    number = result.fetch(:number)
 
     expect(number).to eq(7)
   end

data/spec/acceptance/after_actions_spec.rb

@@ -0,0 +1,67 @@
+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 =
+        lambda do |ctx|
+          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 = [
+        lambda do |ctx|
+          ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction
+        end
+      ]
+
+      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 LightService::Organizer
+        after_actions (lambda do |ctx|
+                         if ctx.current_action == TestDoubles::AddsOneAction
+                           ctx.number -= 2
+                         end
+                       end),
+                      (lambda do |ctx|
+                         if ctx.current_action == TestDoubles::AddsThreeAction
+                           ctx.number -= 3
+                         end
+                       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
+end

data/spec/acceptance/before_actions_spec.rb

@@ -0,0 +1,109 @@
+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 =
+        lambda do |ctx|
+          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 = [
+        lambda do |ctx|
+          ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction
+        end
+      ]
+
+      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 LightService::Organizer
+        before_actions (lambda do |ctx|
+                          if ctx.current_action == TestDoubles::AddsOneAction
+                            ctx.number -= 2
+                          end
+                        end),
+                       (lambda do |ctx|
+                          if ctx.current_action == TestDoubles::AddsThreeAction
+                            ctx.number -= 3
+                          end
+                        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 = [
+        lambda do |ctx|
+          if ctx.current_action == TestDoubles::AddToTotalAction
+            ctx.total -= 1000
+          end
+        end
+      ]
+      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 = [
+        lambda do |ctx|
+          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