u-case 2.3.1 → 3.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f5a28fb237f74e009225d20bcc65115e6d8159818a3cfdbfcb7e23c3726aef4
-  data.tar.gz: fa34ab50f7b2d0df65ba75f4b59734e0326d8431652823ad35e406d243801853
+  metadata.gz: dfc46204c461937d19681ae26dca7846a8d36720b735d759023b4c1369ef2a9a
+  data.tar.gz: 21bfd7bc9d2c2a13c901672eac77f15da4b7975aeeea925b3f94ff7e36dd1161
 SHA512:
-  metadata.gz: cd2a5fd871fd561ab98d96297e474f3ea251cdee866d5b14cc69e5e04bf654b98c3b2f75ef55d4c774f0d91ca6297a89746c923a29cd1fd1985e5761db6848b3
-  data.tar.gz: 12c467840bab805b562ae9de9fe6c80ccda0129672989d6b14f844e916fd270f0f5f9c2f213fed508c439e6d17142712f2013475bbc6f0f9a22066ab0aeb84ef
+  metadata.gz: 1e6992400490ef920d9ad855ebf698174ee2fcf9ab555db880ab2dea065360b921af7e38e4be5eb74e28c484862a25ca476beba9e2daebbc668bae07ef1b1853
+  data.tar.gz: d081ddf7bf5b3209f31c385060fd8dbbc9f72a8b1a05e553b1666df2f2de1550859017e9aa85aa329118bdef965f390a1637348c2a7549139e462e3cb091c250

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

@@ -18,7 +18,27 @@ end
 group :test do
   gem 'minitest', activemodel_version < '4.1' ? '~> 4.2' : '~> 5.0'
   gem 'simplecov', require: false
-  gem 'minitest-reporters', require: false
+end
+
+pry_byebug_version =
+  case RUBY_VERSION
+  when /\A2.2/ then '3.6'
+  when /\A2.3/ then '3.7'
+  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 'pry', "~> #{pry_version}"
+  gem 'pry-byebug', "~> #{pry_byebug_version}"
 end
 
 # Specify your gem's dependencies in u-case.gemspec

data/README.md

