functional-light-service 0.2.5 → 0.4.4

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

@@ -1,165 +1,152 @@
-require 'active_support/deprecation'
-
-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?
-      success? == false
-    end
-
-    def skip_remaining?
-      @skip_remaining
-    end
-
-    def reset_skip_remaining!
-      @outcome = Success(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, *args)
-    end
-
-    def fail_with_rollback!(message = nil, error_code = nil)
-      fail!(message, error_code)
-      raise FailWithRollbackError
-    end
-
-    def skip_all!(message = nil)
-      warning_msg = "Using skip_all! has been deprecated, " \
-                    "please use `skip_remaining!` instead."
-      ActiveSupport::Deprecation.warn(warning_msg)
-
-      skip_remaining!(message)
-    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
 
@@ -219,7 +215,7 @@ module FunctionalLightService
 
           args = params_spec.map { |spec| spec[1] }
 
-          type = Kernel.eval("#{mod.name}::#{m}")
+          type = mod.const_get(m)
 
           guard = nil if guard && !guard.is_a?(Proc)
 

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
@@ -17,20 +17,14 @@ module FunctionalLightService
   # rubocop:disable Metrics/BlockLength
   FunctionalLightService.impl(Result) do
     def map(proc = nil, &block)
-      match do
-        Success() { |_| bind(proc || block) }
-        Failure() { |_| self }
-      end
+      success? ? bind(proc || block) : self
     end
 
     alias :>> :map
     alias :and_then :map
 
     def map_err(proc = nil, &block)
-      match do
-        Success() { |_| self }
-        Failure() { |_| bind(proc || block) }
-      end
+      failure? ? bind(proc || block) : self
     end
 
     alias :or_else :map_err

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

@@ -1,3 +1,5 @@
+require 'i18n'
+
 module FunctionalLightService
   class LocalizationAdapter
     def failure(message_or_key, action_class, i18n_options = {})
@@ -34,11 +36,12 @@ module FunctionalLightService
       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)
-      "#{action_class.name.underscore}.light_service.#{type.to_s.pluralize}"
+      inflector = Dry::Inflector.new
+      "#{inflector.underscore(action_class.name)}.light_service.#{inflector.pluralize(type)}"
     end
   end
 end

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

@@ -1,3 +1,5 @@
+require "dry/inflector"
+
 module FunctionalLightService
   module Organizer
     class Iterate
@@ -8,7 +10,8 @@ module FunctionalLightService
           return ctx if ctx.stop_processing?
 
           collection = ctx[collection_key]
-          item_key = collection_key.to_s.singularize.to_sym
+          inflector = Dry::Inflector.new
+          item_key = inflector.singularize(collection_key).to_sym
           collection.each do |item|
             ctx[item_key] = item
             ctx = scoped_reduce(organizer, ctx, steps)

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

@@ -11,11 +11,12 @@ module FunctionalLightService
         call_method_exists = klass.methods.include?(:call)
         return if call_method_exists
 
-        warning_msg = "The <#{klass.name}> class is an organizer, " \
+        warning_msg = "DEPRECATION WARNING:" \
+                      "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)
+        print warning_msg
       end
 
       def self.caller_method(first_caller)

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/organizer.rb

@@ -1,5 +1,3 @@
-require 'active_support/deprecation'
-
 module FunctionalLightService
   module Organizer
     def self.extended(base_class)
@@ -8,9 +6,10 @@ module FunctionalLightService
     end
 
     def self.included(base_class)
-      warning_msg = "including FunctionalLightService::Organizer is deprecated. " \
-                    "Please use `extend FunctionalLightService::Organizer` instead"
-      ActiveSupport::Deprecation.warn(warning_msg)
+      msg = "DEPRECATION WARNING:\n" \
+            "Including FunctionalLightService::Organizer is deprecated\n" \
+            "Please use `extend FunctionalLightService::Organizer` instead"
+      print msg
       extended(base_class)
     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.2.5".freeze
+  VERSION = "0.4.4".freeze
 end

data/lib/functional-light-service.rb

@@ -1,5 +1,4 @@
 require 'logger'
-require 'active_support/core_ext/string'
 
 require 'functional-light-service/version'
 

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/include_warning_spec.rb

@@ -3,27 +3,27 @@ require 'spec_helper'
 describe "Including is discouraged" do
   context "when including FunctionalLightService::Organizer" do
     it "gives warning" do
-      expected_msg = "including FunctionalLightService::Organizer is deprecated. " \
+      expected_msg = "DEPRECATION WARNING:\n" \
+                     "Including FunctionalLightService::Organizer is deprecated\n" \
                      "Please use `extend FunctionalLightService::Organizer` instead"
-      expect(ActiveSupport::Deprecation).to receive(:warn)
-        .with(expected_msg)
-
-      class OrganizerIncludingLS
-        include FunctionalLightService::Organizer
-      end
+      expect do
+        class OrganizerIncludingLS
+          include FunctionalLightService::Organizer
+        end
+      end.to output(expected_msg).to_stdout
     end
   end
 
   context "when including FunctionalLightService::Action" do
     it "gives warning" do
-      expected_msg = "including FunctionalLightService::Action is deprecated. " \
+      expected_msg = "DEPRECATION WARNING:\n" \
+                     "Including FunctionalLightService::Action is deprecated\n" \
                      "Please use `extend FunctionalLightService::Action` instead"
-      expect(ActiveSupport::Deprecation).to receive(:warn)
-        .with(expected_msg)
-
-      class ActionIncludingLS
-        include FunctionalLightService::Action
-      end
+      expect do
+        class ActionIncludingLS
+          include FunctionalLightService::Action
+        end
+      end.to output(expected_msg).to_stdout
     end
   end
 end