functional-light-service 0.3.4 → 0.5.4

data/Rakefile

@@ -9,4 +9,4 @@ RuboCop::RakeTask.new
 RSpec::Core::RakeTask.new(:spec)
 
 task(:default).clear
-task :default => %i[spec rubocop]
+task :default => %i[spec rubocop]

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.5.4

data/functional-light-service.gemspec

@@ -15,14 +15,25 @@ Gem::Specification.new do |gem|
   gem.name          = "functional-light-service"
   gem.require_paths = ["lib"]
   gem.version       = FunctionalLightService::VERSION
+  gem.required_ruby_version = '>= 2.6.0'
 
-  gem.add_dependency("dry-inflector", ">= 0.2.0")
-  gem.add_dependency("i18n", ">= 1.8.2")
+  gem.add_runtime_dependency("dry-inflector", "~> 0.2", ">= 0.2.1")
+  gem.add_runtime_dependency("i18n", "~> 1.8", ">= 1.8.11")
   
-  gem.add_development_dependency("i18n", ">= 1.8.2")
-  gem.add_development_dependency("dry-inflector", ">= 0.2.0")
-  gem.add_development_dependency("rspec", "~> 3.0")
-  gem.add_development_dependency("simplecov", "~> 0.16.1")
-  gem.add_development_dependency("rubocop", "~> 0.63.1")
-  gem.add_development_dependency("pry", "~> 0.12.2")
+
+  gem.add_development_dependency("rake", "~> 13.0.6", ">= 13.0.6")
+  gem.add_development_dependency("i18n", "~> 1.8", ">= 1.8.11")
+  gem.add_development_dependency("dry-inflector", "~> 0.2", ">= 0.2.1")
+  gem.add_development_dependency("rspec", "~> 3.10.0")
+  gem.add_development_dependency("rspec-mocks", "= 3.10.2")
+  gem.add_development_dependency("simplecov", "~> 0.21.2")
+  gem.add_development_dependency("simplecov-cobertura", "~> 2.1.0")
+  # rexml >= 3.3 ha un parser XML piu severo che rompe simplecov-cobertura 2.1.0
+  # (Malformed XML: No root element). Blocco alla 3.2.x compatibile.
+  gem.add_development_dependency("rexml", "< 3.3")
+  gem.add_development_dependency("rubocop", "~> 1.25.0")
+  gem.add_development_dependency("rubocop-performance", "~> 1.13.2")
+  gem.add_development_dependency("pry", "~> 0.14.1")
+  gem.add_development_dependency("solargraph", "~> 0.44.2")
+  gem.add_development_dependency("nokogiri", "~> 1.12.5")
 end

data/gemfiles/dry_inflector_0_2_1.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "dry-inflector", "~> 0.2.1"
+
+gemspec :path => "../"

data/gemfiles/i18n_1_8_11.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "i18n", "~> 1.8.11"
+
+gemspec :path => "../"

data/lib/functional-light-service/context/key_verifier.rb

@@ -24,7 +24,7 @@ module FunctionalLightService
 
       def error_message
         "#{type_name} #{format_keys(keys_not_found(keys))} " \
-        "to be in the context during #{action}"
+          "to be in the context during #{action}"
       end
 
       def throw_error_predicate(_keys)
@@ -95,7 +95,7 @@ module FunctionalLightService
 
       def error_message
         "promised or expected keys cannot be a " \
-        "reserved key: [#{format_keys(violated_keys)}]"
+          "reserved key: [#{format_keys(violated_keys)}]"
       end
 
       def keys

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

