functional-light-service 6.2.0 → 6.3.0

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

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  # rubocop:disable Metrics/ClassLength
-  class Context < Hash
-    include FunctionalLightService::Prelude::Option
-    include FunctionalLightService::Prelude::Result
-
-    attr_reader :outcome
-    attr_accessor :current_action, :organized_by
-
-    # rubocop:disable Lint/MissingSuper
-    def initialize(context = {},
-                   outcome = Success(:message => '', :error => nil))
-      @outcome = outcome
-      @skip_remaining = false
-      @skip_all_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 skip_all_remaining?
-      @skip_all_remaining
-    end
-
-    def reset_skip_remaining!
-      # Resetta soltanto il flag: l'esito (e il suo messaggio) non vanno persi
-      @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)
-        # dup: l'hash di opzioni appartiene al chiamante e non va mutato
-        options = options_or_error_code.dup
-        error_code = options.delete(: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
-
-    # Variante non azzerabile di skip_remaining!: salta tutto il resto
-    # dell'organizer, scope annidati compresi (scoped_reduce non la resetta)
-    def skip_all_remaining!(message = nil)
-      @outcome = Success(:message => message)
-      @skip_all_remaining = true
-    end
-
-    def stop_processing?
-      failure? || skip_remaining? || skip_all_remaining?
-    end
-
-    # Registra le chiavi come accessor consentiti: la lettura/scrittura passa
-    # da method_missing con whitelist. Rispetto a define_singleton_method non
-    # materializza una singleton class per ogni context (audit, finding 3.3)
-    def define_accessor_methods_for_keys(keys)
-      return if keys.nil?
-
-      @accessor_methods ||= {}
-      keys.each do |key|
-        key = key.to_sym
-        next if @accessor_methods.key?(key)
-
-        # Prima il conflitto veniva saltato in silenzio e ctx.size (o :count,
-        # :message, ...) ritornava il metodo di Hash invece del valore
-        if respond_to?(key) || respond_to?("#{key}=")
-          raise ReservedKeysInContextError,
-                "expected or promised key :#{key} conflicts with an existing " \
-                "#{self.class.name} method: rename the key or access it via ctx[:#{key}]"
-        end
-
-        @accessor_methods[key] = [:reader, key]
-        @accessor_methods[:"#{key}="] = [:writer, key]
-      end
-    end
-
-    def method_missing(name, *args)
-      accessor = @accessor_methods && @accessor_methods[name]
-      return super unless accessor
-
-      accessor[0] == :reader ? fetch(accessor[1]) : self[accessor[1]] = args.first
-    end
-
-    def respond_to_missing?(name, _include_all = false)
-      (!@accessor_methods.nil? && @accessor_methods.key?(name)) || super
-    end
-
-    def assign_aliases(aliases)
-      @aliases = aliases
-      # Hash inverso precomputato: la risoluzione in lettura/scrittura
-      # resta O(1) invece del reverse-scan di Hash#key
-      @inverse_aliases = aliases.invert
-
-      self
-    end
-
-    def aliases
-      @aliases ||= {}
-    end
-
-    def [](key)
-      super(resolve_key(key))
-    end
-
-    def []=(key, value)
-      super(resolve_key(key), value)
-    end
-
-    def fetch(key, ...)
-      super(resolve_key(key), ...)
-    end
-
-    def key?(key)
-      super(resolve_key(key))
-    end
-
-    alias has_key? key?
-    alias member? key?
-    alias include? key?
-
-    def inspect
-      "#{self.class}(#{self}, success: #{success?}, message: #{check_nil(message)}, error_code: " \
-        "#{check_nil(error_code)}, skip_remaining: #{@skip_remaining}, " \
-        "skip_all_remaining: #{@skip_all_remaining}, aliases: #{aliases})"
-    end
-
-    private
-
-    def resolve_key(key)
-      return key unless @inverse_aliases
-
-      @inverse_aliases[key] || key
-    end
-
-    def check_nil(value)
-      return 'nil' unless value
-
-      "'#{value}'"
-    end
-  end
-  # rubocop:enable Metrics/ClassLength
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  # Deprecation warnings non fatali: ogni messaggio viene emesso una sola
-  # volta per processo (su stderr) e puo' essere silenziato globalmente,
-  # ad esempio nelle suite di test.
-  module Deprecations
-    @emitted = {}
-
-    class << self
-      attr_accessor :silenced
-
-      def warn(message)
-        return if silenced
-        return if @emitted[message]
-
-        @emitted[message] = true
-        Kernel.warn("DEPRECATION WARNING: #{message}")
-      end
-
-      def reset!
-        @emitted = {}
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  class FailWithRollbackError < StandardError; end
-  class ExpectedKeysNotInContextError < StandardError; end
-  class PromisedKeysNotInContextError < StandardError; end
-  class ReservedKeysInContextError < StandardError; end
-  class UnusableExpectKeyDefaultError < StandardError; end
-end

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

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Enum
-    class MatchError < StandardError; end
-  end
-
-  class EnumBuilder
-    def initialize(parent)
-      @parent = parent
-    end
-
-    class DataType
-      module AnyEnum
-        include FunctionalLightService::Monad
-
-        def match(&)
-          parent.match(self, &)
-        end
-
-        def to_s
-          value.to_s
-        end
-
-        def name
-          self.class.name.split("::")[-1]
-        end
-
-        # Returns array. Will fail on Nullary objects.
-        # TODO: define a Unary module so we can define this method differently on Unary vs Binary
-        def wrapped_values
-          if is_a?(FunctionalLightService::EnumBuilder::DataType::Binary)
-            value.values
-          else
-            [value]
-          end
-        end
-
-        # Supporto al pattern matching nativo di Ruby (case/in):
-        #   case result
-        #   in FunctionalLightService::Result::Success(s) then ...
-        #   in FunctionalLightService::Result::Failure(f) then ...
-        #   end
-        def deconstruct
-          is_a?(FunctionalLightService::EnumBuilder::DataType::Nullary) ? [] : wrapped_values
-        end
-
-        def deconstruct_keys(_keys)
-          if is_a?(FunctionalLightService::EnumBuilder::DataType::Binary)
-            value.dup
-          elsif is_a?(FunctionalLightService::EnumBuilder::DataType::Nullary)
-            {}
-          else
-            { args[0] => value }
-          end
-        end
-      end
-
-      module Nullary
-        def initialize(*_args)
-          @value = nil
-        end
-
-        def inspect
-          name
-        end
-      end
-
-      # TODO: this should probably be named Multary
-      module Binary
-        def initialize(*init)
-          unless (init.one? && init[0].is_a?(Hash)) || init.count == args.count
-            raise ArgumentError, "Expected arguments for #{args}, got #{init}"
-          end
-
-          @value = if init.one? && init[0].is_a?(Hash)
-                     args.zip(init[0].values).to_h
-                   else
-                     args.zip(init).to_h
-                   end
-        end
-
-        def inspect
-          params = value.map { |k, v| "#{k}: #{v.inspect}" }
-          "#{name}(#{params.join(', ')})"
-        end
-      end
-
-      # rubocop:disable Metrics/MethodLength
-      def self.create(parent, args)
-        if args.include? :value
-          raise ArgumentError, "#{args} may not contain the reserved name :value"
-        end
-
-        dt = Class.new(parent)
-
-        dt.instance_eval do
-          public_class_method :new
-          include AnyEnum
-
-          define_method(:args) { args }
-
-          define_method(:parent) { parent }
-          private :parent
-        end
-
-        case args.count
-        when 0
-          dt.instance_eval do
-            include Nullary
-
-            private :value
-          end
-        when 1
-          dt.instance_eval do
-            define_method(args[0].to_sym) { value }
-          end
-        else
-          dt.instance_eval do
-            include Binary
-
-            args.each do |m|
-              define_method(m) do
-                @value[m]
-              end
-            end
-          end
-        end
-
-        dt
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      class << self
-        public :new
-      end
-    end
-
-    def method_missing(m, *args)
-      if @parent.const_defined?(m)
-        raise ArgumentError, "variant #{m} is already defined for this enum"
-      end
-
-      @parent.const_set(m, DataType.create(@parent, args))
-    end
-
-    def respond_to_missing?(_m, _include_all = false)
-      true
-    end
-  end
-
-  module_function
-
-  # rubocop:disable Metrics/AbcSize
-  # rubocop:disable Metrics/CyclomaticComplexity
-  # rubocop:disable Metrics/MethodLength
-  # rubocop:disable Metrics/PerceivedComplexity
-  def enum(&block)
-    mod = Class.new do # the enum to be built
-      private_class_method :new
-
-      def self.match(obj, &block)
-        # Binding#receiver: stesso risultato di binding.eval('self') senza eval
-        caller_ctx = block.binding.receiver
-
-        matcher = self::Matcher.new(obj)
-        matcher.instance_eval(&block)
-
-        # exhaustiveness check su classi memoizzate: niente split/sort di
-        # stringhe per chiamata
-        covered = matcher.matches.map { |e| e[1] }
-        missing = variant_classes.reject { |klass| covered.include?(klass) }
-        unless missing.empty?
-          missing_names = missing.map { |klass| klass.name.split('::')[-1].to_sym }
-          raise Enum::MatchError, "Match is non-exhaustive, #{missing_names} not covered"
-        end
-
-        type_matches = matcher.matches.select { |r| r[0].is_a?(r[1]) }
-
-        type_matches.each do |match|
-          obj, _type, block, args, guard = match
-
-          return caller_ctx.instance_eval(&block) if args.empty?
-
-          if args.count != obj.args.count
-            msg = "Pattern (#{args.join(', ')}) must match (#{obj.args.join(', ')})"
-            raise Enum::MatchError, msg
-          end
-
-          guard_ctx = guard_context(obj, args)
-          return caller_ctx.instance_exec(* obj.wrapped_values, &block) unless guard
-
-          if guard && guard_ctx.instance_exec(obj, &guard)
-            return caller_ctx.instance_exec(* obj.wrapped_values, &block)
-          end
-        end
-
-        raise Enum::MatchError, "No match could be made"
-      end
-
-      def self.variants
-        constants - %i[Matcher MatchError]
-      end
-
-      def self.variant_classes
-        @variant_classes ||= variants.map { |v| const_get(v) }.freeze
-      end
-
-      def self.guard_context(obj, args)
-        # Struct.new definisce una classe: va fatto una volta per firma,
-        # non a ogni match con guard
-        @guard_structs ||= {}
-        struct = @guard_structs[args] ||= Struct.new(*args)
-
-        if obj.is_a?(FunctionalLightService::EnumBuilder::DataType::Binary)
-          struct.new(*obj.value.values)
-        else
-          struct.new(obj.value)
-        end
-      end
-    end
-    enum = EnumBuilder.new(mod)
-    enum.instance_eval(&block)
-
-    type_variants = mod.constants
-
-    matcher = Class.new do
-      def initialize(obj)
-        @obj = obj
-        @matches = []
-        @vars = []
-      end
-
-      attr_reader :matches, :vars
-
-      def where(&guard)
-        guard
-      end
-
-      type_variants.each do |m|
-        define_method(m) do |guard = nil, &inner_block|
-          raise ArgumentError, "No block given to `#{m}`" if inner_block.nil?
-
-          params_spec = inner_block.parameters
-          if params_spec.any? { |spec| spec.size < 2 }
-            msg = "Unnamed param found in block parameters: #{params_spec.inspect}"
-            raise ArgumentError, msg
-          end
-          if params_spec.any? { |spec| spec[0] != :req && spec[0] != :opt }
-            msg = "Only :req & :opt params allowed; parameters=#{params_spec.inspect}"
-            raise ArgumentError, msg
-          end
-
-          args = params_spec.map { |spec| spec[1] }
-
-          type = mod.const_get(m)
-
-          guard = nil if guard && !guard.is_a?(Proc)
-
-          @matches << [@obj, type, inner_block, args, guard]
-        end
-      end
-    end
-
-    mod.const_set(:Matcher, matcher)
-
-    type_variants.each do |variant|
-      mod.singleton_class.class_exec do
-        define_method(variant) do |*args|
-          const_get(variant).new(*args)
-        end
-      end
-    end
-    mod
-  end
-  # rubocop:enable Metrics/AbcSize
-  # rubocop:enable Metrics/CyclomaticComplexity
-  # rubocop:enable Metrics/MethodLength
-  # rubocop:enable Metrics/PerceivedComplexity
-
-  def impl(enum_type, &block)
-    enum_type.variants.each do |v|
-      enum_type.const_get(v).class_eval(&block)
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  def null?
-    false
-  end
-
-  def some?
-    true
-  end
-end
-
-# rubocop:disable Naming/MethodName
-def Maybe(obj)
-  FunctionalLightService::Deprecations.warn(
-    "Maybe()/Null are deprecated and will be removed in a future release; " \
-    "use FunctionalLightService::Option (Some/None) instead"
-  )
-  obj.nil? ? Null.instance : obj
-end
-# rubocop:enable Naming/MethodName

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Monad
-    class NotMonadError < StandardError; end
-
-    # Basicly the `pure` function
-    def initialize(init)
-      @value = join(init)
-    end
-
-    # If the passed value is monad already, get the value to avoid nesting
-    # M[M[A]] is equivalent to M[A]
-    def join(other)
-      if other.is_a? self.class
-        other.value
-      else
-        other
-      end
-    end
-
-    # The functor: takes a function (a -> b) and applies it to the inner value of the monad (Ma),
-    # boxes it back to the same monad (Mb)
-    # fmap :: (a -> b) -> M a -> M b
-    def fmap(proc = nil, &block)
-      result = (proc || block).call(value)
-      self.class.new(result)
-    end
-
-    # The monad: takes a function which returns a monad (of the same type), applies the function
-    # bind :: (a -> Mb) -> M a  -> M b
-    # the self.class, i.e. the containing monad is passed as a second (optional) arg to the function
-    def bind(proc = nil, &block)
-      (proc || block).call(value).tap do |result|
-        # rubocop:disable Style/CaseEquality
-        parent = self.class.superclass === Object ? self.class : self.class.superclass
-        # rubocop:enable Style/CaseEquality
-        unless result.is_a? parent
-          raise NotMonadError, "Expected #{result.inspect} to be an #{parent}"
-        end
-      end
-    end
-    # rubocop:disable Naming/MethodName
-    alias :'>>=' :bind
-    # rubocop:enable Naming/MethodName
-
-    # Get the underlying value, return in Haskell
-    # return :: M a -> a
-    def value
-      @value
-    end
-
-    def to_s
-      value.to_s
-    end
-
-    # Two monads are equivalent if they are of the same type and when their values are equal
-    def ==(other)
-      return false unless other.is_a? self.class
-
-      @value == other.monad_value
-    end
-
-    # Reader protetto: #value e' privato nelle varianti Nullary (es. None),
-    # ma il confronto tra monadi dello stesso tipo deve poter leggere il valore
-    def monad_value
-      @value
-    end
-    protected :monad_value
-
-    # Return the string representation of the Monad
-    def inspect
-      pretty_class_name = self.class.name.split('::')[-1]
-      "#{pretty_class_name}(#{value.inspect})"
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-# The simplest NullObject there can be
-class Null
-  class << self
-    def method_missing(m, *args)
-      if m == :new
-        super
-      else
-        Null.instance
-      end
-    end
-
-    def respond_to_missing?(m, _include_all = false)
-      m != :new || super
-    end
-
-    def instance
-      FunctionalLightService::Deprecations.warn(
-        "Maybe()/Null are deprecated and will be removed in a future release; " \
-        "use FunctionalLightService::Option (Some/None) instead"
-      )
-      @instance ||= new([])
-    end
-
-    def null?
-      true
-    end
-
-    def some?
-      false
-    end
-
-    def mimic(klas)
-      FunctionalLightService::Deprecations.warn(
-        "Maybe()/Null are deprecated and will be removed in a future release; " \
-        "use FunctionalLightService::Option (Some/None) instead"
-      )
-      new(klas.instance_methods(false))
-    end
-
-    def ==(other)
-      other.respond_to?(:null?) && other.null?
-    end
-  end
-  private_class_method :new
-
-  def initialize(methods)
-    @methods = methods
-  end
-
-  # implicit conversions
-  def to_str
-    ''
-  end
-
-  def to_ary
-    []
-  end
-
-  def method_missing(m, *args)
-    return self if respond_to_missing?(m)
-
-    super
-  end
-
-  def null?
-    true
-  end
-
-  def some?
-    false
-  end
-
-  # Convenzione Ruby: si estende respond_to_missing?, mai respond_to?
-  # (il vecchio override aveva anche la firma sbagliata: mancava include_all)
-  def respond_to_missing?(m, _include_all = false)
-    @methods.empty? || @methods.include?(m) || super
-  end
-
-  def inspect
-    'Null'
-  end
-
-  def ==(other)
-    other.respond_to?(:null?) && other.null?
-  end
-end