functional-light-service 0.4.4 → 6.0.0

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

@@ -1,116 +1,129 @@
-module FunctionalLightService
-  Result = FunctionalLightService.enum do
-    Success(:s)
-    Failure(:f)
-  end
-
-  class Result
-    class << self
-      def try!
-        Success.new(yield)
-      rescue StandardError => e
-        Failure.new(e)
-      end
-    end
-  end
-
-  # rubocop:disable Metrics/BlockLength
-  FunctionalLightService.impl(Result) do
-    def map(proc = nil, &block)
-      success? ? bind(proc || block) : self
-    end
-
-    alias :>> :map
-    alias :and_then :map
-
-    def map_err(proc = nil, &block)
-      failure? ? bind(proc || block) : self
-    end
-
-    alias :or_else :map_err
-
-    def pipe(proc = nil, &block)
-      (proc || block).call(self)
-      self
-    end
-
-    alias :<< :pipe
-
-    def success?
-      is_a? Result::Success
-    end
-
-    def failure?
-      is_a? Result::Failure
-    end
-
-    def or(other)
-      unless other.is_a? Result
-        msg = "Expected #{other.inspect} to be a Result"
-        raise FunctionalLightService::Monad::NotMonadError, msg
-      end
-
-      match do
-        Success() { |_| self }
-        Failure() { |_| other }
-      end
-    end
-
-    def and(other)
-      unless other.is_a? Result
-        msg = "Expected #{other.inspect} to be a Result"
-        raise FunctionalLightService::Monad::NotMonadError, msg
-      end
-
-      match do
-        Success() { |_| other }
-        Failure() { |_| self }
-      end
-    end
-
-    def +(other)
-      unless other.is_a? Result
-        msg = "Expected #{other.inspect} to be a Result"
-        raise FunctionalLightService::Monad::NotMonadError, msg
-      end
-
-      match do
-        Success(where { other.success? }) { |s| Result::Success.new(s + other.value) }
-        Failure(where { other.failure? }) { |f| Result::Failure.new(f + other.value) }
-        Success() { |_| other } # implied other.failure?
-        Failure() { |_| self } # implied other.success?
-      end
-    end
-
-    def try(proc = nil, &block)
-      map(proc, &block)
-    rescue StandardError => e
-      Result::Failure.new(e)
-    end
-
-    alias :>= :try
-  end
-  # rubocop:enable Metrics/BlockLength
-end
-
-module FunctionalLightService
-  module Prelude
-    module Result
-      # rubocop:disable Naming/MethodName
-      def try!(&block)
-        FunctionalLightService::Result.try!(&block)
-      end
-
-      def Success(s)
-        FunctionalLightService::Result::Success.new(s)
-      end
-
-      def Failure(f)
-        FunctionalLightService::Result::Failure.new(f)
-      end
-      # rubocop:enable Naming/MethodName
-    end
-
-    include Result
-  end
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  Result = FunctionalLightService.enum do
+    Success(:s)
+    Failure(:f)
+  end
+
+  class Result
+    class << self
+      def try!
+        Success.new(yield)
+      rescue StandardError => e
+        Failure.new(e)
+      end
+    end
+  end
+
+  # rubocop:disable Metrics/BlockLength
+  FunctionalLightService.impl(Result) do
+    def map(proc = nil, &block)
+      success? ? bind(proc || block) : self
+    end
+
+    alias :>> :map
+    alias :and_then :map
+
+    def map_err(proc = nil, &block)
+      failure? ? bind(proc || block) : self
+    end
+
+    alias :or_else :map_err
+
+    def pipe(proc = nil, &block)
+      (proc || block).call(self)
+      self
+    end
+
+    def <<(proc = nil, &block)
+      FunctionalLightService::Deprecations.warn(
+        "Result#<< is deprecated; use #pipe instead"
+      )
+      pipe(proc, &block)
+    end
+
+    def success?
+      is_a? Result::Success
+    end
+
+    def failure?
+      is_a? Result::Failure
+    end
+
+    # Le operazioni usano il dispatch diretto invece del motore match:
+    # stessa semantica, ~2 ordini di grandezza piu veloce (audit, finding 3.1)
+    def or(other)
+      unless other.is_a? Result
+        msg = "Expected #{other.inspect} to be a Result"
+        raise FunctionalLightService::Monad::NotMonadError, msg
+      end
+
+      success? ? self : other
+    end
+
+    def and(other)
+      unless other.is_a? Result
+        msg = "Expected #{other.inspect} to be a Result"
+        raise FunctionalLightService::Monad::NotMonadError, msg
+      end
+
+      success? ? other : self
+    end
+
+    def +(other)
+      FunctionalLightService::Deprecations.warn(
+        "Result#+ is deprecated and will be removed in a future release; " \
+        "combine the two results explicitly"
+      )
+      unless other.is_a? Result
+        msg = "Expected #{other.inspect} to be a Result"
+        raise FunctionalLightService::Monad::NotMonadError, msg
+      end
+
+      if success? == other.success?
+        self.class.new(value + other.value)
+      elsif success?
+        other # other is the failure
+      else
+        self # self is the failure
+      end
+    end
+
+    def try(proc = nil, &block)
+      map(proc, &block)
+    rescue StandardError => e
+      Result::Failure.new(e)
+    end
+
+    def >=(proc = nil, &block)
+      FunctionalLightService::Deprecations.warn(
+        "Result#>= is deprecated; use #try instead"
+      )
+      try(proc, &block)
+    end
+  end
+  # rubocop:enable Metrics/BlockLength
+end
+
+module FunctionalLightService
+  module Prelude
+    module Result
+      # rubocop:disable Naming/MethodName
+      def try!(&)
+        FunctionalLightService::Result.try!(&)
+      end
+
+      def Success(s)
+        FunctionalLightService::Result::Success.new(s)
+      end
+
+      def Failure(f)
+        FunctionalLightService::Result::Failure.new(f)
+      end
+      # rubocop:enable Naming/MethodName
+    end
+
+    include Result
+  end
+end

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

