light-service 0.6.0 → 0.6.1

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

@@ -1,50 +1,64 @@
-module LightService; module Organizer
-  class WithReducer
-    attr_reader :context
+module LightService
+  module Organizer
+    class WithReducer
+      attr_reader :context, :around_each_handler
 
-    def with(data = {})
-      @context = LightService::Context.make(data)
-      self
-    end
-
-    def reduce(*actions)
-      raise "No action(s) were provided" if actions.empty?
-      actions.flatten!
-
-      actions.reduce(context) do |current_context, action|
-        begin
-          result = action.execute(current_context)
-        rescue FailWithRollbackError
-          result = reduce_rollback(actions)
-        ensure
-          # For logging
-          yield(current_context, action) if block_given?
-        end
+      def with(data = {})
+        @context = LightService::Context.make(data)
+        self
+      end
 
-        result
+      def around_each(handler)
+        @around_each_handler = handler
+        self
       end
-    end
 
-    def reduce_rollback(actions)
-      reversable_actions(actions)
-        .reverse
-        .reduce(context) do |context, action|
-          if action.respond_to?(:rollback)
-            action.rollback(context)
-          else
-            context
+      def reduce(*actions)
+        fail "No action(s) were provided" if actions.empty?
+        actions.flatten!
+
+        actions.reduce(context) do |current_context, action|
+          begin
+            result = invoke_action(current_context, action)
+          rescue FailWithRollbackError
+            result = reduce_rollback(actions)
+          ensure
+            # For logging
+            yield(current_context, action) if block_given?
           end
+
+          result
         end
-    end
+      end
 
-    private
+      def reduce_rollback(actions)
+        reversable_actions(actions)
+          .reverse
+          .reduce(context) do |context, action|
+            if action.respond_to?(:rollback)
+              action.rollback(context)
+            else
+              context
+            end
+          end
+      end
 
-    def reversable_actions(actions)
-      index_of_current_action = actions.index(@context.current_action) || 0
+      private
 
-      # Reverse from the point where the fail was triggered
-      actions.take(index_of_current_action + 1)
-    end
+      def invoke_action(current_context, action)
+        return action.execute(current_context) unless around_each_handler
 
+        around_each_handler.call(action, current_context) do
+          action.execute(current_context)
+        end
+      end
+
+      def reversable_actions(actions)
+        index_of_current_action = actions.index(@context.current_action) || 0
+
+        # Reverse from the point where the fail was triggered
+        actions.take(index_of_current_action + 1)
+      end
+    end
   end
-end; end
+end

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

@@ -2,11 +2,10 @@ module LightService
   module Organizer
     class WithReducerFactory
       def self.make(monitored_organizer)
-        if (LightService::Configuration.logger.nil?)
-          ::LightService::Organizer::WithReducer.new
+        if LightService::Configuration.logger.nil?
+          WithReducer.new
         else
-          ::LightService::Organizer::WithReducerLogDecorator.new(
-            ::LightService::Organizer::WithReducer.new, monitored_organizer)
+          WithReducerLogDecorator.new(monitored_organizer, WithReducer.new)
         end
       end
     end

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

@@ -1,69 +1,99 @@
-module LightService; module Organizer
-  class WithReducerLogDecorator
-    attr_reader :logged, :logger, :decorated, :organizer
+module LightService
+  module Organizer
+    class WithReducerLogDecorator
+      attr_reader :logged, :logger, :decorated, :organizer
 
-    alias_method :logged?, :logged
+      alias logged? logged
 
-    def initialize(decorated = WithReducer.new, organizer)
-      @decorated, @organizer = decorated, organizer
-      @logger = ::LightService::Configuration.logger
-      @logged = false
-    end
+      def initialize(organizer, decorated = WithReducer.new)
+        @decorated = decorated
+        @organizer = organizer
+        @logger = LightService::Configuration.logger
+        @logged = false
+      end
 
-    def with(data = {})
-      logger.info("[LightService] - calling organizer <#{organizer.to_s}>")
+      def with(data = {})
+        logger.info("[LightService] - calling organizer <#{organizer}>")
 
-      decorated.with(data)
+        decorated.with(data)
 
