light-service 0.11.0 → 0.16.0

data/lib/light-service/localization_adapter.rb

@@ -34,7 +34,7 @@ module LightService
       scope = i18n_scope_from_class(action_class, type)
       options[:scope] = scope
 
-      I18n.t(key, options)
+      I18n.t(key, **options)
     end
 
     def i18n_scope_from_class(action_class, type)

data/lib/light-service/organizer.rb

@@ -56,6 +56,33 @@ module LightService
       def with_callback(action, steps)
         WithCallback.run(self, action, steps)
       end
+
+      def log_with(logger)
+        @logger = logger
+      end
+
+      def logger
+        @logger
+      end
+
+      # 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
+
+      def add_aliases(args)
+        execute(->(ctx) { ctx.assign_aliases(ctx.aliases.merge(args)) })
+      end
     end
 
     module Macros

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

@@ -1,10 +1,16 @@
 module LightService
   module Organizer
     class WithReducer
-      attr_reader :context
+      attr_reader   :context
+      attr_accessor :organizer
+
+      def initialize(monitored_organizer = nil)
+        @organizer = monitored_organizer
+      end
 
       def with(data = {})
         @context = LightService::Context.make(data)
+        @context.organized_by = organizer
         self
       end
 
@@ -23,6 +29,7 @@ module LightService
 
       def reduce(*actions)
         raise "No action(s) were provided" if actions.empty?
+
         actions.flatten!
 
         actions.each_with_object(context) do |action, current_context|

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

@@ -2,13 +2,17 @@ module LightService
   module Organizer
     class WithReducerFactory
       def self.make(monitored_organizer)
-        if LightService::Configuration.logger.nil?
-          # :nocov:
-          WithReducer.new
-          # :nocov:
-        else
-          WithReducerLogDecorator.new(monitored_organizer, WithReducer.new)
-        end
+        logger = monitored_organizer.logger ||
+                 LightService::Configuration.logger
+        decorated = WithReducer.new(monitored_organizer)
+
+        return decorated if logger.nil?
+
+        WithReducerLogDecorator.new(
+          monitored_organizer,
+          :decorated => decorated,
+          :logger => logger
+        )
       end
     end
   end

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

@@ -5,10 +5,13 @@ module LightService
 
       alias logged? logged
 
-      def initialize(organizer, decorated = WithReducer.new)
+      def initialize(organizer, decorated: WithReducer.new, logger:)
         @decorated = decorated
         @organizer = organizer
-        @logger = LightService::Configuration.logger
+
+        decorated.organizer = organizer
+
+        @logger = logger
         @logged = false
       end
 

data/lib/light-service/version.rb

@@ -1,3 +1,3 @@
 module LightService
-  VERSION = "0.11.0".freeze
+  VERSION = "0.16.0".freeze
 end

data/light-service.gemspec

@@ -15,11 +15,17 @@ Gem::Specification.new do |gem|
   gem.name          = "light-service"
   gem.require_paths = ["lib"]
   gem.version       = LightService::VERSION
+  gem.required_ruby_version = '>= 2.5.0'
 
