functional-light-service 6.1.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 436934533c3db4aa6ac6e3ce7410b67454fe0e7f3f8b516e9b6ba7674e86fc29
-  data.tar.gz: c4a36634905f4253a0d32bf9068b70a236f67291e43e20d02f3617679a797ef7
+  metadata.gz: 53e332561acc819e0d2d6488a38adeb3600aadcf31c100e474e1d1b0a6397157
+  data.tar.gz: 6500b3cdbf6895ce0e165eb36cc3dc7634ed4fc341cd42ceea3a5553eaf6033d
 SHA512:
-  metadata.gz: 8ba109d1688a3e2e3c1904682d55e800cd841fa7870364f04916d9f5528ac0e954fe28f650261b1217c0d0819f0df0c1143331fd82f72a1dfc6726549a95cc82
-  data.tar.gz: 4da5cc5beae3e452b7400ce696a05a7ab5e69c354d27cd3c3e918c86ef47166789a7349a9967215ca53f35cb4d00dac986ac109d673cee00e07abace42b6569f
+  metadata.gz: 7b64b265d6d63225baca32509169796242f4003c4000e429f4ab9758a310ae4b1a4668553512b40bc9d070a61cd2566ef0eb1efc8cdad3e06cda7b5b478a1854
+  data.tar.gz: 959de9564732c9acd2108c746b36be9da3445ea969a7940943c5c88543044d25fd5e3c5df5f6f6b749aa54f950a9a9a511320d992d0536d901eff116f70d2431

data/.gitignore

@@ -19,4 +19,6 @@ vendor/bundle
 bin
 gems.tags
 tags
+.claude/
+.ruby-lsp/
 !*.gitkeep

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 6.2.0 (2026-07-18)
+
+Port selettivo delle feature di light-service upstream 0.14-0.21 (niente Rails
+support; solo aggiunte retro-compatibili).
+
+### Added
+-  skip_all_remaining!: salta tutto il resto dell'organizer, scope annidati compresi; non viene resettato da reduce_if/iterate/ecc. (upstream 0.21) ( 2026-07-18 ) [ sphynx79]
+-  reduce_while: macro dell'organizer che controlla la condizione prima di ogni step (upstream 0.21) ( 2026-07-18 ) [ sphynx79]
+-  reduce_if_else: come reduce_if ma con ramo else (upstream 0.17) ( 2026-07-18 ) [ sphynx79]
+-  reduce_case: dispatch sugli step in base a un valore del context, kwargs :value/:when/:else (upstream 0.18) ( 2026-07-18 ) [ sphynx79]
+-  expects :key, default: valore-o-lambda per chiavi attese opzionali; kwarg diverso da :default solleva UnusableExpectKeyDefaultError (upstream 0.17) ( 2026-07-18 ) [ sphynx79]
+-  execute accetta un blocco oltre alla lambda (upstream master) ( 2026-07-18 ) [ sphynx79]
+-  :organized_by tra le chiavi riservate del KeyVerifier: errore piu chiaro in caso di collisione (upstream 0.14) ( 2026-07-18 ) [ sphynx79]
+
+### Changed
+-  add_to_context registra anche gli accessor delle chiavi aggiunte (ctx.mia_chiave); chiavi che collidono con metodi del Context ora sollevano ReservedKeysInContextError invece di passare in silenzio (upstream 0.16) ( 2026-07-18 ) [ sphynx79]
+-  i18n non e' piu una dipendenza runtime: di default i simboli si risolvono col nuovo adapter built-in (LocalizationMap + Configuration.locale); l'adapter I18n trasloca in FunctionalLightService::I18n::LocalizationAdapter e viene selezionato solo se l'applicazione carica la gem i18n (upstream 0.19/0.20) ( 2026-07-18 ) [ sphynx79]
+
+
 ## 6.1.0 (2026-07-03)
 
 ### Added

data/README.md

@@ -419,6 +419,28 @@ end
 In the example above, the organizer invokes four actions.
 The first two run successfully; the third calls skip_remaining!, so the fourth is never executed, yet the overall context stays successful.
 
