functional-light-service 0.2.4

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

@@ -0,0 +1,17 @@
+module FunctionalLightService
+  module Organizer
+    class ReduceIf
+      extend ScopedReducable
+
+      def self.run(organizer, condition_block, steps)
+        ->(ctx) do
+          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/functional-light-service/organizer/reduce_until.rb

@@ -0,0 +1,20 @@
+module FunctionalLightService
+  module Organizer
+    class ReduceUntil
+      extend ScopedReducable
+
+      def self.run(organizer, condition_block, steps)
+        ->(ctx) do
+          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/functional-light-service/organizer/scoped_reducable.rb

@@ -0,0 +1,13 @@
+module FunctionalLightService
+  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/functional-light-service/organizer/verify_call_method_exists.rb

@@ -0,0 +1,28 @@
+module FunctionalLightService
+  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/functional-light-service/organizer/with_callback.rb

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

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

@@ -0,0 +1,71 @@
+module FunctionalLightService
+  module Organizer
+    class WithReducer
+      attr_reader :context
+
+      def with(data = {})
+        @context = FunctionalLightService::Context.make(data)
+        self
+      end
+
+      def around_each(handler)
+        @around_each_handler = handler
+        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!
+
+        actions.each_with_object(context) do |action, current_context|
+          invoke_action(current_context, action)
+        rescue FailWithRollbackError
+          reduce_rollback(actions)
+        ensure
+          # For logging
+          yield(current_context, action) if block_given?
+        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
+            end
+          end
+      end
+
+      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
+        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

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

@@ -0,0 +1,18 @@
+module FunctionalLightService
+  module Organizer
+    class WithReducerFactory
+      def self.make(monitored_organizer)
+        logger = monitored_organizer.logger || FunctionalLightService::Configuration.logger
+        decorated = WithReducer.new
+
+        return decorated if logger.nil?
+
+        WithReducerLogDecorator.new(
+          monitored_organizer,
+          :decorated => decorated,
+          :logger => logger
+        )
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,105 @@
+require 'active_support/deprecation'
+
+module FunctionalLightService
+  module Organizer
+    def self.extended(base_class)
+      base_class.extend ClassMethods
+      base_class.extend Macros
+    end
+
+    def self.included(base_class)
+      warning_msg = "including FunctionalLightService::Organizer is deprecated. " \
+                    "Please use `extend FunctionalLightService::Organizer` instead"
+      ActiveSupport::Deprecation.warn(warning_msg)
+      extended(base_class)
+    end
+
+    # In case this module is included
+    module ClassMethods
+      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
+
+      def reduce(*actions)
+        with({}).reduce(actions)
+      end
+
+      def reduce_if(condition_block, steps)
+        ReduceIf.run(self, condition_block, steps)
+      end
+
+      def reduce_until(condition_block, steps)
+        ReduceUntil.run(self, condition_block, steps)
+      end
+
+      def iterate(collection_key, steps)
+        Iterate.run(self, collection_key, steps)
+      end
+
+      def execute(code_block)
+        Execute.run(code_block)
+      end
+
+      def with_callback(action, steps)
+        WithCallback.run(self, action, steps)
+      end
+
+      def log_with(logger)
+        @logger = logger
+      end
+
+      def logger
+        @logger
+      end
+    end
+
+    module Macros
+      def aliases(key_hash)
+        @aliases = key_hash
+      end
+
+      # This looks like an accessor,
+      # but it's used as a macro in the Organizer
+      def before_actions(*logic)
+        self.before_actions = logic
+      end
+
+      def before_actions=(logic)
+        @before_actions = [logic].flatten
+      end
+
+      def append_before_actions(action)
+        @before_actions ||= []
+        @before_actions.push(action)
+      end
+
+      # This looks like an accessor,
+      # but it's used as a macro in the Organizer
+      def after_actions(*logic)
+        self.after_actions = logic
+      end
+
+      def after_actions=(logic)
+        @after_actions = [logic].flatten
+      end
+
+      def append_after_actions(action)
+        @after_actions ||= []
+        @after_actions.push(action)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module FunctionalLightService
+  module Testing
+    class ContextFactory
+      attr_reader :organizer
+
+      def self.make_from(organizer)
+        new(organizer)
+      end
+
+      def for(action)
+        @organizer.append_before_actions(
+          ->(ctx) do
+            if ctx.current_action == action
+              # The last `:_before_actions` hook is for
+              # ContextFactory, remove it, so it won't
+              # be invoked again
+              ctx[:_before_actions].pop
+
+              throw(:return_ctx_from_execution, ctx)
+            end
+          end
+        )
+
+        self
+      end
+
+      # More than one arguments can be passed to the
+      # Organizer's #call method
+      def with(*args, &block)
+        catch(:return_ctx_from_execution) do
+          @organizer.call(*args, &block)
+        end
+      end
+
+      def initialize(organizer)
+        @organizer = organizer
+      end
+    end
+  end
+end

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

