u-case 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f5a28fb237f74e009225d20bcc65115e6d8159818a3cfdbfcb7e23c3726aef4
-  data.tar.gz: fa34ab50f7b2d0df65ba75f4b59734e0326d8431652823ad35e406d243801853
+  metadata.gz: d5b58d2e19bca34b4337e348d4d498b21ee12134082f897122c957ab79e19fa7
+  data.tar.gz: 6cb9e76227b0dc96d92de0c7ae1abdfe4bce2f840f0dced7ce1cae24908c0efb
 SHA512:
-  metadata.gz: cd2a5fd871fd561ab98d96297e474f3ea251cdee866d5b14cc69e5e04bf654b98c3b2f75ef55d4c774f0d91ca6297a89746c923a29cd1fd1985e5761db6848b3
-  data.tar.gz: 12c467840bab805b562ae9de9fe6c80ccda0129672989d6b14f844e916fd270f0f5f9c2f213fed508c439e6d17142712f2013475bbc6f0f9a22066ab0aeb84ef
+  metadata.gz: ea7dd10cd004dc3ef7e3fbfe062afc6e7a09e172b9fca1c5d2f2300c6d876b19eeb4935d06c8650010b14ca318486226fe08ec5c9fa57a9570870caf9b470bb2
+  data.tar.gz: 5742702a5c64d2ed8a32cb83aaa6ee8fb5cb550b7144eba248cf058e340f47751528e38214991f1c92c50370b4a6240f7e29a963d872ffe78219d2d91fa5637e

data/Gemfile

@@ -18,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,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.
@@ -18,44 +19,46 @@ 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.
 
 ## 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 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)
+  - [`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
 
@@ -63,8 +66,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
 
@@ -642,12 +652,147 @@ 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:
 
-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.
+```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 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
+
+> **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-)
 
