u-case 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a64ec32f1fc225bd83e86b56a34eca857b1e1e220e84bd35b64b5324d3d74b60
-  data.tar.gz: 23d17b47d23384fba17ace8e96b22ce07f4d42f01d676e7c29c88d99e9fc2b77
+  metadata.gz: 2cc6d19966687eef5e783d907074f36cb5b27492cea1e5e9bfadeaa68a799e69
+  data.tar.gz: cb63d747bdeaf71604fc52f7adecd80a8f2071c2087222ad9c1423fd29e381bb
 SHA512:
-  metadata.gz: 6b3732611a933699d9b8dfa8db011e58a317565eb7f2ab13c9f965f92f2369ac10838c99cdd1c54a977ed0e2afcf11801f8b233e62615208406da323dfab2d66
-  data.tar.gz: 5e967876fadc6093232c9c5d2d2a70b835cad1b7e670b61d6667cacd50ab0e5b9632ecb6fa231cb09e5f7826a26c4188911dc6fca3b3a4eb970b3eda22f1a50b
+  metadata.gz: aab4e530a1a74c9a3900cf4347a1d8f01b9dea9551565943c46b5e6367aedf3c25ba0e504fdcffd691a9276a1a902242d46489f4df4dfed02b761b46da06db1c
+  data.tar.gz: b409f247130404652073cd18edaf4e69746ed4a50091ee48f936e964e7993bf45e93738b8cde19aa5fee6eddcae5fb7722f5ac23639bede336dec1303491b644

data/Gemfile

@@ -2,14 +2,14 @@ source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
-activemodel_version = ENV.fetch('ACTIVEMODEL_VERSION', '6.1')
+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'
               end
 
-if activemodel_version < '6.1'
+if activemodel_version < '6.1.0'
   gem 'activemodel', activemodel, require: false
   gem 'activesupport', activemodel, require: false
 end

data/README.md

@@ -8,36 +8,43 @@
 
 Create simple and powerful use cases as objects.
 
-The main goals of this project are:
-1. Be simple to use and easy to learn (input **>>** process/transform **>>** output).
-2. Promove referential transparency (transforming instead of modifying) and data integrity.
-3. No callbacks (before, after, around...).
-4. Solve complex business logic using a composition of use cases.
+The main project goals are:
+1. Be simple to use and easy to learn (input **>>** process / transform **>>** 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).
 
 ## Table of Contents <!-- omit in toc -->
