functional-light-service 0.5.4 → 6.1.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/functional/sequencer.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module FunctionalLightService
+  # Do-notation for Result: chains steps that return Success/Failure,
+  # short-circuiting on the first Failure. Ported from the deterministic
+  # gem (MIT License, Copyright (c) Piotr Zolnierek and contributors,
+  # https://github.com/pzol/deterministic).
+  #
+  #   in_sequence do
+  #     get(:user)  { fetch_user(id) }      # binds the Success value to :user
+  #     let(:name)  { user.fetch(:name) }   # binds a plain (non-Result) value
+  #     and_then    { validate(user) }      # step without binding
+  #     observe     { log(name) }           # side effect, return value ignored
+  #     and_yield   { Success(name) }       # final result of the sequence
+  #   end
+  module Sequencer
+    class InvalidSequenceError < StandardError; end
+
+    module Operation
+      Get = Struct.new(:block, :name)
+      Let = Struct.new(:block, :name)
+      AndThen = Struct.new(:block)
+      Observe = Struct.new(:block)
+      AndYield = Struct.new(:block)
+    end
+
+    def in_sequence(&)
+      sequencer = Sequencer.new(self)
+      sequencer.instance_eval(&)
+      sequencer.yield
+    end
+
+    class Sequencer
+      def initialize(instance)
+        @operations = []
+        @operation_wrapper = OperationWrapper.new(instance)
+      end
+
+      def get(name, &block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Get.new(block, name)
+      end
+
+      def let(name, &block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Let.new(block, name)
+      end
+
+      def and_then(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::AndThen.new(block)
+      end
+
+      def observe(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Observe.new(block)
+      end
+
+      def and_yield(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::AndYield.new(block)
+
+        prepare_sequenced_operations
+      end
+
+      def yield
+        raise InvalidSequenceError, 'and_yield not called' unless @sequenced_operations
+
+        @operation_wrapper.instance_eval(&@sequenced_operations)
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      def prepare_sequenced_operations
+        operations = @operations
+
+        @sequenced_operations = ->(_) do
+          operations.reduce(Result::Success.new(nil)) do |last_result, operation|
+            last_result.map do
+              case operation
+              when Operation::Get
+                result = instance_eval(&operation.block)
+                result.map do |output|
+                  # Runs in the context of the OperationWrapper, so the
+                  # bound value is stored within the wrapper itself.
+                  @gotten_results[operation.name] = output
+                  result
+                end
+              when Operation::Let
+                @gotten_results[operation.name] = instance_eval(&operation.block)
+                last_result
+              when Operation::Observe
+                instance_eval(&operation.block)
+                last_result
+              when Operation::AndThen, Operation::AndYield
+                instance_eval(&operation.block)
+              end
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    end
+
+    # OperationWrapper proxies all method calls to the wrapped instance, but
+    # first checks if the name of the called method matches a value stored
+    # within @gotten_results and returns the value if it does.
+    class OperationWrapper < SimpleDelegator
+      def initialize(*args)
+        super
+        @gotten_results = {}
+      end
+
+      def method_missing(name, *args, **kwargs, &)
+        if @gotten_results.key?(name)
+          @gotten_results[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @gotten_results.key?(name) || super
+      end
+    end
+  end
+
+  module Prelude
+    include Sequencer
+  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