-      logger.info("[LightService] -     keys in context: #{extract_keys(decorated.context.keys)}")
-      self
-    end
+        logger.info("[LightService] -     keys in context: " \
+                    "#{extract_keys(decorated.context.keys)}")
+        self
+      end
 
-    def reduce(*actions)
-      decorated.reduce(*actions) do |context, action|
-        next if logged?
-        if has_failure?(context)
-          write_failure_log(context, action) and next
-        end
-        if skip_all?(context)
-          write_skip_all_log(context, action) and next
-        end
+      def around_each(handler)
+        decorated.around_each(handler)
+        self
+      end
 
-        logger.info("[LightService] - executing <#{action.to_s}>")
-        if defined? action.expects and action.expects.any?
-          logger.info("[LightService] -   expects: #{extract_keys(action.expects)}")
+      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_all?(context)
+            write_skip_all_log(context, action)
+            next context
+          end
+
+          write_log(action, context)
         end
-        if defined? action.promises and action.promises.any?
-          logger.info("[LightService] -   promises: #{extract_keys(action.promises)}")
+      end
+
+      private
+
+      def write_log(action, context)
+        logger.info("[LightService] - executing <#{action}>")
+        log_expects(action)
+        log_promises(action)
+        logger.info("[LightService] -     keys in context: "\
+                    "#{extract_keys(context.keys)}")
+      end
+
+      def log_expects(action)
+        if defined?(action.expects) && action.expects.any?
+          logger.info("[LightService] -   expects: " \
+                      "#{extract_keys(action.expects)}")
         end
-        logger.info("[LightService] -     keys in context: #{extract_keys(context.keys)}")
       end
-    end
 
-    private
+      def log_promises(action)
+        if defined?(action.promises) && action.promises.any?
+          logger.info("[LightService] -   promises: " \
+                      "#{extract_keys(action.promises)}")
+        end
+      end
 
-    def extract_keys(keys)
-      keys.map {|key| ":#{key}" }.join(', ')
-    end
+      def extract_keys(keys)
+        keys.map { |key| ":#{key}" }.join(', ')
+      end
 
-    def has_failure?(context)
-      context.respond_to?(:failure?) && context.failure?
-    end
+      def has_failure?(context)
+        context.respond_to?(:failure?) && context.failure?
+      end
 
-    def write_failure_log(context, action)
-      logger.warn("[LightService] - :-((( <#{action.to_s}> has failed...")
-      logger.warn("[LightService] - context message: #{context.message}")
-      @logged = true
-    end
+      def write_failure_log(context, action)
+        logger.warn("[LightService] - :-((( <#{action}> has failed...")
+        logger.warn("[LightService] - context message: #{context.message}")
+        @logged = true
+      end
 
-    def skip_all?(context)
-      context.respond_to?(:skip_all?) && context.skip_all?
-    end
+      def skip_all?(context)
+        context.respond_to?(:skip_all?) && context.skip_all?
+      end
 
-    def write_skip_all_log(context, action)
-      logger.info("[LightService] - ;-) <#{action.to_s}> has decided to skip the rest of the actions")
-      logger.info("[LightService] - context message: #{context.message}")
-      @logged = true
+      def write_skip_all_log(context, action)
+        msg = "[LightService] - ;-) <#{action}> has decided " \
+              "to skip the rest of the actions"
+        logger.info(msg)
+        logger.info("[LightService] - context message: #{context.message}")
+        @logged = true
+      end
     end
   end
-end; end
+end

data/lib/light-service/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module LightService
-  VERSION = "0.6.0"
+  VERSION = "0.6.1".freeze
 end

data/light-service.gemspec

@@ -16,10 +16,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = LightService::VERSION
 
-  gem.add_dependency("activesupport", ">= 4.0")
+  gem.add_dependency("activesupport", ">= 3.0")
 
   gem.add_development_dependency("rspec", "~> 3.0")
-  gem.add_development_dependency("rspec-its", "~> 1.0")
-  gem.add_development_dependency("simplecov", "~> 0.7.1")
-  gem.add_development_dependency("pry", "0.9.12.2")
+  gem.add_development_dependency("simplecov", "~> 0.11")
+  gem.add_development_dependency("rubocop", "~> 0.36")
+  gem.add_development_dependency("pry", "~> 0.10")
 end

