functional-light-service 6.1.0 → 6.3.0

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

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  Option = FunctionalLightService.enum do
-    Some(:s)
-    None()
-  end
-
-  class Option
-    class Some
-      def initialize(init)
-        raise ArgumentError, "Some cannot wrap nil: use None instead" if init.nil?
-
-        super
-      end
-    end
-
-    class << self
-      def some?(expr)
-        to_option(expr) { expr.nil? }
-      end
-
-      def any?(expr)
-        to_option(expr) { expr.nil? || (expr.respond_to?(:empty?) && expr.empty?) }
-      end
-
-      def to_option(expr)
-        yield(expr) ? None.new : Some.new(expr)
-      end
-
-      def try!
-        yield
-      rescue StandardError
-        None.new
-      end
-    end
-  end
-
-  # Le operazioni usano il dispatch diretto invece del motore match:
-  # stessa semantica, ~2 ordini di grandezza piu veloce (audit, finding 3.1)
-  impl(Option) do
-    def fmap
-      some? ? self.class.new(yield(@value)) : self
-    end
-
-    def map(&fn)
-      some? ? bind(&fn) : self
-    end
-
-    def some?
-      is_a? Option::Some
-    end
-
-    def none?
-      is_a? Option::None
-    end
-
-    alias :empty? :none?
-
-    def value_or(n)
-      some? ? @value : n
-    end
-
-    def value_to_a
-      @value
-    end
-
-    def +(other)
-      FunctionalLightService::Deprecations.warn(
-        "Option#+ is deprecated and will be removed in a future release; " \
-        "combine the two options explicitly"
-      )
-      return other if none?
-      raise TypeError, "Other must be an #{Option}" unless other.is_a?(Option)
-
-      other.some? ? Option::Some.new(@value + other.value) : self
-    end
-  end
-
-  module Prelude
-    module Option
-      None = FunctionalLightService::Option::None.new
-      Option = FunctionalLightService::Option
-      # rubocop:disable Naming/MethodName
-      def Some(s)
-        FunctionalLightService::Option::Some.new(s)
-      end
-
-      def None
-        FunctionalLightService::Prelude::Option::None
-      end
-
-      def Option
-        FunctionalLightService::Option
-      end
-      # rubocop:enable Naming/MethodName
-      # include Option
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-# 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

@@ -1,144 +0,0 @@
-# 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,48 +0,0 @@
-# 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,16 +0,0 @@
-# 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,30 +0,0 @@
-# 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,19 +0,0 @@
-# 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,22 +0,0 @@
-# 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,15 +0,0 @@
-# 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,28 +0,0 @@
-# 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

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-      # Handler di default condiviso: prima veniva creata una classe anonima
-      # per ogni WithReducer senza around_each
-      NOOP_AROUND_EACH_HANDLER = ->(_context, &block) { block.call }
-
-      def around_each(handler)
-        @around_each_handler = handler
-        self
-      end
-
-      def around_each_handler
-        @around_each_handler || NOOP_AROUND_EACH_HANDLER
-      end
-
-      def reduce(*actions)
-        raise "No action(s) were provided" if actions.empty?
-
-        actions.flatten!
-
-        actions.each_with_index.with_object(context) do |(action, index), current_context|
-          invoke_action(current_context, action)
-        rescue FailWithRollbackError
-          reduce_rollback(actions, index)
-        ensure
-          # For logging
-          yield(current_context, action) if block_given?
-        end
-      end
-
-      def reduce_rollback(actions, index_of_failed_action = nil)
-        reversable_actions(actions, index_of_failed_action)
-          .reverse
-          .reduce(context) do |context, action|
-            if action.respond_to?(:rollback)
-              action.rollback(context)
-            else
-              context
-            end
-          end
-      end
-
-      private
-
-      def invoke_action(current_context, action)
-        around_each_handler.call(current_context) do
-          if action.respond_to?(:call)
-            action.call(current_context)
-          else
-            action.execute(current_context)
-          end
-        end
-      end
-
-      def reversable_actions(actions, index_of_failed_action = nil)
-        # L'indice viene tracciato nel reduce: actions.index troverebbe la prima
-        # occorrenza e con azioni duplicate il rollback sarebbe parziale
-        index_of_failed_action ||= actions.index(@context.current_action) || 0
-
-        # Reverse from the point where the fail was triggered
-        actions.take(index_of_failed_action + 1)
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Organizer
-    class WithReducerFactory
-      def self.make(monitored_organizer)
-        logger = monitored_organizer.logger || FunctionalLightService::Configuration.logger
-        decorated = WithReducer.new(monitored_organizer)
-
-        return decorated if logger.nil?
-
-        WithReducerLogDecorator.new(
-          monitored_organizer,
-          :decorated => decorated,
-          :logger => logger
-        )
-      end
-    end
-  end
-end