u-case 2.2.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ba53faeaf465b491f94a686da7fc2537e9c50108b18162d11c473246e6a531e
-  data.tar.gz: 6b91c842ad57b917678649f4003f34ade8459a70c56938d2e226a4d8322e855d
+  metadata.gz: de7b8e442e0b578b478d9d63f05901c9023884f3f2b15a1819228af36fe7afc5
+  data.tar.gz: 50e9128500306350a56102b93ca8bd171c75ecae24899c6157a7955e845221a3
 SHA512:
-  metadata.gz: 8d4790abfb49211a69d9874900e83a0237d5fe0f0b288102e9bcff33fd932db4192e66ea2e5814990da2d5e92b5499dd93173257433639e2248463f2b3c991e8
-  data.tar.gz: e2bd4e73018961d931a76298dacf8000836d26f2331f975b777bc0371dcfe84d2064a51ef12636f31eaf22986a76b97f99e7cbe16b653a1bd1923ae5f8f4f125
+  metadata.gz: 93fcec72232ac2d1ce479cdc2efa02d7b4eddf0d3b57e2c93346ecb6359a0f9ccba33f7851b2115c813ef53f79f9276984864f172c341be23be8c11120e933fe
+  data.tar.gz: 9993e5cdcbe6f1e864c32a9db7f637c1cdb839bd838d1823e64b2646b704b079d9f83915af65e364abe8edd66034952202909a42833a634d04aeac11eee384bd

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,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,43 +19,49 @@ 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)](#%ce%bc-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 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-casewithvalidation---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%ef%b8%8f%e2%83%a3-rails-app-api)
-    - [2️⃣ CLI calculator](#2%ef%b8%8f%e2%83%a3-cli-calculator)
-    - [3️⃣ Users creation](#3%ef%b8%8f%e2%83%a3-users-creation)
-    - [4️⃣ Rescuing exception inside of the use cases](#4%ef%b8%8f%e2%83%a3-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)
+      - [How to make attributes data injection using this feature?](#how-to-make-attributes-data-injection-using-this-feature)
+  - [`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
 
@@ -62,8 +69,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
 
@@ -145,6 +159,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-)
 
@@ -415,6 +430,65 @@ accum # 24
 result.value * 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
+
+    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.value    # {'number' => -1}
+result1.failure? # true
+
+# ---
+
+result2 =
+  ForbidNegativeNumber
+    .call(number: 1)
+    .then(Add3)
+
+result2.value    # {'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-)
+
+##### 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?
@@ -598,12 +672,149 @@ 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 }
+```
 
-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.
+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
+
+> **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`.
+
+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:
@@ -717,7 +928,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:
 
@@ -751,7 +964,6 @@ module Users
   end
 end
 
-
 # !------------------------------------------ ! #
 # ! Deprecated: Micro::Case::Safe::Flow mixin ! #
 # !-------------------------------------------! #
@@ -772,11 +984,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
 #
@@ -800,10 +1060,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:
 
@@ -828,7 +1088,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
@@ -850,6 +1110,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`
@@ -858,25 +1143,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>
@@ -916,13 +1201,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>
@@ -965,10 +1250,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,37 +43,60 @@ module Micro
       instance
     end
 
+    def self.__call_and_set_transition__(result, arg)
+      input =
+        arg.is_a?(Hash) ? result.__set_transitions_accessible_attributes__(arg) : arg
+
+      __new__(result, input).call
+    end
+
+    FLOW_STEP = 'Flow_Step'.freeze
+
+    private_constant :FLOW_STEP
+
     def self.__call!
-      return const_get(:Flow_Step) if const_defined?(:Flow_Step)
+      return const_get(FLOW_STEP) if const_defined?(FLOW_STEP, false)
 
-      const_set(:Flow_Step, Class.new(self) do
-        private def __call
-          __call_use_case
-        end
-      end)
+      class_eval("class #{FLOW_STEP} < #{self.name}; private def __call; __call_use_case; end; end")
     end
 
     def self.call!
       self
     end
 
+    def self.inherited(subclass)
+      subclass.attributes(self.attributes_data({}))
+      subclass.extend ::Micro::Attributes.const_get('Macros::ForSubclasses'.freeze)
+
+      if self.send(:__flow_use_cases) && !subclass.name.to_s.end_with?(FLOW_STEP)
+        raise "Wooo, you can't do this! Inherits from a use case which has an inner flow violates "\
+          "one of the project principles: Solve complex business logic, by allowing the composition of use cases. "\
+          "Instead of doing this, declare a new class/constant with the steps needed.\n\n"\
+          "Related issue: https://github.com/serradura/u-case/issues/19\n"
+      end
+    end
+
     def self.__flow_reducer
       Flow::Reducer
     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 +108,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 +129,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 +169,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 +186,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/error.rb

@@ -9,20 +9,36 @@ module Micro
         def initialize(klass); super(klass.name + MESSAGE); end
       end
 
-      ResultIsAlreadyDefined = ArgumentError.new('result is already defined'.freeze)
+      class ResultIsAlreadyDefined < ArgumentError
+        def initialize; super('result is already defined'.freeze); end
+      end
 
-      InvalidResultType = TypeError.new('type must be a Symbol'.freeze)
-      InvalidResultInstance = ArgumentError.new('argument must be an instance of Micro::Case::Result'.freeze)
+      class InvalidResultType < TypeError
+        def initialize; super('type must be a Symbol'.freeze); end
+      end
 
-      InvalidUseCase = TypeError.new('use case must be a kind or an instance of Micro::Case'.freeze)
-      InvalidUseCases = ArgumentError.new('argument must be a collection of `Micro::Case` classes'.freeze)
+      class InvalidResultInstance < ArgumentError
+        def initialize; super('argument must be an instance of Micro::Case::Result'.freeze); end
+      end
 
-      UndefinedFlow = ArgumentError.new("This class hasn't declared its flow. Please, use the `flow()` macro to define one.".freeze)
+      class InvalidUseCase < TypeError
+        def initialize; super('use case must be a kind or an instance of Micro::Case'.freeze); end
+      end
 
-      class InvalidAccessToTheUseCaseObject < StandardError
-        MSG = 'only a failure result can access its use case object'.freeze
+      class InvalidUseCases < ArgumentError
+        def initialize; super('argument must be a collection of `Micro::Case` classes'.freeze); end
+      end
 
-        def initialize(message = MSG); super; end
+      class InvalidInvocationOfTheThenMethod < StandardError
+        def initialize; super('Invalid invocation of the Micro::Case::Result#then method'); end
+      end
+
+      class UndefinedFlow < ArgumentError
+        def initialize; super("This class hasn't declared its flow. Please, use the `flow()` macro to define one.".freeze); end
+      end
+
+      class InvalidAccessToTheUseCaseObject < StandardError
+        def initialize; super('only a failure result can access its use case object'.freeze); end
       end
 
       module ByWrongUsage

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)
+
+              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__ = {}
+      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
 
@@ -41,7 +58,9 @@ module Micro
       end
 
       def on_success(expected_type = nil)
-        self.tap { yield(value) if success_type?(expected_type) }
+        yield(value) if success_type?(expected_type)
+
+        self
       end
 
       def on_failure(expected_type = nil)
@@ -49,11 +68,65 @@ module Micro
 
         data = expected_type.nil? ? Data.new(value, type).tap(&:freeze) : value
 
-        self.tap { yield(data, @use_case) }
+        yield(data, @use_case)
+
+        self
+      end
+
+      def on_exception(expected_exception = nil)
+        return self unless failure_type?(:exception)
+
+        if !expected_exception || (Kind.is(Exception, expected_exception) && value.is_a?(expected_exception))
+          yield(value, @use_case)
+        end
+
+        self
+      end
+
+      def then(arg = nil, attributes = nil, &block)
+        can_yield_self = respond_to?(:yield_self)
+
+        if block
+          raise Error::InvalidInvocationOfTheThenMethod if arg
+          raise NotImplementedError if !can_yield_self
+
+          yield_self(&block)
+        else
+          return yield_self if !arg && can_yield_self
+
+          raise Error::InvalidInvocationOfTheThenMethod if !is_a_use_case?(arg)
+
+          return self if failure?
+
+          input = attributes.is_a?(Hash) ? self.value.merge(attributes) : self.value
+
+          arg.__call_and_set_transition__(self, input)
+        end
+      end
+
+      def transitions
+        @__transitions__.clone
+      end
+
+      def __set_transitions_accessible_attributes__(attributes_data)
+        return attributes_data if @@transition_tracking_disabled
+
+        __set_transitions_accessible_attributes__!(attributes_data)
       end
 
       private
 
+        def __set_transitions_accessible_attributes__!(attributes_data)
+          attributes = Utils.symbolize_hash_keys(attributes_data)
+
+          __update_transitions_accessible_attributes__(attributes)
+        end
+
+        def __update_transitions_accessible_attributes__(attributes)
+          @__transitions_accessible_attributes__.merge!(attributes)
+          @__transitions_accessible_attributes__
+        end
+
         def success_type?(expected_type)
           success? && (expected_type.nil? || expected_type == type)
         end
@@ -65,6 +138,21 @@ 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_hash_keys(@use_case.attributes)
+
+          __update_transitions_accessible_attributes__(use_case_attributes)
+
+          result = @success ? :success : :failure
+
+          @__transitions__ << {
+            use_case: { class: use_case_class, attributes: use_case_attributes },
+            result => { type: @type, value: @value },
+            accessible_attributes: @__transitions_accessible_attributes__.keys
+          }
+        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_hash_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.2.0'.freeze
+    VERSION = '2.6.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
@@ -22,12 +22,14 @@ module Micro
 
     private
 
-      def __call
-        return __call_use_case_flow if __call_use_case_flow?
-
+      def __call_use_case
         return failure_by_validation_error(self) if !self.class.auto_validation_disabled? && invalid?
 
-        __call_use_case
+        result = call!
+
+        return result if result.is_a?(Result)
+
+        raise Error::UnexpectedResult.new(self.class)
       end
 
       def failure_by_validation_error(object)

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

@@ -14,20 +14,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/serradura/u-case'
   spec.license       = 'MIT'
 
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  if spec.respond_to?(:metadata)
-    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-
-    # spec.metadata["homepage_uri"] = spec.homepage
-    # spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
-    # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
-  else
-    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
-  end
+  raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.' unless spec.respond_to?(:metadata)
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|assets|benchmarks|comparisons|examples)/}) }
   end
@@ -37,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.2.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-12 00:00:00.000000000 Z
+date: 2020-07-07 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
@@ -103,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Create simple and powerful use cases as objects.