functional-light-service 0.4.4 → 6.0.0

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

@@ -1,118 +1,124 @@
-module FunctionalLightService
-  class Context
-    class KeyVerifier
-      attr_reader :context, :action
-
-      def initialize(context, action)
-        @context = context
-        @action = action
-      end
-
-      def are_all_keys_in_context?(keys)
-        not_found_keys = keys_not_found(keys)
-        not_found_keys.none?
-      end
-
-      def keys_not_found(keys)
-        keys ||= context.keys
-        keys - context.keys
-      end
-
-      def format_keys(keys)
-        keys.map { |k| ":#{k}" }.join(', ')
-      end
-
-      def error_message
-        "#{type_name} #{format_keys(keys_not_found(keys))} " \
-          "to be in the context during #{action}"
-      end
-
-      def throw_error_predicate(_keys)
-        raise NotImplementedError, 'Sorry, you have to override length'
-      end
-
-      def verify
-        return context if context.failure?
-
-        if throw_error_predicate(keys)
-          Configuration.logger.error error_message
-          raise error_to_throw, error_message
-        end
-
-        context
-      end
-
-      def self.verify_keys(context, action, &block)
-        ReservedKeysVerifier.new(context, action).verify
-        ExpectedKeyVerifier.new(context, action).verify
-
-        block.call
-
-        PromisedKeyVerifier.new(context, action).verify
-      end
-    end
-
-    class ExpectedKeyVerifier < KeyVerifier
-      def type_name
-        "expected"
-      end
-
-      def keys
-        action.expected_keys
-      end
-
-      def error_to_throw
-        ExpectedKeysNotInContextError
-      end
-
-      def throw_error_predicate(keys)
-        !are_all_keys_in_context?(keys)
-      end
-    end
-
-    class PromisedKeyVerifier < KeyVerifier
-      def type_name
-        "promised"
-      end
-
-      def keys
-        action.promised_keys
-      end
-
-      def error_to_throw
-        PromisedKeysNotInContextError
-      end
-
-      def throw_error_predicate(keys)
-        !are_all_keys_in_context?(keys)
-      end
-    end
-
-    class ReservedKeysVerifier < KeyVerifier
-      def violated_keys
-        (action.promised_keys + action.expected_keys) & reserved_keys
-      end
-
-      def error_message
-        "promised or expected keys cannot be a " \
-          "reserved key: [#{format_keys(violated_keys)}]"
-      end
-
-      def keys
-        violated_keys
-      end
-
-      def error_to_throw
-        ReservedKeysInContextError
-      end
-
-      def throw_error_predicate(keys)
-        keys.any?
-      end
-
-      def reserved_keys
-        %i[message error_code current_action].freeze
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  class Context
+    class KeyVerifier
+      attr_reader :context, :action
+
+      def initialize(context, action)
+        @context = context
+        @action = action
+      end
+
+      def are_all_keys_in_context?(keys)
+        not_found_keys = keys_not_found(keys)
+        not_found_keys.none?
+      end
+
+      def keys_not_found(keys)
+        keys ||= context.keys
+        # context.key? risolve anche gli alias
+        keys.reject { |key| context.key?(key) }
+      end
+
+      def format_keys(keys)
+        keys.map { |k| ":#{k}" }.join(', ')
+      end
+
+      def error_message
+        "#{type_name} #{format_keys(keys_not_found(keys))} " \
+          "to be in the context during #{action}"
+      end
+
+      def throw_error_predicate(_keys)
+        raise NotImplementedError, 'Sorry, you have to override length'
+      end
+
+      def verify
+        return context if context.failure?
+
+        if throw_error_predicate(keys)
+          Configuration.logger.error error_message
+          raise error_to_throw, error_message
+        end
+
+        context
+      end
+
+      def self.verify_keys(context, action, &block)
+        ReservedKeysVerifier.new(context, action).verify
+        ExpectedKeyVerifier.new(context, action).verify
+
+        block.call
+
+        PromisedKeyVerifier.new(context, action).verify
+      end
+    end
+
+    class ExpectedKeyVerifier < KeyVerifier
+      def type_name
+        "expected"
+      end
+
+      def keys
+        action.expected_keys
+      end
+
+      def error_to_throw
+        ExpectedKeysNotInContextError
+      end
+
+      def throw_error_predicate(keys)
+        !are_all_keys_in_context?(keys)
+      end
+    end
+
+    class PromisedKeyVerifier < KeyVerifier
+      def type_name
+        "promised"
+      end
+
+      def keys
+        action.promised_keys
+      end
+
+      def error_to_throw
+        PromisedKeysNotInContextError
+      end
+
+      def throw_error_predicate(keys)
+        !are_all_keys_in_context?(keys)
+      end
+    end
+
+    class ReservedKeysVerifier < KeyVerifier
+      def violated_keys
+        (action.promised_keys + action.expected_keys) & reserved_keys
+      end
+
+      def error_message
+        "promised or expected keys cannot be a " \
+          "reserved key: [#{format_keys(violated_keys)}]"
+      end
+
+      def keys
+        violated_keys
+      end
+
+      def error_to_throw
+        ReservedKeysInContextError
+      end
+
+      def throw_error_predicate(keys)
+        keys.any?
+      end
+
+      def reserved_keys
+        # _aliases/_before_actions/_after_actions sono chiavi infrastrutturali
+        # scritte da Organizer.with nel context
+        %i[message error_code current_action
+           _aliases _before_actions _after_actions].freeze
+      end
+    end
+  end
+end

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

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module FunctionalLightService
   # rubocop:disable Metrics/ClassLength
   class Context < Hash
     include FunctionalLightService::Prelude::Option
     include FunctionalLightService::Prelude::Result