@@ -1,154 +1,152 @@
-module FunctionalLightService
-  # rubocop:disable ClassLength
-  class Context < Hash
-    include FunctionalLightService::Prelude::Option
-    include FunctionalLightService::Prelude::Result
-    attr_accessor :outcome, :current_action
-
-    def initialize(context = {}, outcome = Success(:message => '', :error => nil))
-      @outcome = outcome
-      @skip_remaining = false
-      context.to_hash.each { |k, v| self[k] = v }
-    end
-
-    def self.make(context = {})
-      unless context.is_a?(Hash) || context.is_a?(FunctionalLightService::Context)
-        msg = 'Argument must be Hash or FunctionalLightService::Context'
-        raise ArgumentError, msg
-      end
-
-      context = new(context) unless context.is_a?(Context)
-
-      context.assign_aliases(context.delete(:_aliases)) if context[:_aliases]
-      context
-    end
-
-    def add_to_context(values)
-      merge! values
-    end
-
-    def success?
-      @outcome.success?
-    end
-
-    def failure?
-      @outcome.failure?
-    end
-
-    def skip_remaining?
-      @skip_remaining
-    end
-
-    def reset_skip_remaining!
-      @outcome = Success(:message => '', :error => nil)
-      @skip_remaining = false
-    end
-
-    def message
-      @outcome.value.dig(:message)
-    end
-
-    def error_code
-      @outcome.value.dig(:error)
-    end
-
-    def succeed!(message = nil, options = {})
-      message = Configuration.localization_adapter.success(message,
-                                                           current_action,
-                                                           options)
-      @outcome = Success(:message => message)
-    end
-
-    def fail!(message = nil, options_or_error_code = {})
-      options_or_error_code ||= {}
-
-      if options_or_error_code.is_a?(Hash)
-        error_code = options_or_error_code.delete(:error_code)
-        options = options_or_error_code
-      else
-        error_code = options_or_error_code
-        options = {}
-      end
-
-      message = Configuration.localization_adapter.failure(message,
-                                                           current_action,
-                                                           options)
-
-      @outcome = Failure(:message => message, :error => error_code)
-    end
-
-    def fail_and_return!(*args)
-      fail!(*args)
-      throw(:jump_when_failed)
-    end
-
-    def fail_with_rollback!(message = nil, error_code = nil)
-      fail!(message, error_code)
-      raise FailWithRollbackError
-    end
-
-    def skip_remaining!(message = nil)
-      @outcome = Success(:message => message)
-      @skip_remaining = true
-    end
-
-    def stop_processing?
-      failure? || skip_remaining?
-    end
-
-    def define_accessor_methods_for_keys(keys)
-      return if keys.nil?
-
-      keys.each do |key|
-        next if respond_to?(key.to_sym)
-
-        define_singleton_method(key.to_s) { fetch(key) }
-        define_singleton_method("#{key}=") { |value| self[key] = value }
-      end
-    end
-
-    def assign_aliases(aliases)
-      @aliases = aliases
-
-      aliases.each_pair do |key, key_alias|
-        self[key_alias] = self[key]
-      end
-    end
-
-    def aliases
-      @aliases ||= {}
-    end
-
-    def [](key)
-      key = aliases.key(key) || key
-      return super(key)
-    end
-
-    def fetch(key, default = nil, &blk)
-      self[key] ||= if block_given?
-                      super(key, &blk)
-                    else
-                      super
-                    end
-    end
-
-    def inspect
-      "#{self.class}(#{self}, " \
-      + "success: #{success?}, " \
-      + "message: #{check_nil(message)}, " \
-      + "error_code: #{check_nil(error_code)}, " \
-      + "skip_remaining: #{@skip_remaining}, " \
-      + "aliases: #{@aliases}" \
-      + ")"
-    end
-
-    private
-
-    def check_nil(value)
-      return 'nil' unless value
-
-      "'#{value}'"
-    end
-  end
-  # rubocop:enable ClassLength
-end
+module FunctionalLightService
+  # rubocop:disable Metrics/ClassLength
+  class Context < Hash
+    include FunctionalLightService::Prelude::Option
+    include FunctionalLightService::Prelude::Result
+    attr_accessor :outcome, :current_action, :organized_by
+
+    # rubocop:disable Lint/MissingSuper
+    def initialize(context = {},
+                   outcome = Success(:message => '', :error => nil))
+      @outcome = outcome
+      @skip_remaining = false
+      context.to_hash.each { |k, v| self[k] = v }
+    end
+    # rubocop:enable Lint/MissingSuper
+
+    def self.make(context = {})
+      unless context.is_a?(Hash) || context.is_a?(FunctionalLightService::Context)
+        msg = 'Argument must be Hash or FunctionalLightService::Context'
+        raise ArgumentError, msg
+      end
+
+      context = new(context) unless context.is_a?(Context)
+
+      context.assign_aliases(context.delete(:_aliases)) if context[:_aliases]
+      context
+    end
+
+    def add_to_context(values)
+      merge! values
+    end
+
+    def success?
+      @outcome.success?
+    end
+
+    def failure?
+      @outcome.failure?
+    end
+
+    def skip_remaining?
+      @skip_remaining
+    end
+
+    def reset_skip_remaining!
+      @outcome = Success(:message => '', :error => nil)
+      @skip_remaining = false
+    end
+
+    def message
+      @outcome.value[:message]
+    end
+
+    def error_code
+      @outcome.value[:error]
+    end
+
+    def succeed!(message = nil, options = {})
+      message = Configuration.localization_adapter.success(message,
+                                                           current_action,
+                                                           options)
+      @outcome = Success(:message => message)
+    end
+
+    def fail!(message = nil, options_or_error_code = {})
+      options_or_error_code ||= {}
+
+      if options_or_error_code.is_a?(Hash)
+        error_code = options_or_error_code.delete(:error_code)
+        options = options_or_error_code
+      else
+        error_code = options_or_error_code
+        options = {}
+      end
+
+      message = Configuration.localization_adapter.failure(message,
+                                                           current_action,
+                                                           options)
+
+      @outcome = Failure(:message => message, :error => error_code)
+    end
+
+    def fail_and_return!(*args)
+      fail!(*args)
+      throw(:jump_when_failed)
+    end
+
+    def fail_with_rollback!(message = nil, error_code = nil)
+      fail!(message, error_code)
+      raise FailWithRollbackError
+    end
+
+    def skip_remaining!(message = nil)
+      @outcome = Success(:message => message)
+      @skip_remaining = true
+    end
+
+    def stop_processing?
+      failure? || skip_remaining?
+    end
+
+    def define_accessor_methods_for_keys(keys)
+      return if keys.nil?
+
+      keys.each do |key|
+        next if respond_to?(key.to_sym)
+
+        define_singleton_method(key.to_s) { fetch(key) }
+        define_singleton_method("#{key}=") { |value| self[key] = value }
+      end
+    end
+
+    def assign_aliases(aliases)
+      @aliases = aliases
+
+      aliases.each_pair do |key, key_alias|
+        self[key_alias] = self[key]
+      end
+    end
+
+    def aliases
+      @aliases ||= {}
+    end
+
+    def [](key)
+      key = aliases.key(key) || key
+      return super(key)
+    end
+
+    def fetch(key, default = nil, &blk)
+      self[key] ||= if block_given?
+                      super(key, &blk)
+                    else
+                      super
+                    end
+    end
+
+    def inspect
+      "#{self.class}(#{self}, success: #{success?}, message: #{check_nil(message)}, error_code: " \
+        "#{check_nil(error_code)}, skip_remaining: #{@skip_remaining}, aliases: #{@aliases})"
+    end
+
+    private
+
+    def check_nil(value)
+      return 'nil' unless value
+
+      "'#{value}'"
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

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