+### Skipping everything, including nested scopes
+
+`skip_remaining!` is scoped: constructs like `reduce_if` or `iterate` reset it
+at their boundary, so it only exits the **current** scope. When you need to stop
+the whole organizer from inside a nested construct, use
+`context.skip_all_remaining!` — it is never reset, so every remaining step (in
+the current scope and in the outer ones) is skipped while the context stays
+successful:
+
+```ruby
+class StopsEverythingAction
+  extend FunctionalLightService::Action
+  expects :item
+
+  executed do |context|
+    if context.item.poison_pill?
+      context.skip_all_remaining!("Poison pill found, stopping the pipeline")
+    end
+  end
+end
+```
+
 ## Benchmarking Actions with Around Advice
 
 When you need to profile a pipeline, adding timing code inside every single
@@ -620,6 +642,33 @@ end
 
 Want to see it in practice? Check out [this spec](spec/action_expects_and_promises_spec.rb) test file.
 
+### Default values for expected keys
+
+An expected key can declare a `default`, used when the key is missing from the
+context (also when the action runs inside an organizer). The default can be a
+static value or a lambda receiving the context:
+
+```ruby
+class GreetsSomeoneAction
+  extend FunctionalLightService::Action
+
+  expects :name
+  expects :greeting, :default => "Hello"
+  expects :message,  :default => ->(ctx) { "#{ctx[:greeting]}, #{ctx[:name]}!" }
+
+  executed do |context|
+    puts context.message
+  end
+end
+
+GreetsSomeoneAction.execute(:name => "Rick") # ⇒ "Hello, Rick!"
+```
+
+Note that `expects` accepts a single key when a default is given, and any
+keyword other than `default` raises `UnusableExpectKeyDefaultError` at class
+definition time. Keys already reachable through an alias are considered
+present, so their default is not applied.
+
 ## Key Aliases
 
 Need to wire together actions that use different key names?  
@@ -830,10 +879,30 @@ For a full example, see [this acceptance test](spec/acceptance/rollback_spec.rb)
 
 ## Localizing Messages
 