@@ -0,0 +1 @@
+require 'functional-light-service/testing/context_factory'

data/lib/functional-light-service/version.rb

@@ -0,0 +1,3 @@
+module FunctionalLightService
+  VERSION = "0.2.4".freeze
+end

data/lib/functional-light-service.rb

@@ -0,0 +1,29 @@
+require 'logger'
+require 'active_support/core_ext/string'
+
+require 'functional-light-service/version'
+
+module FunctionalLightService; end
+
+require 'functional-light-service/functional/monad'
+require 'functional-light-service/functional/enum'
+require 'functional-light-service/functional/result'
+require 'functional-light-service/functional/option'
+require 'functional-light-service/functional/null'
+require 'functional-light-service/errors'
+require 'functional-light-service/configuration'
+require 'functional-light-service/localization_adapter'
+require 'functional-light-service/context'
+require 'functional-light-service/context/key_verifier'
+require 'functional-light-service/organizer/scoped_reducable'
+require 'functional-light-service/organizer/with_reducer'
+require 'functional-light-service/organizer/with_reducer_log_decorator'
+require 'functional-light-service/organizer/with_reducer_factory'
+require 'functional-light-service/organizer/reduce_if'
+require 'functional-light-service/organizer/reduce_until'
+require 'functional-light-service/organizer/iterate'
+require 'functional-light-service/organizer/execute'
+require 'functional-light-service/organizer/with_callback'
+require 'functional-light-service/organizer/verify_call_method_exists'
+require 'functional-light-service/action'
+require 'functional-light-service/organizer'

data/spec/acceptance/add_numbers_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'test_doubles'
+
+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(:number)
+
+    expect(number).to eq(7)
+  end
+end

data/spec/acceptance/after_actions_spec.rb

@@ -0,0 +1,71 @@
+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 = ->(ctx) do
+        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 = [
+        ->(ctx) { ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction }
+      ]
+
+      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 FunctionalLightService::Organizer
+        after_actions (->(ctx) do
+                         ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction
+                       end),
+                      (->(ctx) do
+                        ctx.number -= 3 if ctx.current_action == TestDoubles::AddsThreeAction
+                      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
+
+  describe 'after_actions can be appended' do
+    it 'adds to the :_after_actions collection' do
+      TestDoubles::AdditionOrganizer.append_after_actions(
+        ->(ctx) { ctx.number -= 3 if ctx.current_action == TestDoubles::AddsThreeAction }
+      )
+
+      result = TestDoubles::AdditionOrganizer.call(0)
+      expect(result.fetch(:number)).to eq(3)
+    end
+  end
+end

data/spec/acceptance/around_each_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe 'Executing arbitrary code around each action' do
+  it 'can be used to log data' do
+    context = { :number => 0, :logger => TestDoubles::TestLogger.new }
+
+    result = TestDoubles::AroundEachOrganizer.call(context)
+
+    expect(result.fetch(:number)).to eq(2)
+    expect(result[:logger].logs).to eq(
+      [{
+        :action => TestDoubles::AddsTwoActionWithFetch,
+        :before => 0,
+        :after => 2
+      }]
+    )
+  end
+end