data/spec/acceptance/around_each_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe "Executing arbitrary code around each action" do
+  def assert_before_action_execute_log
+    expect(MyLogger).to receive(:info)
+      .with(TestDoubles::AddsTwoActionWithFetch, :number => 0)
+  end
+
+  def assert_after_action_execute_log
+    expect(MyLogger).to receive(:info)
+      .with(TestDoubles::AddsTwoActionWithFetch, :number => 2)
+  end
+
+  it "can be used to log data" do
+    MyLogger = double
+    context = { :number => 0 }
+
+    assert_before_action_execute_log
+    assert_after_action_execute_log
+
+    result = TestDoubles::AroundEachOrganizer.add(context)
+
+    expect(result.fetch(:number)).to eq(2)
+  end
+end
+

data/spec/acceptance/include_warning_spec.rb

@@ -4,8 +4,10 @@ require 'test_doubles'
 describe "Including is discouraged" do
   context "when including LightService::Organizer" do
     it "gives warning" do
+      expected_msg = "including LightService::Organizer is deprecated. " \
+                     "Please use `extend LightService::Organizer` instead"
       expect(ActiveSupport::Deprecation).to receive(:warn)
-                                        .with("including LightService::Organizer is deprecated. Please use `extend LightService::Organizer` instead")
+        .with(expected_msg)
 
       class OrganizerIncludingLS
         include LightService::Organizer
@@ -15,8 +17,10 @@ describe "Including is discouraged" do
 
   context "when including LightService::Action" do
     it "gives warning" do
+      expected_msg = "including LightService::Action is deprecated. " \
+                     "Please use `extend LightService::Action` instead"
       expect(ActiveSupport::Deprecation).to receive(:warn)
-                                        .with("including LightService::Action is deprecated. Please use `extend LightService::Action` instead")
+        .with(expected_msg)
 
       class ActionIncludingLS
         include LightService::Action

data/spec/acceptance/log_from_organizer_spec.rb

@@ -19,24 +19,29 @@ describe "Logs from organizer" do
   context "when every action has expects or promises" do
     subject(:log_message) do
       collects_log do
-        TestDoubles::MakesTeaAndCappuccino.call("black tea", "2% milk", "espresso coffee")
+        TestDoubles::MakesTeaAndCappuccino
+          .call("black tea", "2% milk", "espresso coffee")
       end
     end
 
     it "describes what organizer was invoked" do
-      organizer_log_message = "[LightService] - calling organizer <TestDoubles::MakesTeaAndCappuccino>"
+      organizer_log_message = "[LightService] - calling organizer " \
+                              "<TestDoubles::MakesTeaAndCappuccino>"
       expect(log_message).to include(organizer_log_message)
     end
 
     it "describes the actions invoked" do
-      organizer_log_message = "[LightService] - executing <TestDoubles::MakesTeaWithMilkAction>"
+      organizer_log_message = "[LightService] - executing " \
+                              "<TestDoubles::MakesTeaWithMilkAction>"
       expect(log_message).to include(organizer_log_message)
-      organizer_log_message = "[LightService] - executing <TestDoubles::MakesLatteAction>"
+      organizer_log_message = "[LightService] - executing " \
+                              "<TestDoubles::MakesLatteAction>"
       expect(log_message).to include(organizer_log_message)
     end
 
     it "lists the keys in context before the actions are executed" do
-      organizer_log_message = "[LightService] -     keys in context: :tea, :milk, :coffee"
+      organizer_log_message = "[LightService] -     " \
+                              "keys in context: :tea, :milk, :coffee"
       expect(log_message).to include(organizer_log_message)
     end
 
@@ -55,7 +60,8 @@ describe "Logs from organizer" do
     end
 
     it "lists the keys in contect after the actions are executed" do
-      organizer_log_message = "[LightService] -     keys in context: :tea, :milk, :coffee, :milk_tea, :latte"
+      organizer_log_message = "[LightService] -     keys in context: " \
+                              ":tea, :milk, :coffee, :milk_tea, :latte"
       expect(log_message).to include(organizer_log_message)
     end
   end
@@ -68,7 +74,8 @@ describe "Logs from organizer" do
     end
 
     it "describes what organizer was invoked" do
