bcdd-result 0.9.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78ccef0bd217127baf1bf96cabf4074c2ab2e8bb7befffd7c7f2f3df4631bf27
-  data.tar.gz: '0429c37305f2265dd13517c7a64e977929f6a4bde4b70421de01c8a418b67656'
+  metadata.gz: c0043be8de0b26bac0d803f067537fbc65e4a54f3a38a2644c01bd987d87c7b5
+  data.tar.gz: f152ac78abb8847721f2b2ec3c3fd1db66016c421f5348f038a79501a86f761a
 SHA512:
-  metadata.gz: f8756ac806f830d458b3c830c15ac667cbb29f1737fa97cb59870541e2f3e8000839ab775c16559370499a7055db7f0938bb8a71071db9b5392507af5f0ec7de
-  data.tar.gz: 1003e299eec64ddb62a51b1f8d358b9dca2b58add3f8b4b9a4c46a5a70cb825907b2de7339c4f5e94817fb92e48c3a702eae67cd6eeca80942c60bdc80dff071
+  metadata.gz: 17abccc11ad3c7ccd2cedc6f9634659decee457e08ef1c8dfb13d59d2afc7390fdeb6fc1d48749362d691815c41b789197d2bf79b5f57f9e7e07ad770ddbb304
+  data.tar.gz: 2e0b67fbc99ef2a3a8187a2d42212e8cbadca22a2c2625c3be8e7bbfb5d2b92689b9a27b7592a295863e89437e912d34cb8f6e5a2e77e9c0afdbcbf7c4591bd6

data/.rubocop.yml

@@ -9,6 +9,10 @@ AllCops:
   NewCops: enable
   TargetRubyVersion: 2.7
 
+Lint/RescueException:
+  Exclude:
+    - lib/bcdd/result/transitions.rb
+
 Layout/LineLength:
   Max: 120
 
@@ -70,6 +74,10 @@ Minitest/AssertEmptyLiteral:
 Minitest/AssertOperator:
   Enabled: false
 
+Minitest/AssertWithExpectedArgument:
+  Exclude:
+    - test/test_helper.rb
+
 Naming/FileName:
   Exclude:
     - lib/bcdd-result.rb

data/CHANGELOG.md

