u-case 2.5.0 → 3.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 349609a8d927ab7fd8edb1eb96141dff2f78f9957f31f2b88a8975239fc0de87
-  data.tar.gz: 4b6293023f49f28dd8283656a0d423f7d24abbfb7f010a90ba4d0dd17f577d22
+  metadata.gz: b3374584a2cf58a68aa1bed216c91bfd715cc4365d2e7972e5693a8c3acb52eb
+  data.tar.gz: 9bbe75661a2cd53e549cf60692811d47d1aaf5895ee71cf89f3fc7e8f8d72f0b
 SHA512:
-  metadata.gz: 0553e560e40f71d0e8284ebbbbf7a51326d8c9bc9de6ad0de76db526466a94f633e2b038563868a2c93234800b7bdacc30a99ba57f1624ce08463fdc012d165d
-  data.tar.gz: 2866ca201676827b2ffc82877b1615e7ecbb6fc6e993df17007c6446b348a850266faf162a0953954ee6adfb0d35a88c303bee385d2fb52a9c228f45513655db
+  metadata.gz: d43a4e404c554e4e489cd4875af61bf66ab41bec68a84c6022b04b3ae8dd79975f8522e8ecf8c0211ae0f08cbd4fe95ac6d7320a94d0c140ce3c436d26650afb
+  data.tar.gz: '084cabc2b47f424a789f0e0cc9f120bfa50516771e669763207bed6c2884b4f6c3b8731be495eafc5bf1dc1c68b1b82b85a308c4a77cb546d77d99f6a088a827'

data/.travis.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
 
-bundle exec rake test
-
 ruby_v=$(ruby -v)
 
 ACTIVEMODEL_VERSION='3.2' bundle update
@@ -16,3 +14,6 @@ if [[ $ruby_v =~ '2.5.' ]] || [[ $ruby_v =~ '2.6.' ]] || [[ $ruby_v =~ '2.7.' ]]
   ACTIVEMODEL_VERSION='6.0' bundle update
   ACTIVEMODEL_VERSION='6.0' bundle exec rake test
 fi
+
+bundle update
+bundle exec rake test

data/Gemfile

@@ -27,9 +27,19 @@ pry_byebug_version =
   else '3.9'
   end
 
+pry_version =
+  case RUBY_VERSION
+  when /\A2.2/ then '0.12.2'
+  when /\A2.3/ then '0.12.2'
+  else '0.13.1'
+  end
+
 group :development, :test do
   gem 'awesome_print', '~> 1.8'
 
+  gem 'byebug', '~> 10.0', '>= 10.0.2' if RUBY_VERSION =~ /\A2.2/
+
+  gem 'pry', "~> #{pry_version}"
   gem 'pry-byebug', "~> #{pry_byebug_version}"
 end
 

data/README.md

@@ -18,6 +18,14 @@ The main project goals are:
 
 > Note: Check out the repo https://github.com/serradura/from-fat-controllers-to-use-cases to see a Rails application that uses this gem to handle its business logic.
 