-FunctionalLightService integrates with **I18n** out of the box, so you can translate
-success or failure messages without extra plumbing.  
-If your app needs something more advanced, you can swap in a custom localization
-adapter.
+Symbols passed to `fail!`/`succeed!` are looked up through a localization
+adapter. Two adapters ship with the gem:
+
+- **Built-in adapter** (default): resolves messages from
+  `FunctionalLightService::LocalizationMap.instance`, a plain hash keyed by
+  `Configuration.locale` (default `:en`) — no extra dependency needed:
+
+  ```ruby
+  FunctionalLightService::LocalizationMap.instance[:en] = {
+    :foo_action => {
+      :light_service => {
+        :failures => { :exceeded_api_limit => "Exceeded API limit" },
+        :successes => { :api_call_ok => "All good" }
+      }
+    }
+  }
+  ```
+
+- **I18n adapter**: selected automatically when your application loads the
+  `i18n` gem (it is no longer a runtime dependency of this gem — add it to
+  your own Gemfile if you want I18n-backed lookups).
+
+If your app needs something more advanced, you can swap in a custom
+localization adapter.
 
 ```ruby
 class FooAction
@@ -906,7 +975,7 @@ configuration:
 FunctionalLightService::Configuration.localization_adapter = MyLocalizer.new
 
 # lib/my_localizer.rb
-class MyLocalizer < FunctionalLightService::LocalizationAdapter
+class MyLocalizer < FunctionalLightService::I18n::LocalizationAdapter
   # change default scope to: "light_service.failures.<class_path>"
   def i18n_scope_from_class(action_class, type)
     "light_service.#{type.pluralize}.#{action_class.name.underscore}"
@@ -984,15 +1053,18 @@ your actions.
 
 | Construct                                                          | Declarative “equivalent” | What it does (in one line)                                                                  |
 | ------------------------------------------------------------------ | ------------------------ | ------------------------------------------------------------------------------------------- |
-| [reduce_until](spec/acceptance/organizer/reduce_until_spec.rb)     | `while` loop             | Keeps reducing the listed steps **until** the lambda returns `true`.                        |
-| [reduce_if](spec/acceptance/organizer/reduce_if_spec.rb)           | `if/else`                | Reduces its sub‑steps **only if** the lambda returns `true`.                                |
+| [reduce_until](spec/acceptance/organizer/reduce_until_spec.rb)     | `until` loop             | Keeps reducing the listed steps **until** the lambda returns `true`.                        |
+| [reduce_while](spec/acceptance/organizer/reduce_while_spec.rb)     | `while` guard            | Checks the lambda **before each step** and stops as soon as it returns `false`.             |
+| [reduce_if](spec/acceptance/organizer/reduce_if_spec.rb)           | `if`                     | Reduces its sub‑steps **only if** the lambda returns `true`.                                |
+| [reduce_if_else](spec/acceptance/organizer/reduce_if_else_spec.rb) | `if/else`                | Reduces the first list of steps when the lambda is `true`, the second one otherwise.        |
+| [reduce_case](spec/acceptance/organizer/reduce_case_spec.rb)       | `case/when`              | Dispatches to the steps matching a context value (`:value`, `:when`, `:else` kwargs).       |
 | [iterate](spec/acceptance/organizer/iterate_spec.rb)               | `each` loop              | Loops over a collection key; each element is exposed under the **singular** name.           |
-| [execute](spec/acceptance/organizer/execute_spec.rb)               | one‑off lambda           | Runs an inline lambda for quick context tweaks (add keys, transform values, etc.).          |
+| [execute](spec/acceptance/organizer/execute_spec.rb)               | one‑off lambda           | Runs an inline lambda or block for quick context tweaks (add keys, transform values, etc.). |
 | [with_callback](spec/acceptance/organizer/with_callback_spec.rb)   | streaming callback       | Defers execution like a SAX parser—great for huge inputs without loading everything in RAM. |
-| [add_to_context](spec/acceptance/organizer/add_to_context_spec.rb) | N/A (context inject)     | Injects key–value pairs into the context just before the following steps run.               |
+| [add_to_context](spec/acceptance/organizer/add_to_context_spec.rb) | N/A (context inject)     | Injects key–value pairs into the context (defining accessors) before the next steps run.    |
 | [add_aliases](spec/acceptance/organizer/add_aliases_spec.rb)       | key aliasing             | Creates an alias so actions can read/write the same value under different names.            |
 
-All seven are covered by acceptance tests in spec/acceptance/organizer/*_spec.rb.
+All ten are covered by acceptance tests in spec/acceptance/organizer/*_spec.rb.
 
 **Tip**: When iterating, the collection must already be in the context.
 iterate(:items) expects context[:items]; it then places each element under
@@ -1003,10 +1075,23 @@ iterate(:items, [ProcessItem])
 # Inside ProcessItem → context.item
 ```
 
-Need a quick context mutation? Use execute:
+Need a quick context mutation? Use execute, with a lambda or a block:
 
 ```ruby
 execute(->(c) { c[:some_values] = c.some_hash.values })
+# or
+execute { |c| c[:some_values] = c.some_hash.values }
+```
+
+Need to branch on a context value? Use reduce_case:
+
+```ruby
+reduce_case :value => :status,
+            :when => {
+              :active   => [NotifiesUserAction],
+              :archived => [ArchivesRecordAction]
+            },
+            :else => [RaisesUnknownStatusAction]
 ```
 
 ## ContextFactory for Faster Action Testing

data/functional-light-service.gemspec

@@ -16,11 +16,13 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 3.1.0'
 
   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")
 
+  # 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")

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

@@ -17,6 +17,12 @@ module FunctionalLightService
 
     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
 
@@ -66,11 +72,53 @@ module FunctionalLightService
       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

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

@@ -3,7 +3,7 @@
 module FunctionalLightService
   class Configuration
     class << self
-      attr_writer :logger, :localization_adapter
+      attr_writer :logger, :localization_adapter, :locale
 
       def logger
         @logger = _default_logger unless instance_variable_defined?("@logger")
@@ -11,7 +11,17 @@ module FunctionalLightService
       end
 
       def localization_adapter
-        @localization_adapter ||= LocalizationAdapter.new
+        # 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

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

@@ -116,7 +116,7 @@ module FunctionalLightService
       def reserved_keys
         # _aliases/_before_actions/_after_actions sono chiavi infrastrutturali
         # scritte da Organizer.with nel context
