switchyard 7.0.0

data/Rakefile

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

@@ -0,0 +1 @@
+7.0.0

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 'switchyard'
+require 'benchmark/ips'
+
+include Switchyard::Prelude::Result
+include Switchyard::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?(Switchyard::Option::Some) ? some.value : 0 }
+  x.report("case/in nativo Ruby") do
+    case some
+    in Switchyard::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?(Switchyard::Result::Success) && other.is_a?(Switchyard::Result::Success)
+      Switchyard::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?(Switchyard::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 = Switchyard::Context.make(:number => 1, :total => 2, :counter => 3)
+    ctx.define_accessor_methods_for_keys(keys)
+  end
+  x.report("nuovo Context senza accessor") do
+    Switchyard::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 = Switchyard::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 Switchyard::Action
+  expects :number
+  executed { |ctx| ctx[:number] = ctx[:number] + 1 }
+end
+class BenchOrg
+  extend Switchyard::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 'switchyard'
+
+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 Switchyard::Action
+  expects :number
+  promises :number
+  executed { |ctx| ctx.number = ctx.number + 1 }
+end
+
+class Org1
+  extend Switchyard::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 = Switchyard::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 = Switchyard::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 = Switchyard::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 Switchyard::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?(Switchyard::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 = Switchyard::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 = Switchyard::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 Switchyard::Action
+  executed { |ctx| ctx.skip_remaining!("basta") if ctx[:counter] == 2 }
+end
+class CollectAction
+  extend Switchyard::Action
+  executed { |ctx| (ctx[:seen] ||= []) << ctx[:counter] }
+end
+class OrgIter
+  extend Switchyard::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 = Switchyard::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 = Switchyard::Context.make(:a => 1)
+  sel = ctx.select { |_k, _v| true }
+  [!sel.is_a?(Switchyard::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 = Switchyard::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 Switchyard::Action
+  executed { |ctx| (ctx[:trace] ||= []) << :a }
+  rolled_back { |ctx| (ctx[:rb] ||= []) << :a }
+end
+class RollB
+  extend Switchyard::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 Switchyard::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/gemfiles/dry_inflector_0_2_1.gemfile

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

data/gemfiles/i18n_1_8_11.gemfile

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

data/lib/switchyard/action.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Switchyard
+  module Action
+    def self.extended(base_class)
+      base_class.extend Macros
+      base_class.extend Switchyard::Prelude::Result
+    end
+
+    def self.included(base_class)
+      Switchyard::Deprecations.warn(
+        "Including Switchyard::Action is deprecated; " \
+        "use `extend Switchyard::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? Switchyard::Context
+
+        Switchyard::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/switchyard/configuration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Switchyard
+  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')
+                                    Switchyard::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/switchyard/context/key_verifier.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Switchyard
+  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