u-case 3.0.0.rc3 → 3.0.0.rc8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de27799d2fbf95d3399af2caa3053038fd9817c6f800747213eb8ee3722604b5
-  data.tar.gz: dc2f1b40964d646978d28ffb44c049a58ddca614440e296ff5fa7f35e347def1
+  metadata.gz: c2265a60386ce542b8ee6006a58d4fb801dcfb396d7dfcf84d342910095fcbf8
+  data.tar.gz: 1502d1a284c616860ae99e0c03fe02a81be3e9d0adc0cc75a414825b4132f792
 SHA512:
-  metadata.gz: 90af10df71576124850933260f703e7a2f9c6a67df5e5add06d7d657de34a291879e279eec59795bfd548c0e0f898dc3795657de1de524e3aac16dddf25b24cf
-  data.tar.gz: e5b374929b87a7a5a0f604afa5742195910809b9198c11d01110bb8cf9f2540de73aa80fedb4432357ee86b96fe5e81b91a003fd410da989ac5b22b9ad40aa30
+  metadata.gz: ab5c45e1e1e12f157a4e5f5fa596fdb778e6bd6267d5111e438094ff37e017a0452e4a1d85a39df0e63ec28876260bad8f7c4a56ca18796a95805187efe2d002
+  data.tar.gz: 6cefcdbbb39a4400bbd4c52b7ccf77f2c142958680049a3e53f4af37d1ef696fdc3a9019cde0f8f18463dd814e79e9753ef5a270eb446dbb2bee81e7c734ffab

data/.travis.sh

@@ -3,17 +3,21 @@
 ruby_v=$(ruby -v)
 
 ACTIVEMODEL_VERSION='3.2' bundle update
-ACTIVEMODEL_VERSION='3.2' bundle exec rake test
+ACTIVEMODEL_VERSION='3.2' ENABLE_TRANSITIONS='true' bundle exec rake test
+ACTIVEMODEL_VERSION='3.2' ENABLE_TRANSITIONS='false' bundle exec rake test
 
 if [[ ! $ruby_v =~ '2.2.0' ]]; then
   ACTIVEMODEL_VERSION='5.2' bundle update
-  ACTIVEMODEL_VERSION='5.2' bundle exec rake test
+  ACTIVEMODEL_VERSION='5.2' ENABLE_TRANSITIONS='true' bundle exec rake test
+  ACTIVEMODEL_VERSION='5.2' ENABLE_TRANSITIONS='false' bundle exec rake test
 fi
 
 if [[ $ruby_v =~ '2.5.' ]] || [[ $ruby_v =~ '2.6.' ]] || [[ $ruby_v =~ '2.7.' ]]; then
   ACTIVEMODEL_VERSION='6.0' bundle update
-  ACTIVEMODEL_VERSION='6.0' bundle exec rake test
+  ACTIVEMODEL_VERSION='6.0' ENABLE_TRANSITIONS='true' bundle exec rake test
+  ACTIVEMODEL_VERSION='6.0' ENABLE_TRANSITIONS='false' bundle exec rake test
 fi
 
 bundle update
-bundle exec rake test
+ENABLE_TRANSITIONS='true' bundle exec rake test
+ENABLE_TRANSITIONS='false' bundle exec rake test

data/Gemfile

@@ -22,8 +22,7 @@ end
 
 pry_byebug_version =
   case RUBY_VERSION
-  when /\A2.2/ then '3.6'
-  when /\A2.3/ then '3.7'
+  when /\A2.[23]/ then '3.6'
   else '3.9'
   end
 
@@ -37,6 +36,8 @@ pry_version =
 group :development, :test do
   gem 'awesome_print', '~> 1.8'
 
+  gem 'byebug', '~> 10.0', '>= 10.0.2' if RUBY_VERSION =~ /\A2.[23]/
+
   gem 'pry', "~> #{pry_version}"
   gem 'pry-byebug', "~> #{pry_byebug_version}"
 end

data/README.md