@@ -53,9 +53,9 @@ module FunctionalLightService
           end
 
           @value = if init.count == 1 && init[0].is_a?(Hash)
-                     Hash[args.zip(init[0].values)]
+                     args.zip(init[0].values).to_h
                    else
-                     Hash[args.zip(init)]
+                     args.zip(init).to_h
                    end
         end
 
@@ -67,7 +67,6 @@ module FunctionalLightService
 
       # rubocop:disable Metrics/MethodLength
       def self.create(parent, args)
-        # rubocop:disable Style/AccessModifierDeclarations
         if args.include? :value
           raise ArgumentError, "#{args} may not contain the reserved name :value"
         end
@@ -106,14 +105,11 @@ module FunctionalLightService
         end
 
         dt
-        # rubocop:enable Style/AccessModifierDeclarations
       end
       # rubocop:enable Metrics/MethodLength
 
       class << self
-        # rubocop:disable Style/AccessModifierDeclarations
         public :new
-        # rubocop:enable Style/AccessModifierDeclarations
       end
     end
 

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

@@ -7,6 +7,7 @@ class Object
     true
   end
 end
+
 # rubocop:disable Naming/MethodName
 def Maybe(obj)
   obj.nil? ? Null.instance : obj

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

@@ -58,7 +58,7 @@ class Null
     false
   end
 