-      organizer_log_message = "[LightService] - calling organizer <TestDoubles::MakesCappuccinoAddsTwo>"
+      organizer_log_message = "[LightService] - calling organizer " \
+                              "<TestDoubles::MakesCappuccinoAddsTwo>"
       expect(log_message).to include(organizer_log_message)
     end
 
@@ -83,16 +90,20 @@ describe "Logs from organizer" do
   context "when the context has failed" do
     subject(:log_message) do
       collects_log do
-        TestDoubles::MakesCappuccinoAddsTwoAndFails.call("espresso coffee")
+        TestDoubles::MakesCappuccinoAddsTwoAndFails
+          .call("espresso coffee")
       end
     end
 
     it "logs it with a warning" do
-      organizer_log_message = "WARN -- : [LightService] - :-((( <TestDoubles::MakesLatteAction> has failed..."
+      organizer_log_message = "WARN -- : [LightService] - :-((( " \
+                              "<TestDoubles::MakesLatteAction> has failed..."
       expect(log_message).to include(organizer_log_message)
-      organizer_log_message = "WARN -- : [LightService] - context message: Can't make a latte from a milk that's very hot!"
+      organizer_log_message = "WARN -- : [LightService] - context message: " \
+                              "Can't make a latte from a milk that's very hot!"
       expect(log_message).to include(organizer_log_message)
-      organizer_log_message = "[LightService] -  :-((( <TestDoubles::AddsTwoAction> has failed..."
+      organizer_log_message = "[LightService] -  :-((( " \
+                              "<TestDoubles::AddsTwoAction> has failed..."
       expect(log_message).not_to include(organizer_log_message)
     end
   end
@@ -100,16 +111,21 @@ describe "Logs from organizer" do
   context "when the context has failed with rollback" do
     subject(:log_message) do
       collects_log do
-        TestDoubles::MakesCappuccinoAddsTwoAndFails.call("espresso coffee", :super_hot)
+        TestDoubles::MakesCappuccinoAddsTwoAndFails
+          .call("espresso coffee", :super_hot)
       end
     end
 
     it "logs it with a warning" do
-      organizer_log_message = "WARN -- : [LightService] - :-((( <TestDoubles::MakesLatteAction> has failed..."
+      organizer_log_message = "WARN -- : [LightService] - :-((( " \
+                              "<TestDoubles::MakesLatteAction> has failed..."
       expect(log_message).to include(organizer_log_message)
-      organizer_log_message = "WARN -- : [LightService] - context message: Can't make a latte from a milk that's super hot!"
+      organizer_log_message = "WARN -- : [LightService] - context message: " \
+                              "Can't make a latte from a milk that's super hot!"
       expect(log_message).to include(organizer_log_message)
-      organizer_log_message = "[LightService] -  :-((( <TestDoubles::AddsTwoAction> has failed..."
+      organizer_log_message = "[LightService] -  :-((( " \
+                              "<TestDoubles::AddsTwoAction> " \
+                              "has failed..."
       expect(log_message).not_to include(organizer_log_message)
     end
   end
@@ -122,11 +138,16 @@ describe "Logs from organizer" do
     end
 
     it "logs it with a warning" do
-      organizer_log_message = "INFO -- : [LightService] - ;-) <TestDoubles::MakesLatteAction> has decided to skip the rest of the actions"
+      organizer_log_message = "INFO -- : [LightService] - ;-) " \
+                              "<TestDoubles::MakesLatteAction> has decided " \
+                              "to skip the rest of the actions"
       expect(log_message).to include(organizer_log_message)
-      organizer_log_message = "INFO -- : [LightService] - context message: Can't make a latte with a fatty milk like that!"
+      organizer_log_message = "INFO -- : [LightService] - context message: " \
+                              "Can't make a latte with a fatty milk like that!"
       expect(log_message).to include(organizer_log_message)
-      organizer_log_message = "INFO -- : [LightService] - ;-) <TestDoubles::AddsTwoAction> has decided to skip the rest of the actions"
+      organizer_log_message = "INFO -- : [LightService] - ;-) " \
+                              "<TestDoubles::AddsTwoAction> has decided " \
+                              "to skip the rest of the actions"
       expect(log_message).not_to include(organizer_log_message)
     end
   end