@@ -1,33 +1,34 @@
 ![Ruby](https://img.shields.io/badge/ruby-2.2+-ruby.svg?colorA=99004d&colorB=cc0066)
 [![Gem](https://img.shields.io/gem/v/u-case.svg?style=flat-square)](https://rubygems.org/gems/u-case)
-[![Build Status](https://travis-ci.com/serradura/u-case.svg?branch=master)](https://travis-ci.com/serradura/u-case)
+[![Build Status](https://travis-ci.com/serradura/u-case.svg?branch=main)](https://travis-ci.com/serradura/u-case)
 [![Maintainability](https://api.codeclimate.com/v1/badges/5c3c8ad1b0b943f88efd/maintainability)](https://codeclimate.com/github/serradura/u-case/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/5c3c8ad1b0b943f88efd/test_coverage)](https://codeclimate.com/github/serradura/u-case/test_coverage)
 
-μ-case (Micro::Case) <!-- omit in toc -->
-====================
+<img src="./assets/ucase_logo_v1.png" alt="u-case - Create simple and powerful use cases as Ruby objects.">
 
-Create simple and powerful use cases as objects.
+Create simple and powerful use cases as Ruby objects.
 
 The main project goals are:
 1. Easy to use and easy to learn (input **>>** process **>>** output).
-2. Promote referential transparency (transforming instead of modifying) and data integrity.
-3. No callbacks (e.g: before, after, around).
-4. Solve complex business logic, by allowing the composition of use cases.
+2. Promote immutability (transforming data instead of modifying it) and data integrity.
+3. No callbacks (ex: before, after, around) to avoid code indirections that could compromise the state and understanding of application flows.
+4. Solve complex business logic, by allowing the composition of use cases (flow creation).
 5. Be fast and optimized (Check out the [benchmarks](#benchmarks) section).
 
-> 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.
+> **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
+3.0.0.rc8 | https://github.com/serradura/u-case/blob/main/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
 
+> **Note:** Você entende português? 🇧🇷🇵🇹 Verifique o [README traduzido em pt-BR](https://github.com/serradura/u-case/blob/main/README.pt-BR.md).
+
 ## Table of Contents <!-- omit in toc -->
-- [Required Ruby version](#required-ruby-version)
+- [Compatibility](#compatibility)
 - [Dependencies](#dependencies)
 - [Installation](#installation)
 - [Usage](#usage)
@@ -35,48 +36,54 @@ Version   | Documentation
   - [`Micro::Case::Result` - What is a use case result?](#microcaseresult---what-is-a-use-case-result)
     - [What are the default result types?](#what-are-the-default-result-types)
     - [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)
+    - [Is it possible to define a custom type without a result data?](#is-it-possible-to-define-a-custom-type-without-a-result-data)
     - [How to use the result hooks?](#how-to-use-the-result-hooks)
-    - [Why the failure hook (without a type) exposes result itself?](#why-the-failure-hook-without-a-type-exposes-result-itself)
+    - [Why the hook usage without a defined type exposes the result itself?](#why-the-hook-usage-without-a-defined-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)
       - [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 to compose a flow with other flows?](#is-it-possible-to-compose-a-flow-with-other-flows)
     - [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)
+    - [Is it possible to declare a flow that includes the use case itself as a step?](#is-it-possible-to-declare-a-flow-that-includes-the-use-case-itself-as-a-step)
   - [`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::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)
+  - [`u-case/with_activemodel_validation` - How to validate the use case attributes?](#u-casewith_activemodel_validation---how-to-validate-the-use-case-attributes)
+    - [If I enabled the auto validation, is it possible to disable it only in specific use cases?](#if-i-enabled-the-auto-validation-is-it-possible-to-disable-it-only-in-specific-use-cases)
     - [`Kind::Validator`](#kindvalidator)
 - [`Micro::Case.config`](#microcaseconfig)
 - [Benchmarks](#benchmarks)
-  - [`Micro::Case` (v2.6.0)](#microcase-v260)
-    - [Best overall](#best-overall)
+  - [`Micro::Case` (v3.0.0)](#microcase-v300)
     - [Success results](#success-results)
     - [Failure results](#failure-results)
-  - [`Micro::Case::Flow` (v2.6.0)](#microcaseflow-v260)
+  - [`Micro::Cases::Flow` (v3.0.0)](#microcasesflow-v300)
   - [Comparisons](#comparisons)
 - [Examples](#examples)
-  - [1️⃣ Rails App (API)](#1️⃣-rails-app-api)
-  - [2️⃣ CLI calculator](#2️⃣-cli-calculator)
-  - [3️⃣ Users creation](#3️⃣-users-creation)
-  - [4️⃣ Rescuing exception inside of the use cases](#4️⃣-rescuing-exception-inside-of-the-use-cases)
+  - [1️⃣ Users creation](#1️⃣-users-creation)
+  - [2️⃣ Rails App (API)](#2️⃣-rails-app-api)
+  - [3️⃣ CLI calculator](#3️⃣-cli-calculator)
+  - [4️⃣ Rescuing exceptions inside of the use cases](#4️⃣-rescuing-exceptions-inside-of-the-use-cases)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
 - [Code of Conduct](#code-of-conduct)
 
-## Required Ruby version
+## Compatibility
+
+| u-case         | branch  | ruby     |  activemodel  |
+| -------------- | ------- | -------- | ------------- |
+| 3.0.0.rc8      | main    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 2.6.0          | v2.x    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 1.1.0          | v1.x    | >= 2.2.0 | >= 3.2, < 6.1 |
 
-> \>= 2.2.0
+> Note: The activemodel is an optional dependency, this module [can be enabled](#u-casewith_activemodel_validation---how-to-validate-use-case-attributes) to validate the use cases' attributes.
 
 ## Dependencies
 
@@ -84,7 +91,7 @@ Version   | Documentation
 
     A simple type system (at runtime) for Ruby.
 
-    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.
+    It is used to validate some internal u-case's methods input. This gem also exposes an  [`ActiveModel validator`](https://github.com/serradura/kind#kindvalidator-activemodelvalidations) when requiring the [`u-case/with_activemodel_validation`](#u-casewith_activemodel_validation---how-to-validate-use-case-attributes) module, or when the [`Micro::Case.config`](#microcaseconfig) was used to enable it. Lastly, two type checkers are available through it: [`Kind::Of::Micro::Case`, `Kind::Of::Micro::Case::Result`](https://github.com/serradura/kind#registering-new-custom-type-checker).
 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.
@@ -95,7 +102,7 @@ Version   | Documentation
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'u-case'
+gem 'u-case', '~> 3.0.0.rc8'
 ```
 
 And then execute:
@@ -104,7 +111,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install u-case
+    $ gem install u-case --pre
 
 ## Usage
 
@@ -118,7 +125,7 @@ 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(result: *)` or `Failure(result: *)` methods
+    # 3. Wrap the use case output using the `Success(result: *)` or `Failure(result: *)` methods
     if a.is_a?(Numeric) && b.is_a?(Numeric)
       Success result: { number: a * b }
     else
@@ -127,9 +134,9 @@ class Multiply < Micro::Case
   end
 end
 
-#==========================#
-# Calling a use case class #
-#==========================#
+#========================#
+# Performing an use case #
+#========================#
 
 # Success result
 
@@ -145,18 +152,9 @@ bad_result = Multiply.call(a: 2, b: '2')
 bad_result.failure? # true
 bad_result.data     # { message: "`a` and `b` attributes must be numeric" }
 
-#-----------------------------#
-# Calling a use case instance #
-#-----------------------------#
-
-result = Multiply.new(a: 2, b: 3).call
-
-result.value # { number: 6 }
-
 # Note:
 # ----
-# The result of a Micro::Case.call
-# is an instance of Micro::Case::Result
+# The result of a Micro::Case.call is an instance of Micro::Case::Result
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
@@ -170,6 +168,9 @@ A `Micro::Case::Result` stores the use cases output data. These are their main m
 - `#type` a Symbol which gives meaning for the result, this is useful to declare different types of failures or success.
 - `#data` the result data itself.
 - `#[]` and `#values_at` are shortcuts to access the `#data` values.
+- `#key?` returns `true` if the key is present in `#data`.
+- `#value?` returns `true` if the given value is present in `#data`.
+- `#slice` returns a new hash that includes only the given keys. If the given keys don't exist, an empty hash is returned.
 - `#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).
@@ -180,9 +181,9 @@ A `Micro::Case::Result` stores the use cases output data. These are their main m
 
 #### What are the default result types?
 
-Every result has a type and these are the defaults:
+Every result has a type, and these are their default values:
 - `:ok` when success
-- `:error`/`:exception` when failures
+- `:error` or `:exception` when failures
 
 ```ruby
 class Divide < Micro::Case
@@ -276,9 +277,9 @@ bad_result.failure? # true
 
 [⬆️ Back to Top](#table-of-contents-)
 
-#### Is it possible to define a custom result type without a block?
+#### Is it possible to define a custom type without a result data?
 
-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.
+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
@@ -310,7 +311,7 @@ result.use_case.attributes # {"a"=>2, "b"=>"2"}
 
 #### How to use the result hooks?
 
-As mentioned earlier, the `Micro::Case::Result` has two methods to improve the flow control. They are: `#on_success`, `on_failure`.
+As [mentioned earlier](#microcaseresult---what-is-a-use-case-result), the `Micro::Case::Result` has two methods to improve the application flow control. They are: `#on_success`, `on_failure`.
 
 The examples below show how to use them:
 
@@ -336,7 +337,7 @@ Double
   .on_failure(:invalid) { |result| raise TypeError, result[:msg] }
   .on_failure(:lte_zero) { |result| raise ArgumentError, result[:msg] }
 
-# The output because it is a success:
+# The output will be:
 #   6
 
 #=============================#
@@ -352,18 +353,17 @@ Double
 
 # The outputs will be:
 #
-# 1. Prints the message: Double was the use case responsible for the failure
-# 2. Raises the exception: ArgumentError (the number must be greater than 0)
+# 1. It will print the message: Double was the use case responsible for the failure
+# 2. It will raise the exception: ArgumentError (the number must be greater than 0)
 
 # Note:
 # ----
-# The use case responsible for the failure will be accessible as the second hook argument
+# The use case responsible for the result will always be accessible as the second hook argument
 ```
 
-#### Why the failure hook (without a type) exposes result itself?
+#### Why the hook usage without a defined 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`).
+Answer: To allow you to define how to handle the program flow using some conditional statement like an `if` or `case when`.
 
 ```ruby
 class Double < Micro::Case
@@ -377,12 +377,8 @@ class Double < Micro::Case
   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, "number must be a numeric value"
@@ -391,22 +387,23 @@ Double
     end
   end
 
-# The output will be the exception:
+# The output will be an exception:
 #
 # ArgumentError (number `-1` must be greater than 0)
+```
 
-#=========================================================#
-# Using decomposition to access the result data 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 it, check out the Ruby doc:
-# https://ruby-doc.org/core-2.2.0/doc/syntax/assignment_rdoc.html#label-Array+Decomposition
-#
-# The object exposed in the hook failure is a Micro::Case::Result, and it 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 assignments and in method/block arguments.
+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 without a type is a Micro::Case::Result and it can be decomposed. e.g:
 
 Double
-  .call(-2)
+  .call(number: -2)
   .on_failure do |(data, type), use_case|
     case type
     when :invalid then raise TypeError, 'number must be a numeric value'
@@ -420,6 +417,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?
@@ -445,10 +444,11 @@ result[:number] * 4 # 24
 
 accum = 0
 
-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] }
+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
 
@@ -457,8 +457,7 @@ 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:
+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
@@ -504,7 +503,7 @@ result2.success? # true
 
 ##### 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:
+It will yields self (a `Micro::Case::Result` instance) to the block, and will return the output of the block instead of itself. e.g:
 
 ```ruby
 class Add < Micro::Case
@@ -556,8 +555,7 @@ Todo::FindAllForUser
 
 ### `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.
+We call as **flow** a composition of use cases. The main idea of this feature is to use/reuse use cases as steps of a new use case. e.g.
 
 ```ruby
 module Steps
@@ -612,24 +610,23 @@ result = Add2ToAllNumbers.call(numbers: %w[1 1 2 2 3 4])
 result.success? # true
 result.data    # {:numbers => [3, 3, 4, 4, 5, 6]}
 
-#---------------------------------------------------#
-# An alternative way to create a flow using classes #
-#---------------------------------------------------#
+#-------------------------------#
+# Creating a flow using classes #
+#-------------------------------#
 
 class DoubleAllNumbers < Micro::Case
   flow Steps::ConvertTextToNumbers,
        Steps::Double
 end
 
-DoubleAllNumbers
-  .call(numbers: %w[1 1 b 2 3 4])
-  .on_failure { |message| p message } # "numbers must contain only numeric types"
+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
+When happening a failure, the use case responsible will be accessible in the result.
 
+```ruby
 result = DoubleAllNumbers.call(numbers: %w[1 1 b 2 3 4])
 
 result.failure?                                    # true
@@ -642,7 +639,7 @@ end
 
 [⬆️ Back to Top](#table-of-contents-)
 
-#### Is it possible to compose a use case flow with other ones?
+#### Is it possible to compose a flow with other flows?
 
 Answer: Yes, it is possible.
 
@@ -705,20 +702,20 @@ DoubleAllNumbersAndSquareAndAdd2 =
 
 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/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/cases/flow/blend_test.rb#L5-L35).
+> **Note:** You can blend any [approach](#microcasesflow---how-to-compose-use-cases) 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 possible! 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 a flow execution.
 
 ```ruby
 module Users
@@ -762,7 +759,7 @@ Users::Authenticate
   .on_failure(:user_not_found) { render status: 404 }
 ```
 
-First, lets see the attributes used by each use case:
+First, let's see the attributes used by each use case:
 
 ```ruby
 class Users::FindByEmail < Micro::Case
@@ -775,14 +772,13 @@ 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::FindByEmail` success result!
+Answer: It receives the user from the `Users::FindByEmail` success result!
 
-And this, is the power of use cases composition because the output
-of one step will compose the input of the next use case in the flow!
+And this is the power of use cases composition because the output 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::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.
+> **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 having access to the data in a flow.
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -831,7 +827,7 @@ 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][:result]`) 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, 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).
 
@@ -848,11 +844,11 @@ And look up the `accessible_attributes` property, it shows whats attributes are
     [success:, failure:] => {   # (Output)
       type:  <Symbol>,          # Result type. Defaults:
                                 # Success = :ok, Failure = :error/:exception
-      result: <Hash>            # The data returned by the use case
+      result: <Hash>            # The data returned by the use case result
     },
     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
-                                    # with each result value of the flow's use cases.
+                                    # it starts with Hash used to invoke it and that will be incremented
+                                    # with the result values of each use case in the flow.
   }
 ]
 ```
@@ -861,9 +857,9 @@ And look up the `accessible_attributes` property, it shows whats attributes are
 
 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?
+#### Is it possible to declare a flow that includes the use case itself as a step?
 
-Answer: Yes, it is! You can use the `self.call!` macro. e.g:
+Answer: Yes, it is! You can use `self` or the `self.call!` macro. e.g:
 
 ```ruby
 class ConvertTextToNumber < Micro::Case
@@ -898,16 +894,15 @@ result = Double.call(text: '4')
 
 result.success? # true
 result[:number] # "8"
-
-# NOTE: This feature can be used with the Micro::Case::Safe.
-#       Checkout this test: https://github.com/serradura/u-case/blob/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/case/safe/with_inner_flow_test.rb
 ```
 
+> **Note:** This feature can be used with the Micro::Case::Safe. Checkout this test to see an example: https://github.com/serradura/u-case/blob/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/case/safe/with_inner_flow_test.rb
+
 [⬆️ Back to Top](#table-of-contents-)
 
 ### `Micro::Case::Strict` - What is a strict use case?
 
-Answer: Is a use case which will require all the keywords (attributes) on its initialization.
+Answer: it is a kind of use case that will require all the keywords (attributes) on its initialization.
 
 ```ruby
 class Double < Micro::Case::Strict
@@ -920,7 +915,7 @@ end
 
 Double.call({})
 
-# The output will be the following exception:
+# The output will be:
 # ArgumentError (missing keyword: :numbers)
 ```
 
@@ -928,11 +923,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 one!
-
-**Use cases:**
-
-Like `Micro::Case::Strict` the `Micro::Case::Safe` is another kind of use case. It has the ability to auto intercept any exception as a failure result. e.g:
+Yes, there is one! Like `Micro::Case::Strict` the `Micro::Case::Safe` is another kind of use case. It has the ability to auto intercept any exception as a failure result. e.g:
 
 ```ruby
 require 'logger'
@@ -956,28 +947,24 @@ 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:
-# ----
-# If you need to handle a specific error,
-# I recommend the usage of a case statement. e,g:
+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
+```ruby
+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
 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/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/case/safe_test.rb#L90-L118
 ```
 
+> **Note:** It is possible to rescue an exception even when is a safe use case. Examples: https://github.com/serradura/u-case/blob/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/case/safe_test.rb#L90-L118
+
 [⬆️ Back to Top](#table-of-contents-)
 
 #### `Micro::Cases::Safe::Flow`
@@ -993,9 +980,11 @@ module Users
     SendToCRM
   ])
 end
+```
 
-# or within classes
+Defining within classes:
 
+```ruby
 module Users
   class Create < Micro::Case::Safe
     flow ProcessParams,
@@ -1014,9 +1003,9 @@ 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` flow or use case.
 
-How does it work?
+**How does it work?**
 
 ```ruby
 class Divide < Micro::Case::Safe
@@ -1052,21 +1041,19 @@ Divide.
 # Oh no, something went wrong!
 ```
 
-As you can see, this hook has the same behavior of `result.on_failure(:exception)`, but, the ideia here is to have a better communication in the code, making an explicit reference when some failure happened because of an exception.
+As you can see, this hook has the same behavior of `result.on_failure(:exception)`, but, the idea here is to have a better communication in the code, making an explicit reference when some failure happened because of an exception.
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### `u-case/with_activemodel_validation` - How to validate use case attributes?
+### `u-case/with_activemodel_validation` - How to validate the use case attributes?
 
 **Requirement:**
 
 To do this your application must have the [activemodel >= 3.2, < 6.1.0](https://rubygems.org/gems/activemodel) as a dependency.
 
+By default, if your application has ActiveModel as a dependency, any kind of use case can make use of it to validate its attributes.
+
 ```ruby
-#
-# By default, if your application has the activemodel as a dependency,
-# any kind of use case can use it to validate their attributes.
-#
 class Multiply < Micro::Case
   attributes :a, :b
 
@@ -1080,9 +1067,9 @@ class Multiply < Micro::Case
 end
 ```
 
-But if do you want an automatic way to fail your use cases on validation errors, you can:
+But if do you want an automatic way to fail your use cases on validation errors, you could do:
 
-1. **require 'u-case/with_activemodel_validation'** mode
+1. **require 'u-case/with_activemodel_validation'** in the Gemfile
 
   ```ruby
   gem 'u-case', require: 'u-case/with_activemodel_validation'
@@ -1104,16 +1091,13 @@ class Multiply < Micro::Case
     Success result: { number: a * b }
   end
 end
-
-# Note:
-# ----
-# After requiring the validation mode, the
-# Micro::Case::Strict and Micro::Case::Safe classes will inherit this new behavior.
 ```
 
-#### If I enabled the auto validation, is it possible to disable it only in specific use case classes?
+> **Note:** After requiring the validation mode, the `Micro::Case::Strict` and `Micro::Case::Safe` classes will inherit this new behavior.
+
+#### If I enabled the auto validation, is it possible to disable it only in specific use cases?
 
-Answer: Yes, it is possible. To do this, you only need to use the `disable_auto_validation` macro. e.g:
+Answer: Yes, it is possible. To do this, you will need to use the `disable_auto_validation` macro. e.g:
 
 ```ruby
 require 'u-case/with_activemodel_validation'
@@ -1132,7 +1116,7 @@ end
 
 Multiply.call(a: 2, b: 'a')
 
-# The output will be the following exception:
+# The output will be:
 # TypeError (String can't be coerced into Integer)
 ```
 
@@ -1140,9 +1124,9 @@ Multiply.call(a: 2, b: 'a')
 
 #### `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).
+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 also require the [`Kind::Validator`](https://github.com/serradura/kind#kindvalidator-activemodelvalidations).
 
-The example below shows how to validate the attributes data types.
+The example below shows how to validate the attributes types.
 
 ```ruby
 class Todo::List::AddItem < Micro::Case
@@ -1163,160 +1147,175 @@ class Todo::List::AddItem < Micro::Case
 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.
+The idea of this resource 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:
+You can see below, which are 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
+  config.enable_activemodel_validation = false
 
-  # Use to enable/disable the `Micro::Case::Results#transitions` tracking.
+  # Use to enable/disable the `Micro::Case::Results#transitions`.
   config.enable_transitions = true
 end
 ```
 
-## Benchmarks
-
-### `Micro::Case` (v2.6.0)
-
-#### Best overall
-
-The table below contains the average between the [Success results](#success-results) and [Failure results](#failure-results) benchmarks.
+[⬆️ Back to Top](#table-of-contents-)
 
-| Gem / Abstraction      | Iterations per second |       Comparison  |
-| ---------------------- | --------------------: | ----------------: |
-| **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  |
+## Benchmarks
 
----
+### `Micro::Case` (v3.0.0)
 
 #### Success results
 
 | Gem / Abstraction      | Iterations per second |       Comparison  |
 | -----------------      | --------------------: | ----------------: |
-| 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  |
+| Dry::Monads            |              141730.1 | _**The Fastest**_ |
+| **Micro::Case**        |              103541.3 |     1.37x slower  |
+| Interactor             |               29100.8 |     4.87x slower  |
+| Trailblazer::Operation |               15031.4 |     9.43x slower  |
+| Dry::Transaction       |                5674.0 |    24.98x slower  |
 
 <details>
   <summary>Show the full <a href="https://github.com/evanphx/benchmark-ips">benchmark/ips</a> results.</summary>
 
 ```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
+#           Interactor     2.915k i/100ms
+# Trailblazer::Operation   1.543k i/100ms
+#          Dry::Monads    14.288k i/100ms
+#     Dry::Transaction   571.000  i/100ms
+#          Micro::Case    10.418k i/100ms
+#  Micro::Case::Strict     8.296k i/100ms
+#    Micro::Case::Safe    10.254k 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
+#           Interactor     29.101k (± 2.1%) i/s -    145.750k in   5.010660s
+# Trailblazer::Operation   15.031k (± 2.0%) i/s -     75.607k in   5.032071s
+#          Dry::Monads    141.730k (± 3.1%) i/s -    714.400k in   5.045546s
+#     Dry::Transaction      5.674k (± 1.9%) i/s -     28.550k in   5.033564s
+#          Micro::Case    103.541k (± 1.6%) i/s -    520.900k in   5.032077s
+#  Micro::Case::Strict     83.045k (± 2.4%) i/s -    423.096k in   5.098031s
+#    Micro::Case::Safe    101.662k (± 1.5%) i/s -    512.700k in   5.044386s
 
 # 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
+#          Dry::Monads:   141730.1 i/s
+#          Micro::Case:   103541.3 i/s - 1.37x  (± 0.00) slower
+#    Micro::Case::Safe:   101662.2 i/s - 1.39x  (± 0.00) slower
+#  Micro::Case::Strict:    83044.6 i/s - 1.71x  (± 0.00) slower
+#           Interactor:    29100.8 i/s - 4.87x  (± 0.00) slower
+# Trailblazer::Operation:  15031.4 i/s - 9.43x  (± 0.00) slower
+#     Dry::Transaction:     5674.0 i/s - 24.98x  (± 0.00) slower
 ```
 </details>
 
-https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_success_result.rb
+https://github.com/serradura/u-case/blob/main/benchmarks/use_case/with_success_result.rb
 
 #### Failure results
 
 | Gem / Abstraction      | Iterations per second |       Comparison  |
 | -----------------      | --------------------: | ----------------: |
-| **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  |
+| **Micro::Case**        |               98820.8 | _**The Fastest**_ |
+| Dry::Monads            |               71329.7 |     1.39x slower  |
+| Trailblazer::Operation |               15034.9 |     6.57x slower  |
+| Interactor             |               13958.7 |     7.08x slower  |
+| Dry::Transaction       |                5067.5 |    19.50x slower  |
 
 <details>
   <summary>Show the full <a href="https://github.com/evanphx/benchmark-ips">benchmark/ips</a> results.</summary>
 
 ```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
+#           Interactor     1.324k i/100ms
+# Trailblazer::Operation   1.525k i/100ms
+#          Dry::Monads     7.126k i/100ms
+#     Dry::Transaction   499.000  i/100ms
+#          Micro::Case     9.919k i/100ms
+#  Micro::Case::Strict     7.837k i/100ms
+#    Micro::Case::Safe     9.762k 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
+#           Interactor     13.959k (± 2.5%) i/s -     70.172k in   5.030240s
+# Trailblazer::Operation   15.035k (± 2.2%) i/s -     76.250k in   5.074108s
+#          Dry::Monads     71.330k (± 2.4%) i/s -    363.426k in   5.097993s
+#     Dry::Transaction      5.068k (± 1.9%) i/s -     25.449k in   5.023922s
+#          Micro::Case     98.821k (± 2.9%) i/s -    495.950k in   5.023421s
+#  Micro::Case::Strict     79.936k (± 3.1%) i/s -    399.687k in   5.005435s
+#    Micro::Case::Safe     98.695k (± 1.9%) i/s -    497.862k in   5.046246s
 
 # 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
+#          Micro::Case:    98820.8 i/s
+#    Micro::Case::Safe:    98695.0 i/s - same-ish: difference falls within error
+#  Micro::Case::Strict:    79935.9 i/s - 1.24x  (± 0.00) slower
+#          Dry::Monads:    71329.7 i/s - 1.39x  (± 0.00) slower
+# Trailblazer::Operation:  15034.9 i/s - 6.57x  (± 0.00) slower
+#           Interactor:    13958.7 i/s - 7.08x  (± 0.00) slower
+#     Dry::Transaction:     5067.5 i/s - 19.50x  (± 0.00) slower
 ```
 </details>
 
-https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_failure_result.rb
+https://github.com/serradura/u-case/blob/main/benchmarks/use_case/with_failure_result.rb
 
 ---
 
-### `Micro::Case::Flow` (v2.6.0)
+### `Micro::Cases::Flow` (v3.0.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.27x slower  |     5.48x slower  |
+| Gems / Abstraction      | [Success results](https://github.com/serradura/u-case/blob/main/benchmarks/flow/with_success_result.rb#L40) | [Failure results](https://github.com/serradura/u-case/blob/main/benchmarks/flow/with_failure_result.rb#L40) |
+| ------------------------------------------- | ----------------: | ----------------: |
+| Micro::Case internal flow (private methods) | _**The Fastest**_ | _**The Fastest**_ |
+| Micro::Case internal flow (through lambdas) |      1.03x slower |      1.04x slower |
+| Micro::Case `then` method                   |      1.49x slower |         0x slower |
+| Micro::Cases.flow                           |      1.53x slower |      1.04x slower |
+| Micro::Cases.safe_flow                      |      1.54x slower |      1.04x slower |
+| Interactor::Organizer                       |      2.05x slower |      6.27x slower |
 
-\* The `Dry::Monads`, `Dry::Transaction`, `Trailblazer::Operation` are out of this analysis because all of them doesn't have this kind of feature.
+\* The `Dry::Monads`, `Dry::Transaction`, `Trailblazer::Operation` gems 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.765k i/100ms
-#     Micro::Case::Flow    5.372k i/100ms
-# Micro::Case::Safe::Flow  5.855k i/100ms
+# Interactor::Organizer
+#                          4.837k i/100ms
+# Micro::Cases.flow([])
+#                          6.755k i/100ms
+# Micro::Cases::safe_flow([])
+#                          6.809k i/100ms
+# Micro::Case flow using `then` method
+#                          6.968k i/100ms
+# Micro::Case flow using private methods
+#                         10.362k i/100ms
+# Micro::Case flow using private methods through lambdas
+#                         10.258k 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
+# Interactor::Organizer
+#                          50.731k (± 1.6%) i/s -    256.361k in   5.054694s
+# Micro::Cases.flow([])
+#                          67.757k (± 1.6%) i/s -    344.505k in   5.085681s
+# Micro::Cases::safe_flow([])
+#                          67.613k (± 1.6%) i/s -    340.450k in   5.036562s
+# Micro::Case flow using `then` method
+#                          69.483k (± 1.5%) i/s -    348.400k in   5.015351s
+# Micro::Case flow using private methods
+#                         103.788k (± 1.0%) i/s -    528.462k in   5.092240s
+# Micro::Case flow using private methods through lambdas
+#                         101.081k (± 1.2%) i/s -    512.900k in   5.074904s
 
 # 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\
+# Micro::Case flow using private methods:                 103787.5 i/s
+# Micro::Case flow using private methods through lambdas: 101080.6 i/s - 1.03x  (± 0.00) slower
+# Micro::Case flow using `then` method:                    69483.3 i/s - 1.49x  (± 0.00) slower
+# Micro::Cases.flow([]):                                   67757.2 i/s - 1.53x  (± 0.00) slower
+# Micro::Cases::safe_flow([]):                             67613.3 i/s - 1.54x  (± 0.00) slower
+# Interactor::Organizer:                                   50730.8 i/s - 2.05x  (± 0.00) slower
 ```
 </details>
 
@@ -1325,56 +1324,76 @@ https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_failure
 
 ```ruby
 # Warming up --------------------------------------
-# Interactor::Organizer   2.209k i/100ms
-#     Micro::Case::Flow   11.508k i/100ms
-# Micro::Case::Safe::Flow 11.605k i/100ms
-
+# Interactor::Organizer
+#                          2.299k i/100ms
+# Micro::Cases.flow([])
+#                         14.187k i/100ms
+# Micro::Cases::safe_flow([])
+#                         13.609k i/100ms
+# Micro::Case flow using `then` method
+#                         14.578k i/100ms
+# Micro::Case flow using private methods
+#                         14.101k i/100ms
+# Micro::Case flow using private methods through lambdas
+#                         13.670k 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
+# Interactor::Organizer
+#                          23.306k (± 2.1%) i/s -    117.249k in   5.033171s
+# Micro::Cases.flow([])
+#                         140.111k (± 1.6%) i/s -    709.350k in   5.064041s
+# Micro::Cases::safe_flow([])
+#                         139.927k (± 1.7%) i/s -    707.668k in   5.058971s
+# Micro::Case flow using `then` method
+#                         146.073k (± 2.0%) i/s -    743.478k in   5.091741s
+# Micro::Case flow using private methods
+#                         142.092k (± 1.5%) i/s -    719.151k in   5.062298s
+# Micro::Case flow using private methods through lambdas
+#                         140.791k (± 1.2%) i/s -    710.840k in   5.049584s
 
 # 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
+# Micro::Case flow using `then` method:                     146073.0 i/s
+# Micro::Case flow using private methods:                   142091.7 i/s - same-ish: difference falls within error
+# Micro::Case flow using private methods through lambdas:   140791.1 i/s - 1.04x  (± 0.00) slower
+# Micro::Cases.flow([]):                                    140110.8 i/s - 1.04x  (± 0.00) slower
+# Micro::Cases::safe_flow([]):                              139926.6 i/s - 1.04x  (± 0.00) slower
+# Interactor::Organizer:                                     23305.9 i/s - 6.27x  (± 0.00) slower
 ```
 </details>
 
-https://github.com/serradura/u-case/tree/master/benchmarks/flow
+https://github.com/serradura/u-case/tree/main/benchmarks/flow
 
 ### Comparisons
 
 Check it out implementations of the same use case with different gems/abstractions.
 
-* [interactor](https://github.com/serradura/u-case/blob/master/comparisons/interactor.rb)
-* [u-case](https://github.com/serradura/u-case/blob/master/comparisons/u-case.rb)
+* [interactor](https://github.com/serradura/u-case/blob/main/comparisons/interactor.rb)
+* [u-case](https://github.com/serradura/u-case/blob/main/comparisons/u-case.rb)
 
 [⬆️ Back to Top](#table-of-contents-)
 
 ## Examples
 
-### 1️⃣ Rails App (API)
+### 1️⃣ Users creation
 
-> This project shows different kinds of architecture (one per commit), and in the last one, how to use the Micro::Case gem to handle the application business logic.
+> An example of a flow that defines steps to sanitize, validate, and persist its input data. It has all possible approaches to represent use cases using the `u-case` gem.
 >
-> Link: https://github.com/serradura/from-fat-controllers-to-use-cases
+> Link: https://github.com/serradura/u-case/blob/main/examples/users_creation
 
-### 2️⃣ CLI calculator
+### 2️⃣ Rails App (API)
 
-> Rake tasks to demonstrate how to handle user data, and how to use different failure types to control the program flow.
+> This project shows different kinds of architecture (one per commit), and in the last one, how to use the `Micro::Case` gem to handle the application business logic.
 >
-> Link: https://github.com/serradura/u-case/tree/master/examples/calculator
+> Link: https://github.com/serradura/from-fat-controllers-to-use-cases
 
-### 3️⃣ Users creation
+### 3️⃣ CLI calculator
 
-> An example of a use case flow that define steps to sanitize, validate, and persist its input data.
+> Rake tasks to demonstrate how to handle user data, and how to use different failure types to control the program flow.
 >
-> Link: https://github.com/serradura/u-case/blob/master/examples/users_creation.rb
+> Link: https://github.com/serradura/u-case/tree/main/examples/calculator
 
-### 4️⃣ Rescuing exception inside of the use cases
+### 4️⃣ Rescuing exceptions inside of the use cases
 
-> Link: https://github.com/serradura/u-case/blob/master/examples/rescuing_exceptions.rb
+> Link: https://github.com/serradura/u-case/blob/main/examples/rescuing_exceptions.rb
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -1394,4 +1413,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Micro::Case project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/serradura/u-case/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Micro::Case project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/serradura/u-case/blob/main/CODE_OF_CONDUCT.md).