+## Documentation <!-- omit in toc -->
+
+Version   | Documentation
+--------- | -------------
+3.0.0.rc3 | https://github.com/serradura/u-case/blob/master/README.md
+2.6.0     | https://github.com/serradura/u-case/blob/v2.x/README.md
+1.1.0     | https://github.com/serradura/u-case/blob/v1.x/README.md
+
 ## Table of Contents <!-- omit in toc -->
 - [Required Ruby version](#required-ruby-version)
 - [Dependencies](#dependencies)
@@ -29,28 +37,33 @@ The main project goals are:
     - [How to define custom result types?](#how-to-define-custom-result-types)
     - [Is it possible to define a custom result type without a block?](#is-it-possible-to-define-a-custom-result-type-without-a-block)
     - [How to use the result hooks?](#how-to-use-the-result-hooks)
-    - [Why the failure hook (without a type) exposes a different kind of data?](#why-the-failure-hook-without-a-type-exposes-a-different-kind-of-data)
+    - [Why the hook usage without a type exposes the result itself?](#why-the-hook-usage-without-a-type-exposes-the-result-itself)
+      - [Using decomposition to access the result data and type](#using-decomposition-to-access-the-result-data-and-type)
     - [What happens if a result hook was declared multiple times?](#what-happens-if-a-result-hook-was-declared-multiple-times)
     - [How to use the `Micro::Case::Result#then` method?](#how-to-use-the-microcaseresultthen-method)
-  - [`Micro::Case::Flow` - How to compose use cases?](#microcaseflow---how-to-compose-use-cases)
+      - [What does happens when a `Micro::Case::Result#then` receives a block?](#what-does-happens-when-a-microcaseresultthen-receives-a-block)
+      - [How to make attributes data injection using this feature?](#how-to-make-attributes-data-injection-using-this-feature)
+  - [`Micro::Cases::Flow` - How to compose use cases?](#microcasesflow---how-to-compose-use-cases)
     - [Is it possible to compose a use case flow with other ones?](#is-it-possible-to-compose-a-use-case-flow-with-other-ones)
     - [Is it possible a flow accumulates its input and merges each success result to use as the argument of the next use cases?](#is-it-possible-a-flow-accumulates-its-input-and-merges-each-success-result-to-use-as-the-argument-of-the-next-use-cases)
     - [How to understand what is happening during a flow execution?](#how-to-understand-what-is-happening-during-a-flow-execution)
       - [`Micro::Case::Result#transitions` schema](#microcaseresulttransitions-schema)
+      - [Is it possible disable the `Micro::Case::Result#transitions`?](#is-it-possible-disable-the-microcaseresulttransitions)
     - [Is it possible to declare a flow which includes the use case itself?](#is-it-possible-to-declare-a-flow-which-includes-the-use-case-itself)
   - [`Micro::Case::Strict` - What is a strict use case?](#microcasestrict---what-is-a-strict-use-case)
   - [`Micro::Case::Safe` - Is there some feature to auto handle exceptions inside of a use case or flow?](#microcasesafe---is-there-some-feature-to-auto-handle-exceptions-inside-of-a-use-case-or-flow)
-    - [`Micro::Case::Safe::Flow`](#microcasesafeflow)
+    - [`Micro::Cases::Safe::Flow`](#microcasessafeflow)
     - [`Micro::Case::Result#on_exception`](#microcaseresulton_exception)
   - [`u-case/with_activemodel_validation` - How to validate use case attributes?](#u-casewith_activemodel_validation---how-to-validate-use-case-attributes)
     - [If I enabled the auto validation, is it possible to disable it only in specific use case classes?](#if-i-enabled-the-auto-validation-is-it-possible-to-disable-it-only-in-specific-use-case-classes)
-    - [Kind::Validator](#kindvalidator)
+    - [`Kind::Validator`](#kindvalidator)
+- [`Micro::Case.config`](#microcaseconfig)
 - [Benchmarks](#benchmarks)
-  - [`Micro::Case`](#microcase)
+  - [`Micro::Case` (v2.6.0)](#microcase-v260)
     - [Best overall](#best-overall)
     - [Success results](#success-results)
     - [Failure results](#failure-results)
-  - [`Micro::Case::Flow`](#microcaseflow)
+  - [`Micro::Case::Flow` (v2.6.0)](#microcaseflow-v260)
   - [Comparisons](#comparisons)
 - [Examples](#examples)
   - [1️⃣ Rails App (API)](#1️⃣-rails-app-api)
@@ -72,7 +85,7 @@ The main project goals are:
 
     A simple type system (at runtime) for Ruby.
 
-    Used to validate method inputs, expose `Kind.of.Micro::Case::Result` type checker and its [`activemodel validation`](https://github.com/serradura/kind#kindvalidator-activemodelvalidations) module is auto required by [`u-case/with_activemodel_validation`](#u-casewith_activemodel_validation---how-to-validate-use-case-attributes) mode.
+    Used to validate method inputs using its [`activemodel validation`](https://github.com/serradura/kind#kindvalidator-activemodelvalidations) module is auto required by [`u-case/with_activemodel_validation`](#u-casewith_activemodel_validation---how-to-validate-use-case-attributes) mode, and expose `Kind::Of::Micro::Case`, `Kind::Of::Micro::Case::Result` type checkers.
 2. [`u-attributes`](https://github.com/serradura/u-attributes) gem.
 
     This gem allows defining read-only attributes, that is, your objects will have only getters to access their attributes data.
@@ -106,11 +119,11 @@ class Multiply < Micro::Case
   # 2. Define the method `call!` with its business logic
   def call!
 
-    # 3. Wrap the use case result/output using the `Success()` or `Failure()` methods
+    # 3. Wrap the use case result/output using the `Success(result: *)` or `Failure(result: *)` methods
     if a.is_a?(Numeric) && b.is_a?(Numeric)
-      Success(a * b)
+      Success result: { number: a * b }
     else
-      Failure { '`a` and `b` attributes must be numeric' }
+      Failure result: { message: '`a` and `b` attributes must be numeric' }
     end
   end
 end
@@ -124,22 +137,14 @@ end
 result = Multiply.call(a: 2, b: 2)
 
 result.success? # true
-result.value    # 4
+result.data     # { number: 4 }
 
 # Failure result
 
 bad_result = Multiply.call(a: 2, b: '2')
 
 bad_result.failure? # true
-bad_result.value    # "`a` and `b` attributes must be numeric"
-
-#-----------------------------#
-# Calling a use case instance #
-#-----------------------------#
-
-result = Multiply.new(a: 2, b: 3).call
-
-result.value # 6
+bad_result.data     # { message: "`a` and `b` attributes must be numeric" }
 
 # Note:
 # ----
@@ -154,11 +159,15 @@ result.value # 6
 A `Micro::Case::Result` stores the use cases output data. These are their main methods:
 - `#success?` returns true if is a successful result.
 - `#failure?` returns true if is an unsuccessful result.
-- `#value` the result value itself.
+- `#use_case` returns the use case responsible for it. This feature is handy to handle a flow failure (this topic will be covered ahead).
 - `#type` a Symbol which gives meaning for the result, this is useful to declare different types of failures or success.
-- `#on_success` or `#on_failure` are hook methods that help you define the application flow.
-- `#use_case` if is a failure result, the use case responsible for it will be accessible through this method. This feature is handy to handle a flow failure (this topic will be covered ahead).
-- `#then` allows if the current result is a success, the `then` method will allow to applying a new use case for its value.
+- `#data` the result data itself.
+- `#[]` and `#values_at` are shortcuts to access the `#data` values.
+- `#on_success` or `#on_failure` are hook methods that help you to define the application flow.
+- `#then` this method will allow applying a new use case if the current result was a success. The idea of this feature is to allow the creation of dynamic flows.
+- `#transitions` returns an array with all of transformations wich a result [has during a flow](#how-to-understand-what-is-happening-during-a-flow-execution).
+
+> **Note:** for backward compatibility, you could use the `#value` method as an alias of `#data` method.
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -173,9 +182,13 @@ class Divide < Micro::Case
   attributes :a, :b
 
   def call!
-    invalid_attributes.empty? ? Success(a / b) : Failure(invalid_attributes)
-  rescue => e
-    Failure(e)
+    if invalid_attributes.empty?
+      Success result: { number: a / b }
+    else
+      Failure result: { invalid_attributes: invalid_attributes }
+    end
+  rescue => exception
+    Failure result: exception
   end
 
   private def invalid_attributes
@@ -188,49 +201,51 @@ end
 result = Divide.call(a: 2, b: 2)
 
 result.type     # :ok
-result.value    # 1
+result.data     # { number: 1 }
 result.success? # true
-result.use_case # raises `Micro::Case::Error::InvalidAccessToTheUseCaseObject: only a failure result can access its own use case`
+result.use_case # #<Divide:0x0000 @__attributes={"a"=>2, "b"=>2}, @a=2, @b=2, @__result=...>
 
 # Failure result (type == :error)
 
 bad_result = Divide.call(a: 2, b: '2')
 
 bad_result.type     # :error
-bad_result.value    # {"b"=>"2"}
+bad_result.data     # { invalid_attributes: { "b"=>"2" } }
 bad_result.failure? # true
-bad_result.use_case # #<Divide:0x0000 @__attributes={"a"=>2, "b"=>"2"}, @a=2, @b="2", @__result=#<Micro::Case::Result:0x0000 @use_case=#<Divide:0x0000 ...>, @type=:error, @value={"b"=>"2"}, @success=false>>
+bad_result.use_case # #<Divide:0x0000 @__attributes={"a"=>2, "b"=>"2"}, @a=2, @b="2", @__result=...>
 
 # Failure result (type == :exception)
 
 err_result = Divide.call(a: 2, b: 0)
 
 err_result.type     # :exception
-err_result.value    # <ZeroDivisionError: divided by 0>
+err_result.data     # { exception: <ZeroDivisionError: divided by 0> }
 err_result.failure? # true
-err_result.use_case # #<Divide:0x0000 @__attributes={"a"=>2, "b"=>0}, @a=2, @b=0, @__result=#<Micro::Case::Result:0x0000 @use_case=#<Divide:0x0000 ...>, @type=:exception, @value=#<ZeroDivisionError: divided by 0>, @success=false>>
+err_result.use_case # #<Divide:0x0000 @__attributes={"a"=>2, "b"=>0}, @a=2, @b=0, @__result=#<Micro::Case::Result:0x0000 @use_case=#<Divide:0x0000 ...>, @type=:exception, @value=#<ZeroDivisionError: divided by 0>, @success=false>
 
 # Note:
 # ----
 # Any Exception instance which is wrapped by
-# the Failure() method will receive `:exception` instead of the `:error` type.
+# the Failure(result: *) method will receive `:exception` instead of the `:error` type.
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
 
 #### How to define custom result types?
 
-Answer: Use a symbol as the argument of `Success()`, `Failure()` methods and declare a block to set their values.
+Answer: Use a symbol as the argument of `Success()`, `Failure()` methods and declare the `result:` keyword to set the result data.
 
 ```ruby
 class Multiply < Micro::Case
   attributes :a, :b
 
   def call!
-    return Success(a * b) if a.is_a?(Numeric) && b.is_a?(Numeric)
-
-    Failure(:invalid_data) do
-      attributes.reject { |_, input| input.is_a?(Numeric) }
+    if a.is_a?(Numeric) && b.is_a?(Numeric)
+      Success result: { number: a * b }
+    else
+      Failure :invalid_data, result: {
+        attributes: attributes.reject { |_, input| input.is_a?(Numeric) }
+      }
     end
   end
 end
@@ -240,7 +255,7 @@ end
 result = Multiply.call(a: 3, b: 2)
 
 result.type     # :ok
-result.value    # 6
+result.data     # { number: 6 }
 result.success? # true
 
 # Failure result
@@ -248,7 +263,7 @@ result.success? # true
 bad_result = Multiply.call(a: 3, b: '2')
 
 bad_result.type     # :invalid_data
-bad_result.value    # {"b"=>"2"}
+bad_result.data     # { attributes: {"b"=>"2"} }
 bad_result.failure? # true
 ```
 
@@ -256,23 +271,25 @@ bad_result.failure? # true
 
 #### Is it possible to define a custom result type without a block?
 
-Answer: Yes, it is. But only for failure results!
+Answer: Yes, it is possible. But this will have special behavior because the result data will be a hash with the given type as the key and true as its value.
 
 ```ruby
 class Multiply < Micro::Case
   attributes :a, :b
 
   def call!
-    return Failure(:invalid_data) unless a.is_a?(Numeric) && b.is_a?(Numeric)
-
-    Success(a * b)
+    if a.is_a?(Numeric) && b.is_a?(Numeric)
+      Success result: { number: a * b }
+    else
+      Failure(:invalid_data)
+    end
   end
 end
 
 result = Multiply.call(a: 2, b: '2')
 
 result.failure?            # true
-result.value               # :invalid_data
+result.data                # { :invalid_data => true }
 result.type                # :invalid_data
 result.use_case.attributes # {"a"=>2, "b"=>"2"}
 
@@ -295,10 +312,10 @@ class Double < Micro::Case
   attribute :number
 
   def call!
-    return Failure(:invalid) { 'the number must be a numeric value' } unless number.is_a?(Numeric)
-    return Failure(:lte_zero) { 'the number must be greater than 0' } if number <= 0
+    return Failure :invalid, result: { msg: 'number must be a numeric value' } unless number.is_a?(Numeric)
+    return Failure :lte_zero, result: { msg: 'number must be greater than 0' } if number <= 0
 
-    Success(number * 2)
+    Success result: { number: number * 2 }
   end
 end
 
@@ -308,9 +325,9 @@ end
 
 Double
   .call(number: 3)
-  .on_success { |number| p number }
-  .on_failure(:invalid) { |msg| raise TypeError, msg }
-  .on_failure(:lte_zero) { |msg| raise ArgumentError, msg }
+  .on_success { |result| p result[:number] }
+  .on_failure(:invalid) { |result| raise TypeError, result[:msg] }
+  .on_failure(:lte_zero) { |result| raise ArgumentError, result[:msg] }
 
 # The output because it is a success:
 #   6
@@ -321,10 +338,10 @@ Double
 
 Double
   .call(number: -1)
-  .on_success { |number| p number }
+  .on_success { |result| p result[:number] }
   .on_failure { |_result, use_case| puts "#{use_case.class.name} was the use case responsible for the failure" }
-  .on_failure(:invalid) { |msg| raise TypeError, msg }
-  .on_failure(:lte_zero) { |msg| raise ArgumentError, msg }
+  .on_failure(:invalid) { |result| raise TypeError, result[:msg] }
+  .on_failure(:lte_zero) { |result| raise ArgumentError, result[:msg] }
 
 # The outputs will be:
 #
@@ -336,7 +353,7 @@ Double
 # The use case responsible for the failure will be accessible as the second hook argument
 ```
 
-#### Why the failure hook (without a type) exposes a different kind of data?
+#### Why the hook usage without a type exposes the result itself?
 
 Answer: To allow you to define how to handle the program flow using some
 conditional statement (like an `if`, `case/when`).
@@ -347,46 +364,43 @@ class Double < Micro::Case
 
   def call!
     return Failure(:invalid) unless number.is_a?(Numeric)
-    return Failure(:lte_zero) { number } if number <= 0
+    return Failure :lte_zero, result: attributes(:number) if number <= 0
 
-    Success(number * 2)
+    Success result: { number: number * 2 }
   end
 end
 
-#=================================#
-# Using the result type and value #
-#=================================#
-
 Double
-  .call(-1)
+  .call(number: -1)
   .on_failure do |result, use_case|
     case result.type
-    when :invalid then raise TypeError, 'the number must be a numeric value'
-    when :lte_zero then raise ArgumentError, "the number `#{result.value}` must be greater than 0"
+    when :invalid then raise TypeError, "number must be a numeric value"
+    when :lte_zero then raise ArgumentError, "number `#{result[:number]}` must be greater than 0"
     else raise NotImplementedError
     end
   end
 
 # The output will be the exception:
 #
-# ArgumentError (the number `-1` must be greater than 0)
+# ArgumentError (number `-1` must be greater than 0)
+```
 
-#=====================================================#
-# Using decomposition to access result value and type #
-#=====================================================#
+> **Note:** The same that was did in the previous examples could be done with `#on_success` hook!
 
-# The syntax to decompose an Array can be used in methods, blocks and assigments.
-# If you doesn't know that, check out:
-# https://ruby-doc.org/core-2.2.0/doc/syntax/assignment_rdoc.html#label-Array+Decomposition
-#
-# And the object exposed in the hook failure can be decomposed using this syntax. e.g:
+##### Using decomposition to access the result data and type
+
+The syntax to decompose an Array can be used in methods, blocks and assigments.
+If you doesn't know it, check out the [Ruby doc](https://ruby-doc.org/core-2.2.0/doc/syntax/assignment_rdoc.html#label-Array+Decomposition).
+
+```ruby
+# The object exposed in the hook is a Micro::Case::Result, and it can be decomposed using this syntax. e.g:
 
 Double
-  .call(-2)
-  .on_failure do |(value, type), use_case|
+  .call(number: -2)
+  .on_failure do |(data, type), use_case|
     case type
-    when :invalid then raise TypeError, 'the number must be a numeric value'
-    when :lte_zero then raise ArgumentError, "the number `#{value}` must be greater than 0"
+    when :invalid then raise TypeError, 'number must be a numeric value'
+    when :lte_zero then raise ArgumentError, "number `#{data[:number]}` must be greater than 0"
     else raise NotImplementedError
     end
   end
@@ -396,6 +410,8 @@ Double
 # ArgumentError (the number `-2` must be greater than 0)
 ```
 
+> **Note:** The same that was did in the previous examples could be done with `#on_success` hook!
+
 [⬆️ Back to Top](#table-of-contents-)
 
 #### What happens if a result hook was declared multiple times?
@@ -407,38 +423,44 @@ class Double < Micro::Case
   attributes :number
 
   def call!
-    return Failure(:invalid) { 'the number must be a numeric value' } unless number.is_a?(Numeric)
-
-    Success(:computed) { number * 2 }
+    if number.is_a?(Numeric)
+      Success :computed, result: { number: number * 2 }
+    else
+      Failure :invalid, result: { msg: 'number must be a numeric value' }
+    end
   end
 end
 
 result = Double.call(number: 3)
-result.value     # 6
-result.value * 4 # 24
+result.data         # { number: 6 }
+result[:number] * 4 # 24
 
 accum = 0
 
-result.on_success { |number| accum += number }
-      .on_success { |number| accum += number }
-      .on_success(:computed) { |number| accum += number }
-      .on_success(:computed) { |number| accum += number }
+result
+  .on_success { |result| accum += result[:number] }
+  .on_success { |result| accum += result[:number] }
+  .on_success(:computed) { |result| accum += result[:number] }
+  .on_success(:computed) { |result| accum += result[:number] }
 
 accum # 24
 
-result.value * 4 == accum # true
+result[:number] * 4 == accum # true
 ```
 
 #### How to use the `Micro::Case::Result#then` method?
 
+This method allows you to create dynamic flows, so, with it,
+you can add new use cases or flows to continue the result transformation. e.g:
+
 ```ruby
 class ForbidNegativeNumber < Micro::Case
   attribute :number
 
   def call!
-    return Success { attributes } if number >= 0
+    return Success result: attributes if number >= 0
 
-    Failure { attributes }
+    Failure result: attributes
   end
 end
 
@@ -446,7 +468,7 @@ class Add3 < Micro::Case
   attribute :number
 
   def call!
-    Success { { number: number + 3 } }
+    Success result: { number: number + 3 }
   end
 end
 
@@ -455,8 +477,7 @@ result1 =
     .call(number: -1)
     .then(Add3)
 
-result1.type     # :error
-result1.value    # {'number' => -1}
+result1.data    # {'number' => -1}
 result1.failure? # true
 
 # ---
@@ -466,16 +487,69 @@ result2 =
     .call(number: 1)
     .then(Add3)
 
-result2.type     # :ok
-result2.value    # {'number' => 4}
+result2.data     # {'number' => 4}
 result2.success? # true
 ```
 
+> **Note:** this method changes the [`Micro::Case::Result#transitions`](#how-to-understand-what-is-happening-during-a-flow-execution).
+
 [⬆️ Back to Top](#table-of-contents-)
 
-### `Micro::Case::Flow` - How to compose use cases?
+##### What does happens when a `Micro::Case::Result#then` receives a block?
+
+It will yields self (a `Micro::Case::Result instance`) to the block and return the result of the block. e.g:
+
+```ruby
+class Add < Micro::Case
+  attributes :a, :b
 
-In this case, this will be a **flow** (`Micro::Case::Flow`).
+  def call!
+    if Kind.of?(Numeric, a, b)
+      Success result: { sum: a + b }
+    else
+      Failure(:attributes_arent_numbers)
+    end
+  end
+end
+
+# --
+
+success_result =
+  Add
+    .call(a: 2, b: 2)
+    .then { |result| result.success? ? result[:sum] : 0 }
+
+puts success_result # 4
+
+# --
+
+failure_result =
+  Add
+    .call(a: 2, b: '2')
+    .then { |result| result.success? ? result[:sum] : 0 }
+
+puts failure_result # 0
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+##### How to make attributes data injection using this feature?
+
+Pass a Hash as the second argument of the `Micro::Case::Result#then` method.
+
+```ruby
+Todo::FindAllForUser
+  .call(user: current_user, params: params)
+  .then(Paginate)
+  .then(Serialize::PaginatedRelationAsJson, serializer: Todo::Serializer)
+  .on_success { |result| render_json(200, data: result[:todos]) }
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### `Micro::Cases::Flow` - How to compose use cases?
+
+In this case, this will be a **flow** (`Micro::Cases::Flow`).
 The main idea of this feature is to use/reuse use cases as steps of a new use case.
 
 ```ruby
@@ -485,9 +559,9 @@ module Steps
 
     def call!
       if numbers.all? { |value| String(value) =~ /\d+/ }
-        Success(numbers: numbers.map(&:to_i))
+        Success result: { numbers: numbers.map(&:to_i) }
       else
-        Failure('numbers must contain only numeric types')
+        Failure result: { message: 'numbers must contain only numeric types' }
       end
     end
   end
@@ -496,7 +570,7 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number + 2 })
+      Success result: { numbers: numbers.map { |number| number + 2 } }
     end
   end
 
@@ -504,7 +578,7 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number * 2 })
+      Success result: { numbers: numbers.map { |number| number * 2 } }
     end
   end
 
@@ -512,24 +586,24 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number * number })
+      Success result: { numbers: numbers.map { |number| number * number } }
     end
   end
 end
 
-#---------------------------------------------#
-# Creating a flow using the collection syntax #
-#---------------------------------------------#
+#-------------------------------------------#
+# Creating a flow using Micro::Cases.flow() #
+#-------------------------------------------#
 
-Add2ToAllNumbers = Micro::Case::Flow([
+Add2ToAllNumbers = Micro::Cases.flow([
   Steps::ConvertTextToNumbers,
   Steps::Add2
 ])
 
 result = Add2ToAllNumbers.call(numbers: %w[1 1 2 2 3 4])
 
-p result.success? # true
-p result.value    # {:numbers => [3, 3, 4, 4, 5, 6]}
+result.success? # true
+result.data    # {:numbers => [3, 3, 4, 4, 5, 6]}
 
 #---------------------------------------------------#
 # An alternative way to create a flow using classes #
@@ -540,45 +614,18 @@ class DoubleAllNumbers < Micro::Case
        Steps::Double
 end
 
-DoubleAllNumbers
-  .call(numbers: %w[1 1 b 2 3 4])
-  .on_failure { |message| p message } # "numbers must contain only numeric types"
-
-# !------------------------------------ ! #
-# ! Deprecated: Micro::Case::Flow mixin ! #
-# !-------------------------------------! #
-
-# The code below still works, but it will output a warning message:
-# Deprecation: Micro::Case::Flow mixin is being deprecated, please use `Micro::Case` inheritance instead.
-
-class DoubleAllNumbers
-  include Micro::Case::Flow
-
-  flow Steps::ConvertTextToNumbers,
-       Steps::Double
-end
-
-# Note: This feature will be removed in the next major release (3.0)
-
-#-------------------------------------------------------------#
-# Another way to create a flow using the composition operator #
-#-------------------------------------------------------------#
-
-SquareAllNumbers =
-  Steps::ConvertTextToNumbers >> Steps::Square
-
-SquareAllNumbers
-  .call(numbers: %w[1 1 2 2 3 4])
-  .on_success { |value| p value[:numbers] } # [1, 1, 4, 4, 9, 16]
+DoubleAllNumbers.
+  call(numbers: %w[1 1 b 2 3 4]).
+  on_failure { |result| puts result[:message] } # "numbers must contain only numeric types"
 
 # Note:
 # ----
 # When happening a failure, the use case responsible
 # will be accessible in the result
 
-result = SquareAllNumbers.call(numbers: %w[1 1 b 2 3 4])
+result = DoubleAllNumbers.call(numbers: %w[1 1 b 2 3 4])
 
-result.failure?                                # true
+result.failure?                                    # true
 result.use_case.is_a?(Steps::ConvertTextToNumbers) # true
 
 result.on_failure do |_message, use_case|
@@ -590,7 +637,7 @@ end
 
 #### Is it possible to compose a use case flow with other ones?
 
-Answer: Yes, it is.
+Answer: Yes, it is possible.
 
 ```ruby
 module Steps
@@ -599,9 +646,9 @@ module Steps
 
     def call!
       if numbers.all? { |value| String(value) =~ /\d+/ }
-        Success(numbers: numbers.map(&:to_i))
+        Success result: { numbers: numbers.map(&:to_i) }
       else
-        Failure('numbers must contain only numeric types')
+        Failure result: { message: 'numbers must contain only numeric types' }
       end
     end
   end
@@ -610,7 +657,7 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number + 2 })
+      Success result: { numbers: numbers.map { |number| number + 2 } }
     end
   end
 
@@ -618,7 +665,7 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number * 2 })
+      Success result: { numbers: numbers.map { |number| number * 2 } }
     end
   end
 
@@ -626,47 +673,55 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number * number })
+      Success result: { numbers: numbers.map { |number| number * number } }
     end
   end
 end
 
-Add2ToAllNumbers = Steps::ConvertTextToNumbers >> Steps::Add2
-DoubleAllNumbers = Steps::ConvertTextToNumbers >> Steps::Double
-SquareAllNumbers = Steps::ConvertTextToNumbers >> Steps::Square
+DoubleAllNumbers =
+  Micro::Cases.flow([Steps::ConvertTextToNumbers, Steps::Double])
+
+SquareAllNumbers =
+  Micro::Cases.flow([Steps::ConvertTextToNumbers, Steps::Square])
+
+DoubleAllNumbersAndAdd2 =
+  Micro::Cases.flow([DoubleAllNumbers, Steps::Add2])
 
-DoubleAllNumbersAndAdd2 = DoubleAllNumbers >> Steps::Add2
-SquareAllNumbersAndAdd2 = SquareAllNumbers >> Steps::Add2
+SquareAllNumbersAndAdd2 =
+  Micro::Cases.flow([SquareAllNumbers, Steps::Add2])
 
-SquareAllNumbersAndDouble = SquareAllNumbersAndAdd2 >> DoubleAllNumbers
-DoubleAllNumbersAndSquareAndAdd2 = DoubleAllNumbers >> SquareAllNumbersAndAdd2
+SquareAllNumbersAndDouble =
+  Micro::Cases.flow([SquareAllNumbersAndAdd2, DoubleAllNumbers])
+
+DoubleAllNumbersAndSquareAndAdd2 =
+  Micro::Cases.flow([DoubleAllNumbers, SquareAllNumbersAndAdd2])
 
 SquareAllNumbersAndDouble
   .call(numbers: %w[1 1 2 2 3 4])
-  .on_success { |value| p value[:numbers] } # [6, 6, 12, 12, 22, 36]
+  .on_success { |result| p result[:numbers] } # [6, 6, 12, 12, 22, 36]
 
 DoubleAllNumbersAndSquareAndAdd2
   .call(numbers: %w[1 1 2 2 3 4])
-  .on_success { |value| p value[:numbers] } # [6, 6, 18, 18, 38, 66]
+  .on_success { |result| p result[:numbers] } # [6, 6, 18, 18, 38, 66]
 ```
 
-Note: You can blend any of the [available syntaxes/approaches](#how-to-create-a-flow-which-has-reusable-steps-to-define-a-complex-use-case) to create use case flows - [examples](https://github.com/serradura/u-case/blob/master/test/micro/case/flow/blend_test.rb#L7-L34).
+Note: You can blend any of the [available syntaxes/approaches](#how-to-create-a-flow-which-has-reusable-steps-to-define-a-complex-use-case) to create use case flows - [examples](https://github.com/serradura/u-case/blob/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/cases/flow/blend_test.rb#L5-L35).
 
 [⬆️ Back to Top](#table-of-contents-)
 
 #### Is it possible a flow accumulates its input and merges each success result to use as the argument of the next use cases?
 
-Answer: Yes, it is! Look at the example below to understand how the data accumulation works inside of the flow execution.
+Answer: Yes, it is possible! Look at the example below to understand how the data accumulation works inside of the flow execution.
 
 ```ruby
 module Users
-  class Find < Micro::Case
+  class FindByEmail < Micro::Case
     attribute :email
 
     def call!
       user = User.find_by(email: email)
 
-      return Success { { user: user } } if user
+      return Success result: { user: user } if user
 
       Failure(:user_not_found)
     end
@@ -681,14 +736,14 @@ module Users
       return Failure(:user_must_be_persisted) if user.new_record?
       return Failure(:wrong_password) if user.wrong_password?(password)
 
-      return Success { attributes(:user) }
+      return Success result: attributes(:user)
     end
   end
 end
 
 module Users
-  Authenticate = Micro::Case::Flow([
-    Find,
+  Authenticate = Micro::Cases.flow([
+    FindByEmail,
     ValidatePassword
   ])
 end
@@ -696,14 +751,14 @@ end
 Users::Authenticate
   .call(email: 'somebody@test.com', password: 'password')
   .on_success { |result| sign_in(result[:user]) }
-  .on_failure(:wrong_password) { |result| render status: 401 }
-  .on_failure(:user_not_found) { |result| render status: 404 }
+  .on_failure(:wrong_password) { render status: 401 }
+  .on_failure(:user_not_found) { render status: 404 }
 ```
 
-First, lets see the attribute of each use case:
+First, lets see the attributes used by each use case:
 
 ```ruby
-class Users::Find < Micro::Case
+class Users::FindByEmail < Micro::Case
   attribute :email
 end
 
@@ -713,14 +768,14 @@ end
 ```
 
 As you can see the `Users::ValidatePassword` expects a user as its input. So, how does it receives the user?
-It receives the user from the `Users::Find` success result!
+It receives the user from the `Users::FindByEmail` success result!
 
 And this, is the power of use cases composition because the output
-of one flow will compose the input of the next use case in the flow!
+of one step will compose the input of the next use case in the flow!
 
 > input **>>** process **>>** output
 
-> **Note:** Check out these test examples [Micro::Case::Flow](https://github.com/serradura/u-case/blob/b6d63b0db0caada67d2a6cf5cc5937000c0acf04/test/micro/case/flow/reducer_test.rb) and [Micro::Case::Safe::Flow](https://github.com/serradura/u-case/blob/b1d84b355f2b92d329e10d5d56d8012df1d32681/test/micro/case/safe/flow/reducer_test.rb) to see different use cases sharing their own data.
+> **Note:** Check out these test examples [Micro::Cases::Flow](https://github.com/serradura/u-case/blob/c96a3650469da40dc9f83ff678204055b7015d01/test/micro/cases/flow/result_transitions_test.rb) and [Micro::Cases::Safe::Flow](https://github.com/serradura/u-case/blob/c96a3650469da40dc9f83ff678204055b7015d01/test/micro/cases/safe/flow/result_transitions_test.rb) to see different use cases sharing their own data.
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -738,12 +793,12 @@ user_authenticated.transitions
 [
   {
     :use_case => {
-      :class      => Users::Find,
+      :class      => Users::FindByEmail,
       :attributes => { :email => "rodrigo@test.com" }
     },
     :success => {
       :type  => :ok,
-      :value => {
+      :result => {
         :user => #<User:0x00007fb57b1c5f88 @email="rodrigo@test.com" ...>
       }
     },
@@ -759,7 +814,7 @@ user_authenticated.transitions
     },
     :success => {
       :type  => :ok,
-      :value => {
+      :result => {
         :user => #<User:0x00007fb57b1c5f88 @email="rodrigo@test.com" ...>
       }
     },
@@ -769,14 +824,12 @@ user_authenticated.transitions
 ```
 
 The example above shows the output generated by the `Micro::Case::Result#transitions`.
-With it is possible to analyze the use cases execution order and what were the given `inputs` (attributes) and `outputs` (`success.value`) in the entire execution.
+With it is possible to analyze the use cases execution order and what were the given `inputs` (`[:attributes]`) and `outputs` (`[:success][:result]`) in the entire execution.
 
-And look up the `accessible_attributes` property, because it shows whats attributes are accessible in that flow step. For example, in the last step, you can see that the `accessible_attributes` increased because of the [flow data accumulation](#is-it-possible-a-flow-accumulates-its-input-and-merges-each-success-result-to-use-as-the-argument-of-the-next-use-cases).
+And look up the `accessible_attributes` property, it shows whats attributes are accessible in that flow step. For example, in the last step, you can see that the `accessible_attributes` increased because of the [data flow accumulation](#is-it-possible-a-flow-accumulates-its-input-and-merges-each-success-result-to-use-as-the-argument-of-the-next-use-cases).
 
 > **Note:** The [`Micro::Case::Result#then`](#how-to-use-the-microcaseresultthen-method) increments the `Micro::Case::Result#transitions`.
 
-PS: Use the `Micro::Case::Result.disable_transition_tracking` global feature toggle to disable this feature (use once) and increase the use cases' performance.
-
 ##### `Micro::Case::Result#transitions` schema
 ```ruby
 [
@@ -788,7 +841,7 @@ PS: Use the `Micro::Case::Result.disable_transition_tracking` global feature tog
     [success:, failure:] => {   # (Output)
       type:  <Symbol>,          # Result type. Defaults:
                                 # Success = :ok, Failure = :error/:exception
-      value: <Hash>             # The data returned by the use case
+      result: <Hash>            # The data returned by the use case
     },
     accessible_attributes: <Array>, # Properties that can be accessed by the use case's attributes,
                                     # starting with Hash used to invoke it and which are incremented
@@ -797,6 +850,10 @@ PS: Use the `Micro::Case::Result.disable_transition_tracking` global feature tog
 ]
 ```
 
+##### Is it possible disable the `Micro::Case::Result#transitions`?
+
+Answer: Yes, it is! You can use the `Micro::Case.config` to do this. [Link to](#microcaseconfig) this section.
+
 #### Is it possible to declare a flow which includes the use case itself?
 
 Answer: Yes, it is! You can use the `self.call!` macro. e.g:
@@ -806,7 +863,7 @@ class ConvertTextToNumber < Micro::Case
   attribute :text
 
   def call!
-    Success { { number: text.to_i } }
+    Success result: { number: text.to_i }
   end
 end
 
@@ -814,7 +871,7 @@ class ConvertNumberToText < Micro::Case
   attribute :number
 
   def call!
-    Success { { text: number.to_s } }
+    Success result: { text: number.to_s }
   end
 end
 
@@ -826,17 +883,17 @@ class Double < Micro::Case
   attribute :number
 
   def call!
-    Success { { number: number * 2 } }
+    Success result: { number: number * 2 }
   end
 end
 
 result = Double.call(text: '4')
 
 result.success? # true
-result.value    # "8"
+result[:number] # "8"
 
 # NOTE: This feature can be used with the Micro::Case::Safe.
-#       Checkout the test: test/micro/case/safe/flow/with_classes/using_itself_test.rb
+#       Checkout this test: https://github.com/serradura/u-case/blob/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/case/safe/with_inner_flow_test.rb
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
@@ -850,7 +907,7 @@ class Double < Micro::Case::Strict
   attribute :numbers
 
   def call!
-    Success(numbers.map { |number| number * 2 })
+    Success result: { numbers: numbers.map { |number| number * 2 } }
   end
 end
 
@@ -864,7 +921,7 @@ Double.call({})
 
 ### `Micro::Case::Safe` - Is there some feature to auto handle exceptions inside of a use case or flow?
 
-Answer: Yes, there is!
+Answer: Yes, there is one!
 
 **Use cases:**
 
@@ -879,17 +936,21 @@ class Divide < Micro::Case::Safe
   attributes :a, :b
 
   def call!
-    return Success(a / b) if a.is_a?(Integer) && b.is_a?(Integer)
-    Failure(:not_an_integer)
+    if a.is_a?(Integer) && b.is_a?(Integer)
+      Success result: { number: a / b}
+    else
+      Failure(:not_an_integer)
+    end
   end
 end
 
 result = Divide.call(a: 2, b: 0)
-result.type == :exception             # true
-result.value.is_a?(ZeroDivisionError) # true
+result.type == :exception                   # true
+result.data                                 # { exception: #<ZeroDivisionError...> }
+result[:exception].is_a?(ZeroDivisionError) # true
 
-result.on_failure(:exception) do |exception|
-  AppLogger.error(exception.message) # E, [2019-08-21T00:05:44.195506 #9532] ERROR -- : divided by 0
+result.on_failure(:exception) do |result|
+  AppLogger.error(result[:exception].message) # E, [2019-08-21T00:05:44.195506 #9532] ERROR -- : divided by 0
 end
 
 # Note:
@@ -897,8 +958,8 @@ end
 # If you need to handle a specific error,
 # I recommend the usage of a case statement. e,g:
 
-result.on_failure(:exception) do |exception, use_case|
-  case exception
+result.on_failure(:exception) do |data, use_case|
+  case exception = data[:exception]
   when ZeroDivisionError then AppLogger.error(exception.message)
   else AppLogger.debug("#{use_case.class.name} was the use case responsible for the exception")
   end
@@ -907,27 +968,18 @@ end
 # Another note:
 # ------------
 # It is possible to rescue an exception even when is a safe use case.
-# Examples: https://github.com/serradura/u-case/blob/5a85fc238b63811a32737493dc6c59965f92491d/test/micro/case/safe_test.rb#L95-L123
+# Examples: https://github.com/serradura/u-case/blob/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/case/safe_test.rb#L90-L118
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
 
-#### `Micro::Case::Safe::Flow`
+#### `Micro::Cases::Safe::Flow`
 
 As the safe use cases, safe flows can intercept an exception in any of its steps. These are the ways to define one:
 
 ```ruby
 module Users
-  Create = ProcessParams & ValidateParams & Persist & SendToCRM
-end
-
-# Note:
-# The ampersand is based on the safe navigation operator. https://ruby-doc.org/core-2.6/doc/syntax/calling_methods_rdoc.html#label-Safe+navigation+operator
-
-# The alternatives to declare a safe flow are:
-
-module Users
-  Create = Micro::Case::Safe::Flow([
+  Create = Micro::Cases.safe_flow([
     ProcessParams,
     ValidateParams,
     Persist,
@@ -945,23 +997,6 @@ module Users
          SendToCRM
   end
 end
-
-# !------------------------------------------ ! #
-# ! Deprecated: Micro::Case::Safe::Flow mixin ! #
-# !-------------------------------------------! #
-
-# The code below still works, but it will output a warning message:
-# Deprecation: Micro::Case::Flow mixin is being deprecated, please use `Micro::Case` inheritance instead.
-
-module Users
-  class Create
-    include Micro::Case::Safe::Flow
-
-    flow ProcessParams, ValidateParams, Persist, SendToCRM
-  end
-end
-
-# Note: This feature will be removed in the next major release (3.0)
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
@@ -972,7 +1007,7 @@ In functional programming errors/exceptions are handled as regular data, the ide
 
 To address this the `Micro::Case::Result` has a special hook `#on_exception` to helping you to handle the control flow in the case of exceptions.
 
-> **Note** this feature will work better if you use it with a `Micro::Case::Safe` use case/flow.
+> **Note**: this feature will work better if you use it with a `Micro::Case::Safe` use case/flow.
 
 How does it work?
 
@@ -981,7 +1016,7 @@ class Divide < Micro::Case::Safe
   attributes :a, :b
 
   def call!
-    Success(division: a / b)
+    Success result: { division: a / b }
   end
 end
 
@@ -1031,23 +1066,27 @@ class Multiply < Micro::Case
   validates :a, :b, presence: true, numericality: true
 
   def call!
-    return Failure(:validation_error) { {errors: self.errors} } unless valid?
+    return Failure :validation_error, result: { errors: self.errors } if invalid?
 
-    Success(number: a * b)
+    Success result: { number: a * b }
   end
 end
+```
 
-#
-# But if do you want an automatic way to fail
-# your use cases on validation errors, you can use:
+But if do you want an automatic way to fail your use cases on validation errors, you can:
+
+1. **require 'u-case/with_activemodel_validation'** mode
+
+  ```ruby
+  gem 'u-case', require: 'u-case/with_activemodel_validation'
+  ```
 
-# In some file. e.g: A Rails initializer
-require 'u-case/with_activemodel_validation' # or require 'micro/case/with_validation'
+2. Use the `Micro::Case.config` to enable it. [Link to](#microcaseconfig) this section.
 
-# In the Gemfile
-gem 'u-case', require: 'u-case/with_activemodel_validation'
+Using this approach, you can rewrite the previous example with less code. e.g:
 
-# Using this approach, you can rewrite the previous example with less code. e.g:
+```ruby
+require 'u-case/with_activemodel_validation'
 
 class Multiply < Micro::Case
   attributes :a, :b
@@ -1055,7 +1094,7 @@ class Multiply < Micro::Case
   validates :a, :b, presence: true, numericality: true
 
   def call!
-    Success(number: a * b)
+    Success result: { number: a * b }
   end
 end
 
@@ -1067,7 +1106,7 @@ end
 
 #### If I enabled the auto validation, is it possible to disable it only in specific use case classes?
 
-Answer: Yes, it is. To do this, you only need to use the `disable_auto_validation` macro. e.g:
+Answer: Yes, it is possible. To do this, you only need to use the `disable_auto_validation` macro. e.g:
 
 ```ruby
 require 'u-case/with_activemodel_validation'
@@ -1080,7 +1119,7 @@ class Multiply < Micro::Case
   validates :a, :b, presence: true, numericality: true
 
   def call!
-    Success(number: a * b)
+    Success result: { number: a * b }
   end
 end
 
@@ -1092,7 +1131,7 @@ Multiply.call(a: 2, b: 'a')
 
 [⬆️ Back to Top](#table-of-contents-)
 
-#### Kind::Validator
+#### `Kind::Validator`
 
 The [kind gem](https://github.com/serradura/kind) has a module to enable the validation of data type through [`ActiveModel validations`](https://guides.rubyonrails.org/active_model_basics.html#validations). So, when you require the `'u-case/with_activemodel_validation'`, this module will require the [`Kind::Validator`](https://github.com/serradura/kind#kindvalidator-activemodelvalidations).
 
@@ -1106,20 +1145,41 @@ class Todo::List::AddItem < Micro::Case
   validates :params, kind: ActionController::Parameters
 
   def call!
-    todo_params = Todo::Params.to_save(params)
+    todo_params = params.require(:todo).permit(:title, :due_at)
 
     todo = user.todos.create(todo_params)
 
-    Success { { todo: todo} }
+    Success result: { todo: todo }
   rescue ActionController::ParameterMissing => e
-    Failure(:parameter_missing) { { message: e.message } }
+    Failure :parameter_missing, result: { message: e.message }
   end
 end
 ```
 
+[⬆️ Back to Top](#table-of-contents-)
+
+## `Micro::Case.config`
+
+The idea of this feature is to allow the configuration of some `u-case` features/modules.
+I recommend you use it only once in your codebase. e.g. In a Rails initializer.
+
+You can see below, which are all of the available configurations with their default values:
+
+```ruby
+Micro::Case.config do |config|
+  # Use ActiveModel to auto-validate your use cases' attributes.
+  config.enable_activemodel_validations = false
+
+  # Use to enable/disable the `Micro::Case::Results#transitions` tracking.
+  config.enable_transitions = true
+end
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
 ## Benchmarks
 
-### `Micro::Case`
+### `Micro::Case` (v2.6.0)
 
 #### Best overall
 
@@ -1127,11 +1187,11 @@ The table below contains the average between the [Success results](#success-resu
 
 | Gem / Abstraction      | Iterations per second |       Comparison  |
 | ---------------------- | --------------------: | ----------------: |
-| **Micro::Case**        |              116629.7 | _**The Fastest**_ |
-| Dry::Monads            |              101796.3 |     1.14x slower  |
-| Interactor             |               21230.5 |     5.49x slower  |
-| Trailblazer::Operation |               16466.6 |     7.08x slower  |
-| Dry::Transaction       |                5069.5 |    23.00x slower  |
+| **Micro::Case**        |              105124.3 | _**The Fastest**_ |
+| Dry::Monads            |              103290.1 |     0.02x slower  |
+| Interactor             |               21342.3 |     4.93x slower  |
+| Trailblazer::Operation |               14652.7 |     7.17x slower  |
+| Dry::Transaction       |                5310.3 |    19.80x slower  |
 
 ---
 
@@ -1139,44 +1199,43 @@ The table below contains the average between the [Success results](#success-resu
 
 | Gem / Abstraction      | Iterations per second |       Comparison  |
 | -----------------      | --------------------: | ----------------: |
-| Dry::Monads            |              139352.5 | _**The Fastest**_ |
-| **Micro::Case**        |              124749.4 |     1.12x slower  |
-| Interactor             |               28974.4 |     4.81x slower  |
-| Trailblazer::Operation |               17275.6 |     8.07x slower  |
-| Dry::Transaction       |                5571.7 |    25.01x slower  |
+| Dry::Monads            |              134801.0 | _**The Fastest**_ |
+| **Micro::Case**        |              105909.2 |     1.27x slower  |
+| Interactor             |               29458.2 |     4.58x slower  |
+| Trailblazer::Operation |               14714.9 |     9.16x slower  |
+| Dry::Transaction       |                5642.6 |    28.89x slower  |
 
 <details>
   <summary>Show the full <a href="https://github.com/evanphx/benchmark-ips">benchmark/ips</a> results.</summary>
 
-  ```ruby
-  # Warming up --------------------------------------
-  #           Interactor     2.865k i/100ms
-  # Trailblazer::Operation
-  #                          1.686k i/100ms
-  #          Dry::Monads    13.389k i/100ms
-  #     Dry::Transaction   551.000  i/100ms
-  #          Micro::Case    11.984k i/100ms
-  #  Micro::Case::Strict     9.102k i/100ms
-  #    Micro::Case::Safe    11.747k i/100ms
-  # Calculating -------------------------------------
-  #           Interactor     28.974k (± 2.7%) i/s -    146.115k in   5.046703s
-  # Trailblazer::Operation
-  #                          17.276k (± 1.8%) i/s -     87.672k in   5.076609s
-  #          Dry::Monads    139.353k (± 2.5%) i/s -    709.617k in   5.095599s
-  #     Dry::Transaction      5.572k (± 3.6%) i/s -     28.101k in   5.050376s
-  #          Micro::Case    124.749k (± 1.9%) i/s -    635.152k in   5.093310s
-  #  Micro::Case::Strict     93.417k (± 4.8%) i/s -    473.304k in   5.081341s
-  #    Micro::Case::Safe    120.607k (± 3.2%) i/s -    610.844k in   5.070394s
-
-  # Comparison:
-  #          Dry::Monads:   139352.5 i/s
-  #          Micro::Case:   124749.4 i/s - 1.12x  slower
-  #    Micro::Case::Safe:   120607.3 i/s - 1.16x  slower
-  #  Micro::Case::Strict:    93417.3 i/s - 1.49x  slower
-  #           Interactor:    28974.4 i/s - 4.81x  slower
-  # Trailblazer::Operation:  17275.6 i/s - 8.07x  slower
-  #     Dry::Transaction:     5571.7 i/s - 25.01x  slower
-  ```
+```ruby
+# Warming up --------------------------------------
+#           Interactor     2.897k i/100ms
+# Trailblazer::Operation   1.494k i/100ms
+#          Dry::Monads    13.854k i/100ms
+#     Dry::Transaction   561.000  i/100ms
+#          Micro::Case    10.523k i/100ms
+#  Micro::Case::Strict     7.982k i/100ms
+#    Micro::Case::Safe    10.568k i/100ms
+
+# Calculating -------------------------------------
+#           Interactor     29.458k (± 3.4%) i/s -    147.747k in   5.021405s
+# Trailblazer::Operation   14.715k (± 1.8%) i/s -     74.700k in   5.078128s
+#          Dry::Monads    134.801k (± 8.7%) i/s -    678.846k in   5.088739s
+#     Dry::Transaction      5.643k (± 2.1%) i/s -     28.611k in   5.072969s
+#          Micro::Case    105.909k (± 2.4%) i/s -    536.673k in   5.070329s
+#  Micro::Case::Strict     84.234k (± 1.5%) i/s -    423.046k in   5.023447s
+#    Micro::Case::Safe    105.725k (± 1.9%) i/s -    538.968k in   5.099817s
+
+# Comparison:
+#          Dry::Monads:   134801.0 i/s
+#          Micro::Case:   105909.2 i/s - 1.27x  (± 0.00) slower
+#    Micro::Case::Safe:   105725.0 i/s - 1.28x  (± 0.00) slower
+#  Micro::Case::Strict:    84234.4 i/s - 1.60x  (± 0.00) slower
+#           Interactor:    29458.2 i/s - 4.58x  (± 0.00) slower
+# Trailblazer::Operation:    14714.9 i/s - 9.16x  (± 0.00) slower
+#     Dry::Transaction:     5642.6 i/s - 23.89x  (± 0.00) slower
+```
 </details>
 
 https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_success_result.rb
@@ -1185,100 +1244,98 @@ https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_success
 
 | Gem / Abstraction      | Iterations per second |       Comparison  |
 | -----------------      | --------------------: | ----------------: |
-| **Micro::Case**        |              108510.0 | _**The Fastest**_ |
-| Dry::Monads            |               64240.1 |     1.69x slower  |
-| Trailblazer::Operation |               15657.7 |     6.93x slower  |
-| Interactor             |               13486.7 |     8.05x slower  |
-| Dry::Transaction       |                4567.3 |    23.76x slower  |
+| **Micro::Case**        |              104339.4 | _**The Fastest**_ |
+| Dry::Monads            |               71779.2 |     1.45x slower  |
+| Trailblazer::Operation |               14590.6 |     7.15x slower  |
+| Interactor             |               13226.5 |     7.89x slower  |
+| Dry::Transaction       |                4978.1 |    20.96x slower  |
 
 <details>
   <summary>Show the full <a href="https://github.com/evanphx/benchmark-ips">benchmark/ips</a> results.</summary>
 
-  ```ruby
-  # Warming up --------------------------------------
-  #           Interactor     1.331k i/100ms
-  # Trailblazer::Operation
-  #                          1.544k i/100ms
-  #          Dry::Monads     6.343k i/100ms
-  #     Dry::Transaction   456.000  i/100ms
-  #          Micro::Case    10.429k i/100ms
-  #  Micro::Case::Strict     8.109k i/100ms
-  #    Micro::Case::Safe    10.280k i/100ms
-  # Calculating -------------------------------------
-  #           Interactor     13.487k (± 1.9%) i/s -     67.881k in   5.035059s
-  # Trailblazer::Operation
-  #                          15.658k (± 1.6%) i/s -     78.744k in   5.030427s
-  #          Dry::Monads     64.240k (± 1.8%) i/s -    323.493k in   5.037461s
-  #     Dry::Transaction      4.567k (± 1.3%) i/s -     23.256k in   5.092699s
-  #          Micro::Case    108.510k (± 2.3%) i/s -    542.308k in   5.000605s
-  #  Micro::Case::Strict     83.527k (± 1.4%) i/s -    421.668k in   5.049245s
-  #    Micro::Case::Safe    105.641k (± 3.7%) i/s -    534.560k in   5.067836s
-
-  # Comparison:
-  #          Micro::Case:   108510.0 i/s
-  #    Micro::Case::Safe:   105640.6 i/s - same-ish: difference falls within error
-  #  Micro::Case::Strict:    83526.8 i/s - 1.30x  slower
-  #          Dry::Monads:    64240.1 i/s - 1.69x  slower
-  # Trailblazer::Operation:  15657.7 i/s - 6.93x  slower
-  #           Interactor:    13486.7 i/s - 8.05x  slower
-  #     Dry::Transaction:     4567.3 i/s - 23.76x  slower
-  ```
+```ruby
+# Warming up --------------------------------------
+#           Interactor     1.339k i/100ms
+# Trailblazer::Operation   1.393k i/100ms
+#          Dry::Monads     7.208k i/100ms
+#     Dry::Transaction     423.000  i/100ms
+#          Micro::Case     9.620k i/100ms
+#  Micro::Case::Strict     8.238k i/100ms
+#    Micro::Case::Safe     9.906k i/100ms
+
+# Calculating -------------------------------------
+#           Interactor     13.227k (± 3.3%) i/s -     66.950k in   5.067145s
+# Trailblazer::Operation   14.591k (± 4.0%) i/s -     73.829k in   5.069162s
+#          Dry::Monads     71.779k (± 2.5%) i/s -    360.400k in   5.024294s
+#     Dry::Transaction      4.978k (± 3.3%) i/s -     24.957k in   5.019153s
+#          Micro::Case    103.957k (± 1.8%) i/s -    529.100k in   5.091221s
+#  Micro::Case::Strict     83.094k (± 2.0%) i/s -    420.138k in   5.058233s
+#    Micro::Case::Safe    104.339k (± 1.7%) i/s -    525.018k in   5.033381s
+
+# Comparison:
+#    Micro::Case::Safe:   104339.4 i/s
+#          Micro::Case:   103957.2 i/s - same-ish: difference falls within error
+#  Micro::Case::Strict:    83094.5 i/s - 1.26x  (± 0.00) slower
+#          Dry::Monads:    71779.2 i/s - 1.45x  (± 0.00) slower
+# Trailblazer::Operation:    14590.6 i/s - 7.15x  (± 0.00) slower
+#           Interactor:    13226.5 i/s - 7.89x  (± 0.00) slower
+#     Dry::Transaction:     4978.1 i/s - 20.96x  (± 0.00) slower
+```
 </details>
 
 https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_failure_result.rb
 
 ---
 
-### `Micro::Case::Flow`
+### `Micro::Case::Flow` (v2.6.0)
 
 | Gems / Abstraction      | [Success results](https://github.com/serradura/u-case/blob/master/benchmarks/flow/with_success_result.rb#L40) | [Failure results](https://github.com/serradura/u-case/blob/master/benchmarks/flow/with_failure_result.rb#L40) |
 | ------------------      | ----------------: | ----------------: |
 | Micro::Case::Flow       | _**The Fastest**_ | _**The Fastest**_ |
 | Micro::Case::Safe::Flow |        0x slower  |        0x slower  |
-| Interactor::Organizer   |     1.47x slower  |     5.51x slower  |
+| Interactor::Organizer   |     1.27x slower  |     5.48x slower  |
 
 \* The `Dry::Monads`, `Dry::Transaction`, `Trailblazer::Operation` are out of this analysis because all of them doesn't have this kind of feature.
 
 <details>
   <summary><strong>Success results</strong> - Show the full benchmark/ips results.</summary>
 
-  ```ruby
-  # Warming up --------------------------------------
-  #   Interactor::Organizer  4.880k i/100ms
-  #       Micro::Case::Flow  7.035k i/100ms
-  # Micro::Case::Safe::Flow  7.059k i/100ms
-
-  # Calculating -------------------------------------
-  #   Interactor::Organizer  50.208k (± 1.3%) i/s -    253.760k in   5.055099s
-  #       Micro::Case::Flow  73.791k (± 0.9%) i/s -    372.855k in   5.053311s
-  # Micro::Case::Safe::Flow  73.314k (± 1.1%) i/s -    367.068k in   5.007473s
-
-  # Comparison:
-  #       Micro::Case::Flow: 73790.7 i/s
-  # Micro::Case::Safe::Flow: 73313.7 i/s - same-ish: difference falls within error
-  #   Interactor::Organizer: 50207.7 i/s - 1.47x  slower
-  ```
+```ruby
+# Warming up --------------------------------------
+# Interactor::Organizer    4.765k i/100ms
+#     Micro::Case::Flow    5.372k i/100ms
+# Micro::Case::Safe::Flow  5.855k i/100ms
+# Calculating -------------------------------------
+# Interactor::Organizer    48.598k (± 5.2%) i/s -    243.015k in   5.014307s
+#     Micro::Case::Flow    61.606k (± 4.4%) i/s -    311.576k in   5.068602s
+# Micro::Case::Safe::Flow  60.688k (± 4.8%) i/s -    304.460k in   5.028877s
+
+# Comparison:
+#     Micro::Case::Flow:    61606.3 i/s
+# Micro::Case::Safe::Flow:  60688.3 i/s - same-ish: difference falls within error
+# Interactor::Organizer:    48598.2 i/s - 1.27x  slower\
+```
 </details>
 
 <details>
   <summary><strong>Failure results</strong> - Show the full benchmark/ips results.</summary>
 
-  ```ruby
-  # Warming up --------------------------------------
-  #   Interactor::Organizer   2.372k i/100ms
-  #       Micro::Case::Flow   12.802k i/100ms
-  # Micro::Case::Safe::Flow   12.673k i/100ms
-
-  # Calculating -------------------------------------
-  #   Interactor::Organizer   24.522k (± 2.0%) i/s -    123.344k in   5.032159s
-  #       Micro::Case::Flow   135.122k (± 1.7%) i/s -    678.506k in   5.022903s
-  # Micro::Case::Safe::Flow   133.980k (± 1.4%) i/s -    671.669k in   5.014181s
-
-  # Comparison:
-  #       Micro::Case::Flow:   135122.0 i/s
-  # Micro::Case::Safe::Flow:   133979.8 i/s - same-ish: difference falls within error
-  #   Interactor::Organizer:   24521.8 i/s - 5.51x  slower
-  ```
+```ruby
+# Warming up --------------------------------------
+# Interactor::Organizer   2.209k i/100ms
+#     Micro::Case::Flow   11.508k i/100ms
+# Micro::Case::Safe::Flow 11.605k i/100ms
+
+# Calculating -------------------------------------
+# Interactor::Organizer   22.592k (± 2.8%) i/s -    114.868k in   5.088685s
+#     Micro::Case::Flow   123.629k (± 2.9%) i/s -    621.432k in   5.030844s
+# Micro::Case::Safe::Flow 123.862k (± 3.0%) i/s -    626.670k in   5.064097s
+
+# Comparison:
+# Micro::Case::Safe::Flow: 123862.4 i/s
+#     Micro::Case::Flow:   123629.3 i/s - same-ish: difference falls within error
+# Interactor::Organizer:   22592.2 i/s - 5.48x  slower
+```
 </details>
 
 https://github.com/serradura/u-case/tree/master/benchmarks/flow