u-case 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ba53faeaf465b491f94a686da7fc2537e9c50108b18162d11c473246e6a531e
-  data.tar.gz: 6b91c842ad57b917678649f4003f34ade8459a70c56938d2e226a4d8322e855d
+  metadata.gz: e4b75e85c821351da3ee8298a9c9d97980be292488746a25a48510d6ad43b1d5
+  data.tar.gz: e8bd964807111d6895f113e0951d0d2c643664110646f433edb35883e0d585a9
 SHA512:
-  metadata.gz: 8d4790abfb49211a69d9874900e83a0237d5fe0f0b288102e9bcff33fd932db4192e66ea2e5814990da2d5e92b5499dd93173257433639e2248463f2b3c991e8
-  data.tar.gz: e2bd4e73018961d931a76298dacf8000836d26f2331f975b777bc0371dcfe84d2064a51ef12636f31eaf22986a76b97f99e7cbe16b653a1bd1923ae5f8f4f125
+  metadata.gz: 7395bdc572be3cce61d7358333e2bade896e9c240012c443e6015f02bae8022cad7d90323866b0229341729375ff63d381860418fcd2cac3a0f6608669fe59c5
+  data.tar.gz: 448b78286a29b60ae3bf79f7786011572bbb39cd5f9cf2091f32be7b8d1017b7e8973c2bea1e0a1d1f9c65c5e96c764261d1a3b9d7584b765ea937aca998291b

data/.tool-versions

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

data/README.md

@@ -18,7 +18,7 @@ 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)
+- [μ-case (Micro::Case)](#μ-case-microcase)
   - [Required Ruby version](#required-ruby-version)
   - [Dependencies](#dependencies)
   - [Installation](#installation)
@@ -31,13 +31,14 @@ The main project goals are:
       - [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-casewithvalidation---how-to-validate-use-case-attributes)
+    - [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)
@@ -47,10 +48,10 @@ The main project goals are:
     - [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)
+    - [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)
@@ -145,6 +146,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 +417,48 @@ accum # 24
 result.value * 4 == accum # true
 ```
 
+#### How to use the `Micro::Case::Result#then` method?
+
+```ruby
+class ForbidNegativeNumber < Micro::Case
+  attribute :number
+
+  def call!
+    return Success { attributes } if number >= 0
+
+    Failure { attributes }
+  end
+end
+
+class Add3 < Micro::Case
+  attribute :number
+
+  def call!
+    Success { { number: number + 3 } }
+  end
+end
+
+result1 =
+  ForbidNegativeNumber
+    .call(number: -1)
+    .then(Add3)
+
+result1.type     # :error
+result1.value    # {'number' => -1}
+result1.failure? # true
+
+# ---
+
+result2 =
+  ForbidNegativeNumber
+    .call(number: 1)
+    .then(Add3)
+
+result2.type     # :ok
+result2.value    # {'number' => 4}
+result2.success? # true
+```
+
 [⬆️ Back to Top](#table-of-contents-)
 
 ### `Micro::Case::Flow` - How to compose use cases?

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/result.rb

@@ -52,6 +52,25 @@ module Micro
         self.tap { yield(data, @use_case) }
       end
 
+      def then(arg = 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?
+
+          arg.call(self.value)
+        end
+      end
+
       private
 
         def success_type?(expected_type)

data/lib/micro/case/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-case
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-12 00:00:00.000000000 Z
+date: 2019-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: u-attributes
@@ -103,7 +103,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.