-  gem.add_dependency("activesupport", ">= 3.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.
+  gem.add_development_dependency("appraisal", "~> 2.3")
   gem.add_development_dependency("rspec", "~> 3.0")
-  gem.add_development_dependency("simplecov", "~> 0.16.1")
-  gem.add_development_dependency("rubocop", "~> 0.53")
-  gem.add_development_dependency("pry", "~> 0.10")
+  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-performance", "~> 1.2.0")
+  gem.add_development_dependency("pry", "~> 0.12.2")
 end

data/spec/acceptance/after_actions_spec.rb

@@ -65,6 +65,23 @@ 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|
+          if ctx.current_action == TestDoubles::IterateCollectionAction
+            ctx.total -= 1000
+          end
+        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/custom_log_from_organizer_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "Log from an organizer with a custom logger" do
+  context "when overriding the global LightService organizer" do
+    let(:global_logger_organizer) do
+      Class.new do
+        extend LightService::Organizer
+
+        def self.call(number)
+          with(:number => number).reduce(actions)
+        end
+
+        def self.actions
+          [
+            TestDoubles::AddsOneAction,
+            TestDoubles::AddsTwoAction,
+            TestDoubles::AddsThreeAction
+          ]
+        end
+      end
+    end
+
+    let(:global_logger_string) { StringIO.new }
+
+    let(:custom_logger_string) { StringIO.new }
+    let(:custom_logger_organizer) do
+      custom_logger = Logger.new(custom_logger_string)
+
+      Class.new do
+        extend LightService::Organizer
+        log_with custom_logger
+
+        def self.call(coffee, this_hot = :very_hot)
+          with(:milk => this_hot, :coffee => coffee)
+            .reduce(TestDoubles::MakesLatteAction,
+                    TestDoubles::AddsTwoActionWithFetch)
+        end
+      end
+    end
+
+    before do
+      @original_global_logger = LightService::Configuration.logger
+      LightService::Configuration.logger = Logger.new(global_logger_string)
+    end
+
+    it "logs in own logger" do
+      global_logger_organizer.call(1)
+      custom_logger_organizer.call(:coffee => "Cappucino")
+
+      expect(custom_logger_string.string).to include("MakesLatteAction")
+      expect(custom_logger_string.string).to_not include("AddsOneAction")
+      expect(global_logger_string.string).to include("AddsOneAction")
+      expect(global_logger_string.string).to_not include("MakesLatteAction")
+    end
+
+    after do
+      LightService::Configuration.logger = @original_global_logger
+    end
+  end
+end

data/spec/acceptance/fail_spec.rb

@@ -1,24 +1,50 @@
 require 'spec_helper'
 
-RSpec.describe "fail! returns immediately from executed block" do
-  class FailAction
-    extend LightService::Action
-    promises :one, :two
-
-    executed do |ctx|
-      ctx.one = 1
-      # Have to set it in Context
-      ctx.two = nil
-
-      ctx.fail_and_return!('Something went wrong')
-      ctx.two = 2
+RSpec.describe "fail_and_return!" do
+  describe "returns immediately from executed block" do
+    class FailAndReturnAction
+      extend LightService::Action
+      promises :one, :two
+
+      executed do |ctx|
+        ctx.one = 1
+        # Have to set it in Context
+        ctx.two = nil
+
+        ctx.fail_and_return!('Something went wrong')
+        ctx.two = 2
+      end
+    end
+
+    it "returns immediately from executed block" do
+      result = FailAndReturnAction.execute
+
+      expect(result).to be_failure
+      expect(result.two).to be_nil
     end
   end
 
-  it "returns immediately from executed block" do
-    result = FailAction.execute
+  describe "accepts error_code option" do
+    class FailAndReturnWithErrorCodeAction
+      extend LightService::Action
+      promises :one, :two
 
-    expect(result).to be_failure
-    expect(result.two).to be_nil
+      executed do |ctx|
+        ctx.one = 1
+        # Have to set it in Context
+        ctx.two = nil
+
+        ctx.fail_and_return!('Something went wrong', :error_code => 401)
+        ctx.two = 2
+      end
+    end
+
+    it "returned context contains the error_code" do
+      result = FailAndReturnWithErrorCodeAction.execute
+
+      expect(result).to be_failure
+      expect(result.error_code).to eq 401
+      expect(result.two).to be_nil
+    end
   end
 end

data/spec/acceptance/organizer/add_aliases_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+RSpec.describe LightService::Organizer do
+  class TestAddAliases
+    extend LightService::Organizer
+
+    def self.call(context = LightService::Context.make)
+      with(context).reduce(steps)
+    end
+
+    def self.steps
+      [
+        add_to_context(:my_message => 'Hello There'),
+        # This will add the alias `:a_message` which points
+        # to the :my_message key's value
+        add_aliases(:my_message => :a_message),
+        TestDoubles::CapitalizeMessage
+      ]
+    end
+  end
+
+  it 'adds aliases to the context embedded in the series of actions' do
+    result = TestAddAliases.call
+
+    expect(result).to be_success
+    expect(result.final_message).to eq('HELLO THERE')
+  end
+end

data/spec/acceptance/organizer/add_to_context_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+RSpec.describe LightService::Organizer do
+  class TestAddToContext
+    extend LightService::Organizer
+
+    def self.call(context = LightService::Context.make)
+      with(context).reduce(steps)
+    end
+
+    def self.steps
+      [
+        # This will add the `:number` key to the context
+        # with the value of 0, so it's available for
+        # AddsOneAction
+        add_to_context(:number => 0),
+        TestDoubles::AddsOneAction,
+        add_to_context(:something => 'hello')
+      ]
+    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
+
+    expect(result).to be_success
+    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_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe LightService::Organizer do
         TestDoubles::AddsOneAction,
         execute(->(ctx) { ctx.number += 1 }),
         execute(->(ctx) { ctx[:something] = 'hello' }),
-        TestDoubles::AddsOneAction
+        TestDoubles::AddsOne.actions
       ]
     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/iterate_spec.rb

@@ -20,6 +20,13 @@ RSpec.describe LightService::Organizer do
     expect(result.number).to eq(5)
   end
 
+  it "knows that it's being iterated from within an organizer" do
+    result = TestDoubles::TestIterate.call(:number => 1,
+                                           :counters => [1, 2, 3, 4])
+
+    expect(result.organized_by).to eq TestDoubles::TestIterate
+  end
+
   it 'will not iterate over a failed context' do
     empty_context.fail!('Something bad happened')
 

data/spec/acceptance/organizer/reduce_if_spec.rb

@@ -48,4 +48,42 @@ RSpec.describe LightService::Organizer do
     result = TestReduceIf.call(empty_context)
     expect(result).to be_success
   end
+
+  it "knows that it's being conditionally reduced from within an organizer" do
+    result = TestReduceIf.call(:number => 2)
+
+    expect(result.organized_by).to eq TestReduceIf
+  end
+
+  it 'skips actions within in its own scope' do
+    org = Class.new do
+      extend LightService::Organizer
+
+      def self.call
+        reduce(actions)
+      end
+
+      def self.actions
+        [
+          reduce_if(
+            ->(c) { !c.nil? },
+            [
+              execute(->(c) { c[:first_reduce_if] = true }),
+              execute(->(c) { c.skip_remaining! }),
+              execute(->(c) { c[:second_reduce_if] = true })
+            ]
+          ),
+          execute(->(c) { c[:last_outside] = true })
+        ]
+      end
+    end
+
+    result = org.call
+
+    aggregate_failures do
+      expect(result[:first_reduce_if]).to be true
+      expect(result[:second_reduce_if]).to be_nil
+      expect(result[:last_outside]).to be true
+    end
+  end
 end