-        %i[message error_code current_action
+        %i[message error_code current_action organized_by
            _aliases _before_actions _after_actions].freeze
       end
     end

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

@@ -14,6 +14,7 @@ module FunctionalLightService
                    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
@@ -46,6 +47,10 @@ module FunctionalLightService
       @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
@@ -100,8 +105,15 @@ module FunctionalLightService
       @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?
+      failure? || skip_remaining? || skip_all_remaining?
     end
 
     # Registra le chiavi come accessor consentiti: la lettura/scrittura passa
@@ -174,7 +186,8 @@ module FunctionalLightService
 
     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}, " \
+        "skip_all_remaining: #{@skip_all_remaining}, aliases: #{aliases})"
     end
 
     private

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

@@ -5,4 +5,5 @@ module FunctionalLightService
   class ExpectedKeysNotInContextError < StandardError; end
   class PromisedKeysNotInContextError < StandardError; end
   class ReservedKeysInContextError < StandardError; end
+  class UnusableExpectKeyDefaultError < StandardError; end
 end

data/lib/functional-light-service/i18n/localization_adapter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry/inflector'
+
+module FunctionalLightService
+  module I18n
+    class LocalizationAdapter
+      def failure(message_or_key, action_class, i18n_options = {})
+        find_translated_message(message_or_key,
+                                action_class,
+                                i18n_options,
+                                :type => :failure)
+      end
+
+      def success(message_or_key, action_class, i18n_options = {})
+        find_translated_message(message_or_key,
+                                action_class,
+                                i18n_options,
+                                :type => :success)
+      end
+
+      private
+
+      def find_translated_message(message_or_key,
+                                  action_class,
+                                  i18n_options,
+                                  type)
+        if message_or_key.is_a?(Symbol)
+          translate(message_or_key, action_class, i18n_options.merge(type))
+        else
+          message_or_key
+        end
+      end
+
+      def translate(key, action_class, options = {})
+        type = options.delete(:type)
+
+        scope = i18n_scope_from_class(action_class, type)
+        options[:scope] = scope
+
+        ::I18n.t(key, **options)
+      end
+
+      def i18n_scope_from_class(action_class, type)
+        inflector = Dry::Inflector.new
+        "#{inflector.underscore(action_class.name)}.light_service.#{inflector.pluralize(type)}"
+      end
+    end
+  end
+end

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

@@ -1,48 +1,39 @@
 # frozen_string_literal: true
 
-require 'i18n'
+require 'dry/inflector'
 
 module FunctionalLightService
+  # Adapter built-in basato su LocalizationMap: nessuna dipendenza da I18n.
+  # Viene selezionato da Configuration quando la costante ::I18n non esiste
   class LocalizationAdapter
-    def failure(message_or_key, action_class, i18n_options = {})
+    INFLECTOR = Dry::Inflector.new
+
+    def failure(message_or_key, action_class, options = {})
       find_translated_message(message_or_key,
-                              action_class,
-                              i18n_options,
-                              :type => :failure)
+                              INFLECTOR.underscore(action_class.to_s),
+                              options.merge(:type => :failures))
     end
 
-    def success(message_or_key, action_class, i18n_options = {})
+    def success(message_or_key, action_class, options = {})
       find_translated_message(message_or_key,
-                              action_class,
-                              i18n_options,
-                              :type => :success)
+                              INFLECTOR.underscore(action_class.to_s),
+                              options.merge(:type => :successes))
     end
 
     private
 
-    def find_translated_message(message_or_key,
-                                action_class,
-                                i18n_options,
-                                type)
+    def find_translated_message(message_or_key, action_class, options)
       if message_or_key.is_a?(Symbol)
-        translate(message_or_key, action_class, i18n_options.merge(type))
+        FunctionalLightService::LocalizationMap.instance.dig(
+          FunctionalLightService::Configuration.locale,
+          action_class.to_sym,
+          :light_service,
+          options[:type],
+          message_or_key
+        )
       else
         message_or_key
       end
     end