-    attr_accessor :outcome, :current_action
+
+    attr_reader :outcome
+    attr_accessor :current_action, :organized_by
 
     # rubocop:disable Lint/MissingSuper
     def initialize(context = {},
@@ -43,7 +47,7 @@ module FunctionalLightService
     end
 
     def reset_skip_remaining!
-      @outcome = Success(:message => '', :error => nil)
+      # Resetta soltanto il flag: l'esito (e il suo messaggio) non vanno persi
       @skip_remaining = false
     end
 
@@ -66,8 +70,9 @@ module FunctionalLightService
       options_or_error_code ||= {}
 
       if options_or_error_code.is_a?(Hash)
-        error_code = options_or_error_code.delete(:error_code)
-        options = options_or_error_code
+        # 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 = {}
@@ -99,23 +104,48 @@ module FunctionalLightService
       failure? || skip_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|
-        next if respond_to?(key.to_sym)
-
-        define_singleton_method(key.to_s) { fetch(key) }
-        define_singleton_method("#{key}=") { |value| self[key] = value }
+        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
 
-      aliases.each_pair do |key, key_alias|
-        self[key_alias] = self[key]
-      end
+      self
     end
 
     def aliases
@@ -123,25 +153,38 @@ module FunctionalLightService
     end
 
     def [](key)
-      key = aliases.key(key) || key
-      return super(key)
+      super(resolve_key(key))
     end
 
-    def fetch(key, default = nil, &blk)
-      self[key] ||= if block_given?
-                      super(key, &blk)
-                    else
-                      super
-                    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}, aliases: #{@aliases})"
+        "#{check_nil(error_code)}, skip_remaining: #{@skip_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
 

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

@@ -0,0 +1,26 @@
+# 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,6 +1,8 @@
-module FunctionalLightService
-  class FailWithRollbackError < StandardError; end
-  class ExpectedKeysNotInContextError < StandardError; end
-  class PromisedKeysNotInContextError < StandardError; end
-  class ReservedKeysInContextError < StandardError; end
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  class FailWithRollbackError < StandardError; end
+  class ExpectedKeysNotInContextError < StandardError; end
+  class PromisedKeysNotInContextError < StandardError; end
+  class ReservedKeysInContextError < StandardError; end
+end