u-case 2.1.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0411016e16662d422a9f6b641ae91a516225e877f5cd8951058b479ea1b413d
-  data.tar.gz: 586af968d98bf2add7a9882a894db2ea4e6ada5eb3c3e31eae39a1d09e2410bf
+  metadata.gz: 349609a8d927ab7fd8edb1eb96141dff2f78f9957f31f2b88a8975239fc0de87
+  data.tar.gz: 4b6293023f49f28dd8283656a0d423f7d24abbfb7f010a90ba4d0dd17f577d22
 SHA512:
-  metadata.gz: ab3231e87cca1c25cc5148f922292177239738da22a7f1528bd4cdc56a601028c4a4e9eec0660e00c1cfc0a126746c53f37db159002639d9226f22cec931b812
-  data.tar.gz: 308404bc8b913d4ef84cd59e31fecd18b6bfe5ba51c6724d4a8880525c6058d01bf7b669676a843f2ff47754a7db9e643abcbbd53f50b178d72efce6c979eb40
+  metadata.gz: 0553e560e40f71d0e8284ebbbbf7a51326d8c9bc9de6ad0de76db526466a94f633e2b038563868a2c93234800b7bdacc30a99ba57f1624ce08463fdc012d165d
+  data.tar.gz: 2866ca201676827b2ffc82877b1615e7ecbb6fc6e993df17007c6446b348a850266faf162a0953954ee6adfb0d35a88c303bee385d2fb52a9c228f45513655db

data/.tool-versions

@@ -1 +1 @@
-ruby 2.6.3
+ruby 2.6.5

data/.travis.sh

@@ -11,3 +11,8 @@ if [[ ! $ruby_v =~ '2.2.0' ]]; then
   ACTIVEMODEL_VERSION='5.2' bundle update
   ACTIVEMODEL_VERSION='5.2' 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
+fi

data/.travis.yml

@@ -9,6 +9,7 @@ rvm:
 - 2.4.0
 - 2.5.0
 - 2.6.0
+- 2.7.0
 
 cache: bundler
 

data/Gemfile

@@ -7,6 +7,7 @@ activemodel_version = ENV.fetch('ACTIVEMODEL_VERSION', '6.1.0')
 activemodel = case activemodel_version
               when '3.2' then '3.2.22'
               when '5.2' then '5.2.3'
+              when '6.0' then '6.0.2'
               end
 
 if activemodel_version < '6.1.0'
@@ -17,7 +18,19 @@ 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
+
+group :development, :test do
+  gem 'awesome_print', '~> 1.8'
+
+  gem 'pry-byebug', "~> #{pry_byebug_version}"
 end
 
 # Specify your gem's dependencies in u-case.gemspec

data/README.md

