bcdd-result 0.12.0 → 0.13.0

data/README.md

@@ -1,9 +1,11 @@
 <p align="center">
   <h1 align="center" id="-bcddresult">🔀 BCDD::Result</h1>
-  <p align="center"><i>Empower Ruby apps with pragmatic use of Result pattern (monad), Railway Oriented Programming, and B/CDD.</i></p>
+  <p align="center"><i>Unleash a pragmatic and observable use of Result Pattern and Railway-Oriented Programming in Ruby.</i></p>
   <p align="center">
     <img src="https://img.shields.io/badge/ruby->%3D%202.7.0-ruby.svg?colorA=99004d&colorB=cc0066" alt="Ruby">
     <a href="https://rubygems.org/gems/bcdd-result"><img src="https://badge.fury.io/rb/bcdd-result.svg" alt="bcdd-result gem version" height="18"></a>
+    <a href="https://codeclimate.com/github/B-CDD/result/maintainability"><img src="https://api.codeclimate.com/v1/badges/aa8360f8f012d7dedd62/maintainability" /></a>
+    <a href="https://codeclimate.com/github/B-CDD/result/test_coverage"><img src="https://api.codeclimate.com/v1/badges/aa8360f8f012d7dedd62/test_coverage" /></a>
   </p>
 </p>
 
