functional-light-service 0.4.4 → 6.0.0

data/Rakefile

@@ -9,4 +9,4 @@ RuboCop::RakeTask.new
 RSpec::Core::RakeTask.new(:spec)
 
 task(:default).clear
-task :default => %i[spec rubocop]
+task :default => %i[spec rubocop]

data/VERSION

@@ -1 +1 @@
-0.4.4
+0.5.4

data/audit/bench.rb

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

@@ -0,0 +1,172 @@
+# 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,34 +1,33 @@
-# -*- encoding: utf-8 -*-
 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{A service skeleton with an emphasis on simplicity with a pinch a functional programming}
+  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.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "functional-light-service"
   gem.require_paths = ["lib"]
   gem.version       = FunctionalLightService::VERSION
-  gem.required_ruby_version = '>= 2.6.0'
+  gem.required_ruby_version = '>= 3.1.0'
 
-  gem.add_runtime_dependency("dry-inflector", "~> 0.2", ">= 0.2.1")
+  gem.add_runtime_dependency("dry-inflector", ">= 0.2.1", "< 2")
   gem.add_runtime_dependency("i18n", "~> 1.8", ">= 1.8.11")
-  
+  # 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")
 
-  gem.add_development_dependency("i18n", "~> 1.8", ">= 1.8.11")
-  gem.add_development_dependency("dry-inflector", "~> 0.2", ">= 0.2.1")
-  gem.add_development_dependency("rspec", "~> 3.10.0")
-  gem.add_development_dependency("simplecov", "~> 0.21.2")
-  gem.add_development_dependency("simplecov-cobertura", "~> 2.1.0")
-  gem.add_development_dependency("rubocop", "~> 1.25.0")
-  gem.add_development_dependency("rubocop-performance", "~> 1.13.2")
-  gem.add_development_dependency("pry", "~> 0.14.1")
-  gem.add_development_dependency("solargraph", "~> 0.44.2")
-  gem.add_development_dependency("nokogiri", "~> 1.12.5")
+  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/lib/functional-light-service/action.rb

@@ -1,101 +1,97 @@
-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)
-      msg = "DEPRECATION WARNING:\n" \
-            "Including FunctionalLightService::Action is deprecated\n" \
-            "Please use `extend FunctionalLightService::Action` instead"
-      print msg
-      base_class.extend Macros
-    end
-
-    module Macros
-      def expects(*args)
-        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 ctx(*args)
-        @ctx ||= args
-      end
-
-      def executed
-        define_singleton_method :execute do |context = {}|
-          action_context = create_action_context(context)
-          return action_context if action_context.stop_processing?
-
-          @ctx = action_context
-
-          # 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)
-        return context if context.is_a? FunctionalLightService::Context
-
-        FunctionalLightService::Context.make(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
+# 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)
+        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)
+        return context if context.is_a? FunctionalLightService::Context
+
+        FunctionalLightService::Context.make(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,24 +1,26 @@
-module FunctionalLightService
-  class Configuration
-    class << self
-      attr_writer :logger, :localization_adapter
-
-      def logger
-        @logger = _default_logger unless instance_variable_defined?("@logger")
-        @logger
-      end
-
-      def localization_adapter
-        @localization_adapter ||= LocalizationAdapter.new
-      end
-
-      private
-
-      def _default_logger
-        logger = Logger.new(nil)
-        logger.level = Logger::WARN
-        logger
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  class Configuration
+    class << self
+      attr_writer :logger, :localization_adapter
+
+      def logger
+        @logger = _default_logger unless instance_variable_defined?("@logger")
+        @logger
+      end
+
+      def localization_adapter
+        @localization_adapter ||= LocalizationAdapter.new
+      end
+
+      private
+
+      def _default_logger
+        logger = Logger.new(nil)
+        logger.level = Logger::WARN
+        logger
+      end
+    end
+  end
+end