@@ -1,54 +1,66 @@
+![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.
 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.
+
 ## 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)
-    - [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 using the use case itself?](#is-it-possible-to-declare-a-flow-using-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)
-  - [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 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 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::Case::Safe::Flow`](#microcasesafeflow)
+    - [`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`](#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
 
@@ -56,8 +68,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, expose `Kind.of.Micro::Case::Result` type checker and its [`activemodel validation`](https://github.com/serradura/kind#kindvalidator-activemodelvalidations) module is auto required by [`u-case/with_activemodel_validation`](#u-casewith_activemodel_validation---how-to-validate-use-case-attributes) mode.
+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
 
@@ -139,6 +158,7 @@ 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.
 - `#on_success` or `#on_failure` are hook methods that help you define the application flow.
 - `#use_case` if is a failure result, the use case responsible for it will be accessible through this method. This feature is handy to handle a flow failure (this topic will be covered ahead).
+- `#then` allows if the current result is a success, the `then` method will allow to applying a new use case for its value.
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -409,6 +429,48 @@ accum # 24
 result.value * 4 == accum # true
 ```
 
+#### How to use the `Micro::Case::Result#then` method?
+
+```ruby
+class ForbidNegativeNumber < Micro::Case
+  attribute :number
+
+  def call!
+    return Success { attributes } if number >= 0
+
+    Failure { attributes }
+  end
+end
+
+class Add3 < Micro::Case
+  attribute :number
+
+  def call!
+    Success { { number: number + 3 } }
+  end
+end
+
+result1 =
+  ForbidNegativeNumber
+    .call(number: -1)
+    .then(Add3)
+
+result1.type     # :error
+result1.value    # {'number' => -1}
+result1.failure? # true
+
+# ---
+
+result2 =
+  ForbidNegativeNumber
+    .call(number: 1)
+    .then(Add3)
+
+result2.type     # :ok
+result2.value    # {'number' => 4}
+result2.success? # true
+```
+
 [⬆️ Back to Top](#table-of-contents-)
 
 ### `Micro::Case::Flow` - How to compose use cases?
@@ -592,13 +654,150 @@ Note: You can blend any of the [available syntaxes/approaches](#how-to-create-a-
 
 [⬆️ 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! Look at the example below to understand how the data accumulation works inside of the flow execution.
+
+```ruby
+module Users
+  class Find < Micro::Case
+    attribute :email
+
+    def call!
+      user = User.find_by(email: email)
+
+      return Success { { 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 { attributes(:user) }
+    end
+  end
+end
+
+module Users
+  Authenticate = Micro::Case::Flow([
+    Find,
+    ValidatePassword
+  ])
+end
+
+Users::Authenticate
+  .call(email: 'somebody@test.com', password: 'password')
+  .on_success { |result| sign_in(result[:user]) }
+  .on_failure(:wrong_password) { |result| render status: 401 }
+  .on_failure(:user_not_found) { |result| render status: 404 }
+```
+
+First, lets see the attribute of each use case:
+
+```ruby
+class Users::Find < 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::Find` success result!
+
+And this, is the power of use cases composition because the output
+of one flow will compose the input of the next use case in the flow!
+
+> input **>>** process **>>** output
 
-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.
+> **Note:** Check out these test examples [Micro::Case::Flow](https://github.com/serradura/u-case/blob/b6d63b0db0caada67d2a6cf5cc5937000c0acf04/test/micro/case/flow/reducer_test.rb) and [Micro::Case::Safe::Flow](https://github.com/serradura/u-case/blob/b1d84b355f2b92d329e10d5d56d8012df1d32681/test/micro/case/safe/flow/reducer_test.rb) to see different use cases sharing their own data.
 
 [⬆️ Back to Top](#table-of-contents-)
 
-#### Is it possible to declare a flow using the use case itself?
+#### 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::Find,
+      :attributes => { :email => "rodrigo@test.com" }
+    },
+    :success => {
+      :type  => :ok,
+      :value => {
+        :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,
+      :value => {
+        :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.value`) in the entire execution.
+
+And look up the `accessible_attributes` property, because it shows whats attributes are accessible in that flow step. For example, in the last step, you can see that the `accessible_attributes` increased because of the [flow data accumulation](#is-it-possible-a-flow-accumulates-its-input-and-merges-each-success-result-to-use-as-the-argument-of-the-next-use-cases).
+
+> **Note:** The [`Micro::Case::Result#then`](#how-to-use-the-microcaseresultthen-method) increments the `Micro::Case::Result#transitions`.
+
+PS: Use the `Micro::Case::Result.disable_transition_tracking` global feature toggle to disable this feature (use once) and increase the use cases' performance.
+
+##### `Micro::Case::Result#transitions` schema
+```ruby
+[
+  {
+    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
+      value: <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:
 
@@ -620,16 +819,15 @@ class ConvertNumberToText < Micro::Case
 end
 
 class Double < Micro::Case
+  flow ConvertTextToNumber,
+       self.call!,
+       ConvertNumberToText
+
   attribute :number
 
   def call!
     Success { { number: number * 2 } }
   end
-
-  # NOTE: You need to declare the flow after the definition of the attributes.
-  flow ConvertTextToNumber,
-       self.call!,
-       ConvertNumberToText
 end
 
 result = Double.call(text: '4')
@@ -712,7 +910,9 @@ end
 # Examples: https://github.com/serradura/u-case/blob/5a85fc238b63811a32737493dc6c59965f92491d/test/micro/case/safe_test.rb#L95-L123
 ```
 
-**Flows:**
+[⬆️ Back to Top](#table-of-contents-)
+
+#### `Micro::Case::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:
 
@@ -746,7 +946,6 @@ module Users
   end
 end
 
-
 # !------------------------------------------ ! #
 # ! Deprecated: Micro::Case::Safe::Flow mixin ! #
 # !-------------------------------------------! #
@@ -767,11 +966,59 @@ end
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### `u-case/with_validation` - How to validate use case attributes?
+#### `Micro::Case::Result#on_exception`
+
+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.
+
+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.
+
+How does it work?
+
+```ruby
+class Divide < Micro::Case::Safe
+  attributes :a, :b
+
+  def call!
+    Success(division: a / b)
+  end
+end
+
+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_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
 #
@@ -795,10 +1042,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:
 
@@ -823,7 +1070,7 @@ end
 Answer: Yes, it is. 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
@@ -845,6 +1092,31 @@ 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 = Todo::Params.to_save(params)
+
+    todo = user.todos.create(todo_params)
+
+    Success { { todo: todo} }
+  rescue ActionController::ParameterMissing => e
+    Failure(:parameter_missing) { { message: e.message } }
+  end
+end
+```
+
 ## Benchmarks
 
 ### `Micro::Case`
@@ -853,25 +1125,25 @@ Multiply.call(a: 2, b: 'a')
 
 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**        |              116629.7 | _**The Fastest**_ |
+| Dry::Monads            |              101796.3 |     1.14x slower  |
+| Interactor             |               21230.5 |     5.49x slower  |
+| Trailblazer::Operation |               16466.6 |     7.08x slower  |
+| Dry::Transaction       |                5069.5 |    23.00x slower  |
 
 ---
 
 #### 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            |              139352.5 | _**The Fastest**_ |
+| **Micro::Case**        |              124749.4 |     1.12x slower  |
+| Interactor             |               28974.4 |     4.81x slower  |
+| Trailblazer::Operation |               17275.6 |     8.07x slower  |
+| Dry::Transaction       |                5571.7 |    25.01x slower  |
 
 <details>
   <summary>Show the full <a href="https://github.com/evanphx/benchmark-ips">benchmark/ips</a> results.</summary>
@@ -911,13 +1183,13 @@ https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_success
 
 #### 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**        |              108510.0 | _**The Fastest**_ |
+| Dry::Monads            |               64240.1 |     1.69x slower  |
+| Trailblazer::Operation |               15657.7 |     6.93x slower  |
+| Interactor             |               13486.7 |     8.05x slower  |
+| Dry::Transaction       |                4567.3 |    23.76x slower  |
 
 <details>
   <summary>Show the full <a href="https://github.com/evanphx/benchmark-ips">benchmark/ips</a> results.</summary>
@@ -960,10 +1232,10 @@ https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_failure
 ### `Micro::Case::Flow`
 
 | 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.47x slower  |     5.51x slower  |
 
 \* The `Dry::Monads`, `Dry::Transaction`, `Trailblazer::Operation` are out of this analysis because all of them doesn't have this kind of feature.
 
@@ -1022,13 +1294,27 @@ Check it out implementations of the same use case with different gems/abstractio
 
 ## Examples
 
-1. [Rescuing an exception inside of use cases](https://github.com/serradura/u-case/blob/master/examples/rescuing_exceptions.rb)
-2. [Users creation](https://github.com/serradura/u-case/blob/master/examples/users_creation.rb)
+### 1️⃣ Rails App (API)
+
+> 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/from-fat-controllers-to-use-cases
+
+### 2️⃣ CLI calculator
+
+> 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/tree/master/examples/calculator
+
+### 3️⃣ Users creation
+
+> An example of a use case flow that define steps to sanitize, validate, and persist its input data.
+>
+> Link: https://github.com/serradura/u-case/blob/master/examples/users_creation.rb
 
-    An example of flow in how to define steps to sanitize, validate, and persist some input data.
-3. [CLI calculator](https://github.com/serradura/u-case/tree/master/examples/calculator)
+### 4️⃣ Rescuing exception inside of the use cases
 
-    A more complex example which use rake tasks to demonstrate how to handle user data, and how to use different failures type to control the program flow.
+> Link: https://github.com/serradura/u-case/blob/master/examples/rescuing_exceptions.rb
 
 [⬆️ Back to Top](#table-of-contents-)