-  def respond_to?(m, include_private = false)
+  def respond_to?(m)
     return true if @methods.empty? || @methods.include?(m)
 
     super

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

@@ -28,8 +28,6 @@ module FunctionalLightService
 
   # rubocop:disable Metrics/BlockLength
   impl(Option) do
-    class NoneValueError < StandardError; end
-
     def fmap
       match do
         Some() { |s| self.class.new(yield(s)) }

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

@@ -8,8 +8,8 @@ module FunctionalLightService
     class << self
       def try!
         Success.new(yield)
-      rescue StandardError => err
-        Failure.new(err)
+      rescue StandardError => e
+        Failure.new(e)
       end
     end
   end

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

@@ -2,9 +2,15 @@ module FunctionalLightService
   module Organizer
     class WithReducer
       attr_reader :context
+      attr_accessor :organizer
+
+      def initialize(monitored_organizer = nil)
+        @organizer = monitored_organizer
+      end
 
       def with(data = {})
         @context = FunctionalLightService::Context.make(data)
+        @context.organized_by = organizer
         self
       end
 

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

@@ -3,7 +3,7 @@ module FunctionalLightService
     class WithReducerFactory
       def self.make(monitored_organizer)
         logger = monitored_organizer.logger || FunctionalLightService::Configuration.logger
-        decorated = WithReducer.new
+        decorated = WithReducer.new(monitored_organizer)
 
         return decorated if logger.nil?
 

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

@@ -5,9 +5,12 @@ module FunctionalLightService
 
       alias logged? logged
 
-      def initialize(organizer, decorated: WithReducer.new, logger:)
+      def initialize(organizer, logger:, decorated: WithReducer.new)
         @decorated = decorated
         @organizer = organizer
+
+        decorated.organizer = organizer
+
         @logger = logger
         @logged = false
       end
@@ -19,7 +22,7 @@ module FunctionalLightService
 
         logger.info do
           "[FunctionalLightService] -     keys in context: " \
-          "#{extract_keys(decorated.context.keys)}"
+            "#{extract_keys(decorated.context.keys)}"
         end
         self
       end

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

@@ -63,6 +63,16 @@ module FunctionalLightService
       def logger
         @logger
       end
+
+      def add_to_context(**args)
+        args.map do |key, value|
+          execute(->(ctx) { ctx[key.to_sym] = value })
+        end
+      end
+
+      def add_aliases(args)
+        execute(->(ctx) { ctx.assign_aliases(ctx.aliases.merge(args)) })
+      end
     end
 
     module Macros

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

@@ -26,11 +26,13 @@ module FunctionalLightService
 
       # More than one arguments can be passed to the
       # Organizer's #call method
+      # rubocop:disable Style/ArgumentsForwarding
       def with(*args, &block)
         catch(:return_ctx_from_execution) do
           @organizer.call(*args, &block)
         end
       end
+      # rubocop:enable Style/ArgumentsForwarding
 
       def initialize(organizer)
         @organizer = organizer

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

@@ -1,3 +1,3 @@
 module FunctionalLightService
-  VERSION = "0.3.4".freeze
+  VERSION = "0.5.4".freeze
 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 FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::Organizer do
+  class TestAddAliases
+    extend FunctionalLightService::Organizer
+
+    def self.call(context = FunctionalLightService::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