functional-light-service 6.2.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/i18n/localization_adapter.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/inflector'
-
-module FunctionalLightService
-  module I18n
-    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
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/inflector'
-
-module FunctionalLightService
-  # Adapter built-in basato su LocalizationMap: nessuna dipendenza da I18n.
-  # Viene selezionato da Configuration quando la costante ::I18n non esiste
-  class LocalizationAdapter
-    INFLECTOR = Dry::Inflector.new
-
-    def failure(message_or_key, action_class, options = {})
-      find_translated_message(message_or_key,
-                              INFLECTOR.underscore(action_class.to_s),
-                              options.merge(:type => :failures))
-    end
-
-    def success(message_or_key, action_class, options = {})
-      find_translated_message(message_or_key,
-                              INFLECTOR.underscore(action_class.to_s),
-                              options.merge(:type => :successes))
-    end
-
-    private
-
-    def find_translated_message(message_or_key, action_class, options)
-      if message_or_key.is_a?(Symbol)
-        FunctionalLightService::LocalizationMap.instance.dig(
-          FunctionalLightService::Configuration.locale,
-          action_class.to_sym,
-          :light_service,
-          options[:type],
-          message_or_key
-        )
-      else
-        message_or_key
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-
-module FunctionalLightService
-  class LocalizationMap < Hash
-    include ::Singleton
-  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_case.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Organizer
-    class ReduceCase
-      extend ScopedReducable
-
-      class Arguments
-        attr_reader :value, :when, :else
-
-        def initialize(**args)
-          validate_arguments(**args)
-          @value = args[:value]
-          @when = args[:when]
-          @else = args[:else]
-        end
-
-        private
-
-        # rubocop:disable Style/MultilineIfModifier
-        def validate_arguments(**args)
-          raise(
-            ArgumentError,
-            "Expected keyword arguments: [:value, :when, :else]. Given: #{args.keys}"
-          ) unless args.keys.intersection(mandatory_arguments).count == mandatory_arguments.count
-        end
-        # rubocop:enable Style/MultilineIfModifier
-
-        def mandatory_arguments
-          %i[value when else]
-        end
-      end
-
-      def self.run(organizer, **args)
-        arguments = Arguments.new(**args)
-
-        ->(ctx) do
-          return ctx if ctx.stop_processing?
-
-          matched_case = arguments.when.keys.find { |k| k.eql?(ctx[arguments.value]) }
-          steps = arguments.when[matched_case] || arguments.else
-
-          ctx = scoped_reduce(organizer, ctx, steps)
-
-          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_if_else.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Organizer
-    class ReduceIfElse
-      extend ScopedReducable
-
-      def self.run(organizer, condition_block, if_steps, else_steps)
-        ->(ctx) do
-          return ctx if ctx.stop_processing?
-
-          ctx = if condition_block.call(ctx)
-                  scoped_reduce(organizer, ctx, if_steps)
-                else
-                  scoped_reduce(organizer, ctx, else_steps)
-                end
-
-          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.stop_processing?
-          end
-
-          ctx
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Organizer
-    class ReduceWhile
-      def self.run(organizer, condition_block, steps)
-        ->(ctx) do
-          return ctx if ctx.stop_processing?
-
-          reset_skip(ctx)
-
-          Array(steps).each do |step|
-            break unless condition_block.call(ctx)
-
-            ctx = organizer.with(ctx).reduce([step])
-            break if ctx.stop_processing?
-          end
-
-          reset_skip(ctx)
-
-          ctx
-        end
-      end
-
-      def self.reset_skip(ctx)
-        ctx.reset_skip_remaining! unless ctx.failure? || ctx.skip_all_remaining?
-      end
-      private_class_method :reset_skip
-    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.skip_all_remaining?
-        ctx = organizer.with(ctx).reduce([steps])
-        ctx.reset_skip_remaining! unless ctx.failure? || ctx.skip_all_remaining?
-
-        ctx
-      end
-    end
-  end
-end