@@ -1,41 +1,68 @@
 - [\[Unreleased\]](#unreleased)
-- [\[0.9.1\] - 2023-12-12](#091---2023-12-12)
+- [\[0.11.0\] - 2024-01-02](#0110---2024-01-02)
+  - [Added](#added)
   - [Changed](#changed)
+- [\[0.10.0\] - 2023-12-31](#0100---2023-12-31)
+  - [Added](#added-1)
+- [\[0.9.1\] - 2023-12-12](#091---2023-12-12)
+  - [Changed](#changed-1)
   - [Fixed](#fixed)
 - [\[0.9.0\] - 2023-12-12](#090---2023-12-12)
-  - [Added](#added)
-  - [Changed](#changed-1)
-- [\[0.8.0\] - 2023-12-11](#080---2023-12-11)
-  - [Added](#added-1)
+  - [Added](#added-2)
   - [Changed](#changed-2)
+- [\[0.8.0\] - 2023-12-11](#080---2023-12-11)
+  - [Added](#added-3)
+  - [Changed](#changed-3)
   - [Removed](#removed)
 - [\[0.7.0\] - 2023-10-27](#070---2023-10-27)
-  - [Added](#added-2)
-  - [Changed](#changed-3)
-- [\[0.6.0\] - 2023-10-11](#060---2023-10-11)
-  - [Added](#added-3)
-  - [Changed](#changed-4)
-- [\[0.5.0\] - 2023-10-09](#050---2023-10-09)
   - [Added](#added-4)
-- [\[0.4.0\] - 2023-09-28](#040---2023-09-28)
+  - [Changed](#changed-4)
+- [\[0.6.0\] - 2023-10-11](#060---2023-10-11)
   - [Added](#added-5)
   - [Changed](#changed-5)
+- [\[0.5.0\] - 2023-10-09](#050---2023-10-09)
+  - [Added](#added-6)
+- [\[0.4.0\] - 2023-09-28](#040---2023-09-28)
+  - [Added](#added-7)
+  - [Changed](#changed-6)
   - [Removed](#removed-1)
 - [\[0.3.0\] - 2023-09-26](#030---2023-09-26)
-  - [Added](#added-6)
+  - [Added](#added-8)
 - [\[0.2.0\] - 2023-09-26](#020---2023-09-26)
-  - [Added](#added-7)
+  - [Added](#added-9)
   - [Removed](#removed-2)
 - [\[0.1.0\] - 2023-09-25](#010---2023-09-25)
-  - [Added](#added-8)
+  - [Added](#added-10)
 
 ## [Unreleased]
 
+## [0.11.0] - 2024-01-02
+
+### Added
+
+- Add the `Given()` addon to produce a `Success(:given, value)` result. As the `Continue()` addon, it is ignored by the expectations. Use it to add a value to the result chain and invoke the next step (through `and_then`).
+
+### Changed
+
+- **(BREAKING)** Rename halted concept to terminal. Failures are terminal by default, but you can make a success terminal by enabling the `:continue` addon.
+
+- **(BREAKING)** Rename `BCDD::Result::Context::Success#and_expose` halted keyword argument to `terminal`.
+
+- **(BREAKING)** Rename `BCDD::Result#halted?` to `BCDD::Result#terminal?`.
+
+## [0.10.0] - 2023-12-31
+
+### Added
+
+- Add `BCDD::Result.transitions(&block)` to track all transitions in the same or between different operations. 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.
+
+- Add `BCDD::Result.config.feature.disable!(:transitions)` and `BCDD::Result.config.feature.enable!(:transitions)` to turn on/off the `BCDD::Result.transitions` feature.
+
 ## [0.9.1] - 2023-12-12
 
 ### Changed
 
-- **(BREAKING)** Make `BCDD::Result::Context::Success#and_expose()` to produce a halted success by default. You can turn this off by passing `halted: false`.
+- **(BREAKING)** Make `BCDD::Result::Context::Success#and_expose()` to produce a terminal success by default. You can turn this off by passing `halted: false`.
 
 ### Fixed
 

data/README.md

@@ -70,8 +70,10 @@ 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!(:continue)`](#configaddonenablecontinue)
+    - [`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)
@@ -916,35 +918,48 @@ Divide.call(4, 2, logger: Logger.new(IO::NULL))
 
 The `BCDD::Result.mixin` also accepts the `config:` argument. It is a hash that will be used to define custom behaviors for the mixin.
 
+**given**
+
+This addon is enabled by default. It will create the `Given(value)` method. Use it to add a value to the result chain and invoke the next step (through `and_then`).
+
+You can turn it off by passing `given: false` to the `config:` argument or using the `BCDD::Result.configuration`.
+
 **continue**
 
-This addon will create the `Continue(value)` method and change the `Success()` behavior to halt the step chain.
+This addon will create the `Continue(value)` method and change the `Success()` behavior to terminate the step chain.
 
-So, if you want to advance to the next step, you must use `Continue(value)` instead of `Success(type, value)`. Otherwise, the step chain will be halted.
+So, if you want to advance to the next step, you must use `Continue(value)` instead of `Success(type, value)`. Otherwise, the step chain will be terminated.
+
+In this example below, the `validate_nonzero` will return a `Success(:division_completed, 0)` and terminate the chain if the first number is zero.
 
 ```ruby
 module Divide
   extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
 
   def call(arg1, arg2)
-    validate_numbers(arg1, arg2)
+    Given([arg1, arg2])
+      .and_then(:validate_numbers)
       .and_then(:validate_nonzero)
       .and_then(:divide)
   end
 
   private
 
-  def validate_numbers(arg1, arg2)
-    arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
-    arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
+  def validate_numbers(numbers)
+    number1, number2 = numbers
 
-    Continue([arg1, arg2])
+    number1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
+    number2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
+
+    Continue(numbers)
   end
 
   def validate_nonzero(numbers)
-    return Continue(numbers) unless numbers.last.zero?
+    return Failure(:division_by_zero, 'arg2 must not be zero') if numbers.last.zero?
 
-    Failure(:division_by_zero, 'arg2 must not be zero')
+    return Success(:division_completed, 0) if numbers.first.zero?
+
+    Continue(numbers)
   end
 
   def divide((number1, number2))
@@ -983,7 +998,7 @@ module Divide
 end
 ```
 
-In the code above, we define a constant `Divide::Expected`. And because of this (it is a constant), we can use it inside and outside the module.
+In the code above, we define a constant `Divide::Result`. And because of this (it is a constant), we can use it inside and outside the module.
 
 Look what happens if you try to create a result without one of the expected types.
 
@@ -1223,7 +1238,7 @@ Divide.call(4, 2)
 
 #### Value checking - Result Creation
 
-The `Result::Expectations` supports types of validations. The first is the type checking only, and the second is the type and value checking.
+The `Result::Expectations` supports two types of validations. The first is the type checking only, and the second is the type and value checking.
 
 To define expectations for your result's values, you must declare a Hash with the type as the key and the value as the value. A value validator is any object that responds to `#===` (case equality operator).
 
@@ -1569,13 +1584,13 @@ Divide.new.call(10, 5)
 #<BCDD::Result::Context::Success type=:ok value={:number=>2, :number1=>10, :number2=>5}>
 ```
 
-> PS: The `#and_expose` produces a halted success by default. This means the next step will not be executed even if you call `#and_then` after `#and_expose`. To change this behavior, you can pass `halted: false` to `#and_expose`.
+> PS: The `#and_expose` produces a terminal success by default. This means the next step will not be executed even if you call `#and_then` after `#and_expose`. To change this behavior, you can pass `terminal: false` to `#and_expose`.
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
 ##### Module example (Singleton Methods)
 
-Yes, the `BCDD::Result::Context.mixin` can produce singleton methods. Look for an example using a module (but it could be a class, too).
+`BCDD::Result::Context.mixin` can also produce singleton methods. Below is an example using a module (but it could be a class, too).
 
 ```ruby
 module Divide
@@ -1660,7 +1675,7 @@ Divide.new.call(10, 5)
 
 As in the `BCDD::Result::Expectations.mixin`, the `BCDD::Result::Context::Expectations.mixin` will add a Result constant in the target class. It can generate success/failure results, which ensure the mixin expectations.
 
-Let's see this using previous example:
+Let's see this using the previous example:
 
 ```ruby
 Divide::Result::Success(:division_completed, number: 2)
@@ -1676,16 +1691,24 @@ Divide::Result::Success(:division_completed, number: '2')
 
 The `BCDD::Result::Context.mixin` and `BCDD::Result::Context::Expectations.mixin` also accepts the `config:` argument. And it works the same way as the `BCDD::Result` mixins.
 
-**Continue**
+**given**
+
+This addon is enabled by default. It will create the `Given(*value)` method. Use it to add a value to the result chain and invoke the next step (through `and_then`).
+
+You can turn it off by passing `given: false` to the `config:` argument or using the `BCDD::Result.configuration`.
+
+The `Given()` addon for a BCDD::Result::Context can be called with one or more arguments. The arguments will be converted to a hash (`to_h`) and merged to define the first value of the result chain.
+
+**continue**
 
-The `BCDD::Result::Context.mixin(config: { addon: { continue: true } })` or `BCDD::Result::Context::Expectations.mixin(config: { addon: { continue: true } })` creates the `Continue(value)` method and change the `Success()` behavior to halt the step chain.
+The `BCDD::Result::Context.mixin(config: { addon: { continue: true } })` or `BCDD::Result::Context::Expectations.mixin(config: { addon: { continue: true } })` creates the `Continue(value)` method and change the `Success()` behavior to terminate the step chain.
 
-So, if you want to advance to the next step, you must use `Continue(**value)` instead of `Success(type, **value)`. Otherwise, the step chain will be halted.
+So, if you want to advance to the next step, you must use `Continue(**value)` instead of `Success(type, **value)`. Otherwise, the step chain will be terminated.
 
 Let's use a mix of `BCDD::Result::Context` features to see in action with this add-on:
 
 ```ruby
-module Divide
+module Division
   require 'logger'
 
   extend self, BCDD::Result::Context::Expectations.mixin(
@@ -1703,25 +1726,28 @@ module Divide
   )
 
   def call(arg1, arg2, logger: ::Logger.new(STDOUT))
-    validate_numbers(arg1, arg2)
-      .and_then(:validate_nonzero)
+    Given(number1: arg1, number2: arg2)
+      .and_then(:require_numbers)
+      .and_then(:check_for_zeros)
       .and_then(:divide, logger: logger)
       .and_expose(:division_completed, [:number])
   end
 
   private
 
-  def validate_numbers(arg1, arg2)
-    arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
-    arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
+  def require_numbers(number1:, number2:)
+    number1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
+    number2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
 
-    Continue(number1: arg1, number2: arg2)
+    Continue()
   end
 
-  def validate_nonzero(number2:, **)
-    return Continue() if number2.nonzero?
+  def check_for_zeros(number1:, number2:)
+    return Failure(:division_by_zero, message: 'arg2 must not be zero') if number2.zero?
 
-    Failure(:division_by_zero, message: 'arg2 must not be zero')
+    return Success(:division_completed, number: 0) if number1.zero?
+
+    Continue()
   end
 
   def divide(number1:, number2:, logger:)
@@ -1733,27 +1759,201 @@ module Divide
   end
 end
 
-Divide.call(14, 2)
+Division.call(14, 2)
 # I, [2023-10-27T02:01:05.812388 #77823]  INFO -- : The division result is 7
 #<BCDD::Result::Context::Success type=:division_completed value={:number=>7}>
 
-Divide.call('14', 2)
+Division.call(0, 2)
+##<BCDD::Result::Context::Success type=:division_completed value={:number=>0}>
+
+Division.call('14', 2)
 #<BCDD::Result::Context::Failure type=:invalid_arg value={:message=>"arg1 must be numeric"}>
 
-Divide.call(14, '2')
+Division.call(14, '2')
 #<BCDD::Result::Context::Failure type=:invalid_arg value={:message=>"arg2 must be numeric"}>
 
-Divide.call(14, 0)
+Division.call(14, 0)
 #<BCDD::Result::Context::Failure type=:division_by_zero value={:message=>"arg2 must not be zero"}>
 ```
 
+### `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.
+
+When you wrap the creation of the result with `BCDD::Result.transitions`, the final result will expose all the transition records through the `BCDD::Result#transitions` method.
+
+```ruby
+class Division
+  include BCDD::Result.mixin(config: { addon: { continue: true } })
+
+  def call(arg1, arg2)
+    BCDD::Result.transitions(name: 'Division', desc: 'divide two numbers') do
+      Given([arg1, arg2])
+        .and_then(:require_numbers)
+        .and_then(:check_for_zeros)
+        .and_then(:divide)
+    end
+  end
+
+  private
+
+  ValidNumber = ->(arg) { arg.is_a?(Numeric) && arg != Float::NAN && arg != Float::INFINITY }
+
+  def require_numbers((arg1, arg2))
+    ValidNumber[arg1] or return Failure(:invalid_arg, 'arg1 must be a valid number')
+    ValidNumber[arg2] or return Failure(:invalid_arg, 'arg2 must be a valid number')
+
+    Continue([arg1, arg2])
+  end
+
+  def check_for_zeros(numbers)
+    num1, num2 = numbers
+
+    return Failure(:division_by_zero, 'num2 cannot be zero') if num2.zero?
+
+    num1.zero? ? Success(:division_completed, 0) : Continue(numbers)
+  end
+
+  def divide((num1, num2))
+    Success(:division_completed, num1 / num2)
+  end
+end
+
+module SumDivisionsByTwo
+  extend self, BCDD::Result.mixin
+
+  def call(*numbers)
+    BCDD::Result.transitions(name: 'SumDivisionsByTwo') do
+      divisions = numbers.map { |number| Division.new.call(number, 2) }
+
+      if divisions.any?(&:failure?)
+        Failure(:errors, divisions.select(&:failure?).map(&:value))
+      else
+        Success(:sum, divisions.sum(&:value))
+      end
+    end
+  end
+end
+```
+
+Let's see the result of the `SumDivisionsByTwo` call:
+
+```ruby
+result = SumDivisionsByTwo.call(20, 10)
+# => #<BCDD::Result::Success type=:sum value=15>
+
+result.transitions
+{
+  :version =>1,
+  :metadata => {
+    :duration => 0,                       # milliseconds
+    :tree_map => [0, [[1, []], [2, []]]], # represents the tree of transitions using the id of each transition block
+  },
+  :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=>:continued, :value=>[20, 2]},
+      :and_then=>{:type=>:method, :arg=>nil, :subject=><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=>:continued, :value=>[20, 2]},
+      :and_then=>{:type=>:method, :arg=>nil, :subject=><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=>:division_completed, :value=>10},
+      :and_then=>{:type=>:method, :arg=>nil, :subject=><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=>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=>:continued, :value=>[10, 2]},
+      :and_then=>{:type=>:method, :arg=>nil, :subject=><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=>:continued, :value=>[10, 2]},
+      :and_then=>{:type=>:method, :arg=>nil, :subject=><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=>:division_completed, :value=>5},
+      :and_then=>{:type=>:method, :arg=>nil, :subject=><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=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :result=>{:kind=>:success, :type=>:sum, :value=>15},
+      :and_then=>{},
+      :time=>2024-01-02 03:35:11.248721 UTC
+    }
+  ]
+}
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Configuration
+
+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.
+
+```ruby
+BCDD::Result.configuration do |config|
+  config.feature.disable!(:transitions)
+end
+
+result = SumDivisionsByTwo.call(20, 10)
+# => #<BCDD::Result::Success type=:sum value=15>
+
+result.transitions
+
+{:version=>1, :records=>[], :metadata=>{:duration=>0, :tree_map=>[]}}
+```
+
+<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.
 
 ```ruby
 BCDD::Result.configuration do |config|
-  config.addon.enable!(:continue)
+  config.addon.enable!(:given, :continue)
 
   config.constant_alias.enable!('Result', 'BCDD::Context')
 
@@ -1767,9 +1967,11 @@ 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!(:continue)`
+#### `config.addon.enable!(:given, :continue)`
+
+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).
 
-This configuration enables the `Continue()` method for `BCDD::Result`, `BCDD::Result::Context`, `BCDD::Result::Expectation`, and `BCDD::Result::Context::Expectation`. 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')`
 
@@ -1793,22 +1995,32 @@ PS: I'm using `::Rails.env.production?` to check the environment, but you can us
 
 ### `BCDD::Result.config`
 
-The `BCDD::Result.config` allows you to access the current configuration. It is useful when you want to check the current configuration.
+The `BCDD::Result.config` allows you to access the current configuration.
 
 **BCDD::Result.config.addon**
 
 ```ruby
 BCDD::Result.config.addon.enabled?(:continue)
+BCDD::Result.config.addon.enabled?(:given)
 
 BCDD::Result.config.addon.options
 # {
 #   :continue=>{
 #     :enabled=>false,
 #     :affects=>[
-#       "BCDD::Result",
-#       "BCDD::Result::Context",
-#       "BCDD::Result::Expectations",
-#       "BCDD::Result::Context::Expectations"
+#       "BCDD::Result.mixin",
+#       "BCDD::Result::Context.mixin",
+#       "BCDD::Result::Expectations.mixin",
+#       "BCDD::Result::Context::Expectations.mixin"
+#     ]
+#   },
+#   :given=>{
+#     :enabled=>true,
+#     :affects=>[
+#       "BCDD::Result.mixin",
+#       "BCDD::Result::Context.mixin",
+#       "BCDD::Result::Expectations.mixin",
+#       "BCDD::Result::Context::Expectations.mixin"
 #     ]
 #   }
 # }
@@ -1859,6 +2071,13 @@ BCDD::Result.config.feature.options
 #       "BCDD::Result::Expectations,
 #       "BCDD::Result::Context::Expectations"
 #     ]
+#   },
+#   :transitions=>{
+#     :enabled=>true,
+#     :affects=>[
+#       "BCDD::Result",
+#       "BCDD::Result::Context"
+#     ]
 #   }
 # }
 ```

data/Rakefile

@@ -3,16 +3,22 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
+Rake::TestTask.new(:test) do |t|
+  t.libs += %w[lib test]
+
+  t.test_files = FileList.new('test/**/*_test.rb')
+end
+
 Rake::TestTask.new(:test_configuration) do |t|
   t.libs += %w[lib test]
 
   t.test_files = FileList.new('test/**/configuration_test.rb')
 end
 
-Rake::TestTask.new(:test) do |t|
+Rake::TestTask.new(:test_transitions_duration) do |t|
   t.libs += %w[lib test]
 
-  t.test_files = FileList.new('test/**/*_test.rb')
+  t.test_files = FileList.new('test/**/duration_test.rb')
 end
 
 require 'rubocop/rake_task'

data/Steepfile

@@ -10,8 +10,8 @@ target :lib do
   # check 'app/models/**/*.rb'        # Glob
   # ignore 'lib/templates/*.rb'
 
-  library 'singleton'               # Standard libraries
-  # library 'strong_json'           # Gems
+  library 'singleton', 'securerandom' # 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

data/lib/bcdd/result/config/switchers/addons.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class Config
+    module Addons
+      AFFECTS = %w[
+        BCDD::Result.mixin
+        BCDD::Result::Context.mixin
+        BCDD::Result::Expectations.mixin
+        BCDD::Result::Context::Expectations.mixin
+      ].freeze
+
+      OPTIONS = {
+        continue: { default: false, affects: AFFECTS },
+        given: { default: true, affects: AFFECTS }
+      }.transform_values!(&:freeze).freeze
+
+      def self.switcher
+        Switcher.new(options: OPTIONS)
+      end
+    end
+
+    private_constant :Addons
+  end
+end

data/lib/bcdd/result/config/{constant_alias.rb → switchers/constant_aliases.rb}

@@ -2,7 +2,7 @@
 
 class BCDD::Result
   class Config
-    module ConstantAlias
+    module ConstantAliases
       MAPPING = {
         'Result' => { target: ::Object, name: :Result, value: ::BCDD::Result },
         'Context' => { target: ::Object, name: :Context, value: ::BCDD::Result::Context },
@@ -15,14 +15,14 @@ class BCDD::Result
         [option_name, { default: false, affects: [affects].freeze }]
       end.freeze
 
-      Listener = ->(option_name, boolean) do
+      Listener = ->(option_name, bool) do
         mapping = MAPPING.fetch(option_name)
 
         target, name, value = mapping.fetch_values(:target, :name, :value)
 
         defined = target.const_defined?(name, false)
 
-        boolean ? defined || target.const_set(name, value) : defined && target.send(:remove_const, name)
+        bool ? defined || target.const_set(name, value) : defined && target.send(:remove_const, name)
       end
 
       def self.switcher
@@ -30,6 +30,6 @@ class BCDD::Result
       end
     end
 
-    private_constant :ConstantAlias
+    private_constant :ConstantAliases
   end
 end