+#### 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`.
+
+##### 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:
@@ -816,11 +961,11 @@ end
 
 [⬆️ 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
 #
@@ -844,10 +989,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:
 
@@ -872,7 +1017,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
@@ -894,6 +1039,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`
@@ -902,25 +1072,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>
@@ -960,13 +1130,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>
@@ -1009,10 +1179,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.
 

data/lib/micro/case.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
+require 'kind'
 require 'micro/attributes'
-# frozen_string_literal: true
 
 module Micro
   class Case
     require 'micro/case/version'
+    require 'micro/case/utils'
     require 'micro/case/result'
     require 'micro/case/error'
     require 'micro/case/safe'
@@ -42,6 +43,14 @@ module Micro
       instance
     end
 
+    def self.__call_and_set_transition__(result, arg)
+      if arg.respond_to?(:keys)
+        result.__set_transitions_accessible_attributes__(arg.keys)
+      end
+
+      __new__(result, arg).call
+    end
+
     def self.__call!
       return const_get(:Flow_Step) if const_defined?(:Flow_Step)
 
@@ -61,18 +70,22 @@ module Micro
     end
 
     def self.__flow_get
-      @__flow
+      return @__flow if defined?(@__flow)
     end
 
-    private_class_method def self.__flow_use_cases_set(args)
-      @__flow_use_cases = args
+    private_class_method def self.__flow_use_cases
+      return @__flow_use_cases if defined?(@__flow_use_cases)
     end
 
     private_class_method def self.__flow_use_cases_get
-      Array(@__flow_use_cases)
+      Array(__flow_use_cases)
         .map { |use_case| use_case == self ? self.__call! : use_case }
     end
 
+    private_class_method def self.__flow_use_cases_set(args)
+      @__flow_use_cases = args
+    end
+
     private_class_method def self.__flow_set(args)
       return if __flow_get
 
@@ -84,7 +97,7 @@ module Micro
     end
 
     def self.__flow_set!
-      __flow_set(__flow_use_cases_get) if !__flow_get && @__flow_use_cases
+      __flow_set(__flow_use_cases_get) if !__flow_get && __flow_use_cases
     end
 
     def self.flow(*args)
@@ -105,7 +118,7 @@ module Micro
 
     def __set_result__(result)
       raise Error::InvalidResultInstance unless result.is_a?(Result)
-      raise Error::ResultIsAlreadyDefined if @__result
+      raise Error::ResultIsAlreadyDefined if defined?(@__result)
 
       @__result = result
     end
@@ -145,18 +158,14 @@ module Micro
       def Success(arg = :ok)
         value, type = block_given? ? [yield, arg] : [arg, :ok]
 
-        __get_result__.__set__(true, value, type, nil)
+        __get_result_with(true, value, type)
       end
 
       def Failure(arg = :error)
         value = block_given? ? yield : arg
         type = __map_failure_type(value, block_given? ? arg : :error)
 
-        __get_result__.__set__(false, value, type, self)
-      end
-
-      def __get_result__
-        @__result ||= Result.new
+        __get_result_with(false, value, type)
       end
 
       def __map_failure_type(arg, type)
@@ -166,5 +175,13 @@ module Micro
 
         type
       end
+
+      def __get_result__
+        @__result ||= Result.new
+      end
+
+      def __get_result_with(is_success, value, type)
+        __get_result__.__set__(is_success, value, type, self)
+      end
   end
 end

data/lib/micro/case/flow.rb

@@ -5,7 +5,7 @@ module Micro
     module Flow
       module ClassMethods
         def __flow__
-          @__flow
+          return @__flow if defined?(@__flow)
         end
 
         def flow(*args)

data/lib/micro/case/flow/reducer.rb

@@ -23,19 +23,18 @@ module Micro
 
         def initialize(use_cases)
           @use_cases = use_cases
+          @first_use_case = use_cases[0]
+          @next_use_cases = use_cases[1..-1]
         end
 
         def call(arg = {})
           memo = arg.is_a?(Hash) ? arg.dup : {}
 
-          @use_cases.reduce(initial_result(arg)) do |result, use_case|
-            break result if result.failure?
+          first_result = first_use_case_result(arg)
 
-            value = result.value
-            input = value.is_a?(Hash) ? memo.tap { |data| data.merge!(value) } : value
+          return first_result if @next_use_cases.empty?
 
-            use_case_result(use_case, result, input)
-          end
+          next_use_cases_result(first_result, memo)
         end
 
         def >>(arg)
@@ -52,16 +51,8 @@ module Micro
 
         private
 
-          def use_case_result(use_case, result, input)
-            use_case.__new__(result, input).call
-          end
-
-          def initial_result(arg)
-            return arg.call if arg_to_call?(arg)
-            return arg if arg.is_a?(Micro::Case::Result)
-
-            result = ::Micro::Case::Result.new
-            result.__set__(true, arg, :ok, nil)
+          def is_a_result?(arg)
+            arg.is_a?(Micro::Case::Result)
           end
 
           def arg_to_call?(arg)
@@ -69,6 +60,44 @@ module Micro
             return true if arg.is_a?(Class) && (arg < ::Micro::Case || arg < ::Micro::Case::Flow)
             return false
           end
+
+          def call_arg(arg)
+            output = arg.call
+
+            is_a_result?(output) ? output.value : output
+          end
+
+          def first_use_case_input(arg)
+            return call_arg(arg) if arg_to_call?(arg)
+            return arg.value if is_a_result?(arg)
+
+            arg
+          end
+
+          def first_use_case_result(arg)
+            input = first_use_case_input(arg)
+
+            result = ::Micro::Case::Result.new
+
+            @first_use_case.__call_and_set_transition__(result, input)
+          end
+
+          def next_use_case_result(use_case, result, input)
+            use_case.__new__(result, input).call
+          end
+
+          def next_use_cases_result(first_result, memo)
+            @next_use_cases.reduce(first_result) do |result, use_case|
+              break result if result.failure?
+
+              value = result.value
+              input = value.is_a?(Hash) ? memo.tap { |data| data.merge!(value) } : value
+
+              result.__set_transitions_accessible_attributes__(memo.keys)
+
+              next_use_case_result(use_case, result, input)
+            end
+          end
       end
     end
   end

data/lib/micro/case/result.rb

@@ -1,8 +1,18 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Micro
   class Case
     class Result
+      Kind::Types.add(self)
+
+      @@transition_tracking_disabled = false
+
+      def self.disable_transition_tracking
+        @@transition_tracking_disabled = true
+      end
+
       class Data
         attr_reader :value, :type
 
@@ -17,12 +27,19 @@ module Micro
 
       attr_reader :value, :type
 
+      def initialize
+        @__transitions__ = {}
+        @__transitions_accessible_attributes__ = Set.new
+      end
+
       def __set__(is_success, value, type, use_case)
         raise Error::InvalidResultType unless type.is_a?(Symbol)
-        raise Error::InvalidUseCase if !is_success && !is_a_use_case?(use_case)
+        raise Error::InvalidUseCase if !is_a_use_case?(use_case)
 
         @success, @value, @type, @use_case = is_success, value, type, use_case
 
+        __set_transition__ unless @@transition_tracking_disabled
+
         self
       end
 
@@ -67,12 +84,32 @@ module Micro
 
           return self if failure?
 
-          arg.call(self.value)
+          arg.__call_and_set_transition__(self, self.value)
         end
       end
 
+      def transitions
+        return [] if @__transitions__.empty?
+
+        @__transitions__.map { |_use_case, transition| transition }
+      end
+
+      def __set_transitions_accessible_attributes__(attribute_names)
+        return if @@transition_tracking_disabled
+
+        __set_transitions_accessible_attributes__!(
+          attribute_names.map!(&:to_sym)
+        )
+      end
+
       private
 
+        def __set_transitions_accessible_attributes__!(attribute_names)
+          @__transitions_accessible_attributes__.merge(
+            attribute_names
+          )
+        end
+
         def success_type?(expected_type)
           success? && (expected_type.nil? || expected_type == type)
         end
@@ -84,6 +121,22 @@ module Micro
         def is_a_use_case?(arg)
           (arg.is_a?(Class) && arg < ::Micro::Case) || arg.is_a?(::Micro::Case)
         end
+
+        def __set_transition__
+          use_case_class = @use_case.class
+          use_case_attributes = Utils.symbolize_keys(@use_case.attributes)
+
+          __set_transitions_accessible_attributes__!(use_case_attributes.keys)
+
+          result = @success ? :success : :failure
+          transition = {
+            use_case: { class: use_case_class, attributes: use_case_attributes },
+            result => { type: @type, value: @value },
+            accessible_attributes: @__transitions_accessible_attributes__.to_a
+          }
+
+          @__transitions__[use_case_class] = transition
+        end
     end
   end
 end

data/lib/micro/case/safe/flow.rb

@@ -19,7 +19,7 @@ module Micro
 
           private
 
-            def use_case_result(use_case, result, input)
+            def next_use_case_result(use_case, result, input)
               begin
                 instance = use_case.__new__(result, input)
                 instance.call

data/lib/micro/case/utils.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Micro
+  class Case
+    module Utils
+      def self.symbolize_keys(hash)
+        if Kind.of.Hash(hash).respond_to?(:transform_keys)
+          hash.transform_keys { |key| key.to_sym rescue key }
+        else
+          hash.each_with_object({}) do |(k, v), memo|
+            key = k.to_sym rescue k
+
+            memo[key] = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/micro/case/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   class Case
-    VERSION = '2.3.1'.freeze
+    VERSION = '2.4.0'.freeze
   end
 end

data/lib/micro/case/{with_validation.rb → with_activemodel_validation.rb}

@@ -7,7 +7,7 @@ module Micro
     include Micro::Attributes::Features::ActiveModelValidations
 
     def self.auto_validation_disabled?
-      @disable_auto_validation
+      return @disable_auto_validation if defined?(@disable_auto_validation)
     end
 
     def self.disable_auto_validation

data/lib/u-case/with_activemodel_validation.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'kind/active_model/validation'
+
+require 'micro/case/with_activemodel_validation'

data/lib/u-case/with_validation.rb

@@ -1,3 +1,6 @@
 # frozen_string_literal: true
 
-require 'micro/case/with_validation'
+warn 'Deprecation: "u-case/with_validation" will be deprecated in the next major release.' \
+    'Please use "u-case/with_activemodel_validation" instead of it.'
+
+require 'u-case/with_activemodel_validation'

data/u-case.gemspec

@@ -25,8 +25,9 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.2.0'
 
+  spec.add_runtime_dependency 'kind', '~> 3.0'
   spec.add_runtime_dependency 'u-attributes', '~> 1.1'
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: u-case
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-29 00:00:00.000000000 Z
+date: 2020-06-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: kind
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: u-attributes
   requirement: !ruby/object:Gem::Requirement
@@ -44,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 description: Create simple and powerful use cases as objects.
 email:
 - rodrigo.serradura@gmail.com
@@ -78,9 +92,11 @@ files:
 - lib/micro/case/safe.rb
 - lib/micro/case/safe/flow.rb
 - lib/micro/case/strict.rb
+- lib/micro/case/utils.rb
 - lib/micro/case/version.rb
-- lib/micro/case/with_validation.rb
+- lib/micro/case/with_activemodel_validation.rb
 - lib/u-case.rb
+- lib/u-case/with_activemodel_validation.rb
 - lib/u-case/with_validation.rb
 - test.sh
 - u-case.gemspec