functional-light-service 0.3.4 → 0.4.4

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
+
+    # 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_log_decorator.rb

@@ -5,7 +5,7 @@ module FunctionalLightService
 
       alias logged? logged
 
-      def initialize(organizer, decorated: WithReducer.new, logger:)
+      def initialize(organizer, logger:, decorated: WithReducer.new)
         @decorated = decorated
         @organizer = organizer
         @logger = logger
@@ -19,7 +19,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/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.4.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/reduce_if_spec.rb

@@ -48,4 +48,36 @@ RSpec.describe FunctionalLightService::Organizer do
     result = TestReduceIf.call(empty_context)
     expect(result).to be_success
   end
+
+  it 'skips actions within in its own scope' do
+    org = Class.new do
+      extend FunctionalLightService::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

data/spec/context/inspect_spec.rb

@@ -13,13 +13,8 @@ RSpec.describe FunctionalLightService::Context do
   describe '#inspect' do
     it 'inspects the hash with all the fields' do
       inspected_context =
-        'FunctionalLightService::Context({}, ' \
-        + 'success: true, ' \
-        + 'message: \'\', ' \
-        + 'error_code: nil, ' \
-        + 'skip_remaining: false, ' \
-        + 'aliases: {}' \
-        + ')'
+        "FunctionalLightService::Context({}, success: true, message: '', error_code: nil, " \
+        "skip_remaining: false, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end
@@ -28,13 +23,8 @@ RSpec.describe FunctionalLightService::Context do
       context.fail!('There was an error')
 
       inspected_context =
-        'FunctionalLightService::Context({}, ' \
-        + 'success: false, ' \
-        + 'message: \'There was an error\', ' \
-        + 'error_code: nil, ' \
-        + 'skip_remaining: false, ' \
-        + 'aliases: {}' \
-        + ')'
+        "FunctionalLightService::Context({}, success: false, message: 'There was an error', " \
+        "error_code: nil, skip_remaining: false, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end
@@ -43,13 +33,8 @@ RSpec.describe FunctionalLightService::Context do
       context.skip_remaining!('No need to process')
 
       inspected_context =
-        'FunctionalLightService::Context({}, ' \
-        + 'success: true, ' \
-        + 'message: \'No need to process\', ' \
-        + 'error_code: nil, ' \
-        + 'skip_remaining: true, ' \
-        + 'aliases: {}' \
-        + ')'
+        "FunctionalLightService::Context({}, success: true, message: 'No need to process', " \
+        "error_code: nil, skip_remaining: true, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end

data/spec/context_spec.rb

@@ -167,7 +167,7 @@ RSpec.describe FunctionalLightService::Context do
   end
 
   it "allows a default block value for #fetch" do
-    expect(context.fetch(:madeup) { :default }).to eq(:default)
+    expect(context.fetch(:madeup, :default)).to eq(:default)
   end
 
   context "when aliases are included via .make" do

data/spec/lib/deterministic/monad_axioms.rb

@@ -34,7 +34,9 @@ shared_examples 'a Monad' do
 
     it '#bind must return a monad' do
       expect(monad.new(1).bind { |v| monad.new(v) }).to eq monad.new(1)
+      # rubocop:disable Lint/EmptyBlock
       expect { monad.new(1).bind {} }.to raise_error(FunctionalLightService::Monad::NotMonadError)
+      # rubocop:enable Lint/EmptyBlock
     end
 
     it '#new must return a monad' do

data/spec/lib/deterministic/monad_spec.rb

@@ -21,8 +21,10 @@ describe FunctionalLightService::Monad do
 
   context '#bind' do
     it "raises an error if the passed function does not return a monad of the same class" do
+      # rubocop:disable Lint/EmptyBlock
       expect { Identity.new(1).bind {} }.to \
         raise_error(FunctionalLightService::Monad::NotMonadError)
+      # rubocop:enable Lint/EmptyBlock
     end
     specify { expect(Identity.new(1).bind { |value| Identity.new(value) }).to eq Identity.new(1) }
 

data/spec/lib/deterministic/null_spec.rb

@@ -38,7 +38,9 @@ describe Null do
     null = Null.instance
     expect(null.to_str).to eq ""
     expect(null.to_ary).to eq []
+    # rubocop:disable Style/StringConcatenation
     expect("" + null).to eq ""
+    # rubocop:enable Style/StringConcatenation
 
     a, b, c = null
     expect(a).to be_nil

data/spec/lib/enum_spec.rb

@@ -8,7 +8,7 @@ describe FunctionalLightService::Enum do
       InvalidEnum = FunctionalLightService.enum do
         Unary(:value)
       end
-    end .to raise_error ArgumentError
+    end.to raise_error ArgumentError
   end
 
   context "Nullary, Unary, Binary" do
@@ -32,7 +32,9 @@ describe FunctionalLightService::Enum do
       expect { n.value }.to raise_error NoMethodError
       expect(n.inspect).to eq "Nullary"
       expect(n.to_s).to eq ""
+      # rubocop:disable Lint/EmptyBlock
       expect(n.fmap {}).to eq n
+      # rubocop:enable Lint/EmptyBlock
     end
 
     it "Unary" do

data/spec/sample/looks_up_tax_percentage_action_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 require_relative 'tax/looks_up_tax_percentage_action'
 
-class TaxRange; end
+class TaxRange
+  extend FunctionalLightService::Action
+end
 
 describe LooksUpTaxPercentageAction do
   let(:region) { double('region') }