-- [μ-case (Micro::Case)](#%ce%bc-case-microcase)
+- [μ-case (Micro::Case)](#μ-case-microcase)
   - [Required Ruby version](#required-ruby-version)
   - [Dependencies](#dependencies)
   - [Installation](#installation)
   - [Usage](#usage)
-    - [How to define a use case?](#how-to-define-a-use-case)
-    - [What is a `Micro::Case::Result`?](#what-is-a-microcaseresult)
-      - [What are the default `Micro::Case::Result` types?](#what-are-the-default-microcaseresult-types)
+    - [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 on_failure result hook exposes a different kind of data?](#why-the-onfailure-result-hook-exposes-a-different-kind-of-data)
-      - [What happens if a result hook is declared multiple times?](#what-happens-if-a-result-hook-is-declared-multiple-times)
-    - [How to compose uses cases to represents complex ones?](#how-to-compose-uses-cases-to-represents-complex-ones)
+      - [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)
-    - [What is a strict use case?](#what-is-a-strict-use-case)
-    - [Is there some feature to auto handle exceptions inside of a use case or flow?](#is-there-some-feature-to-auto-handle-exceptions-inside-of-a-use-case-or-flow)
-    - [How to validate use case attributes?](#how-to-validate-use-case-attributes)
-      - [If I enable the auto validation, is it possible to disable it only in some specific use case classes?](#if-i-enable-the-auto-validation-is-it-possible-to-disable-it-only-in-some-specific-use-case-classes)
-    - [Examples](#examples)
-  - [Comparisons](#comparisons)
+      - [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)
@@ -70,7 +77,7 @@ Or install it yourself as:
 
 ## Usage
 
-### How to define a use case?
+### `Micro::Case` - How to define a use case?
 
 ```ruby
 class Multiply < Micro::Case
@@ -123,7 +130,7 @@ result.value # 6
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### What is a `Micro::Case::Result`?
+### `Micro::Case::Result` - What is a use case result?
 
 A `Micro::Case::Result` stores the use cases output data. These are their main methods:
 - `#success?` returns true if is a successful result.
@@ -135,7 +142,7 @@ A `Micro::Case::Result` stores the use cases output data. These are their main m
 
 [⬆️ Back to Top](#table-of-contents-)
 
-#### What are the default `Micro::Case::Result` types?
+#### What are the default result types?
 
 Every result has a type and these are the defaults:
 - `:ok` when success
@@ -309,7 +316,7 @@ Double
 # The use case responsible for the failure will be accessible as the second hook argument
 ```
 
-#### Why the on_failure result hook exposes a different kind of data?
+#### Why the failure hook (without a type) exposes a different kind of data?
 
 Answer: To allow you to define how to handle the program flow using some
 conditional statement (like an `if`, `case/when`).
@@ -371,7 +378,7 @@ Double
 
 [⬆️ Back to Top](#table-of-contents-)
 
-#### What happens if a result hook is declared multiple times?
+#### What happens if a result hook was declared multiple times?
 
 Answer: The hook always will be triggered if it matches the result type.
 
@@ -404,7 +411,7 @@ result.value * 4 == accum # true
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### How to compose uses cases to represents complex ones?
+### `Micro::Case::Flow` - How to compose use cases?
 
 In this case, this will be a **flow** (`Micro::Case::Flow`).
 The main idea of this feature is to use/reuse use cases as steps of a new use case.
@@ -466,16 +473,31 @@ p result.value    # {:numbers => [3, 3, 4, 4, 5, 6]}
 # An alternative way to create a flow using classes #
 #---------------------------------------------------#
 
-class DoubleAllNumbers
-  include Micro::Case::Flow
-
-  flow Steps::ConvertTextToNumbers, Steps::Double
+class DoubleAllNumbers < Micro::Case
+  flow Steps::ConvertTextToNumbers,
+       Steps::Double
 end
 
 DoubleAllNumbers
   .call(numbers: %w[1 1 b 2 3 4])
   .on_failure { |message| p message } # "numbers must contain only numeric types"
 
+# !------------------------------------ ! #
+# ! Deprecated: Micro::Case::Flow mixin ! #
+# !-------------------------------------! #
+
+# The code below still works, but it will output a warning message:
+# Deprecation: Micro::Case::Flow mixin is being deprecated, please use `Micro::Case` inheritance instead.
+
+class DoubleAllNumbers
+  include Micro::Case::Flow
+
+  flow Steps::ConvertTextToNumbers,
+       Steps::Double
+end
+
+# Note: This feature will be removed in the next major release (3.0)
+
 #-------------------------------------------------------------#
 # Another way to create a flow using the composition operator #
 #-------------------------------------------------------------#
@@ -574,7 +596,54 @@ Note: You can blend any of the [available syntaxes/approaches](#how-to-create-a-
 
 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.
 
-### What is a strict use case?
+[⬆️ Back to Top](#table-of-contents-)
+
+#### Is it possible to declare a flow using the use case itself?
+
+Answer: Yes, it is! You can use the `self.call!` macro. e.g:
+
+```ruby
+class ConvertTextToNumber < Micro::Case
+  attribute :text
+
+  def call!
+    Success { { number: text.to_i } }
+  end
+end
+
+class ConvertNumberToText < Micro::Case
+  attribute :number
+
+  def call!
+    Success { { text: number.to_s } }
+  end
+end
+
+class Double < Micro::Case
+  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')
+
+result.success? # true
+result.value    # "8"
+
+# NOTE: This feature can be used with the Micro::Case::Safe.
+#       Checkout the test: test/micro/case/safe/flow/with_classes/using_itself_test.rb
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### `Micro::Case::Strict` - What is a strict use case?
 
 Answer: Is a use case which will require all the keywords (attributes) on its initialization.
 
@@ -595,7 +664,7 @@ Double.call({})
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### Is there some feature to auto handle exceptions inside of a use case or flow?
+### `Micro::Case::Safe` - Is there some feature to auto handle exceptions inside of a use case or flow?
 
 Answer: Yes, there is!
 
@@ -655,17 +724,7 @@ end
 # Note:
 # The ampersand is based on the safe navigation operator. https://ruby-doc.org/core-2.6/doc/syntax/calling_methods_rdoc.html#label-Safe+navigation+operator
 
-# The alternatives are:
-
-module Users
-  class Create
-    include Micro::Case::Safe::Flow
-
-    flow ProcessParams, ValidateParams, Persist, SendToCRM
-  end
-end
-
-# or
+# The alternatives to declare a safe flow are:
 
 module Users
   Create = Micro::Case::Safe::Flow([
@@ -675,11 +734,40 @@ module Users
     SendToCRM
   ])
 end
+
+# or within classes
+
+module Users
+  class Create < Micro::Case::Safe
+    flow ProcessParams,
+         ValidateParams,
+         Persist,
+         SendToCRM
+  end
+end
+
+
+# !------------------------------------------ ! #
+# ! Deprecated: Micro::Case::Safe::Flow mixin ! #
+# !-------------------------------------------! #
+
+# The code below still works, but it will output a warning message:
+# Deprecation: Micro::Case::Flow mixin is being deprecated, please use `Micro::Case` inheritance instead.
+
+module Users
+  class Create
+    include Micro::Case::Safe::Flow
+
+    flow ProcessParams, ValidateParams, Persist, SendToCRM
+  end
+end
+
+# Note: This feature will be removed in the next major release (3.0)
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### How to validate use case attributes?
+### `u-case/with_validation` - How to validate use case attributes?
 
 **Requirement:**
 
@@ -730,7 +818,7 @@ end
 # Micro::Case::Strict and Micro::Case::Safe classes will inherit this new behavior.
 ```
 
-#### If I enable the auto validation, is it possible to disable it only in some specific use case classes?
+#### If I enabled the auto validation, is it possible to disable it only in specific use case classes?
 
 Answer: Yes, it is. To do this, you only need to use the `disable_auto_validation` macro. e.g:
 
@@ -757,32 +845,192 @@ Multiply.call(a: 2, b: 'a')
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### 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)
-
-    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)
-
-    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.
-
-[⬆️ Back to Top](#table-of-contents-)
+## Benchmarks
 
-## Comparisons
+### `Micro::Case`
+
+#### Best overall
+
+The table below contains the average between the [Success results](#success-results) and [Failure results](#failure-results) benchmarks.
+
+| Gem / Abstraction      | Iterations per second |       Comparison |
+| ---------------------- | --------------------: | ---------------: |
+| **Micro::Case**        |              116629.7 | _**The Faster**_ |
+| Dry::Monads            |              101796.3 |     1.14x slower |
+| Interactor             |               21230.5 |     5.49x slower |
+| Trailblazer::Operation |               16466.6 |     7.08x slower |
+| Dry::Transaction       |                5069.5 |    23.00x slower |
+
+---
+
+#### 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 |
+
+<details>
+  <summary>Show the full <a href="https://github.com/evanphx/benchmark-ips">benchmark/ips</a> results.</summary>
+
+  ```ruby
+  # Warming up --------------------------------------
+  #           Interactor     2.865k i/100ms
+  # Trailblazer::Operation
+  #                          1.686k i/100ms
+  #          Dry::Monads    13.389k i/100ms
+  #     Dry::Transaction   551.000  i/100ms
+  #          Micro::Case    11.984k i/100ms
+  #  Micro::Case::Strict     9.102k i/100ms
+  #    Micro::Case::Safe    11.747k i/100ms
+  # Calculating -------------------------------------
+  #           Interactor     28.974k (± 2.7%) i/s -    146.115k in   5.046703s
+  # Trailblazer::Operation
+  #                          17.276k (± 1.8%) i/s -     87.672k in   5.076609s
+  #          Dry::Monads    139.353k (± 2.5%) i/s -    709.617k in   5.095599s
+  #     Dry::Transaction      5.572k (± 3.6%) i/s -     28.101k in   5.050376s
+  #          Micro::Case    124.749k (± 1.9%) i/s -    635.152k in   5.093310s
+  #  Micro::Case::Strict     93.417k (± 4.8%) i/s -    473.304k in   5.081341s
+  #    Micro::Case::Safe    120.607k (± 3.2%) i/s -    610.844k in   5.070394s
+
+  # Comparison:
+  #          Dry::Monads:   139352.5 i/s
+  #          Micro::Case:   124749.4 i/s - 1.12x  slower
+  #    Micro::Case::Safe:   120607.3 i/s - 1.16x  slower
+  #  Micro::Case::Strict:    93417.3 i/s - 1.49x  slower
+  #           Interactor:    28974.4 i/s - 4.81x  slower
+  # Trailblazer::Operation:  17275.6 i/s - 8.07x  slower
+  #     Dry::Transaction:     5571.7 i/s - 25.01x  slower
+  ```
+</details>
+
+https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_success_result.rb
+
+#### Failure results
+
+| Gem / Abstraction      | Iterations per second |       Comparison |
+| -----------------      | --------------------: | ---------------: |
+| **Micro::Case**        |              108510.0 | _**The Faster**_ |
+| Dry::Monads            |               64240.1 |     1.69x slower |
+| Trailblazer::Operation |               15657.7 |     6.93x slower |
+| Interactor             |               13486.7 |     8.05x slower |
+| Dry::Transaction       |                4567.3 |    23.76x slower |
+
+<details>
+  <summary>Show the full <a href="https://github.com/evanphx/benchmark-ips">benchmark/ips</a> results.</summary>
+
+  ```ruby
+  # Warming up --------------------------------------
+  #           Interactor     1.331k i/100ms
+  # Trailblazer::Operation
+  #                          1.544k i/100ms
+  #          Dry::Monads     6.343k i/100ms
+  #     Dry::Transaction   456.000  i/100ms
+  #          Micro::Case    10.429k i/100ms
+  #  Micro::Case::Strict     8.109k i/100ms
+  #    Micro::Case::Safe    10.280k i/100ms
+  # Calculating -------------------------------------
+  #           Interactor     13.487k (± 1.9%) i/s -     67.881k in   5.035059s
+  # Trailblazer::Operation
+  #                          15.658k (± 1.6%) i/s -     78.744k in   5.030427s
+  #          Dry::Monads     64.240k (± 1.8%) i/s -    323.493k in   5.037461s
+  #     Dry::Transaction      4.567k (± 1.3%) i/s -     23.256k in   5.092699s
+  #          Micro::Case    108.510k (± 2.3%) i/s -    542.308k in   5.000605s
+  #  Micro::Case::Strict     83.527k (± 1.4%) i/s -    421.668k in   5.049245s
+  #    Micro::Case::Safe    105.641k (± 3.7%) i/s -    534.560k in   5.067836s
+
+  # Comparison:
+  #          Micro::Case:   108510.0 i/s
+  #    Micro::Case::Safe:   105640.6 i/s - same-ish: difference falls within error
+  #  Micro::Case::Strict:    83526.8 i/s - 1.30x  slower
+  #          Dry::Monads:    64240.1 i/s - 1.69x  slower
+  # Trailblazer::Operation:  15657.7 i/s - 6.93x  slower
+  #           Interactor:    13486.7 i/s - 8.05x  slower
+  #     Dry::Transaction:     4567.3 i/s - 23.76x  slower
+  ```
+</details>
+
+https://github.com/serradura/u-case/blob/master/benchmarks/use_case/with_failure_result.rb
+
+---
+
+### `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 |
+
+\* The `Dry::Monads`, `Dry::Transaction`, `Trailblazer::Operation` are out of this analysis because all of them doesn't have this kind of feature.
+
+<details>
+  <summary><strong>Success results</strong> - Show the full benchmark/ips results.</summary>
+
+  ```ruby
+  # Warming up --------------------------------------
+  #   Interactor::Organizer  4.880k i/100ms
+  #       Micro::Case::Flow  7.035k i/100ms
+  # Micro::Case::Safe::Flow  7.059k i/100ms
+
+  # Calculating -------------------------------------
+  #   Interactor::Organizer  50.208k (± 1.3%) i/s -    253.760k in   5.055099s
+  #       Micro::Case::Flow  73.791k (± 0.9%) i/s -    372.855k in   5.053311s
+  # Micro::Case::Safe::Flow  73.314k (± 1.1%) i/s -    367.068k in   5.007473s
+
+  # Comparison:
+  #       Micro::Case::Flow: 73790.7 i/s
+  # Micro::Case::Safe::Flow: 73313.7 i/s - same-ish: difference falls within error
+  #   Interactor::Organizer: 50207.7 i/s - 1.47x  slower
+  ```
+</details>
+
+<details>
+  <summary><strong>Failure results</strong> - Show the full benchmark/ips results.</summary>
+
+  ```ruby
+  # Warming up --------------------------------------
+  #   Interactor::Organizer   2.372k i/100ms
+  #       Micro::Case::Flow   12.802k i/100ms
+  # Micro::Case::Safe::Flow   12.673k i/100ms
+
+  # Calculating -------------------------------------
+  #   Interactor::Organizer   24.522k (± 2.0%) i/s -    123.344k in   5.032159s
+  #       Micro::Case::Flow   135.122k (± 1.7%) i/s -    678.506k in   5.022903s
+  # Micro::Case::Safe::Flow   133.980k (± 1.4%) i/s -    671.669k in   5.014181s
+
+  # Comparison:
+  #       Micro::Case::Flow:   135122.0 i/s
+  # Micro::Case::Safe::Flow:   133979.8 i/s - same-ish: difference falls within error
+  #   Interactor::Organizer:   24521.8 i/s - 5.51x  slower
+  ```
+</details>
+
+https://github.com/serradura/u-case/tree/master/benchmarks/flow
+
+### Comparisons
 
 Check it out implementations of the same use case with different gems/abstractions.
 
 * [interactor](https://github.com/serradura/u-case/blob/master/comparisons/interactor.rb)
 * [u-case](https://github.com/serradura/u-case/blob/master/comparisons/u-case.rb)
 
-## Benchmarks
+[⬆️ Back to Top](#table-of-contents-)
 
-**[interactor](https://github.com/collectiveidea/interactor)** VS **[u-case](https://github.com/serradura/u-case)**
+## Examples
 
-https://github.com/serradura/u-case/tree/master/benchmarks/interactor
+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)
 
-![interactor VS u-case](https://github.com/serradura/u-case/blob/master/assets/u-case_benchmarks.png?raw=true)
+    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)
+
+    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.
+
+[⬆️ Back to Top](#table-of-contents-)
 
 ## Development
 

data/lib/micro/case.rb

@@ -42,14 +42,35 @@ module Micro
       instance
     end
 
-    def self.__failure_type(arg, type)
-      return type if type != :error
+    def self.__get_flow__
+      @__flow
+    end
 
-      case arg
-      when Exception then :exception
-      when Symbol then arg
-      else type
-      end
+    private_class_method def self.__set_flow__(reducer, args)
+      def self.use_cases; __get_flow__.use_cases; end
+
+      self.class_eval('def use_cases; self.class.use_cases; end')
+
+      reducer.build(args)
+    end
+
+    def self.flow(*args)
+      @__flow ||= __set_flow__(Flow::Reducer, args)
+    end
+
+    def self.call!
+      return const_get(:Flow_Step) if const_defined?(:Flow_Step)
+
+      const_set(:Flow_Step, Class.new(self) do
+        private def __call
+          __call_use_case
+        end
+      end)
+    end
+
+    def initialize(input)
+      @__input = input
+      self.attributes = input
     end
 
     def call!
@@ -70,6 +91,12 @@ module Micro
     private
 
       def __call
+        return self.class.__get_flow__.call(@__input) if self.class.__get_flow__
+
+        __call_use_case
+      end
+
+      def __call_use_case
         result = call!
 
         return result if result.is_a?(Result)
@@ -77,10 +104,6 @@ module Micro
         raise Error::UnexpectedResult.new(self.class)
       end
 
-      def __get_result__
-        @__result ||= Result.new
-      end
-
       def Success(arg = :ok)
         value, type = block_given? ? [yield, arg] : [arg, :ok]
 
@@ -89,9 +112,21 @@ module Micro
 
       def Failure(arg = :error)
         value = block_given? ? yield : arg
-        type = self.class.__failure_type(value, block_given? ? arg : :error)
+        type = __map_failure_type(value, block_given? ? arg : :error)
 
         __get_result__.__set__(false, value, type, self)
       end
+
+      def __get_result__
+        @__result ||= Result.new
+      end
+
+      def __map_failure_type(arg, type)
+        return type if type != :error
+        return arg if arg.is_a?(Symbol)
+        return :exception if arg.is_a?(Exception)
+
+        type
+      end
   end
 end

data/lib/micro/case/flow.rb

@@ -29,7 +29,10 @@ module Micro
 
       private_constant :ClassMethods, :CONSTRUCTOR
 
+      # Deprecated: Classes with flows are now defined via `Micro::Case` inheritance
       def self.included(base)
+        warn 'Deprecation: Micro::Case::Flow mixin is being deprecated, please use `Micro::Case` inheritance instead.'
+
         def base.flow_reducer; Reducer; end
 
         base.extend(ClassMethods)

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

@@ -35,6 +35,10 @@ module Micro
       def self.Flow(args)
         Flow::Reducer.build(Array(args))
       end
+
+      def self.flow(*args)
+        @__flow ||= __set_flow__(Flow::Reducer, args)
+      end
     end
   end
 end

data/lib/micro/case/version.rb

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

data/lib/micro/case/with_validation.rb

@@ -14,6 +14,12 @@ module Micro
       @disable_auto_validation = true
     end
 
+    def initialize(input)
+      @__input = input
+      self.attributes = input
+      run_validations! if respond_to?(:run_validations!, true)
+    end
+
     def call
       return failure_by_validation_error(self) if !self.class.auto_validation_disabled? && invalid?
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-case
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-19 00:00:00.000000000 Z
+date: 2019-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: u-attributes