functional-light-service 6.2.0 → 6.3.0

data/Rakefile

@@ -1,12 +0,0 @@
-require "bundler/gem_tasks"
-
-require "rubygems"
-require "bundler/setup"
-
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
-RuboCop::RakeTask.new
-RSpec::Core::RakeTask.new(:spec)
-
-task(:default).clear
-task :default => %i[spec rubocop]

data/VERSION

@@ -1 +0,0 @@
-0.5.4

data/audit/bench.rb

@@ -1,99 +0,0 @@
-# Micro-benchmark dei costi nascosti individuati nell'audit
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require 'functional-light-service'
-require 'benchmark/ips'
-
-include FunctionalLightService::Prelude::Result
-include FunctionalLightService::Prelude::Option
-
-puts "Ruby #{RUBY_VERSION}, YJIT: #{defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled? ? 'on' : 'off'}"
-puts
-
-some = Some(42)
-success = Success(42)
-
-# 1) Costo del motore match (Option#value_or usa match) vs equivalente diretto
-Benchmark.ips do |x|
-  x.report("Option#value_or (match engine)") { some.value_or(0) }
-  x.report("equivalente is_a? diretto")      { some.is_a?(FunctionalLightService::Option::Some) ? some.value : 0 }
-  x.report("case/in nativo Ruby") do
-    case some
-    in FunctionalLightService::Option::Some then some.value
-    else 0
-    end
-  end
-  x.compare!
-end
-
-# 2) match esplicito con guard (Struct.new per chiamata) su Result#+
-Benchmark.ips do |x|
-  other = Success(1)
-  x.report("Result#+ (match con guard -> Struct.new/call)") { success + other }
-  x.report("somma diretta is_a?") do
-    if success.is_a?(FunctionalLightService::Result::Success) && other.is_a?(FunctionalLightService::Result::Success)
-      FunctionalLightService::Result::Success.new(success.value + other.value)
-    end
-  end
-  x.compare!
-end
-
-# 3) Result#map (bind, senza match) — per confronto: la parte "sana"
-Benchmark.ips do |x|
-  f = ->(v) { Success(v + 1) }
-  x.report("Result#map via bind") { success.map(f) }
-  x.report("lambda diretta")      { success.is_a?(FunctionalLightService::Result::Success) ? f.call(success.value) : success }
-  x.compare!
-end
-
-# 4) Overhead di Organizer.with: caller(1..1) + methods.include?(:call)
-Benchmark.ips do |x|
-  klass = Class.new { def self.call; end }
-  x.report("caller(1..1) + methods.include?") do
-    c = caller(1..1).first
-    c =~ /`(.*)'/
-    klass.methods.include?(:call)
-  end
-  x.report("respond_to?(:call) soltanto") { klass.respond_to?(:call) }
-  x.compare!
-end
-
-# 5) define_accessor_methods_for_keys: singleton methods per ogni context
-Benchmark.ips do |x|
-  keys = %i[number total counter]
-  x.report("nuovo Context + define accessor per keys") do
-    ctx = FunctionalLightService::Context.make(:number => 1, :total => 2, :counter => 3)
-    ctx.define_accessor_methods_for_keys(keys)
-  end
-  x.report("nuovo Context senza accessor") do
-    FunctionalLightService::Context.make(:number => 1, :total => 2, :counter => 3)
-  end
-  x.compare!
-end
-
-# 6) Context#[] con alias attivi (Hash#key reverse scan) vs Hash puro
-Benchmark.ips do |x|
-  ctx = FunctionalLightService::Context.make(:a => 1, :b => 2, :c => 3)
-  ctx.assign_aliases(:a => :alfa)
-  h = { :a => 1, :b => 2, :c => 3 }
-  x.report("Context#[] (con lookup alias)") { ctx[:b] }
-  x.report("Hash#[] puro")                  { h[:b] }
-  x.compare!
-end
-
-# 7) Organizer end-to-end: quota di overhead per call minimale
-class BenchAdd
-  extend FunctionalLightService::Action
-  expects :number
-  executed { |ctx| ctx[:number] = ctx[:number] + 1 }
-end
-class BenchOrg
-  extend FunctionalLightService::Organizer
-  def self.call(n)
-    with(:number => n).reduce([BenchAdd])
-  end
-end
-Benchmark.ips do |x|
-  x.report("Organizer.call 1 action") { BenchOrg.call(1) }
-  x.report("lavoro utile equivalente") { { :number => 1 }.tap { |h| h[:number] += 1 } }
-  x.compare!
-end

data/audit/verify_findings.rb

@@ -1,172 +0,0 @@
-# Verifica dei finding dell'audit — eseguito contro lib/ reale
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require 'functional-light-service'
-
-results = []
-def check(results, name)
-  ok, detail = yield
-  results << [name, ok, detail]
-rescue => e
-  results << [name, :exception, "#{e.class}: #{e.message}"]
-end
-
-# ---------- F1: before_actions perso alla seconda chiamata ----------
-class AddOne
-  extend FunctionalLightService::Action
-  expects :number
-  promises :number
-  executed { |ctx| ctx.number = ctx.number + 1 }
-end
-
-class Org1
-  extend FunctionalLightService::Organizer
-  before_actions ->(ctx) { ctx.number -= 10 if ctx.current_action == AddOne }
-  def self.call(number)
-    with(:number => number).reduce([AddOne])
-  end
-end
-
-check(results, "F1 before_actions perso alla 2a chiamata") do
-  r1 = Org1.call(0).fetch(:number)   # atteso: -10 + 1 = -9
-  r2 = Org1.call(0).fetch(:number)   # se bug: hook perso -> 1
-  [r1 == -9 && r2 == 1, "prima call=#{r1}, seconda call=#{r2}"]
-end
-
-# ---------- F2: Context#fetch — nessun KeyError e scrittura su read ----------
-check(results, "F2a fetch(:missing) ritorna nil invece di KeyError e scrive la chiave") do
-  ctx = FunctionalLightService::Context.make({})
-  v = ctx.fetch(:missing)
-  [v.nil? && ctx.to_h.key?(:missing), "valore=#{v.inspect}, chiavi dopo fetch=#{ctx.keys.inspect}"]
-end
-
-check(results, "F2b fetch con default sovrascrive un valore falsy esistente") do
-  ctx = FunctionalLightService::Context.make(:flag => false)
-  v = ctx.fetch(:flag, true)
-  [v == true && ctx[:flag] == true, "fetch(:flag, true)=#{v.inspect}, ctx[:flag] ora=#{ctx[:flag].inspect} (era false)"]
-end
-
-# ---------- F3: alias asimmetrico lettura/scrittura ----------
-check(results, "F3 scrittura su alias persa in lettura") do
-  ctx = FunctionalLightService::Context.make(:codice_fiscale => "ABC")
-  ctx.assign_aliases(:codice_fiscale => :cf)
-  ctx[:cf] = "NUOVO"          # scrive la chiave :cf direttamente
-  read = ctx[:cf]              # legge tradotto -> :codice_fiscale -> "ABC"
-  [read == "ABC", "dopo ctx[:cf]='NUOVO', ctx[:cf]=#{read.inspect}; hash=#{ctx.to_h.inspect}"]
-end
-
-# ---------- F4: accessor non definito per chiavi che collidono con metodi Hash ----------
-class UsesSize
-  extend FunctionalLightService::Action
-  expects :size
-  executed { |ctx| ctx[:observed] = ctx.size }  # l'utente si aspetta il valore di :size
-end
-
-check(results, "F4 expects :size -> accessor non definito, ritorna Hash#size") do
-  result = UsesSize.execute(:size => 999)
-  [result[:observed] != 999, "ctx.size dentro l'action=#{result[:observed].inspect} (atteso dal punto di vista utente: 999)"]
-end
-
-# ---------- F5: @ctx a livello di classe Action (retention + race) ----------
-check(results, "F5 la classe Action trattiene l'ultimo context in @ctx") do
-  AddOne.execute(:number => 5)
-  held = AddOne.instance_variable_get(:@ctx)
-  [held.is_a?(FunctionalLightService::Context), "AddOne @ctx = #{held.inspect[0,80]}"]
-end
-
-# ---------- F6: fail! muta l'hash di opzioni del chiamante ----------
-check(results, "F6 fail! cancella :error_code dall'hash del chiamante") do
-  ctx = FunctionalLightService::Context.make({})
-  opts = { :error_code => 500 }
-  ctx.fail!("boom", opts)
-  [!opts.key?(:error_code), "opts dopo fail! = #{opts.inspect}"]
-end
-
-# ---------- F7: Null#respond_to? con firma sbagliata ----------
-check(results, "F7 Null#respond_to?(m, true) solleva ArgumentError") do
-  begin
-    Null.instance.respond_to?(:foo, true)
-    [false, "nessuna eccezione"]
-  rescue ArgumentError => e
-    [true, "ArgumentError: #{e.message}"]
-  end
-end
-
-# ---------- F8: Context#[] con aliases usa Hash#key (reverse lookup O(n)) ----------
-check(results, "F8 lettura di chiave originale con molti alias resta corretta (sanity)") do
-  ctx = FunctionalLightService::Context.make(:a => 1)
-  ctx.assign_aliases(:a => :b)
-  [ctx[:b] == 1 && ctx[:a] == 1, "ctx[:a]=#{ctx[:a]}, ctx[:b]=#{ctx[:b]}"]
-end
-
-# ---------- F9: skip_remaining! dentro iterate viene resettato ad ogni item ----------
-class SkipAll
-  extend FunctionalLightService::Action
-  executed { |ctx| ctx.skip_remaining!("basta") if ctx[:counter] == 2 }
-end
-class CollectAction
-  extend FunctionalLightService::Action
-  executed { |ctx| (ctx[:seen] ||= []) << ctx[:counter] }
-end
-class OrgIter
-  extend FunctionalLightService::Organizer
-  def self.call(ctx)
-    with(ctx).reduce([iterate(:counters, [SkipAll, CollectAction])])
-  end
-end
-
-check(results, "F9 skip_remaining! dentro iterate NON ferma l'iterazione") do
-  r = OrgIter.call(:counters => [1, 2, 3])
-  [r[:seen] == [1, 3], "seen=#{r[:seen].inspect} (2 saltato, ma 3 processato: lo skip e' stato resettato)"]
-end
-
-# ---------- F10: succeed! + message perso da reset_skip_remaining! in scoped_reduce ----------
-check(results, "F10 reset_skip_remaining! azzera anche message/outcome") do
-  ctx = FunctionalLightService::Context.make({})
-  ctx.succeed!("fatto bene")
-  ctx.reset_skip_remaining!
-  [ctx.message == '', "message dopo reset=#{ctx.message.inspect}"]
-end
-
-# ---------- F11: Context#select/map degradano a Hash ----------
-check(results, "F11 Context#select ritorna Hash, non Context (perde outcome)") do
-  ctx = FunctionalLightService::Context.make(:a => 1)
-  sel = ctx.select { |_k, _v| true }
-  [!sel.is_a?(FunctionalLightService::Context), "select.class=#{sel.class}"]
-end
-
-# ---------- F12: Some(nil) e' costruibile ----------
-check(results, "F12 Some(nil) e' consentito (Option non valida il nil)") do
-  s = FunctionalLightService::Option::Some.new(nil)
-  [s.some? && s.value.nil?, "Some(nil).some?=#{s.some?}, value=nil"]
-end
-
-# ---------- F13: rollback con azione duplicata nella lista ----------
-class RollA
-  extend FunctionalLightService::Action
-  executed { |ctx| (ctx[:trace] ||= []) << :a }
-  rolled_back { |ctx| (ctx[:rb] ||= []) << :a }
-end
-class RollB
-  extend FunctionalLightService::Action
-  executed { |ctx| (ctx[:trace] ||= []) << :b; ctx.fail_with_rollback!("ko") if ctx[:trace].count(:b) == 2 }
-  rolled_back { |ctx| (ctx[:rb] ||= []) << :b }
-end
-class OrgRoll
-  extend FunctionalLightService::Organizer
-  def self.call(ctx)
-    with(ctx).reduce([RollB, RollA, RollB])   # RollB duplicata; fallisce la SECONDA RollB
-  end
-end
-
-check(results, "F13 rollback con azione duplicata: index trova la 1a occorrenza -> rollback parziale") do
-  r = OrgRoll.call({})
-  # eseguite: B, A, B(fail). Rollback atteso: B, A, B. Con il bug: index(RollB)=0 -> solo [RollB].take(1) -> rollback solo B
-  [r[:rb] == [:b], "trace=#{r[:trace].inspect}, rollback eseguiti=#{r[:rb].inspect} (attesi: [:b, :a, :b])"]
-end
-
-puts
-results.each do |name, ok, detail|
-  status = ok == true ? "CONFERMATO" : (ok == :exception ? "ECCEZIONE " : "NON RIPRODOTTO")
-  puts "[#{status}] #{name}"
-  puts "             -> #{detail}"
-end

data/functional-light-service.gemspec

@@ -1,35 +0,0 @@
-require File.expand_path('../lib/functional-light-service/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.authors       = ["Boscolo Michele"]
-  gem.email         = ["miboscol@gmail.com"]
-  gem.description   = %q{FunctionalLightService combines the Organizer/Action/Context pattern of LightService with functional programming constructs (Result/Option monads, pattern matching) inspired by Deterministic: complex workflows are organized into small single-purpose actions with functional error handling.}
-  gem.summary       = %q{A service skeleton with an emphasis on simplicity with a pinch a functional programming}
-  gem.homepage      = "https://github.com/sphynx79/functional-light-service"
-  gem.license       = "MIT"
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.name          = "functional-light-service"
-  gem.require_paths = ["lib"]
-  gem.version       = FunctionalLightService::VERSION
-  gem.required_ruby_version = '>= 3.1.0'
-
-  gem.add_runtime_dependency("dry-inflector", ">= 0.2.1", "< 2")
-  # logger non e' piu una default gem da Ruby 3.5/4.0: senza questa
-  # dichiarazione `require 'logger'` fallisce sotto Bundler
-  gem.add_runtime_dependency("logger", "~> 1.5")
-
-  # i18n e' opzionale a runtime: l'adapter I18n viene usato solo se
-  # l'applicazione ospite carica la gem (vedi Configuration)
-  gem.add_development_dependency("i18n", "~> 1.8", ">= 1.8.11")
-  gem.add_development_dependency("rake", "~> 13.0")
-  gem.add_development_dependency("rspec", "~> 3.13")
-  gem.add_development_dependency("simplecov", "~> 0.22")
-  gem.add_development_dependency("simplecov-cobertura", "~> 3.0")
-  gem.add_development_dependency("rubocop", "~> 1.75")
-  gem.add_development_dependency("rubocop-performance", "~> 1.20")
-  gem.add_development_dependency("pry", "~> 0.15")
-  gem.add_development_dependency("solargraph", "~> 0.50")
-  gem.add_development_dependency("benchmark-ips", "~> 2.13")
-end

data/gemfiles/dry_inflector_0_2_1.gemfile

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gem "dry-inflector", "~> 0.2.1"
-
-gemspec :path => "../"

data/gemfiles/i18n_1_8_11.gemfile

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gem "i18n", "~> 1.8.11"
-
-gemspec :path => "../"

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

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  module Action
-    def self.extended(base_class)
-      base_class.extend Macros
-      base_class.extend FunctionalLightService::Prelude::Result
-    end
-
-    def self.included(base_class)
-      FunctionalLightService::Deprecations.warn(
-        "Including FunctionalLightService::Action is deprecated; " \
-        "use `extend FunctionalLightService::Action` instead"
-      )
-      base_class.extend Macros
-    end
-
-    module Macros
-      def expects(*args)
-        if expect_key_having_default?(args)
-          available_defaults[args.first] = args.last[:default]
-
-          args = [args.first]
-        end
-
-        expected_keys.concat(args)
-      end
-
-      def promises(*args)
-        promised_keys.concat(args)
-      end
-
-      def expected_keys
-        @expected_keys ||= []
-      end
-
-      def promised_keys
-        @promised_keys ||= []
-      end
-
-      def executed
-        define_singleton_method :execute do |context = {}|
-          action_context = create_action_context(context)
-          return action_context if action_context.stop_processing?
-
-          # Store the action within the context
-          action_context.current_action = self
-
-          Context::KeyVerifier.verify_keys(action_context, self) do
-            action_context.define_accessor_methods_for_keys(all_keys)
-
-            catch(:jump_when_failed) do
-              call_before_action(action_context)
-              yield(action_context)
-              call_after_action(action_context)
-            end
-          end
-        end
-      end
-
-      def rolled_back
-        msg = "`rolled_back` macro can not be invoked again"
-        raise msg if respond_to?(:rollback)
-
-        define_singleton_method :rollback do |context = {}|
-          yield(context)
-
-          context
-        end
-      end
-
-      private
-
-      def create_action_context(context)
-        # I default vanno applicati anche quando l'action gira dentro un
-        # organizer (il context è già un Context): prima dell'early return.
-        # Il guard sull'ivar evita lavoro (e scritture lazy) nel percorso caldo
-        apply_expects_defaults(context) if @available_defaults
-
-        return context if context.is_a? FunctionalLightService::Context
-
-        FunctionalLightService::Context.make(context)
-      end
-
-      def apply_expects_defaults(context)
-        usable_defaults(context).each do |ctx_key, default|
-          context[ctx_key] = extract_default(default, context)
-        end
-      end
-
-      def available_defaults
-        @available_defaults ||= {}
-      end
-
-      def expect_key_having_default?(key)
-        return false unless key.size == 2 && key.last.is_a?(Hash)
-        return true if key.last.key?(:default)
-
-        bad_key = key.last.keys.first
-        err_msg = "Specify defaults with a `default` key. You have #{bad_key}."
-        raise UnusableExpectKeyDefaultError, err_msg
-      end
-
-      def missing_expected_keys(context)
-        # context.key? risolve anche gli alias: `expected_keys - context.keys`
-        # (upstream) darebbe falsi mancanti sulle chiavi aliasate
-        expected_keys.reject { |key| context.key?(key) }
-      end
-
-      def usable_defaults(context)
-        available_defaults.slice(
-          *(missing_expected_keys(context) & available_defaults.keys)
-        )
-      end
-
-      def extract_default(default, context)
-        return default unless default.respond_to?(:call)
-
-        default.call(context)
-      end
-
-      def all_keys
-        expected_keys + promised_keys
-      end
-
-      def call_before_action(context)
-        invoke_callbacks(context[:_before_actions], context)
-      end
-
-      def call_after_action(context)
-        invoke_callbacks(context[:_after_actions], context)
-      end
-
-      def invoke_callbacks(callbacks, context)
-        return context unless callbacks
-
-        callbacks.each do |cb|
-          cb.call(context)
-        end
-
-        context
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module FunctionalLightService
-  class Configuration
-    class << self
-      attr_writer :logger, :localization_adapter, :locale
-
-      def logger
-        @logger = _default_logger unless instance_variable_defined?("@logger")
-        @logger
-      end
-
-      def localization_adapter
-        # La gem i18n non è una dipendenza: l'adapter I18n viene scelto solo
-        # se la costante è già stata caricata dall'applicazione ospite
-        @localization_adapter ||= if Module.const_defined?('I18n')
-                                    FunctionalLightService::I18n::LocalizationAdapter.new
-                                  else
-                                    LocalizationAdapter.new
-                                  end
-      end
-
-      def locale
-        @locale ||= :en
-      end
-
-      private
-
-      def _default_logger
-        logger = Logger.new(nil)
-        logger.level = Logger::WARN
-        logger
-      end
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-# 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 organized_by
-           _aliases _before_actions _after_actions].freeze
-      end
-    end
-  end
-end