@@ -1,47 +1,48 @@
-require 'i18n'
-
-module FunctionalLightService
-  class LocalizationAdapter
-    def failure(message_or_key, action_class, i18n_options = {})
-      find_translated_message(message_or_key,
-                              action_class,
-                              i18n_options,
-                              :type => :failure)
-    end
-
-    def success(message_or_key, action_class, i18n_options = {})
-      find_translated_message(message_or_key,
-                              action_class,
-                              i18n_options,
-                              :type => :success)
-    end
-
-    private
-
-    def find_translated_message(message_or_key,
-                                action_class,
-                                i18n_options,
-                                type)
-      if message_or_key.is_a?(Symbol)
-        i18n_options.merge!(type)
-        translate(message_or_key, action_class, i18n_options)
-      else
-        message_or_key
-      end
-    end
-
-    def translate(key, action_class, options = {})
-      type = options.delete(:type)
-
-      scope = i18n_scope_from_class(action_class, type)
-      options[:scope] = scope
-
-      I18n.t(key, **options)
-    end
-
-    def i18n_scope_from_class(action_class, type)
-      inflector = Dry::Inflector.new
-      "#{inflector.underscore(action_class.name)}.light_service.#{inflector.pluralize(type)}"
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'i18n'
+
+module FunctionalLightService
+  class LocalizationAdapter
+    def failure(message_or_key, action_class, i18n_options = {})
+      find_translated_message(message_or_key,
+                              action_class,
+                              i18n_options,
+                              :type => :failure)
+    end
+
+    def success(message_or_key, action_class, i18n_options = {})
+      find_translated_message(message_or_key,
+                              action_class,
+                              i18n_options,
+                              :type => :success)
+    end
+
+    private
+
+    def find_translated_message(message_or_key,
+                                action_class,
+                                i18n_options,
+                                type)
+      if message_or_key.is_a?(Symbol)
+        translate(message_or_key, action_class, i18n_options.merge(type))
+      else
+        message_or_key
+      end
+    end
+
+    def translate(key, action_class, options = {})
+      type = options.delete(:type)
+
+      scope = i18n_scope_from_class(action_class, type)
+      options[:scope] = scope
+
+      I18n.t(key, **options)
+    end
+
+    def i18n_scope_from_class(action_class, type)
+      inflector = Dry::Inflector.new
+      "#{inflector.underscore(action_class.name)}.light_service.#{inflector.pluralize(type)}"
+    end
+  end
+end

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

@@ -1,14 +1,16 @@
-module FunctionalLightService
-  module Organizer
-    class Execute
-      def self.run(code_block)
-        ->(ctx) do
-          return ctx if ctx.stop_processing?
-
-          code_block.call(ctx)
-          ctx
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Organizer
+    class Execute
+      def self.run(code_block)
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          code_block.call(ctx)
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -1,25 +1,30 @@
-require "dry/inflector"
-
-module FunctionalLightService
-  module Organizer
-    class Iterate
-      extend ScopedReducable
-
-      def self.run(organizer, collection_key, steps)
-        ->(ctx) do
-          return ctx if ctx.stop_processing?
-
-          collection = ctx[collection_key]
-          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)
-          end
-
-          ctx
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+module FunctionalLightService
+  module Organizer
+    class Iterate
+      extend ScopedReducable
+
+      INFLECTOR = Dry::Inflector.new
+
+      def self.run(organizer, collection_key, steps)
+        # La singolarizzazione dipende solo dalla chiave: si calcola una volta,
+        # non a ogni invocazione dello step (ne' tantomeno per ogni item)
+        item_key = INFLECTOR.singularize(collection_key).to_sym
+
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          ctx[collection_key].each do |item|
+            ctx[item_key] = item
+            ctx = scoped_reduce(organizer, ctx, steps)
+          end
+
+          ctx
+        end
+      end
+    end
+  end
+end

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

@@ -1,17 +1,19 @@
-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
+# frozen_string_literal: true
+
+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

@@ -1,20 +1,22 @@
-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
+# frozen_string_literal: true
+
+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

@@ -1,13 +1,15 @@
-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
+# frozen_string_literal: true
+
+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/with_callback.rb

@@ -1,26 +1,28 @@
-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
+# frozen_string_literal: true
+
+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