light-service 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30ef43a9d6e26800b7599546ffea8b1cb15b1533
-  data.tar.gz: 28ee4863b5ea1a859c9e4ca288c20b23f99bc4e9
+  metadata.gz: 24c5a758ab50b3cd0ec404ef0b8a426a3e77e42b
+  data.tar.gz: 03ec6d27e900c9685bd141340c2b191df781ab84
 SHA512:
-  metadata.gz: dab3019cc90cecb1d97b2d36dcf5ad97dde57a22424eefbe91978d024205ea90215df4045594e8744fc9af5ae58ffd45f9c9727d921aee8af1bae50b0df754d3
-  data.tar.gz: 528fc079179b6e276aa6b4ec331326b51c279c3e234a0fc5998b336098375ad189c0bc274a616446d9aa851f10cda8653901d7f9e13a2e5ee0251f2f037e9324
+  metadata.gz: ef89eee65b07381b629c9f4b8e5aad0e4e719e370e8aa84c32a23f65824d42c3e9c14424810b8518a244df4769b3f2e4f22a1752f6c498e44e146b803041bff3
+  data.tar.gz: 3476522df0af4775eff555a986d0dffbfed8dad3c0cd77a7a5eb19ca25b39c7109c8da8756a30625d39bf89e10fb7a54fd6212c15955bc544c37e66f2be6293d

data/.travis.yml

@@ -4,10 +4,10 @@ env:
   - RUN_COVERAGE_REPORT=true
 
 rvm:
-  - 2.1.8
   - 2.2.2
   - 2.3.3
-  - 2.4.0
+  - 2.4.1
+  - 2.5.0
 
 before_install:
   - 'echo ''gem: --no-ri --no-rdoc'' > ~/.gemrc'

data/README.md

