functional-light-service 6.0.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a02972ac6e701ec1ed5ceafcea5880e961ccbaf23ff886fe8f490c5bb514e6e1
-  data.tar.gz: 0a35af1df1d0820de886bae015cc84846dc0809d4602d12528c7f716b537a2f9
+  metadata.gz: 53e332561acc819e0d2d6488a38adeb3600aadcf31c100e474e1d1b0a6397157
+  data.tar.gz: 6500b3cdbf6895ce0e165eb36cc3dc7634ed4fc341cd42ceea3a5553eaf6033d
 SHA512:
-  metadata.gz: 1ec467e5b62e74629391dfaf9b2e0ede5534338b3ce1411f9c0f7c4a9c38b7aa880701ddd98e4fd5f8a61fa7e8dc741633c626a6b422c544084c825e883b1453
-  data.tar.gz: e526d9bd6c3736ea555db60add374336dd6a9e957f7fae265bee44282ffe0dbb2fb43bba03eaafd210aab7bcf1f9d1f7af96391fa34b680dacfe4cd148fff4ca
+  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,29 @@
+## 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
+-  Sequencer: do-notation per Result con in_sequence/get/let/and_then/observe/and_yield, portato dalla gem deterministic (MIT) e incluso nel Prelude ( 2026-07-03 ) [ sphynx79]
+
+
+
 ## 6.0.0 (2026-07-03)
 
 Release maggiore guidata da un audit tecnico completo (vedi `AUDIT-functional-light-service.md`

data/README.md

@@ -28,6 +28,7 @@
   * [Usage](#functional-usage)
     * [Result: Success & Failure](#functional-usage-success-failure)
     * [Result Chaining](#functional-usage-chaining)
+    * [Sequencing (do-notation)](#functional-usage-sequencing)
     * [Complex Example in a Builder Action](#functional-usage-complex-action)
     * [Pattern matching](#functional-usage-pattern-matching)
     * [Option](#functional-usage-option)
@@ -418,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
@@ -619,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?  
@@ -829,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
@@ -905,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}"
@@ -983,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
@@ -1002,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
@@ -1150,6 +1236,39 @@ Success(params) >>
   build_response
 ```
 
+### Sequencing (do-notation) – `in_sequence` <a name="functional-usage-sequencing"></a>
+
+When a pipeline needs the intermediate values of earlier steps, chaining alone
+gets awkward. `in_sequence` (ported from the [deterministic](https://github.com/pzol/deterministic)
+gem, MIT License) gives you a do-notation style block: each step returns a
+`Result`, the sequence short-circuits on the first `Failure`, and values bound
+with `get`/`let` are available to all subsequent steps by name.
+
+```ruby
+class DownloadRemit
+  include FunctionalLightService::Prelude
+
+  def call(row)
+    in_sequence do
+      get(:url)      { extract_url(row) }        # binds the Success value to :url
+      get(:file)     { fetch(url) }              # :url is available here
+      let(:name)     { File.basename(url) }      # binds a plain (non-Result) value
+      and_then       { validate(file) }          # step without binding
+      observe        { logger.info("got #{name}") } # side effect, return value ignored
+      and_yield      { Success(name) }           # final result of the sequence
+    end
+  end
+end
+```
+
+* `get(:name) { ... }` – runs a step returning a `Result`; on `Success` binds the
+  unwrapped value to `name`, on `Failure` stops the sequence and returns it.
+* `let(:name) { ... }` – binds the block's plain return value (no `Result` involved).
+* `and_then { ... }` – runs a step returning a `Result` without binding its value.
+* `observe { ... }` – runs a side effect; its return value is ignored.
+* `and_yield { ... }` – mandatory final step; its `Result` is the value of the
+  whole `in_sequence` block.
+
 #### Complex Example in a Builder Action <a name="functional-usage-complex-action"></a>
 
 ```ruby

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/functional/sequencer.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module FunctionalLightService
+  # Do-notation for Result: chains steps that return Success/Failure,
+  # short-circuiting on the first Failure. Ported from the deterministic
+  # gem (MIT License, Copyright (c) Piotr Zolnierek and contributors,
+  # https://github.com/pzol/deterministic).
+  #
+  #   in_sequence do
+  #     get(:user)  { fetch_user(id) }      # binds the Success value to :user
+  #     let(:name)  { user.fetch(:name) }   # binds a plain (non-Result) value
+  #     and_then    { validate(user) }      # step without binding
+  #     observe     { log(name) }           # side effect, return value ignored
+  #     and_yield   { Success(name) }       # final result of the sequence
+  #   end
+  module Sequencer
+    class InvalidSequenceError < StandardError; end
+
+    module Operation
+      Get = Struct.new(:block, :name)
+      Let = Struct.new(:block, :name)
+      AndThen = Struct.new(:block)
+      Observe = Struct.new(:block)
+      AndYield = Struct.new(:block)
+    end
+
+    def in_sequence(&)
+      sequencer = Sequencer.new(self)
+      sequencer.instance_eval(&)
+      sequencer.yield
+    end
+
+    class Sequencer
+      def initialize(instance)
+        @operations = []
+        @operation_wrapper = OperationWrapper.new(instance)
+      end
+
+      def get(name, &block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Get.new(block, name)
+      end
+
+      def let(name, &block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Let.new(block, name)
+      end
+
+      def and_then(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::AndThen.new(block)
+      end
+
+      def observe(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Observe.new(block)
+      end
+
+      def and_yield(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::AndYield.new(block)
+
+        prepare_sequenced_operations
+      end
+
+      def yield
+        raise InvalidSequenceError, 'and_yield not called' unless @sequenced_operations
+
+        @operation_wrapper.instance_eval(&@sequenced_operations)
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      def prepare_sequenced_operations
+        operations = @operations
+
+        @sequenced_operations = ->(_) do
+          operations.reduce(Result::Success.new(nil)) do |last_result, operation|
+            last_result.map do
+              case operation
+              when Operation::Get
+                result = instance_eval(&operation.block)
+                result.map do |output|
+                  # Runs in the context of the OperationWrapper, so the
+                  # bound value is stored within the wrapper itself.
+                  @gotten_results[operation.name] = output
+                  result
+                end
+              when Operation::Let
+                @gotten_results[operation.name] = instance_eval(&operation.block)
+                last_result
+              when Operation::Observe
+                instance_eval(&operation.block)
+                last_result
+              when Operation::AndThen, Operation::AndYield
+                instance_eval(&operation.block)
+              end
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    end
+
+    # OperationWrapper proxies all method calls to the wrapped instance, but
+    # first checks if the name of the called method matches a value stored
+    # within @gotten_results and returns the value if it does.
+    class OperationWrapper < SimpleDelegator
+      def initialize(*args)
+        super
+        @gotten_results = {}
+      end
+
+      def method_missing(name, *args, **kwargs, &)
+        if @gotten_results.key?(name)
+          @gotten_results[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @gotten_results.key?(name) || super
+      end
+    end
+  end
+
+  module Prelude
+    include Sequencer
+  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