u-service 0.14.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a511f12c5bc76025f0156c65d934988065f1c51c0d540b67a2cf2f4dcde48f22
-  data.tar.gz: 12489e03b009e02bef85329051952f50866c06f0d585812e55146569b4d535ad
+  metadata.gz: d75c44a6cbf48201cc58937ce39118ddba4af411cccdb6c9c930e4bcac80b451
+  data.tar.gz: 343e21ab69a17bb3cc392bb4ae9ec16ae55e0af73313ccbf376f4381371aed81
 SHA512:
-  metadata.gz: '0811b8d7893d0cb810345a582b3bb2c2a1dd2c0a21753e512212b9445e6f42bcab601e55ee1b683f2477ec72fa6ee690b741d23f105ffe63d1758dffa66fed50'
-  data.tar.gz: 950935aee3330a885206a85333894c2d27886bb1373ac7151efc95dbb9cdacc1ebe489967dafb1cca0351473460f0122e3d2cbbcea9ca52ea6836995a85de241
+  metadata.gz: 66447860551389fba8b39affaee2dbfc60734143227b3dc932932ffddf98b427d97fd596b03eeb22039a854f8c73b93bc2753cd94eba2c8a38f38aac4b94c779
+  data.tar.gz: b08c8959f292ae0e06602738410432aa1f4408abe2dcc9c6174d791e69a2b2171e14f51e6c7757b81ecd4389b88e5f5aa440c6ee0246a2ad0a06909a0497fd27

data/README.md

@@ -9,21 +9,30 @@
 Create simple and powerful service objects.
 
 The main goals of this project are:
-1. The smallest possible learning curve.
+1. The smallest possible learning curve (input **>>** process/transform **>>** output).
 2. Referential transparency and data integrity.
-3. No callbacks, compose a pipeline of service objects to represents complex business logic. (input >> process/transform >> output)
+3. No callbacks.
+4. Compose a pipeline of service objects to represents complex business logic.
 