@@ -11,7 +11,25 @@
 ![Orchestrators-Deprecated](resources/orchestrators_deprecated.svg)
 <br>Version 0.9.0 deprecates Orchestrators and moves all their functionalities into Organizers. Please check out [this PR](https://github.com/adomokos/light-service/pull/132) to see the changes.
 
-<br><br>
+<br>
+
+## Table of Content
+* [Why LightService?](#why-lightservice)
+* [Stopping the Series of Actions](#stopping-the-series-of-actions)
+    * [Failing the Context](#failing-the-context)
+    * [Skipping the Rest of the Actions](#skipping-the-rest-of-the-actions)
+* [Benchmarking Actions with Around Advice](#benchmarking-actions-with-around-advice)
+* [Before and After Action Hooks](#before-and-after-action-hooks)
+* [Key Aliases](#key-aliases)
+* [Logging](#logging)
+* [Error Codes](#error-codes)
+* [Action Rollback](#action-rollback)
+* [Localizing Messages](#localizing-messages)
+* [Orchestrator Logic in Organizers](#orchestrator-logic-in-organizers)
+* [ContextFactory for Faster Action Testing](#contextfactory-for-faster-action-testing)
+
+
+## Why LightService?
 
 What do you think of this code?
 
@@ -116,8 +134,10 @@ class CalculatesOrderTaxAction
   extend ::LightService::Action
   expects :order, :tax_percentage
 
-  executed do |context|
-    order.tax = (order.total * (tax_percentage/100)).round(2)
+  # I am using ctx as an abbreviation for context
+  executed do |ctx|
+    order = ctx.order
+    order.tax = (order.total * (ctx.tax_percentage/100)).round(2)
   end
 
 end
@@ -126,9 +146,9 @@ class ProvidesFreeShippingAction
   extend LightService::Action
   expects :order
 
-  executed do |context|
-    if order.total_with_tax > 200
-      order.provide_free_shipping!
+  executed do |ctx|
+    if ctx.order.total_with_tax > 200
+      ctx.order.provide_free_shipping!
     end
   end
 end
@@ -156,18 +176,6 @@ I gave a [talk at RailsConf 2013](http://www.adomokos.com/2013/06/simple-and-ele
 simple and elegant Rails code where I told the story of how LightService was extracted from the projects I had worked on.
 
 
-## Table of Content
-* [Stopping the Series of Actions](#stopping-the-series-of-actions)
-    * [Failing the Context](#failing-the-context)
-    * [Skipping the Rest of the Actions](#skipping-the-rest-of-the-actions)
-* [Benchmarking Actions with Around Advice](#benchmarking-actions-with-around-advice)
-* [Key Aliases](#key-aliases)
-* [Logging](#logging)
-* [Error Codes](#error-codes)
-* [Action Rollback](#action-rollback)
-* [Localizing Messages](#localizing-messages)
-* [Orchestrator Logic in Organizers](#orchestrator-logic-in-organizers)
-* [ContextFactory for Faster Action Testing](#contextfactory-for-faster-action-testing)
 
 ## Stopping the Series of Actions
 When nothing unexpected happens during the organizer's call, the returned `context` will be successful. Here is how you can check for this:
@@ -196,7 +204,7 @@ When something goes wrong in an action and you want to halt the chain, you need
 The context's `fail!` method can take an optional message argument, this message might help describing what went wrong.
 In case you need to return immediately from the point of failure, you have to do that by calling `next context`.
 
-In case you want to fail the context and stop the execution of the executed block, use the `fail_and_return!('something went wront')` method.
+In case you want to fail the context and stop the execution of the executed block, use the `fail_and_return!('something went wrong')` method.
 This will immediately leave the block, you don't need to call `next context` to return from the block.
 
 Here is an example:
@@ -277,6 +285,103 @@ end
 
 Any object passed into `around_each` must respond to #call with two arguments: the action name and the context it will execute with. It is also passed a block, where LightService's action execution will be done in, so the result must be returned. While this is a little work, it also gives you before and after state access to the data for any auditing and/or checks you may need to accomplish.
 
+## Before and After Action Hooks
+
+In case you need to inject code right before and after the actions are executed, you can use the `before_actions` and `after_actions` hooks. It accepts one or multiple lambdas that the Action implementation will invoke. This addition to LightService is a great way to decouple instrumentation from business logic.
+
+Consider this code:
+
+```ruby
+class SomeOrganizer
+  extend LightService::Organizer
+
+  def call(ctx)
+    with(ctx).reduce(actions)
+  end
+
+  def actions
+    OneAction,
+    TwoAction,
+    ThreeAction
+  end
+end
+
+class TwoAction
+  extend LightService::Action
+  expects :user, :logger
+
+  executed do |ctx|
+    # Logging information
+    if ctx.user.role == 'admin'
+       ctx.logger.info('admin is doing something')
+    end
+
+    ctx.user.do_something
+  end
+end
+```
+
+The logging logic makes `TwoAction` more complex, there is more code for logging than for business logic.
+
+You have two options to decouple instrumentation from real logic with `before_actions` and `after_actions` hooks:
+
+1. Declare your hooks in the Organizer
+2. Attach hooks to the Organizer from the outside
+
+This is how you can declaratively add before and after hooks to the Organizer:
+
+```ruby
+class SomeOrganizer
+  extend LightService::Organizer
+  before_actions (lambda do |ctx|
+                           if ctx.current_action == TwoAction
+                             return unless ctx.user.role == 'admin'
+                             ctx.logger.info('admin is doing something')
+                           end
+                         end)
+  after_actions (lambda do |ctx|
+                          if ctx.current_action == TwoAction
+                            return unless ctx.user.role == 'admin'
+                            ctx.logger.info('admin is DONE doing something')
+                          end
+                        end)
+
+  def call(ctx)
+    with(ctx).reduce(actions)
+  end
+
+  def actions
+    OneAction,
+    TwoAction,
+    ThreeAction
+  end
+end
+
+class TwoAction
+  extend LightService::Action
+  expects :user
+
+  executed do |ctx|
+    ctx.user.do_something
+  end
+end
+```
+
+Note how the action has no logging logic after this change. Also, you can target before and after action logic for specific actions, as the `ctx.current_action` will have the class name of the currently processed action. In the example above, logging will occur only for `TwoAction` and not for `OneAction` or `ThreeAction`.
+
+Here is how you can declaratively add `before_hooks` or `after_hooks` to your Organizer from the outside:
+
+```ruby
+SomeOrganizer.before_actions =
+  lambda do |ctx|
+    if ctx.current_action == TwoAction
+      return unless ctx.user.role == 'admin'
+      ctx.logger.info('admin is doing something')
+    end
+  end
+```
+
+These ideas are originally from Aspect Oriented Programming, read more about them [here](https://en.wikipedia.org/wiki/Aspect-oriented_programming).
 
 ## Expects and Promises
 The `expects` and `promises` macros are rules for the inputs/outputs of an action.
@@ -619,7 +724,7 @@ class ExtractsTransformsLoadsData
   extend LightService::Organizer
 
   def self.call(connection)
-    with(:connection => connection).reduce(steps)
+    with(:connection => connection).reduce(actions)
   end
 
   def self.actions
@@ -629,7 +734,7 @@ class ExtractsTransformsLoadsData
       reduce_if(->(ctx) { ctx.retrieved_items.empty? }, [
         NotifiesEngineeringTeamAction
       ]),
-      iterate(:retrieved_item, [
+      iterate(:retrieved_items, [
         TransformsData
       ]),
       LoadsData,

data/RELEASES.md

@@ -1,5 +1,8 @@
 A brief list of new features and changes introduced with the specified version.
 
+### 0.10.0
+* Adding [before_actions and after_actions hooks](https://github.com/adomokos/light-service/pull/144).
+
 ### 0.9.0
 * [Deprecate Orchestrator](https://github.com/adomokos/light-service/pull/132) by moving its functionality to Organizers.
 

data/gemfiles/activesupport_3.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "appraisal", "~> 2.0"
 gem "activesupport", "~> 3.0"
+gem "appraisal", "~> 2.0"
 
 gemspec :path => "../"

data/gemfiles/activesupport_4.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "appraisal", "~> 2.0"
 gem "activesupport", "~> 4.0"
+gem "appraisal", "~> 2.0"
 
 gemspec :path => "../"

data/gemfiles/activesupport_5.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "appraisal", "~> 2.0"
 gem "activesupport", "~> 5.0"
+gem "appraisal", "~> 2.0"
 
 gemspec :path => "../"

data/lib/light-service/action.rb

@@ -23,11 +23,11 @@ module LightService
       end
 
       def expected_keys
-        @_expected_keys ||= []
+        @expected_keys ||= []
       end
 
       def promised_keys
-        @_promised_keys ||= []
+        @promised_keys ||= []
       end
 
       def executed
@@ -42,7 +42,9 @@ module LightService
             action_context.define_accessor_methods_for_keys(all_keys)
 
             catch(:jump_when_failed) do
+              call_before_action(action_context)
               yield(action_context)
+              call_after_action(action_context)
             end
           end
         end
@@ -70,6 +72,24 @@ module LightService
       def all_keys
         expected_keys + promised_keys
       end
+
+      def call_before_action(context)
+        invoke_callbacks(context[:_before_actions], context)
+      end
+
+      def call_after_action(context)
+        invoke_callbacks(context[:_after_actions], context)
+      end
+
+      def invoke_callbacks(callbacks, context)
+        return context unless callbacks
+
+        callbacks.each do |cb|
+          cb.call(context)
+        end
+
+        context
+      end
     end
   end
 end

data/lib/light-service/organizer.rb

@@ -19,6 +19,17 @@ module LightService
       def with(data = {})
         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
 
@@ -51,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/version.rb

@@ -1,3 +1,3 @@
 module LightService
-  VERSION = "0.9.0".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.15.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/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

data/spec/acceptance/orchestrator/context_failure_and_skipping_spec.rb

@@ -10,18 +10,18 @@ describe LightService::Orchestrator do
       with(:number => 1).reduce([
                                   TestDoubles::SkipAllAction,
                                   reduce_until(->(ctx) { ctx.number == 3 },
-                                               TestDoubles::AddOneAction)
+                                               TestDoubles::AddsOneAction)
                                 ])
     end
 
     def self.run_skip_after
       with(:number => 1).reduce([
-                                  TestDoubles::AddOneAction,
+                                  TestDoubles::AddsOneAction,
                                   reduce_until(->(ctx) { ctx.number == 3 }, [
-                                                 TestDoubles::AddOneAction
+                                                 TestDoubles::AddsOneAction
                                                ]),
                                   TestDoubles::SkipAllAction,
-                                  TestDoubles::AddOneAction
+                                  TestDoubles::AddsOneAction
                                 ])
     end
 
@@ -29,8 +29,8 @@ describe LightService::Orchestrator do
       with(:number => 1).reduce([
                                   TestDoubles::FailureAction,
                                   reduce_until(->(ctx) { ctx[:number] == 3 },
-                                               TestDoubles::AddOneAction),
-                                  TestDoubles::AddOneAction
+                                               TestDoubles::AddsOneAction),
+                                  TestDoubles::AddsOneAction
                                 ])
     end
   end

data/spec/acceptance/orchestrator/execute_spec.rb

@@ -13,10 +13,10 @@ describe LightService::Orchestrator do
 
     def self.steps
       [
-        TestDoubles::AddOneAction,
+        TestDoubles::AddsOneAction,
         execute(->(ctx) { ctx.number += 1 }),
         execute(->(ctx) { ctx[:something] = 'hello' }),
-        TestDoubles::AddOneAction
+        TestDoubles::AddsOneAction
       ]
     end
   end

data/spec/acceptance/orchestrator/iterate_spec.rb

@@ -10,14 +10,14 @@ describe LightService::Orchestrator do
     def self.run(context)
       with(context).reduce([
                              iterate(:numbers, [
-                                       TestDoubles::AddOneAction
+                                       TestDoubles::AddsOneAction
                                      ])
                            ])
     end
 
     def self.run_single(context)
       with(context).reduce([
-                             iterate(:numbers, TestDoubles::AddOneAction)
+                             iterate(:numbers, TestDoubles::AddsOneAction)
                            ])
     end
   end

data/spec/acceptance/orchestrator/organizer_action_combination_spec.rb

@@ -15,7 +15,7 @@ describe LightService::Orchestrator do
   it 'responds to both actions and organizers' do
     result = OrchestratorTestReduce.run({ :number => 0 }, [
                                           TestDoubles::AddTwoOrganizer,
-                                          TestDoubles::AddOneAction
+                                          TestDoubles::AddsOneAction
                                         ])
 
     expect(result).to be_success
@@ -26,7 +26,7 @@ describe LightService::Orchestrator do
     result = OrchestratorTestReduce.run({ :number => 0 }, [
                                           TestDoubles::AddTwoOrganizer,
                                           TestDoubles::FailureAction,
-                                          TestDoubles::AddOneAction
+                                          TestDoubles::AddsOneAction
                                         ])
 
     expect(result).not_to be_success

data/spec/acceptance/orchestrator/reduce_if_spec.rb

@@ -13,9 +13,9 @@ describe LightService::Orchestrator do
 
     def self.steps
       [
-        TestDoubles::AddOneAction,
+        TestDoubles::AddsOneAction,
         reduce_if(->(ctx) { ctx.number == 1 },
-                  TestDoubles::AddOneAction)
+                  TestDoubles::AddsOneAction)
       ]
     end
   end

data/spec/acceptance/orchestrator/reduce_until_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe LightService::Orchestrator do
     def self.steps
       [
         reduce_until(->(ctx) { ctx.number == 3 },
-                     TestDoubles::AddOneAction)
+                     TestDoubles::AddsOneAction)
       ]
     end
   end

data/spec/acceptance/organizer/around_each_with_reduce_if_spec.rb

@@ -13,9 +13,9 @@ RSpec.describe LightService::Organizer do
 
     def self.actions
       [
-        TestDoubles::AddOneAction,
+        TestDoubles::AddsOneAction,
         reduce_if(->(ctx) { ctx.number == 1 },
-                  TestDoubles::AddOneAction)
+                  TestDoubles::AddsOneAction)
       ]
     end
   end
@@ -29,11 +29,11 @@ RSpec.describe LightService::Organizer do
     expect(result.fetch(:number)).to eq(2)
     expect(result[:logger].logs).to eq(
       [{
-        :action => TestDoubles::AddOneAction,
+        :action => TestDoubles::AddsOneAction,
         :before => 0,
         :after => 1
       }, {
-        :action => TestDoubles::AddOneAction,
+        :action => TestDoubles::AddsOneAction,
         :before => 1,
         :after => 2
       }]

data/spec/acceptance/organizer/context_failure_and_skipping_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe LightService::Organizer do
         .reduce([
                   TestDoubles::SkipAllAction,
                   reduce_until(->(ctx) { ctx.number == 3 },
-                               TestDoubles::AddOneAction)
+                               TestDoubles::AddsOneAction)
                 ])
     end
   end
@@ -19,12 +19,12 @@ RSpec.describe LightService::Organizer do
     def self.call
       with(:number => 1)
         .reduce([
-                  TestDoubles::AddOneAction,
+                  TestDoubles::AddsOneAction,
                   reduce_until(->(ctx) { ctx.number == 3 }, [
-                                 TestDoubles::AddOneAction
+                                 TestDoubles::AddsOneAction
                                ]),
                   TestDoubles::SkipAllAction,
-                  TestDoubles::AddOneAction
+                  TestDoubles::AddsOneAction
                 ])
     end
   end
@@ -36,8 +36,8 @@ RSpec.describe LightService::Organizer do
         .reduce([
                   TestDoubles::FailureAction,
                   reduce_until(->(ctx) { ctx[:number] == 3 },
-                               TestDoubles::AddOneAction),
-                  TestDoubles::AddOneAction
+                               TestDoubles::AddsOneAction),
+                  TestDoubles::AddsOneAction
                 ])
     end
   end

data/spec/acceptance/organizer/execute_spec.rb

@@ -11,10 +11,10 @@ RSpec.describe LightService::Organizer do
 
     def self.steps
       [
-        TestDoubles::AddOneAction,
+        TestDoubles::AddsOneAction,
         execute(->(ctx) { ctx.number += 1 }),
         execute(->(ctx) { ctx[:something] = 'hello' }),
-        TestDoubles::AddOneAction
+        TestDoubles::AddsOneAction
       ]
     end
   end

data/spec/acceptance/organizer/iterate_spec.rb

@@ -2,33 +2,19 @@ require 'spec_helper'
 require 'test_doubles'
 
 RSpec.describe LightService::Organizer do
-  class TestIterate
-    extend LightService::Organizer
-
-    def self.call(context)
-      with(context)
-        .reduce([iterate(:numbers,
-                         [TestDoubles::AddOneAction])])
-    end
-
-    def self.call_single(context)
-      with(context)
-        .reduce([iterate(:numbers,
-                         TestDoubles::AddOneAction)])
-    end
-  end
-
   let(:empty_context) { LightService::Context.make }
 
   it 'reduces each item of a collection and singularizes the collection key' do
-    result = TestIterate.call(:numbers => [1, 2, 3, 4])
+    result = TestDoubles::TestIterate.call(:number => 1,
+                                           :counters => [1, 2, 3, 4])
 
     expect(result).to be_success
     expect(result.number).to eq(5)
   end
 
   it 'accepts a single action or organizer' do
-    result = TestIterate.call_single(:numbers => [1, 2, 3, 4])
+    result = TestDoubles::TestIterate.call_single(:number => 1,
+                                                  :counters => [1, 2, 3, 4])
 
     expect(result).to be_success
     expect(result.number).to eq(5)
@@ -37,7 +23,7 @@ RSpec.describe LightService::Organizer do
   it 'will not iterate over a failed context' do
     empty_context.fail!('Something bad happened')
 
-    result = TestIterate.call(empty_context)
+    result = TestDoubles::TestIterate.call(empty_context)
 
     expect(result).to be_failure
   end
@@ -45,7 +31,7 @@ RSpec.describe LightService::Organizer do
   it 'does not iterate over a skipped context' do
     empty_context.skip_remaining!('No more needed')
 
-    result = TestIterate.call(empty_context)
+    result = TestDoubles::TestIterate.call(empty_context)
     expect(result).to be_success
   end
 end

data/spec/acceptance/organizer/reduce_if_spec.rb

@@ -11,9 +11,9 @@ RSpec.describe LightService::Organizer do
 
     def self.actions
       [
-        TestDoubles::AddOneAction,
+        TestDoubles::AddsOneAction,
         reduce_if(->(ctx) { ctx.number == 1 },
-                  TestDoubles::AddOneAction)
+                  TestDoubles::AddsOneAction)
       ]
     end
   end

data/spec/acceptance/organizer/reduce_until_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe LightService::Organizer do
     def self.actions
       [
         reduce_until(->(ctx) { ctx.number == 3 },
-                     TestDoubles::AddOneAction)
+                     TestDoubles::AddsOneAction)
       ]
     end
   end

data/spec/acceptance/organizer/with_callback_spec.rb

@@ -2,68 +2,9 @@ require 'spec_helper'
 require 'test_doubles'
 
 RSpec.describe LightService::Organizer do
-  class TestWithCallback
-    extend LightService::Organizer
-
-    def self.call(context = {})
-      with(context).reduce(actions)
-    end
-
-    def self.actions
-      [
-        SetUpContextAction,
-        with_callback(IterateCollectionAction,
-                      [IncrementCountAction,
-                       AddToTotalAction])
-      ]
-    end
-  end
-
-  class SetUpContextAction
-    extend LightService::Action
-    promises :numbers, :counter, :total
-
-    executed do |ctx|
-      ctx.numbers = [1, 2, 3]
-      ctx.counter = 0
-      ctx.total = 0
-    end
-  end
-
-  class IterateCollectionAction
-    extend LightService::Action
-    expects :numbers, :callback
-    promises :number
-
-    executed do |ctx|
-      ctx.numbers.each do |number|
-        ctx.number = number
-        ctx.callback.call(ctx)
-      end
-    end
-  end
-
-  class IncrementCountAction
-    extend LightService::Action
-    expects :counter
-
-    executed do |ctx|
-      ctx.counter = ctx.counter + 1
-    end
-  end
-
-  class AddToTotalAction
-    extend LightService::Action
-    expects :number, :total
-
-    executed do |ctx|
-      ctx.total += ctx.number
-    end
-  end
-
   describe 'a simple case with a single callback' do
     it 'calls the actions defined with callback' do
-      result = TestWithCallback.call
+      result = TestDoubles::TestWithCallback.call
 
       expect(result.counter).to eq(3)
       expect(result.total).to eq(6)
@@ -83,9 +24,9 @@ RSpec.describe LightService::Organizer do
           SetUpNestedContextAction,
           with_callback(IterateOuterCollectionAction,
                         [IncrementOuterCountAction,
-                         with_callback(IterateCollectionAction,
-                                       [IncrementCountAction,
-                                        AddToTotalAction])])
+                         with_callback(TestDoubles::IterateCollectionAction,
+                                       [TestDoubles::IncrementCountAction,
+                                        TestDoubles::AddToTotalAction])])
         ]
       end
     end
@@ -150,9 +91,9 @@ RSpec.describe LightService::Organizer do
 
       def self.actions
         [
-          SetUpContextAction,
-          with_callback(IterateCollectionAction,
-                        [IncrementCountAction,
+          TestDoubles::SetUpContextAction,
+          with_callback(TestDoubles::IterateCollectionAction,
+                        [TestDoubles::IncrementCountAction,
                          TestDoubles::FailureAction])
         ]
       end

data/spec/sample/calculates_tax_spec.rb

@@ -6,10 +6,7 @@ require_relative 'tax/provides_free_shipping_action'
 
 describe CalculatesTax do
   let(:order) { double('order') }
-  let(:ctx) do
-    double('ctx', :keys => [:user],
-                  :failure? => false, :skip_remaining? => false)
-  end
+  let(:ctx) { LightService::Context.make(:user => nil) }
 
   it "calls the actions in order" do
     allow(LightService::Context).to receive(:make)

data/spec/test_doubles.rb

@@ -30,21 +30,10 @@ module TestDoubles
     executed(&:fail!)
   end
 
-  class AddOneAction
-    extend LightService::Action
-    expects :number
-    promises :number
-
-    executed do |ctx|
-      ctx.number += 1
-      ctx.message = 'Added 1'
-    end
-  end
-
   class AddTwoOrganizer
     extend LightService::Organizer
     def self.call(context)
-      with(context).reduce([AddOneAction, AddOneAction])
+      with(context).reduce([AddsOneAction, AddsOneAction])
     end
   end
 
@@ -256,10 +245,9 @@ module TestDoubles
   class AddsThreeAction
     extend LightService::Action
     expects :number
-    promises :product
 
     executed do |context|
-      context.product = context.number + 3
+      context.number += 3
     end
   end
 
@@ -341,4 +329,79 @@ module TestDoubles
 
     executed { |_ctx| }
   end
+
+  class TestIterate
+    extend LightService::Organizer
+
+    def self.call(context)
+      with(context)
+        .reduce([iterate(:counters,
+                         [TestDoubles::AddsOneAction])])
+    end
+
+    def self.call_single(context)
+      with(context)
+        .reduce([iterate(:counters,
+                         TestDoubles::AddsOneAction)])
+    end
+  end
+
+  class TestWithCallback
+    extend LightService::Organizer
+
+    def self.call(context = {})
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        SetUpContextAction,
+        with_callback(IterateCollectionAction,
+                      [IncrementCountAction,
+                       AddToTotalAction])
+      ]
+    end
+  end
+
+  class SetUpContextAction
+    extend LightService::Action
+    promises :numbers, :counter, :total
+
+    executed do |ctx|
+      ctx.numbers = [1, 2, 3]
+      ctx.counter = 0
+      ctx.total = 0
+    end
+  end
+
+  class IterateCollectionAction
+    extend LightService::Action
+    expects :numbers, :callback
+    promises :number
+
+    executed do |ctx|
+      ctx.numbers.each do |number|
+        ctx.number = number
+        ctx.callback.call(ctx)
+      end
+    end
+  end
+
+  class IncrementCountAction
+    extend LightService::Action
+    expects :counter
+
+    executed do |ctx|
+      ctx.counter = ctx.counter + 1
+    end
+  end
+
+  class AddToTotalAction
+    extend LightService::Action
+    expects :number, :total
+
+    executed do |ctx|
+      ctx.total += ctx.number
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light-service
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Attila Domokos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-03 00:00:00.000000000 Z
+date: 2018-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.1
+        version: 0.16.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.1
+        version: 0.16.1
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.51'
+        version: '0.53'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.51'
+        version: '0.53'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -133,7 +133,9 @@ files:
 - resources/organizer_and_actions.png
 - resources/skip_actions.png
 - spec/acceptance/add_numbers_spec.rb
+- spec/acceptance/after_actions_spec.rb
 - spec/acceptance/around_each_spec.rb
+- spec/acceptance/before_actions_spec.rb
 - spec/acceptance/fail_spec.rb
 - spec/acceptance/include_warning_spec.rb
 - spec/acceptance/log_from_organizer_spec.rb
@@ -204,7 +206,9 @@ specification_version: 4
 summary: A service skeleton with an emphasis on simplicity
 test_files:
 - spec/acceptance/add_numbers_spec.rb
+- spec/acceptance/after_actions_spec.rb
 - spec/acceptance/around_each_spec.rb
+- spec/acceptance/before_actions_spec.rb
 - spec/acceptance/fail_spec.rb
 - spec/acceptance/include_warning_spec.rb
 - spec/acceptance/log_from_organizer_spec.rb