@@ -70,13 +72,14 @@ Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofi
       - [Module example (Singleton Methods)](#module-example-singleton-methods-1)
     - [`BCDD::Result::Context::Expectations`](#bcddresultcontextexpectations)
     - [Mixin add-ons](#mixin-add-ons)
-  - [`BCDD::Result.transitions`](#bcddresulttransitions)
-    - [Configuration](#configuration)
-  - [`BCDD::Result.configuration`](#bcddresultconfiguration)
-    - [`config.addon.enable!(:given, :continue)`](#configaddonenablegiven-continue)
-    - [`config.constant_alias.enable!('Result', 'BCDD::Context')`](#configconstant_aliasenableresult-bcddcontext)
-    - [`config.pattern_matching.disable!(:nil_as_valid_value_checking)`](#configpattern_matchingdisablenil_as_valid_value_checking)
-    - [`config.feature.disable!(:expectations)`](#configfeaturedisableexpectations)
+- [`BCDD::Result.transitions`](#bcddresulttransitions)
+  - [`ids_tree` *versus* `ids_matrix`](#ids_tree-versus-ids_matrix)
+  - [Configuration](#configuration)
+    - [Turning on/off](#turning-onoff)
+    - [Setting a `trace_id` fetcher](#setting-a-trace_id-fetcher)
+    - [Setting a `listener`](#setting-a-listener)
+    - [Setting multiple `listeners`](#setting-multiple-listeners)
+- [`BCDD::Result.configuration`](#bcddresultconfiguration)
   - [`BCDD::Result.config`](#bcddresultconfig)
 - [`BCDD::Result#and_then!`](#bcddresultand_then)
     - [Dependency Injection](#dependency-injection-1)
@@ -1418,7 +1421,7 @@ result = Divide.new.call(4, 2)
 
 # The example below shows an error because the :ok type is not allowed.
 # But look at the allowed types have only one type (:division_completed).
-# This is because the :continued type is ignored by the expectations.
+# This is because the :_continue_ type is ignored by the expectations.
 #
 result.success?(:ok)
 # type :ok is not allowed. Allowed types: :division_completed (BCDD::Result::Contract::Error::UnexpectedType)
@@ -1783,7 +1786,9 @@ Division.call(14, 0)
 #<BCDD::Result::Context::Failure type=:division_by_zero value={:message=>"arg2 must not be zero"}>
 ```
 
-### `BCDD::Result.transitions`
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+## `BCDD::Result.transitions`
 
 Use `BCDD::Result.transitions(&block)` to track all transitions in the same or between different operations (it works with `BCDD::Result` and `BCDD::Result::Context`). When there is a nesting of transition blocks, this mechanism will be able to correlate parent and child blocks and present the duration of all operations in milliseconds.
 
@@ -1804,7 +1809,7 @@ class Division
 
   private
 
-  ValidNumber = ->(arg) { arg.is_a?(Numeric) && arg != Float::NAN && arg != Float::INFINITY }
+  ValidNumber = ->(arg) { arg.is_a?(Numeric) && (!arg.respond_to?(:finite?) || arg.finite?) }
 
   def require_numbers((arg1, arg2))
     ValidNumber[arg1] or return Failure(:invalid_arg, 'arg1 must be a valid number')
@@ -1851,83 +1856,85 @@ result = SumDivisionsByTwo.call(20, 10)
 
 result.transitions
 {
-  :version =>1,
+  :version => 1,
   :metadata => {
-    :duration => 0,                       # milliseconds
-    :tree_map => [0, [[1, []], [2, []]]], # represents the tree of transitions using the id of each transition block
+    :duration => 0,   # milliseconds
+    :trace_id => nil, # can be set through configuration
+    :ids_tree => [0, [[1, []], [2, []]]],
+    :ids_matrix => {0 => [0, 0], 1 => [1, 1], 2 => [2, 1]}
   },
-  :records => [
+  :records=> [
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:given, :value=>[20, 2]},
-      :and_then=>{},
-      :time=>2024-01-02 03:35:11.248418 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_given_, :value=>[20, 2], :source=><Division:0x0000000102fd7ed0>},
+      :and_then => {},
+      :time => 2024-01-26 02:53:11.310346 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:continued, :value=>[20, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:require_numbers},
-      :time=>2024-01-02 03:35:11.248558 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_continue_, :value=>[20, 2], :source=><Division:0x0000000102fd7ed0>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:require_numbers},
+      :time => 2024-01-26 02:53:11.310392 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:continued, :value=>[20, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:check_for_zeros},
-      :time=>2024-01-02 03:35:11.248587 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_continue_, :value=>[20, 2], :source=><Division:0x0000000102fd7ed0>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:check_for_zeros},
+      :time=>2024-01-26 02:53:11.310403 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:division_completed, :value=>10},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:divide},
-      :time=>2024-01-02 03:35:11.248607 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:division_completed, :value=>10, :source=><Division:0x0000000102fd7ed0>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:divide},
+      :time => 2024-01-26 02:53:11.310409 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:given, :value=>[10, 2]},
-      :and_then=>{},
-      :time=>2024-01-02 03:35:11.24865 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_given_, :value=>[10, 2], :source=><Division:0x0000000102fd6378>},
+      :and_then => {},
+      :time => 2024-01-26 02:53:11.310424 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:continued, :value=>[10, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:require_numbers},
-      :time=>2024-01-02 03:35:11.248661 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_continue_, :value=>[10, 2], :source=><Division:0x0000000102fd6378>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:require_numbers},
+      :time => 2024-01-26 02:53:11.310428 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:continued, :value=>[10, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:check_for_zeros},
-      :time=>2024-01-02 03:35:11.248672 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_continue_, :value=>[10, 2], :source=><Division:0x0000000102fd6378>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:check_for_zeros},
+      :time => 2024-01-26 02:53:11.310431 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:division_completed, :value=>5},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:divide},
-      :time=>2024-01-02 03:35:11.248682 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:division_completed, :value=>5, :source=><Division:0x0000000102fd6378>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:divide},
+      :time => 2024-01-26 02:53:11.310434 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :result=>{:kind=>:success, :type=>:sum, :value=>15},
-      :and_then=>{},
-      :time=>2024-01-02 03:35:11.248721 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :result => {:kind=>:success, :type=>:sum, :value=>15, :source=>SumDivisionsByTwo},
+      :and_then => {},
+      :time => 2024-01-26 02:53:11.310444 UTC
     }
   ]
 }
@@ -1935,7 +1942,46 @@ result.transitions
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
-#### Configuration
+### `ids_tree` *versus* `ids_matrix`
+
+The `:ids_matrix`. It is a simplification of the `:ids_tree` property (a graph/tree representation of the transitions ids).
+
+The matrix rows are the direct transitions from the root transition block, and the columns are the transitions nested from the direct transitions.
+
+Use these data structures to build your own visualization of the transitions.
+
+> Check out [Transitions Listener example](examples/single_listener/lib/single_transitions_listener.rb) to see how a listener can be used to build a visualization of the transitions, using these properties.
+
+```ruby
+# ids_tree         #
+0                  # [0, [
+|- 1               #   [1, [[2, []]]],
+|  |- 2            #   [3, []],
+|- 3               #   [4, [
+|- 4               #     [5, []],
+|  |- 5            #     [6, [[7, []]]]
+|  |- 6            #   ]],
+|     |- 7         #   [8, []]
+|- 8               # ]]
+
+# ids_matrix       # {
+0 | 1 | 2 | 3 | 4  #   0 => [0, 0],
+- | - | - | - | -  #   1 => [1, 1],
+0 |   |   |   |    #   2 => [1, 2],
+1 | 1 | 2 |   |    #   3 => [2, 1],
+2 | 3 |   |   |    #   4 => [3, 1],
+3 | 4 | 5 | 6 | 7  #   5 => [3, 2],
+4 | 8 |   |   |    #   6 => [3, 3],
+                   #   7 => [3, 4],
+                   #   8 => [4, 1]
+                   # }
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+### Configuration
+
+#### Turning on/off
 
 You can use `BCDD::Result.config.feature.disable!(:transitions)` and `BCDD::Result.config.feature.enable!(:transitions)` to turn on/off the `BCDD::Result.transitions` feature.
 
@@ -1949,15 +1995,179 @@ result = SumDivisionsByTwo.call(20, 10)
 
 result.transitions
 
-{:version=>1, :records=>[], :metadata=>{:duration=>0, :tree_map=>[]}}
+{:version=>1, :records=>[], :metadata=>{:duration=>0, :ids_tree=>[]}}
 ```
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
-### `BCDD::Result.configuration`
+#### Setting a `trace_id` fetcher
+
+You can define a lambda (arity 0) to fetch the trace_id. This lambda will be called before the first transition and will be used to set the `:trace_id` in the `:metadata` property.
+
+Use to correlate different or the same operation (executed multiple times).
+
+```ruby
+BCDD::Result.config.transitions.trace_id = -> { Thread.current[:bcdd_result_transitions_trace_id] }
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Setting a `listener`
+
+You can define a listener to be called during the result transitions tracking (check out [this example](examples/single_listener/lib/single_transitions_listener.rb)). It must be a class that includes `BCDD::Result::Transitions::Listener`.
+
+Use it to build your additional logic on top of the transitions tracking. Examples:
+  - Log the transitions.
+  - Perform a trace of the transitions.
+  - Instrument the transitions (measure/report).
+  - Build a visualization of the transitions (Diagrams, using the `records` + `:ids_tree` and `:ids_matrix` properties).
+
+After implementing your listener, you can set it to the `BCDD::Result.config.transitions.listener=`:
+
+```ruby
+BCDD::Result.config.transitions.listener = MyTransitionsListener
+```
+
+See the example below to understand how to implement one:
+
+```ruby
+class MyTransitionsListener
+  include BCDD::Result::Transitions::Listener
+
+  # A listener will be initialized before the first transition, and it is discarded after the last one.
+  def initialize
+  end
+
+  # This method will be called before each transition block.
+  # The parent transition block will be called first in the case of nested transition blocks.
+  #
+  # @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
+  def on_start(scope:)
+  end
+
+  # This method will wrap all the transitions in the same block.
+  # It can be used to perform an instrumentation (measure/report) of the transitions.
+  #
+  # @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
+  def around_transitions(scope:)
+    yield
+  end
+
+  # This method will wrap each and_then call.
+  # It can be used to perform an instrumentation (measure/report) of the and_then calls.
+  #
+  # @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
+  # @param and_then:
+  #  {:type=>:block, :arg=>:some_injected_value}
+  #  {:type=>:method, :arg=>:some_injected_value, :method_name=>:some_method_name}
+  def around_and_then(scope:, and_then:)
+    yield
+  end
+
+  # This method will be called after each result recording/tracking.
+  #
+  # @param record:
+  # {
+  #   :root => {:id=>0, :name=>"RootOperation", :desc=>nil},
+  #   :parent => {:id=>0, :name=>"RootOperation", :desc=>nil},
+  #   :current => {:id=>1, :name=>"SomeOperation", :desc=>nil},
+  #   :result => {:kind=>:success, :type=>:_continue_, :value=>{some: :thing}, :source=><MyProcess:0x0000000102fd6378>},
+  #   :and_then => {:type=>:method, :arg=>nil, :method_name=>:some_method},
+  #   :time => 2024-01-26 02:53:11.310431 UTC
+  # }
+  def on_record(record:)
+  end
+
+  # This method will be called at the end of the transitions tracking.
+  #
+  # @param transitions:
+  # {
+  #   :version => 1,
+  #   :metadata => {
+  #     :duration => 0,
+  #     :trace_id => nil,
+  #     :ids_tree => [0, [[1, []], [2, []]]],
+  #     :ids_matrix => {0 => [0, 0], 1 => [1, 1], 2 => [2, 1]}
+  #   },
+  #   :records => [
+  #     # ...
+  #   ]
+  # }
+  def on_finish(transitions:)
+  end
+
+  # This method will be called when an exception is raised during the transitions tracking.
+  #
+  # @param exception: Exception
+  # @param transitions: Hash
+  def before_interruption(exception:, transitions:)
+  end
+end
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Setting multiple `listeners`
+
+You can use `BCDD::Result::Transitions::Listeners[]` to creates a listener of listeners (check out [this example](examples/multiple_listeners/Rakefile)), which will be called in the order they were added.
+
+**Attention:** It only allows one listener to handle `around_and_then` and another `around_transitions` events.
+
+> The example below defines different listeners to handle `around_and_then` and `around_transitions,` but it is also possible to define a listener to handle both.
+
+```ruby
+class AroundAndThenListener
+  include BCDD::Result::Transitions::Listener
+
+  # It must be a static/singleton method.
+  def self.around_and_then?
+    true
+  end
+
+  def around_and_then(scope:, and_then:)
+    #...
+  end
+end
+
+class AroundTransitionsListener
+  include BCDD::Result::Transitions::Listener
+
+  # It must be a static/singleton method.
+  def self.around_transitions?
+    true
+  end
+
+  def around_transitions(scope:)
+    #...
+  end
+end
+
+class MyTransitionsListener
+  include BCDD::Result::Transitions::Listener
+end
+```
+
+How to use it:
+
+```ruby
+# The listeners will be called in the order they were added.
+BCDD::Result.config.transitions.listener = BCDD::Result::Transitions::Listeners[
+  MyTransitionsListener,
+  AroundAndThenListener,
+  AroundTransitionsListener
+]
+```
+
+> Check out [this example](examples/multiple_listeners) to see a listener to print the transitions and another to store them in the database.
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+## `BCDD::Result.configuration`
 
 The `BCDD::Result.configuration` allows you to configure default behaviors for `BCDD::Result` and `BCDD::Result::Context` through a configuration block. After using it, the configuration is frozen, ensuring the expected behaviors for your application.
 
+> Note: You can use `BCDD::Result.configuration(freeze: false) {}` to avoid the freezing. This can be useful in tests. Please be sure to use it with caution.
+
 ```ruby
 BCDD::Result.configuration do |config|
   config.addon.enable!(:given, :continue)
@@ -1974,13 +2184,13 @@ Use `disable!` to disable a feature and `enable!` to enable it.
 
 Let's see what each configuration in the example above does:
 
-#### `config.addon.enable!(:given, :continue)`
+### `config.addon.enable!(:given, :continue)` <!-- omit in toc -->
 
 This configuration enables the `Continue()` method for `BCDD::Result.mixin`, `BCDD::Result::Context.mixin`, `BCDD::Result::Expectation.mixin`, and `BCDD::Result::Context::Expectation.mixin`. Link to documentations: [(1)](#add-ons) [(2)](#mixin-add-ons).
 
 It is also enabling the `Given()` which is already enabled by default. Link to documentation: [(1)](#add-ons) [(2)](#mixin-add-ons).
 
-#### `config.constant_alias.enable!('Result', 'BCDD::Context')`
+### `config.constant_alias.enable!('Result', 'BCDD::Context')` <!-- omit in toc -->
 
 This configuration make `Result` a constant alias for `BCDD::Result`, and `BCDD::Context` a constant alias for `BCDD::Result::Context`.
 
@@ -1988,23 +2198,23 @@ Link to documentations:
 - [Result alias](#bcddresult-versus-result)
 - [Context aliases](#constant-aliases)
 
-#### `config.pattern_matching.disable!(:nil_as_valid_value_checking)`
+### `config.pattern_matching.disable!(:nil_as_valid_value_checking)` <!-- omit in toc -->
 
 This configuration disables the `nil_as_valid_value_checking` for `BCDD::Result` and `BCDD::Result::Context`. Link to [documentation](#pattern-matching-support).
 
-<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
-
-#### `config.feature.disable!(:expectations)`
+### `config.feature.disable!(:expectations)` <!-- omit in toc -->
 
 This configuration turns off the expectations for `BCDD::Result` and `BCDD::Result::Context`. The expectations are helpful in development and test environments, but they can be disabled in production environments for performance gain.
 
 PS: I'm using `::Rails.env.production?` to check the environment, but you can use any logic you want.
 
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
 ### `BCDD::Result.config`
 
 The `BCDD::Result.config` allows you to access the current configuration.
 
-**BCDD::Result.config.addon**
+#### **BCDD::Result.config.addon** <!-- omit in toc -->
 
 ```ruby
 BCDD::Result.config.addon.enabled?(:continue)
@@ -2033,7 +2243,7 @@ BCDD::Result.config.addon.options
 # }
 ```
 
-**BCDD::Result.config.constant_alias**
+#### **BCDD::Result.config.constant_alias** <!-- omit in toc -->
 
 ```ruby
 BCDD::Result.config.constant_alias.enabled?('Result')
@@ -2048,7 +2258,7 @@ BCDD::Result.config.constant_alias.options
 # }
 ```
 
-**BCDD::Result.config.pattern_matching**
+#### **BCDD::Result.config.pattern_matching** <!-- omit in toc -->
 
 ```ruby
 BCDD::Result.config.pattern_matching.enabled?(:nil_as_valid_value_checking)
@@ -2065,7 +2275,7 @@ BCDD::Result.config.pattern_matching.options
 # }
 ```
 
-**BCDD::Result.config.feature**
+#### **BCDD::Result.config.feature** <!-- omit in toc -->
 
 ```ruby
 BCDD::Result.config.feature.enabled?(:expectations)
@@ -2287,7 +2497,7 @@ end
 
 ## About
 
-[Rodrigo Serradura](https://github.com/serradura) created this project. He is the B/CDD process/method creator and has already made similar gems like the [u-case](https://github.com/serradura/u-case) and [kind](https://github.com/serradura/kind/blob/main/lib/kind/result.rb). This gem is a general-purpose abstraction/monad, but it also contains key features that serve as facilitators for adopting B/CDD in the code.
+[Rodrigo Serradura](https://github.com/serradura) created this project. He is the B/CDD process/method creator and has already made similar gems like the [u-case](https://github.com/serradura/u-case) and [kind](https://github.com/serradura/kind/blob/main/lib/kind/result.rb). This gem can be used independently, but it also contains essential features that facilitate the adoption of B/CDD in code.
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 

data/Steepfile

@@ -10,16 +10,16 @@ target :lib do
   # check 'app/models/**/*.rb'        # Glob
   # ignore 'lib/templates/*.rb'
 
-  library 'singleton', 'securerandom' # Standard libraries
+  library 'singleton'                 # Standard libraries
   # library 'strong_json'             # Gems
 
   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
-  # configure_code_diagnostics do |hash|             # You can setup everything yourself
-  #   hash[D::Ruby::NoMethod] = :information
-  # end
+  configure_code_diagnostics do |hash|             # You can setup everything yourself
+    hash[D::Ruby::NoMethod] = :information
+  end
 end
 
 # target :test do

data/examples/multiple_listeners/Rakefile

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION <= '3.1'
+  puts 'This example requires Ruby 3.1 or higher.'
+  exit! 1
+end
+
+# Usage:
+#
+# rake DISABLE_TRANSITIONS=t
+# rake DISABLE_LISTENER=t
+#
+# rake HIDE_GIVEN_AND_CONTINUE=t
+#
+# rake BREAK_ACCOUNT_CREATION=t
+# rake BREAK_USER_CREATION=t
+# rake BREAK_USER_TOKEN_CREATION=t
+#
+# rake BREAK_ACCOUNT_CREATION=t HIDE_GIVEN_AND_CONTINUE=t
+task default: %i[bcdd_result_transitions]
+
+desc 'creates an account and an owner user through BCDD::Result'
+task :bcdd_result_transitions do
+  require_relative 'config'
+
+  BCDD::Result.configuration do |config|
+    config.feature.disable!(:transitions) if ENV['DISABLE_TRANSITIONS']
+
+    unless ENV['DISABLE_LISTENER']
+      config.transitions.listener = BCDD::Result::Transitions::Listeners[
+        TransitionsListener::Stdout,
+        BCDD::Result::TransitionsRecord::Listener
+      ]
+    end
+  end
+
+  result = nil
+
+  bench = Benchmark.measure do
+    result = Account::OwnerCreation.new.call(
+      owner: {
+        name: "\tJohn     Doe \n",
+        email: '   JOHN.doe@email.com',
+        password: '123123123',
+        password_confirmation: '123123123'
+      }
+    )
+  rescue RuntimeBreaker::Interruption => e
+    nil
+  end
+
+  puts "\nBCDD::Result::TransitionsRecord.count: #{BCDD::Result::TransitionsRecord.count}"
+
+  puts "\nBenchmark: #{bench}"
+end

data/examples/multiple_listeners/app/models/account/member.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Account::Member < ActiveRecord::Base
+  self.table_name = 'account_members'
+
+  enum role: { owner: 0, admin: 1, contributor: 2 }
+
+  belongs_to :user, inverse_of: :memberships
+  belongs_to :account, inverse_of: :memberships
+end