+## Table of Contents
 - [μ-service (Micro::Service)](#%ce%bc-service-microservice)
+  - [Table of Contents](#table-of-contents)
   - [Required Ruby version](#required-ruby-version)
   - [Installation](#installation)
   - [Usage](#usage)
-    - [How to create a Service Object?](#how-to-create-a-service-object)
-    - [How to use the result hooks?](#how-to-use-the-result-hooks)
+    - [How to define a Service Object?](#how-to-define-a-service-object)
+    - [What is a `Micro::Service::Result`?](#what-is-a-microserviceresult)
+      - [What are the default types of a `Micro::Service::Result`?](#what-are-the-default-types-of-a-microserviceresult)
+      - [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)
+        - [What happens if a hook is declared multiple times?](#what-happens-if-a-hook-is-declared-multiple-times)
     - [How to create a pipeline of Service Objects?](#how-to-create-a-pipeline-of-service-objects)
+      - [Is it possible to compose pipelines with other pipelines?](#is-it-possible-to-compose-pipelines-with-other-pipelines)
     - [What is a strict Service Object?](#what-is-a-strict-service-object)
+    - [Is there some feature to auto handle exceptions inside of services/pipelines?](#is-there-some-feature-to-auto-handle-exceptions-inside-of-servicespipelines)
     - [How to validate Service Object attributes?](#how-to-validate-service-object-attributes)
-    - [It's possible to compose pipelines with other pipelines?](#its-possible-to-compose-pipelines-with-other-pipelines)
-  - [Examples](#examples)
+    - [Examples](#examples)
   - [Comparisons](#comparisons)
   - [Benchmarks](#benchmarks)
   - [Development](#development)
@@ -53,55 +62,196 @@ Or install it yourself as:
 
 ## Usage
 
-### How to create a Service Object?
+### How to define a Service Object?
 
 ```ruby
 class Multiply < Micro::Service::Base
+  # 1. Define its inputs as attributes
   attributes :a, :b
 
+  # 2. Define the method `call!` with its business logic
   def call!
+
+    # 3. Return the calling result using the `Success()` and `Failure()` methods
     if a.is_a?(Numeric) && b.is_a?(Numeric)
       Success(a * b)
     else
-      Failure(:invalid_data)
+      Failure { '`a` and `b` attributes must be numeric' }
     end
   end
 end
 
-#====================#
-# Calling a service  #
-#====================#
+#================================#
+# Calling a Service Object class #
+#================================#
+
+# Success result
 
 result = Multiply.call(a: 2, b: 2)
 
-p result.success? # true
-p result.value    # 4
+result.success? # true
+result.value    # 4
+
+# Failure result
+
+bad_result = Multiply.call(a: 2, b: '2')
+
+bad_result.failure? # true
+bad_result.value    # "`a` and `b` attributes must be numeric"
+
+#-----------------------------------#
+# Calling a Service Object instance #
+#-----------------------------------#
+
+result = Multiply.new(a: 2, b: 3).call
+
+result.value # 6
 
 # Note:
-# The result of a Micro::Service#call
+# ----
+# The result of a Micro::Service::Base.call
 # is an instance of Micro::Service::Result
+```
 
-#----------------------------#
-# Calling a service instance #
-#----------------------------#
+[⬆️ Back to Top](#table-of-contents)
 
-result = Multiply.new(a: 2, b: 3).call
+### What is a `Micro::Service::Result`?
 
-p result.success? # true
-p result.value    # 6
+A `Micro::Service::Result` carries the output data of some Service Object. These are their main methods:
+- `#success?` returns true if is a successful result.
+- `#failure?` returns true if is an unsuccessful result.
+- `#value` the result value itself.
+- `#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 which help you define the flow of your application.
+- `#service` if the result is a failure the service will be accessible through this method. This feature is handy to use with pipeline failures (this topic will be covered ahead).
+
+[⬆️ Back to Top](#table-of-contents)
+
+#### What are the default types of a `Micro::Service::Result`?
+
+Every result has a type and these are the default values: :ok when success, and :error/:exception when failures.
+
+```ruby
+class Divide < Micro::Service::Base
+  attributes :a, :b
+
+  def call!
+    invalid_attributes.empty? ? Success(a / b) : Failure(invalid_attributes)
+  rescue => e
+    Failure(e)
+  end
+
+  private def invalid_attributes
+    attributes.select { |_key, value| !value.is_a?(Numeric) }
+  end
+end
+
+# Success result
+
+result = Divide.call(a: 2, b: 2)
+
+result.type     # :ok
+result.value    # 1
+result.success? # true
+result.service  # raises `Micro::Service::Error::InvalidAccessToTheServiceObject: only a failure result can access its service object`
+
+# Failure result - type == :error
+
+bad_result = Divide.call(a: 2, b: '2')
+
+bad_result.type     # :error
+bad_result.value    # {"b"=>"2"}
+bad_result.failure? # true
+bad_result.service  # #<Divide:0x0000 @__attributes={"a"=>2, "b"=>"2"}, @a=2, @b="2", @__result=#<Micro::Service::Result:0x0000 @service=#<Divide:0x0000 ...>, @type=:error, @value={"b"=>"2"}, @success=false>>
+
+# Failure result - type == :exception
+
+err_result = Divide.call(a: 2, b: 0)
+
+err_result.type     # :exception
+err_result.value    # <ZeroDivisionError: divided by 0>
+err_result.failure? # true
+err_result.service  # #<Divide:0x0000 @__attributes={"a"=>2, "b"=>0}, @a=2, @b=0, @__result=#<Micro::Service::Result:0x0000 @service=#<Divide:0x0000 ...>, @type=:exception, @value=#<ZeroDivisionError: divided by 0>, @success=false>>
+
+# Note:
+# ----
+# Any Exception instance which is wrapped by
+# the Failure() method will receive `:exception` instead of the `:error` type.
+```
+
+[⬆️ Back to Top](#table-of-contents)
+
+#### How to define custom result types?
+
+Answer: Use a symbol as the argument of Success() and Failure() methods and declare a block to set the value.
+
+```ruby
+class Multiply < Micro::Service::Base
+  attributes :a, :b
+
+  def call!
+    return Success(a * b) if a.is_a?(Numeric) && b.is_a?(Numeric)
+
+    Failure(:invalid_data) do
+      attributes.reject { |_, input| input.is_a?(Numeric) }
+    end
+  end
+end
+
+# Success result
+
+result = Multiply.call(a: 3, b: 2)
+
+result.type     # :ok
+result.value    # 6
+result.success? # true
+
+# Failure result
+
+bad_result = Multiply.call(a: 3, b: '2')
+
+bad_result.type     # :invalid_data
+bad_result.value    # {"b"=>"2"}
+bad_result.failure? # true
+```
+
+[⬆️ Back to Top](#table-of-contents)
+
+##### Is it possible to define a custom result type without a block?
+
+Answer: Yes, it is. But only for failure results!
+
+```ruby
+class Multiply < Micro::Service::Base
+  attributes :a, :b
 
-#===========================#
-# Verify the result failure #
-#===========================#
+  def call!
+    return Failure(:invalid_data) unless a.is_a?(Numeric) && b.is_a?(Numeric)
+
+    Success(a * b)
+  end
+end
+
+result = Multiply.call(a: 2, b: '2')
 
-result = Multiply.call(a: '2', b: 2)
+result.failure?           #true
+result.value              #:invalid_data
+result.type               #:invalid_data
+result.service.attributes # {"a"=>2, "b"=>"2"}
 
-p result.success? # false
-p result.failure? # true
-p result.value    # :invalid_data
+# Note:
+# ----
+# This feature is handy to respond to some pipeline failure
+# (this topic will be covered ahead).
 ```
 
-### How to use the result hooks?
+[⬆️ Back to Top](#table-of-contents)
+
+#### How to use the result hooks?
+
+As mentioned earlier, the `Micro::Service::Result` has two methods to improve the flow control. They are: `#on_success`, `on_failure`.
+
+The examples below show how to use them:
 
 ```ruby
 class Double < Micro::Service::Base
@@ -125,8 +275,8 @@ Double
   .on_failure(:invalid) { |msg| raise TypeError, msg }
   .on_failure(:lte_zero) { |msg| raise ArgumentError, msg }
 
-# The output when is a success:
-# 6
+# The output because is a success:
+#   6
 
 #=============================#
 # Raising an error if failure #
@@ -135,13 +285,55 @@ Double
 Double
   .call(number: -1)
   .on_success { |number| p number }
+  .on_failure { |_msg, service| puts "#{service.class.name} was the service responsible for the failure" }
   .on_failure(:invalid) { |msg| raise TypeError, msg }
   .on_failure(:lte_zero) { |msg| raise ArgumentError, msg }
 
-# The output (raised an error) when is a failure:
-# ArgumentError (the number must be greater than 0)
+# The outputs because is a failure:
+#   Double was the service responsible for the failure
+# (throws the error)
+#   ArgumentError (the number must be greater than 0)
+
+# Note:
+# ----
+# The service responsible for the failure will be accessible as the second hook argument
 ```
 
+[⬆️ Back to Top](#table-of-contents)
+
+##### What happens if a hook is declared multiple times?
+
+Answer: The hook will be triggered if it matches the result type.
+
+```ruby
+class Double < Micro::Service::Base
+  attributes :number
+
+  def call!
+    return Failure(:invalid) { 'the number must be a numeric value' } unless number.is_a?(Numeric)
+
+    Success(:computed) { number * 2 }
+  end
+end
+
+result = Double.call(number: 3)
+result.value     # 6
+result.value * 4 # 24
+
+accum = 0
+
+result.on_success { |number| accum += number }
+      .on_success { |number| accum += number }
+      .on_success(:computed) { |number| accum += number }
+      .on_success(:computed) { |number| accum += number }
+
+accum # 24
+
+result.value * 4 == accum # true
+```
+
+[⬆️ Back to Top](#table-of-contents)
+
 ### How to create a pipeline of Service Objects?
 
 ```ruby
@@ -222,11 +414,10 @@ SquareAllNumbers
   .call(numbers: %w[1 1 2 2 3 4])
   .on_success { |value| p value[:numbers] } # [1, 1, 4, 4, 9, 16]
 
-#=================================================================#
-# Attention:                                                      #
-# When happening a failure, the service object responsible for it #
-# will be accessible in the result                                #
-#=================================================================#
+# Note:
+# ----
+# When happening a failure, the service object responsible for this
+# will be accessible in the result
 
 result = SquareAllNumbers.call(numbers: %w[1 1 b 2 3 4])
 
@@ -234,13 +425,81 @@ result.failure?                               # true
 result.service.is_a?(Steps::ConvertToNumbers) # true
 
 result.on_failure do |_message, service|
-  puts "#{service.class.name} was the service responsible by the failure" } # Steps::ConvertToNumbers was the service responsible by the failure
+  puts "#{service.class.name} was the service responsible for the failure" } # Steps::ConvertToNumbers was the service responsible for the failure
 end
 ```
 
+[⬆️ Back to Top](#table-of-contents)
+
+#### Is it possible to compose pipelines with other pipelines?
+
+Answer: Yes, it is.
+
+```ruby
+module Steps
+  class ConvertToNumbers < Micro::Service::Base
+    attribute :numbers
+
+    def call!
+      if numbers.all? { |value| String(value) =~ /\d+/ }
+        Success(numbers: numbers.map(&:to_i))
+      else
+        Failure('numbers must contain only numeric types')
+      end
+    end
+  end
+
+  class Add2 < Micro::Service::Strict
+    attribute :numbers
+
+    def call!
+      Success(numbers: numbers.map { |number| number + 2 })
+    end
+  end
+
+  class Double < Micro::Service::Strict
+    attribute :numbers
+
+    def call!
+      Success(numbers: numbers.map { |number| number * 2 })
+    end
+  end
+
+  class Square < Micro::Service::Strict
+    attribute :numbers
+
+    def call!
+      Success(numbers: numbers.map { |number| number * number })
+    end
+  end
+end
+
+Add2ToAllNumbers = Steps::ConvertToNumbers >> Steps::Add2
+DoubleAllNumbers = Steps::ConvertToNumbers >> Steps::Double
+SquareAllNumbers = Steps::ConvertToNumbers >> Steps::Square
+
+DoubleAllNumbersAndAdd2 = DoubleAllNumbers >> Steps::Add2
+SquareAllNumbersAndAdd2 = SquareAllNumbers >> Steps::Add2
+
+SquareAllNumbersAndDouble = SquareAllNumbersAndAdd2 >> DoubleAllNumbers
+DoubleAllNumbersAndSquareAndAdd2 = DoubleAllNumbers >> SquareAllNumbersAndAdd2
+
+SquareAllNumbersAndDouble
+  .call(numbers: %w[1 1 2 2 3 4])
+  .on_success { |value| p value[:numbers] } # [6, 6, 12, 12, 22, 36]
+
+DoubleAllNumbersAndSquareAndAdd2
+  .call(numbers: %w[1 1 2 2 3 4])
+  .on_success { |value| p value[:numbers] } # [6, 6, 18, 18, 38, 66]
+```
+
+Note: You can blend any of the [syntaxes/approaches to create the pipelines](#how-to-create-a-pipeline-of-service-objects)) - [examples](https://github.com/serradura/u-service/blob/master/test/micro/service/pipeline/blend_test.rb#L7-L34).
+
+[⬆️ Back to Top](#table-of-contents)
+
 ### What is a strict Service Object?
 
-A: Is a service object which will require all keywords (attributes) on its initialization.
+Answer: Is a service object which will require all keywords (attributes) on its initialization.
 
 ```ruby
 class Double < Micro::Service::Strict
@@ -257,9 +516,97 @@ Double.call({})
 # ArgumentError (missing keyword: :numbers)
 ```
 
+[⬆️ Back to Top](#table-of-contents)
+
+### Is there some feature to auto handle exceptions inside of services/pipelines?
+
+Answer: Yes, there is!
+
+**Service Objects:**
+
+Like `Micro::Service::Strict` the `Micro::Service::Safe` is another special kind of Service object. It has the ability to auto wrap an exception into a failure result. e.g:
+
+```ruby
+require 'logger'
+
+AppLogger = Logger.new(STDOUT)
+
+class Divide < Micro::Service::Safe
+  attributes :a, :b
+
+  def call!
+    return Success(a / b) if a.is_a?(Integer) && b.is_a?(Integer)
+    Failure(:not_an_integer)
+  end
+end
+
+result = Divide.call(a: 2, b: 0)
+result.type == :exception             # true
+result.value.is_a?(ZeroDivisionError) # true
+
+result.on_failure(:exception) do |exception|
+  AppLogger.error(exception.message) # E, [2019-08-21T00:05:44.195506 #9532] ERROR -- : divided by 0
+end
+
+# Note:
+# ----
+# If you need a specific error handling,
+# I recommend the usage of a case statement. e,g:
+
+result.on_failure(:exception) do |exception, service|
+  case exception
+  when ZeroDivisionError then AppLogger.error(exception.message)
+  else AppLogger.debug("#{service.class.name} was the service responsible for the exception")
+  end
+end
+
+# Another note:
+# ------------
+# It is possible to rescue an exception even when is a safe service.
+# Examples: https://github.com/serradura/u-service/blob/a6d0a8aa5d28d1f062484eaa0d5a17c4fb08b6fb/test/micro/service/safe_test.rb#L95-L123
+```
+
+**Pipelines:**
+
+As the safe services, safe pipelines have the ability to intercept an exception in any of its steps. These are the ways to define one:
+
+```ruby
+module Users
+  Create = ProcessParams & ValidateParams & Persist & SendToCRM
+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::Service::Pipeline::Safe
+
+    pipeline ProcessParams, ValidateParams, Persist, SendToCRM
+  end
+end
+
+# or
+
+module Users
+  Create = Micro::Service::Pipeline::Safe[
+    ProcessParams,
+    ValidateParams,
+    Persist,
+    SendToCRM
+  ]
+end
+```
+
+[⬆️ Back to Top](#table-of-contents)
+
 ### How to validate Service Object attributes?
 
-Note: To do this your application must have the [activemodel >= 3.2](https://rubygems.org/gems/activemodel) as a dependency.
+**Requirement:**
+
+To do this your application must have the [activemodel >= 3.2](https://rubygems.org/gems/activemodel) as a dependency.
 
 ```ruby
 #
@@ -272,7 +619,7 @@ class Multiply < Micro::Service::Base
   validates :a, :b, presence: true, numericality: true
 
   def call!
-    return Failure(errors: self.errors) unless valid?
+    return Failure(:validation_error) { self.errors } unless valid?
 
     Success(number: a * b)
   end
@@ -287,7 +634,7 @@ end
 require 'micro/service/with_validation' # or require 'u-service/with_validation'
 
 # In the Gemfile
-gem 'u-service', '~> 0.12.0', require: 'u-service/with_validation'
+gem 'u-service', require: 'u-service/with_validation'
 
 # Using this approach, you can rewrite the previous sample with fewer lines of code.
 
@@ -302,73 +649,14 @@ class Multiply < Micro::Service::Base
 end
 
 # Note:
+# ----
 # After requiring the validation mode, the
-# Micro::Service::Strict classes will inherit this new behavior.
+# Micro::Service::Strict and Micro::Service::Safe classes will inherit this new behavior.
 ```
 
-### It's possible to compose pipelines with other pipelines?
+[⬆️ Back to Top](#table-of-contents)
 
-Answer: Yes
-
-```ruby
-module Steps
-  class ConvertToNumbers < Micro::Service::Base
-    attribute :numbers
-
-    def call!
-      if numbers.all? { |value| String(value) =~ /\d+/ }
-        Success(numbers: numbers.map(&:to_i))
-      else
-        Failure('numbers must contain only numeric types')
-      end
-    end
-  end
-
-  class Add2 < Micro::Service::Strict
-    attribute :numbers
-
-    def call!
-      Success(numbers: numbers.map { |number| number + 2 })
-    end
-  end
-
-  class Double < Micro::Service::Strict
-    attribute :numbers
-
-    def call!
-      Success(numbers: numbers.map { |number| number * 2 })
-    end
-  end
-
-  class Square < Micro::Service::Strict
-    attribute :numbers
-
-    def call!
-      Success(numbers: numbers.map { |number| number * number })
-    end
-  end
-end
-
-Add2ToAllNumbers = Steps::ConvertToNumbers >> Steps::Add2
-DoubleAllNumbers = Steps::ConvertToNumbers >> Steps::Double
-SquareAllNumbers = Steps::ConvertToNumbers >> Steps::Square
-DoubleAllNumbersAndAdd2 = DoubleAllNumbers >> Steps::Add2
-SquareAllNumbersAndAdd2 = SquareAllNumbers >> Steps::Add2
-SquareAllNumbersAndDouble = SquareAllNumbersAndAdd2 >> DoubleAllNumbers
-DoubleAllNumbersAndSquareAndAdd2 = DoubleAllNumbers >> SquareAllNumbersAndAdd2
-
-SquareAllNumbersAndDouble
-  .call(numbers: %w[1 1 2 2 3 4])
-  .on_success { |value| p value[:numbers] } # [6, 6, 12, 12, 22, 36]
-
-DoubleAllNumbersAndSquareAndAdd2
-  .call(numbers: %w[1 1 2 2 3 4])
-  .on_success { |value| p value[:numbers] } # [6, 6, 18, 18, 38, 66]
-```
-
-Note: You can blend any of the [syntaxes/approaches to create the pipelines](#how-to-create-a-pipeline-of-service-objects)) - [examples](https://github.com/serradura/u-service/blob/master/test/micro/service/pipeline/blend_test.rb#L7-L34).
-
-## Examples
+### Examples
 
 1. [Rescuing an exception inside of service objects](https://github.com/serradura/u-service/blob/master/examples/rescuing_exceptions.rb)
 2. [Users creation](https://github.com/serradura/u-service/blob/master/examples/users_creation.rb)
@@ -378,6 +666,8 @@ Note: You can blend any of the [syntaxes/approaches to create the pipelines](#ho
 
     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 app flow.
 
+[⬆️ Back to Top](#table-of-contents)
+
 ## Comparisons
 
 Check it out implementations of the same use case with different libs (abstractions).

data/lib/micro/service.rb

@@ -3,8 +3,10 @@
 require 'micro/attributes'
 
 require 'micro/service/version'
-
+require 'micro/service/error'
 require 'micro/service/result'
 require 'micro/service/base'
+require 'micro/service/safe'
 require 'micro/service/strict'
+require 'micro/service/pipeline/reducer'
 require 'micro/service/pipeline'

data/lib/micro/service/base.rb

@@ -5,14 +5,16 @@ module Micro
     class Base
       include Micro::Attributes.without(:strict_initialize)
 
-      UNEXPECTED_RESULT = '#call! must return an instance of Micro::Service::Result'.freeze
-      InvalidResultInstance = ArgumentError.new('argument must be an instance of Micro::Service::Result'.freeze)
-      ResultIsAlreadyDefined = ArgumentError.new('result is already defined'.freeze)
-
-      private_constant :UNEXPECTED_RESULT, :ResultIsAlreadyDefined, :InvalidResultInstance
+      def self.to_proc
+        Proc.new { |arg| call(arg) }
+      end
 
       def self.>>(service)
-        Micro::Service::Pipeline[self, service]
+        Pipeline[self, service]
+      end
+
+      def self.&(service)
+        Pipeline::Safe[self, service]
       end
 
       def self.call(options = {})
@@ -20,12 +22,21 @@ module Micro
       end
 
       def self.__new__(result, arg)
-        instance = allocate
+        instance = new(arg)
         instance.__set_result__(result)
-        instance.send(:initialize, arg)
         instance
       end
 
+      def self.__failure_type(arg, type)
+        return type if type != :error
+
+        case arg
+        when Exception then :exception
+        when Symbol then arg
+        else type
+        end
+      end
+
       def call!
         raise NotImplementedError
       end
@@ -35,8 +46,8 @@ module Micro
       end
 
       def __set_result__(result)
-        raise InvalidResultInstance unless result.is_a?(Result)
-        raise ResultIsAlreadyDefined if @__result
+        raise Error::InvalidResultInstance unless result.is_a?(Result)
+        raise Error::ResultIsAlreadyDefined if @__result
         @__result = result
       end
 
@@ -44,8 +55,8 @@ module Micro
 
         def __call
           result = call!
-          return result if result.is_a?(Service::Result)
-          raise TypeError, self.class.name + UNEXPECTED_RESULT
+          return result if result.is_a?(Result)
+          raise Error::UnexpectedResult.new(self.class)
         end
 
         def __get_result__
@@ -58,7 +69,8 @@ module Micro
         end
 
         def Failure(arg = :error)
-          value, type = block_given? ? [yield, arg] : [arg, :error]
+          value = block_given? ? yield : arg
+          type = self.class.__failure_type(value, block_given? ? arg : :error)
           __get_result__.__set__(false, value, type, self)
         end
     end

data/lib/micro/service/error.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Micro
+  module Service
+    module Error
+      class UnexpectedResult < TypeError
+        MESSAGE = '#call! must return an instance of Micro::Service::Result'.freeze
+
+        def initialize(klass); super(klass.name + MESSAGE); end
+      end
+
+      ResultIsAlreadyDefined = ArgumentError.new('result is already defined'.freeze)
+
+      InvalidResultType = TypeError.new('type must be a Symbol'.freeze)
+      InvalidResultInstance = ArgumentError.new('argument must be an instance of Micro::Service::Result'.freeze)
+
+      InvalidService = TypeError.new('service must be a kind or an instance of Micro::Service::Base'.freeze)
+      InvalidServices = ArgumentError.new('argument must be a collection of `Micro::Service::Base` classes'.freeze)
+
+      UndefinedPipeline = ArgumentError.new("This class hasn't declared its pipeline. Please, use the `pipeline()` macro to define one.".freeze)
+
+      class InvalidAccessToTheServiceObject < StandardError
+        MSG = 'only a failure result can access its service object'.freeze
+
+        def initialize(message = MSG); super; end
+      end
+
+      module ByWrongUsage
+        def self.check(exception)
+          exception.is_a?(Error::UnexpectedResult) || exception.is_a?(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/lib/micro/service/pipeline.rb

@@ -3,65 +3,13 @@
 module Micro
   module Service
     module Pipeline
-      class Reducer
-        attr_reader :services
-
-        InvalidServices = ArgumentError.new('argument must be a collection of `Micro::Service::Base` classes'.freeze)
-
-        private_constant :InvalidServices
-
-        def self.map_services(arg)
-          return arg.services if arg.is_a?(Reducer)
-          return arg.__pipeline__.services if arg.is_a?(Class) && arg < Micro::Service::Pipeline
-          Array(arg)
-        end
-
-        def self.build(args)
-          services = Array(args).flat_map { |arg| map_services(arg) }
-
-          raise InvalidServices if services.any? { |klass| !(klass < ::Micro::Service::Base) }
-
-          new(services)
-        end
-
-        def initialize(services)
-          @services = services
-        end
-
-        def call(arg = {})
-          @services.reduce(initial_result(arg)) do |result, service|
-            break result if result.failure?
-            service.__new__(result, result.value).call
-          end
-        end
-
-        def >>(arg)
-          Reducer.build(services + self.class.map_services(arg))
-        end
-
-        private
-
-          def initial_result(arg)
-            return arg.call if arg_to_call?(arg)
-            return arg if arg.is_a?(Micro::Service::Result)
-            result = Micro::Service::Result.new
-            result.__set__(true, arg, :ok, nil)
-          end
-
-          def arg_to_call?(arg)
-            return true if arg.is_a?(Micro::Service::Base) || arg.is_a?(Reducer)
-            return true if arg.is_a?(Class) && (arg < Micro::Service::Base || arg < Micro::Service::Pipeline)
-            return false
-          end
-      end
-
       module ClassMethods
         def __pipeline__
           @__pipeline
         end
 
         def pipeline(*args)
-          @__pipeline = Reducer.build(args)
+          @__pipeline = pipeline_reducer.build(args)
         end
 
         def call(options = {})
@@ -69,30 +17,40 @@ module Micro
         end
       end
 
-      private_constant :ClassMethods
-
-      def self.[](*args)
-        Reducer.build(args)
+      CONSTRUCTOR = <<-RUBY
+      def initialize(options)
+        @options = options
+        pipeline = self.class.__pipeline__
+        raise Error::UndefinedPipeline unless pipeline
       end
+      RUBY
 
-      UndefinedPipeline = ArgumentError.new("This class hasn't declared its pipeline. Please, use the `pipeline()` macro to define one.".freeze)
-
-      private_constant :UndefinedPipeline
+      private_constant :ClassMethods, :CONSTRUCTOR
 
       def self.included(base)
+        def base.pipeline_reducer; Reducer; end
         base.extend(ClassMethods)
-        base.class_eval(<<-RUBY)
-        def initialize(options)
-          @options = options
-          pipeline = self.class.__pipeline__
-          raise UndefinedPipeline unless pipeline
-        end
-        RUBY
+        base.class_eval(CONSTRUCTOR)
+      end
+
+      def self.[](*args)
+        Reducer.build(args)
       end
 
       def call
         self.class.__pipeline__.call(@options)
       end
+
+      module Safe
+        def self.included(base)
+          base.send(:include, Micro::Service::Pipeline)
+          def base.pipeline_reducer; SafeReducer; end
+        end
+
+        def self.[](*args)
+          SafeReducer.build(args)
+        end
+      end
     end
   end
 end

data/lib/micro/service/pipeline/reducer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Micro
+  module Service
+    module Pipeline
+      class Reducer
+        attr_reader :services
+        def self.map_services(arg)
+          return arg.services if arg.is_a?(Reducer)
+          return arg.__pipeline__.services if arg.is_a?(Class) && arg < Micro::Service::Pipeline
+          Array(arg)
+        end
+
+        def self.build(args)
+          services = Array(args).flat_map { |arg| map_services(arg) }
+
+          raise Error::InvalidServices if services.any? { |klass| !(klass < ::Micro::Service::Base) }
+
+          new(services)
+        end
+
+        def initialize(services)
+          @services = services
+        end
+
+        def call(arg = {})
+          @services.reduce(initial_result(arg)) do |result, service|
+            break result if result.failure?
+            service.__new__(result, result.value).call
+          end
+        end
+
+        def >>(arg)
+          self.class.build(services + self.class.map_services(arg))
+        end
+
+        def &(arg)
+          raise NoMethodError, "undefined method `&' for #{self.inspect}. Please, use the method `>>' to avoid this error."
+        end
+
+        def to_proc
+          Proc.new { |arg| call(arg) }
+        end
+
+        private
+
+          def initial_result(arg)
+            return arg.call if arg_to_call?(arg)
+            return arg if arg.is_a?(Micro::Service::Result)
+            result = Micro::Service::Result.new
+            result.__set__(true, arg, :ok, nil)
+          end
+
+          def arg_to_call?(arg)
+            return true if arg.is_a?(Micro::Service::Base) || arg.is_a?(Reducer)
+            return true if arg.is_a?(Class) && (arg < Micro::Service::Base || arg < Micro::Service::Pipeline)
+            return false
+          end
+      end
+
+      class SafeReducer < Reducer
+        def call(arg = {})
+          @services.reduce(initial_result(arg)) do |result, service|
+            break result if result.failure?
+            service_result(service, result)
+          end
+        end
+
+        alias_method :&, :>>
+
+        def >>(arg)
+          raise NoMethodError, "undefined method `>>' for #{self.inspect}. Please, use the method `&' to avoid this error."
+        end
+
+        private
+
+          def service_result(service, result)
+            begin
+              instance = service.__new__(result, result.value)
+              instance.call
+            rescue => exception
+              raise exception if Error::ByWrongUsage.check(exception)
+              result.__set__(false, exception, :exception, instance)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/micro/service/result.rb

@@ -3,20 +3,11 @@
 module Micro
   module Service
     class Result
-      InvalidType = TypeError.new('type must be a Symbol'.freeze)
-      InvalidService = TypeError.new('service must be a kind or an instance of Micro::Service::Base'.freeze)
-
-      class InvalidAccessToTheServiceObject < StandardError
-        MSG = 'only a failure result can access its service object'.freeze
-
-        def initialize(message = MSG); super; end
-      end
-
       attr_reader :value, :type
 
       def __set__(is_success, value, type, service)
-        raise InvalidType unless type.is_a?(Symbol)
-        raise InvalidService if !is_success && !is_a_service?(service)
+        raise Error::InvalidResultType unless type.is_a?(Symbol)
+        raise Error::InvalidService if !is_success && !is_a_service?(service)
 
         @success, @value, @type, @service = is_success, value, type, service
 
@@ -34,25 +25,25 @@ module Micro
       def service
         return @service if failure?
 
-        raise InvalidAccessToTheServiceObject
+        raise Error::InvalidAccessToTheServiceObject
       end
 
-      def on_success(arg = :ok)
+      def on_success(arg = nil)
         self.tap { yield(value) if success_type?(arg) }
       end
 
-      def on_failure(arg = :error)
+      def on_failure(arg = nil)
         self.tap{ yield(value, @service) if failure_type?(arg) }
       end
 
       private
 
         def success_type?(arg)
-          success? && (arg == :ok || arg == type)
+          success? && (arg.nil? || arg == type)
         end
 
         def failure_type?(arg)
-          failure? && (arg == :error || arg == type)
+          failure? && (arg.nil? || arg == type)
         end
 
         def is_a_service?(arg)

data/lib/micro/service/safe.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Micro
+  module Service
+    class Safe < Service::Base
+      def call
+        super
+      rescue => exception
+        raise exception if Error::ByWrongUsage.check(exception)
+        Failure(exception)
+      end
+    end
+  end
+end

data/lib/micro/service/strict.rb

@@ -4,6 +4,10 @@ module Micro
   module Service
     class Strict < Service::Base
       include Micro::Attributes::Features::StrictInitialize
+
+      class Safe < Service::Safe
+        include Micro::Attributes::Features::StrictInitialize
+      end
     end
   end
 end

data/lib/micro/service/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   module Service
-    VERSION = '0.14.0'.freeze
+    VERSION = '1.0.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-service
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-20 00:00:00.000000000 Z
+date: 2019-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: u-attributes
@@ -72,8 +72,11 @@ files:
 - bin/setup
 - lib/micro/service.rb
 - lib/micro/service/base.rb
+- lib/micro/service/error.rb
 - lib/micro/service/pipeline.rb
+- lib/micro/service/pipeline/reducer.rb
 - lib/micro/service/result.rb
+- lib/micro/service/safe.rb
 - lib/micro/service/strict.rb
 - lib/micro/service/version.rb
 - lib/micro/service/with_validation.rb