@@ -1,15 +1,16 @@
+![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)
 [![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)
-==========================
+μ-case (Micro::Case) <!-- omit in toc -->
+====================
 
 Create simple and powerful use cases as objects.
 
 The main project goals are:
-1. Be simple to use and easy to learn (input **>>** process / transform **>>** output).
+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.
@@ -17,45 +18,59 @@ 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.rc2 | 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 -->
-- [μ-case (Micro::Case)](#μ-case-microcase)
-  - [Required Ruby version](#required-ruby-version)
-  - [Dependencies](#dependencies)
-  - [Installation](#installation)
-  - [Usage](#usage)
-    - [Micro::Case - How to define a use case?](#microcase---how-to-define-a-use-case)
-    - [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)
-      - [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)
-      - [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)
-      - [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 their use cases?](#is-it-possible-a-flow-accumulates-its-input-and-merges-each-success-result-to-use-as-the-argument-of-their-use-cases)
-      - [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)
-    - [u-case/with_validation - How to validate use case attributes?](#u-casewith_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)
-  - [Benchmarks](#benchmarks)
-    - [Micro::Case](#microcase)
-      - [Best overall](#best-overall)
-      - [Success results](#success-results)
-      - [Failure results](#failure-results)
-    - [Micro::Case::Flow](#microcaseflow)
-    - [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)
-  - [Development](#development)
-  - [Contributing](#contributing)
-  - [License](#license)
-  - [Code of Conduct](#code-of-conduct)
+- [Required Ruby version](#required-ruby-version)
+- [Dependencies](#dependencies)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [`Micro::Case` - How to define a use case?](#microcase---how-to-define-a-use-case)
+  - [`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)
+    - [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)
+    - [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 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 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::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)
+- [Benchmarks](#benchmarks)
+  - [`Micro::Case` (v2.6.0)](#microcase-v260)
+    - [Best overall](#best-overall)
+    - [Success results](#success-results)
+    - [Failure results](#failure-results)
+  - [`Micro::Case::Flow` (v2.6.0)](#microcaseflow-v260)
+  - [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)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+- [Code of Conduct](#code-of-conduct)
 
 ## Required Ruby version
 
@@ -63,8 +78,15 @@ The main project goals are:
 
 ## Dependencies
 
-This project depends on [Micro::Attribute](https://github.com/serradura/u-attributes) gem.
-It is used to define the use case attributes.
+1. [`kind`](https://github.com/serradura/kind) gem.
+
+    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.
+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.
+    It is used to define the use case attributes.
 
 ## Installation
 
@@ -94,11 +116,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
@@ -112,14 +134,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"
+bad_result.data     # { message: "`a` and `b` attributes must be numeric" }
 
 #-----------------------------#
 # Calling a use case instance #
@@ -127,7 +149,7 @@ bad_result.value    # "`a` and `b` attributes must be numeric"
 
 result = Multiply.new(a: 2, b: 3).call
 
-result.value # 6
+result.value # { number: 6 }
 
 # Note:
 # ----
@@ -142,11 +164,14 @@ 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.
+- `#data` the result data itself.
 - `#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.
+- `#on_success` or `#on_failure` are hook methods that help you to 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.
+- `#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.
+- `#[]` and `#values_at` are shortcuts to access the `#data` values.
+
+> **Note:** for backward compatibility, you could use the `#value` method as an alias of `#data` method.
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -161,9 +186,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
@@ -176,7 +205,7 @@ 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`
 
@@ -185,40 +214,42 @@ result.use_case # raises `Micro::Case::Error::InvalidAccessToTheUseCaseObject: o
 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=#<Micro::Case::Result:0x0000 @use_case=#<Divide:0x0000 ...>, @type=:error, @value={"b"=>"2"}, @success=false>
 
 # 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
@@ -228,7 +259,7 @@ end
 result = Multiply.call(a: 3, b: 2)
 
 result.type     # :ok
-result.value    # 6
+result.data     # { number: 6 }
 result.success? # true
 
 # Failure result
@@ -236,7 +267,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
 ```
 
@@ -244,23 +275,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"}
 
@@ -283,10 +316,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
 
@@ -296,9 +329,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
@@ -309,10 +342,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:
 #
@@ -324,7 +357,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 failure hook (without a type) exposes result itself?
 
 Answer: To allow you to define how to handle the program flow using some
 conditional statement (like an `if`, `case/when`).
@@ -335,9 +368,9 @@ 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
 
@@ -349,32 +382,32 @@ Double
   .call(-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 #
-#=====================================================#
+#=========================================================#
+# 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 that, check out:
+# 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
 #
-# And the object exposed in the hook failure can be decomposed using this syntax. e.g:
+# The object exposed in the hook failure 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|
+  .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
@@ -395,38 +428,43 @@ 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
 
@@ -434,7 +472,7 @@ class Add3 < Micro::Case
   attribute :number
 
   def call!
-    Success { { number: number + 3 } }
+    Success result: { number: number + 3 }
   end
 end
 
@@ -443,8 +481,7 @@ result1 =
     .call(number: -1)
     .then(Add3)
 
-result1.type     # :error
-result1.value    # {'number' => -1}
+result1.data    # {'number' => -1}
 result1.failure? # true
 
 # ---
@@ -454,16 +491,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-)
+
+##### 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
+
+  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::Case::Flow` - How to compose use cases?
+### `Micro::Cases::Flow` - How to compose use cases?
 
-In this case, this will be a **flow** (`Micro::Case::Flow`).
+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
@@ -473,9 +563,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
@@ -484,7 +574,7 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number + 2 })
+      Success result: { numbers: numbers.map { |number| number + 2 } }
     end
   end
 
@@ -492,7 +582,7 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number * 2 })
+      Success result: { numbers: numbers.map { |number| number * 2 } }
     end
   end
 
@@ -500,24 +590,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 #
@@ -532,41 +622,14 @@ 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]
-
 # 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|
@@ -578,7 +641,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
@@ -587,9 +650,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
@@ -598,7 +661,7 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number + 2 })
+      Success result: { numbers: numbers.map { |number| number + 2 } }
     end
   end
 
@@ -606,7 +669,7 @@ module Steps
     attribute :numbers
 
     def call!
-      Success(numbers: numbers.map { |number| number * 2 })
+      Success result: { numbers: numbers.map { |number| number * 2 } }
     end
   end
 
@@ -614,20 +677,28 @@ 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])
@@ -638,16 +709,153 @@ DoubleAllNumbersAndSquareAndAdd2
   .on_success { |value| p value[: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 their 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?
 
-Answer: Yes, it is! Check out these test examples [Micro::Case::Flow](https://github.com/serradura/u-case/blob/e0066d8a6e3a9404069dfcb9bf049b854f08a33c/test/micro/case/flow/reducer_test.rb) and [Micro::Case::Safe::Flow](https://github.com/serradura/u-case/blob/e0066d8a6e3a9404069dfcb9bf049b854f08a33c/test/micro/case/safe/flow/reducer_test.rb) to see different use cases sharing their own data.
+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 FindByEmail < Micro::Case
+    attribute :email
+
+    def call!
+      user = User.find_by(email: email)
+
+      return Success result: { user: user } if user
+
+      Failure(:user_not_found)
+    end
+  end
+end
+
+module Users
+  class ValidatePassword < Micro::Case::Strict
+    attributes :user, :password
+
+    def call!
+      return Failure(:user_must_be_persisted) if user.new_record?
+      return Failure(:wrong_password) if user.wrong_password?(password)
+
+      return Success result: attributes(:user)
+    end
+  end
+end
+
+module Users
+  Authenticate = Micro::Cases.flow([
+    FindByEmail,
+    ValidatePassword
+  ])
+end
+
+Users::Authenticate
+  .call(email: 'somebody@test.com', password: 'password')
+  .on_success { |result| sign_in(result[:user]) }
+  .on_failure(:wrong_password) { render status: 401 }
+  .on_failure(:user_not_found) { render status: 404 }
+```
+
+First, lets see the attributes used by each use case:
+
+```ruby
+class Users::FindByEmail < Micro::Case
+  attribute :email
+end
+
+class Users::ValidatePassword < Micro::Case
+  attributes :user, :password
+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!
+
+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.
 
 [⬆️ Back to Top](#table-of-contents-)
 
+#### How to understand what is happening during a flow execution?
+
+Use `Micro::Case::Result#transitions`!
+
+Let's use the [previous section example](#is-it-possible-a-flow-accumulates-its-input-and-merges-each-success-result-to-use-as-the-argument-of-the-next-use-cases) to ilustrate how to use this feature.
+
+```ruby
+user_authenticated =
+  Users::Authenticate.call(email: 'rodrigo@test.com', password: user_password)
+
+user_authenticated.transitions
+[
+  {
+    :use_case => {
+      :class      => Users::FindByEmail,
+      :attributes => { :email => "rodrigo@test.com" }
+    },
+    :success => {
+      :type  => :ok,
+      :result => {
+        :user => #<User:0x00007fb57b1c5f88 @email="rodrigo@test.com" ...>
+      }
+    },
+    :accessible_attributes => [ :email, :password ]
+  },
+  {
+    :use_case => {
+      :class      => Users::ValidatePassword,
+      :attributes => {
+        :user     => #<User:0x00007fb57b1c5f88 @email="rodrigo@test.com" ...>
+        :password => "123456"
+      }
+    },
+    :success => {
+      :type  => :ok,
+      :result => {
+        :user => #<User:0x00007fb57b1c5f88 @email="rodrigo@test.com" ...>
+      }
+    },
+    :accessible_attributes => [ :email, :password, :user ]
+  }
+]
+```
+
+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.
+
+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` feature toggle to disable this feature (use once, because it is global) and increase the use cases' performance.
+
+##### `Micro::Case::Result#transitions` schema
+```ruby
+[
+  {
+    use_case: {
+      class:      <Micro::Case>,# Use case which was executed
+      attributes: <Hash>        # (Input) The use case's attributes
+    },
+    [success:, failure:] => {   # (Output)
+      type:  <Symbol>,          # Result type. Defaults:
+                                # Success = :ok, Failure = :error/:exception
+      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
+                                    # with each result value of the flow's use cases.
+  }
+]
+```
+
 #### 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:
@@ -657,7 +865,7 @@ class ConvertTextToNumber < Micro::Case
   attribute :text
 
   def call!
-    Success { { number: text.to_i } }
+    Success result: { number: text.to_i }
   end
 end
 
@@ -665,7 +873,7 @@ class ConvertNumberToText < Micro::Case
   attribute :number
 
   def call!
-    Success { { text: number.to_s } }
+    Success result: { text: number.to_s }
   end
 end
 
@@ -677,17 +885,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-)
@@ -701,7 +909,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
 
@@ -715,7 +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!
+Answer: Yes, there is one!
 
 **Use cases:**
 
@@ -730,14 +938,18 @@ 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
@@ -758,25 +970,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
 ```
 
-**Flows:**
+[⬆️ Back to Top](#table-of-contents-)
+
+#### `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,
@@ -794,33 +999,63 @@ module Users
          SendToCRM
   end
 end
+```
 
+[⬆️ Back to Top](#table-of-contents-)
 
-# !------------------------------------------ ! #
-# ! Deprecated: Micro::Case::Safe::Flow mixin ! #
-# !-------------------------------------------! #
+#### `Micro::Case::Result#on_exception`
 
-# 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.
+In functional programming errors/exceptions are handled as regular data, the idea is to transform the output even when it happens an unexpected behavior. For many, [exceptions are very similar to the GOTO statement](https://softwareengineering.stackexchange.com/questions/189222/are-exceptions-as-control-flow-considered-a-serious-antipattern-if-so-why), jumping the application flow to paths which could be difficult to figure out how things work in a system.
 
-module Users
-  class Create
-    include Micro::Case::Safe::Flow
+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.
 
-    flow ProcessParams, ValidateParams, Persist, SendToCRM
+How does it work?
+
+```ruby
+class Divide < Micro::Case::Safe
+  attributes :a, :b
+
+  def call!
+    Success result: { division: a / b }
   end
 end
 
-# Note: This feature will be removed in the next major release (3.0)
+Divide
+  .call(a: 2, b: 0)
+  .on_success { |result| puts result[:division] }
+  .on_exception(TypeError) { puts 'Please, use only numeric attributes.' }
+  .on_exception(ZeroDivisionError) { |_error| puts "Can't divide a number by 0." }
+  .on_exception { |_error, _use_case| puts 'Oh no, something went wrong!' }
+
+# Output:
+# -------
+# Can't divide a number by 0
+# Oh no, something went wrong!
+
+Divide.
+  .call(a: 2, b: '2').
+  .on_success { |result| puts result[:division] }
+  .on_exception(TypeError) { puts 'Please, use only numeric attributes.' }
+  .on_exception(ZeroDivisionError) { |_error| puts "Can't divide a number by 0." }
+  .on_exception { |_error, _use_case| puts 'Oh no, something went wrong!' }
+
+# Output:
+# -------
+# Please, use only numeric attributes.
+# 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.
+
 [⬆️ Back to Top](#table-of-contents-)
 
-### `u-case/with_validation` - How to validate use case attributes?
+### `u-case/with_activemodel_validation` - How to validate use case attributes?
 
 **Requirement:**
 
-To do this your application must have the [activemodel >= 3.2](https://rubygems.org/gems/activemodel) as a dependency.
+To do this your application must have the [activemodel >= 3.2, < 6.1.0](https://rubygems.org/gems/activemodel) as a dependency.
 
 ```ruby
 #
@@ -833,9 +1068,9 @@ 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
 
@@ -844,10 +1079,10 @@ end
 # your use cases on validation errors, you can use:
 
 # In some file. e.g: A Rails initializer
-require 'u-case/with_validation' # or require 'micro/case/with_validation'
+require 'u-case/with_activemodel_validation' # or require 'micro/case/with_validation'
 
 # In the Gemfile
-gem 'u-case', require: 'u-case/with_validation'
+gem 'u-case', require: 'u-case/with_activemodel_validation'
 
 # Using this approach, you can rewrite the previous example with less code. e.g:
 
@@ -857,7 +1092,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
 
@@ -869,10 +1104,10 @@ 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_validation'
+require 'u-case/with_activemodel_validation'
 
 class Multiply < Micro::Case
   disable_auto_validation
@@ -882,7 +1117,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
 
@@ -894,168 +1129,190 @@ Multiply.call(a: 2, b: 'a')
 
 [⬆️ Back to Top](#table-of-contents-)
 
+#### `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 example below shows how to validate the attributes data types.
+
+```ruby
+class Todo::List::AddItem < Micro::Case
+  attributes :user, :params
+
+  validates :user, kind: User
+  validates :params, kind: ActionController::Parameters
+
+  def call!
+    todo_params = params.require(:todo).permit(:title, :due_at)
+
+    todo = user.todos.create(todo_params)
+
+    Success result: { todo: todo }
+  rescue ActionController::ParameterMissing => e
+    Failure :parameter_missing, result: { message: e.message }
+  end
+end
+```
+
 ## Benchmarks
 
-### `Micro::Case`
+### `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.
 
-| Gem / Abstraction      | Iterations per second |       Comparison |
-| ---------------------- | --------------------: | ---------------: |
-| **Micro::Case**        |              116629.7 | _**The Faster**_ |
-| 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 |
+| 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  |
 
 ---
 
 #### Success results
 
-| Gem / Abstraction      | Iterations per second |       Comparison |
-| -----------------      | --------------------: | ---------------: |
-| Dry::Monads            |              139352.5 | _**The Faster**_ |
-| **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 |
+| 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  |
 
 <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
 
 #### Failure results
 
-| Gem / Abstraction      | Iterations per second |       Comparison |
-| -----------------      | --------------------: | ---------------: |
-| **Micro::Case**        |              108510.0 | _**The Faster**_ |
-| 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 |
+| 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  |
 
 <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 Faster**_ | _**The Faster**_ |
-| Micro::Case::Safe::Flow |        0x slower |        0x slower |
-| Interactor::Organizer   |     1.47x slower |     5.51x slower |
+| ------------------      | ----------------: | ----------------: |
+| Micro::Case::Flow       | _**The Fastest**_ | _**The Fastest**_ |
+| Micro::Case::Safe::Flow |        0x slower  |        0x 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