-
-    def translate(key, action_class, options = {})
-      type = options.delete(:type)
-
-      scope = i18n_scope_from_class(action_class, type)
-      options[:scope] = scope
-
-      I18n.t(key, **options)
-    end
-
-    def i18n_scope_from_class(action_class, type)
-      inflector = Dry::Inflector.new
-      "#{inflector.underscore(action_class.name)}.light_service.#{inflector.pluralize(type)}"
-    end
   end
 end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module FunctionalLightService
+  class LocalizationMap < Hash
+    include ::Singleton
+  end
+end

data/lib/functional-light-service/organizer/reduce_case.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Organizer
+    class ReduceCase
+      extend ScopedReducable
+
+      class Arguments
+        attr_reader :value, :when, :else
+
+        def initialize(**args)
+          validate_arguments(**args)
+          @value = args[:value]
+          @when = args[:when]
+          @else = args[:else]
+        end
+
+        private
+
+        # rubocop:disable Style/MultilineIfModifier
+        def validate_arguments(**args)
+          raise(
+            ArgumentError,
+            "Expected keyword arguments: [:value, :when, :else]. Given: #{args.keys}"
+          ) unless args.keys.intersection(mandatory_arguments).count == mandatory_arguments.count
+        end
+        # rubocop:enable Style/MultilineIfModifier
+
+        def mandatory_arguments
+          %i[value when else]
+        end
+      end
+
+      def self.run(organizer, **args)
+        arguments = Arguments.new(**args)
+
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          matched_case = arguments.when.keys.find { |k| k.eql?(ctx[arguments.value]) }
+          steps = arguments.when[matched_case] || arguments.else
+
+          ctx = scoped_reduce(organizer, ctx, steps)
+
+          ctx
+        end
+      end
+    end
+  end
+end

data/lib/functional-light-service/organizer/reduce_if_else.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Organizer
+    class ReduceIfElse
+      extend ScopedReducable
+
+      def self.run(organizer, condition_block, if_steps, else_steps)
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          ctx = if condition_block.call(ctx)
+                  scoped_reduce(organizer, ctx, if_steps)
+                else
+                  scoped_reduce(organizer, ctx, else_steps)
+                end
+
+          ctx
+        end
+      end
+    end
+  end
+end

data/lib/functional-light-service/organizer/reduce_until.rb

@@ -11,7 +11,7 @@ module FunctionalLightService
 
           loop do
             ctx = scoped_reduce(organizer, ctx, steps)
-            break if condition_block.call(ctx) || ctx.failure?
+            break if condition_block.call(ctx) || ctx.stop_processing?
           end
 
           ctx

data/lib/functional-light-service/organizer/reduce_while.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Organizer
+    class ReduceWhile
+      def self.run(organizer, condition_block, steps)
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          reset_skip(ctx)
+
+          Array(steps).each do |step|
+            break unless condition_block.call(ctx)
+
+            ctx = organizer.with(ctx).reduce([step])
+            break if ctx.stop_processing?
+          end
+
+          reset_skip(ctx)
+
+          ctx
+        end
+      end
+
+      def self.reset_skip(ctx)
+        ctx.reset_skip_remaining! unless ctx.failure? || ctx.skip_all_remaining?
+      end
+      private_class_method :reset_skip
+    end
+  end
+end

data/lib/functional-light-service/organizer/scoped_reducable.rb

@@ -4,9 +4,9 @@ module FunctionalLightService
   module Organizer
     module ScopedReducable
       def scoped_reduce(organizer, ctx, steps)
-        ctx.reset_skip_remaining! unless ctx.failure?
+        ctx.reset_skip_remaining! unless ctx.failure? || ctx.skip_all_remaining?
         ctx = organizer.with(ctx).reduce([steps])
-        ctx.reset_skip_remaining! unless ctx.failure?
+        ctx.reset_skip_remaining! unless ctx.failure? || ctx.skip_all_remaining?
 
         ctx
       end

data/lib/functional-light-service/organizer/with_reducer_log_decorator.rb

@@ -93,7 +93,8 @@ module FunctionalLightService
       end
 
       def skip_remaining?(context)
-        context.respond_to?(:skip_remaining?) && context.skip_remaining?
+        (context.respond_to?(:skip_remaining?) && context.skip_remaining?) ||
+          (context.respond_to?(:skip_all_remaining?) && context.skip_all_remaining?)
       end
 
       def write_skip_remaining_log(context, action)