u-case 3.0.0.rc3 → 3.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de27799d2fbf95d3399af2caa3053038fd9817c6f800747213eb8ee3722604b5
-  data.tar.gz: dc2f1b40964d646978d28ffb44c049a58ddca614440e296ff5fa7f35e347def1
+  metadata.gz: b3374584a2cf58a68aa1bed216c91bfd715cc4365d2e7972e5693a8c3acb52eb
+  data.tar.gz: 9bbe75661a2cd53e549cf60692811d47d1aaf5895ee71cf89f3fc7e8f8d72f0b
 SHA512:
-  metadata.gz: 90af10df71576124850933260f703e7a2f9c6a67df5e5add06d7d657de34a291879e279eec59795bfd548c0e0f898dc3795657de1de524e3aac16dddf25b24cf
-  data.tar.gz: e5b374929b87a7a5a0f604afa5742195910809b9198c11d01110bb8cf9f2540de73aa80fedb4432357ee86b96fe5e81b91a003fd410da989ac5b22b9ad40aa30
+  metadata.gz: d43a4e404c554e4e489cd4875af61bf66ab41bec68a84c6022b04b3ae8dd79975f8522e8ecf8c0211ae0f08cbd4fe95ac6d7320a94d0c140ce3c436d26650afb
+  data.tar.gz: '084cabc2b47f424a789f0e0cc9f120bfa50516771e669763207bed6c2884b4f6c3b8731be495eafc5bf1dc1c68b1b82b85a308c4a77cb546d77d99f6a088a827'

data/Gemfile

@@ -37,6 +37,8 @@ pry_version =
 group :development, :test do
   gem 'awesome_print', '~> 1.8'
 
+  gem 'byebug', '~> 10.0', '>= 10.0.2' if RUBY_VERSION =~ /\A2.2/
+
   gem 'pry', "~> #{pry_version}"
   gem 'pry-byebug', "~> #{pry_byebug_version}"
 end

data/README.md

@@ -37,7 +37,8 @@ Version   | Documentation
     - [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 result itself?](#why-the-failure-hook-without-a-type-exposes-result-itself)
+    - [Why the hook usage without a type exposes the result itself?](#why-the-hook-usage-without-a-type-exposes-the-result-itself)
+      - [Using decomposition to access the result data and type](#using-decomposition-to-access-the-result-data-and-type)
     - [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)
       - [What does happens when a `Micro::Case::Result#then` receives a block?](#what-does-happens-when-a-microcaseresultthen-receives-a-block)
@@ -145,14 +146,6 @@ bad_result = Multiply.call(a: 2, b: '2')
 bad_result.failure? # true
 bad_result.data     # { message: "`a` and `b` attributes must be numeric" }
 
-#-----------------------------#
-# Calling a use case instance #
-#-----------------------------#
-
-result = Multiply.new(a: 2, b: 3).call
-
-result.value # { number: 6 }
-
 # Note:
 # ----
 # The result of a Micro::Case.call
@@ -360,7 +353,7 @@ Double
 # The use case responsible for the failure will be accessible as the second hook argument
 ```
 
-#### Why the failure hook (without a type) exposes result itself?
+#### Why the hook usage without a type exposes the result itself?
 
 Answer: To allow you to define how to handle the program flow using some
 conditional statement (like an `if`, `case/when`).
@@ -377,12 +370,8 @@ class Double < Micro::Case
   end
 end
 
-#=================================#
-# Using the result type and value #
-#=================================#
-
 Double
-  .call(-1)
+  .call(number: -1)
   .on_failure do |result, use_case|
     case result.type
     when :invalid then raise TypeError, "number must be a numeric value"
@@ -394,19 +383,20 @@ Double
 # The output will be the exception:
 #
 # ArgumentError (number `-1` must be greater than 0)
+```
 
-#=========================================================#
-# Using decomposition to access the result data and type #
-#=========================================================#
+> **Note:** The same that was did in the previous examples could be done with `#on_success` hook!
 
-# The syntax to decompose an Array can be used in methods, blocks and assigments.
-# If you doesn't know it, check out the Ruby doc:
-# https://ruby-doc.org/core-2.2.0/doc/syntax/assignment_rdoc.html#label-Array+Decomposition
-#
-# The object exposed in the hook failure is a Micro::Case::Result, and it can be decomposed using this syntax. e.g:
+##### Using decomposition to access the result data and type
+
+The syntax to decompose an Array can be used in methods, blocks and assigments.
+If you doesn't know it, check out the [Ruby doc](https://ruby-doc.org/core-2.2.0/doc/syntax/assignment_rdoc.html#label-Array+Decomposition).
+
+```ruby
+# The object exposed in the hook is a Micro::Case::Result, and it can be decomposed using this syntax. e.g:
 
 Double
-  .call(-2)
+  .call(number: -2)
   .on_failure do |(data, type), use_case|
     case type
     when :invalid then raise TypeError, 'number must be a numeric value'
@@ -420,6 +410,8 @@ Double
 # ArgumentError (the number `-2` must be greater than 0)
 ```
 
+> **Note:** The same that was did in the previous examples could be done with `#on_success` hook!
+
 [⬆️ Back to Top](#table-of-contents-)
 
 #### What happens if a result hook was declared multiple times?
@@ -445,10 +437,11 @@ result[:number] * 4 # 24
 
 accum = 0
 
-result.on_success { |result| accum += result[:number] }
-      .on_success { |result| accum += result[:number] }
-      .on_success(:computed) { |result| accum += result[:number] }
-      .on_success(:computed) { |result| accum += result[:number] }
+result
+  .on_success { |result| accum += result[:number] }
+  .on_success { |result| accum += result[:number] }
+  .on_success(:computed) { |result| accum += result[:number] }
+  .on_success(:computed) { |result| accum += result[:number] }
 
 accum # 24
 
@@ -621,9 +614,9 @@ class DoubleAllNumbers < Micro::Case
        Steps::Double
 end
 
-DoubleAllNumbers
-  .call(numbers: %w[1 1 b 2 3 4])
-  .on_failure { |message| p message } # "numbers must contain only numeric types"
+DoubleAllNumbers.
+  call(numbers: %w[1 1 b 2 3 4]).
+  on_failure { |result| puts result[:message] } # "numbers must contain only numeric types"
 
 # Note:
 # ----
@@ -705,11 +698,11 @@ DoubleAllNumbersAndSquareAndAdd2 =
 
 SquareAllNumbersAndDouble
   .call(numbers: %w[1 1 2 2 3 4])
-  .on_success { |value| p value[:numbers] } # [6, 6, 12, 12, 22, 36]
+  .on_success { |result| p result[: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]
+  .on_success { |result| p result[:numbers] } # [6, 6, 18, 18, 38, 66]
 ```
 
 Note: You can blend any of the [available syntaxes/approaches](#how-to-create-a-flow-which-has-reusable-steps-to-define-a-complex-use-case) to create use case flows - [examples](https://github.com/serradura/u-case/blob/714c6b658fc6aa02617e6833ddee09eddc760f2a/test/micro/cases/flow/blend_test.rb#L5-L35).
@@ -956,8 +949,8 @@ result.type == :exception                   # true
 result.data                                 # { exception: #<ZeroDivisionError...> }
 result[:exception].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
+result.on_failure(:exception) do |result|
+  AppLogger.error(result[:exception].message) # E, [2019-08-21T00:05:44.195506 #9532] ERROR -- : divided by 0
 end
 
 # Note:
@@ -965,8 +958,8 @@ end
 # If you need to handle a specific error,
 # I recommend the usage of a case statement. e,g:
 
-result.on_failure(:exception) do |exception, use_case|
-  case exception
+result.on_failure(:exception) do |data, use_case|
+  case exception = data[:exception]
   when ZeroDivisionError then AppLogger.error(exception.message)
   else AppLogger.debug("#{use_case.class.name} was the use case responsible for the exception")
   end
@@ -1163,6 +1156,8 @@ class Todo::List::AddItem < Micro::Case
 end
 ```
 
+[⬆️ Back to Top](#table-of-contents-)
+
 ## `Micro::Case.config`
 
 The idea of this feature is to allow the configuration of some `u-case` features/modules.
@@ -1180,6 +1175,8 @@ Micro::Case.config do |config|
 end
 ```
 
+[⬆️ Back to Top](#table-of-contents-)
+
 ## Benchmarks
 
 ### `Micro::Case` (v2.6.0)

data/lib/micro/case.rb

@@ -18,26 +18,30 @@ module Micro
 
     include Micro::Attributes.without(:strict_initialize)
 
-    def self.config
-      yield(Config.instance)
-    end
-
     def self.call(options = {})
-      new(options).call
+      new(options).__call__
     end
 
     def self.to_proc
       Proc.new { |arg| call(arg) }
     end
 
-    def self.call!
-      self
-    end
-
     def self.flow(*args)
       @__flow_use_cases = args
     end
 
+    class << self
+      alias __call__ call
+
+      def config
+        yield(Config.instance)
+      end
+
+      def call!
+        self
+      end
+    end
+
     def self.inherited(subclass)
       subclass.attributes(self.attributes_data({}))
       subclass.extend ::Micro::Attributes.const_get('Macros::ForSubclasses'.freeze)
@@ -60,32 +64,32 @@ module Micro
       input =
         arg.is_a?(Hash) ? result.__set_transitions_accessible_attributes__(arg) : arg
 
-      __new__(result, input).call
+      __new__(result, input).__call__
     end
 
-    def self.__flow_builder
+    def self.__flow_builder__
       Cases::Flow
     end
 
-    def self.__flow_get
+    def self.__flow_get__
       return @__flow if defined?(@__flow)
     end
 
     private_class_method def self.__flow_set(args)
-      return if __flow_get
+      return if __flow_get__
 
-      def self.use_cases; __flow_get.use_cases; end
+      def self.use_cases; __flow_get__.use_cases; end
 
       self.class_eval('def use_cases; self.class.use_cases; end')
 
-      @__flow = __flow_builder.build(args)
+      @__flow = __flow_builder__.build(args)
     end
 
     FLOW_STEP = 'Flow_Step'.freeze
 
     private_constant :FLOW_STEP
 
-    def self.__call!
+    def self.__call__!
       return const_get(FLOW_STEP) if const_defined?(FLOW_STEP, false)
 
       class_eval("class #{FLOW_STEP} < #{self.name}; private def __call; __call_use_case; end; end")
@@ -97,11 +101,11 @@ module Micro
 
     private_class_method def self.__flow_use_cases_get
       Array(__flow_use_cases)
-        .map { |use_case| use_case == self ? self.__call! : use_case }
+        .map { |use_case| use_case == self ? self.__call__! : use_case }
     end
 
-    def self.__flow_set!
-      __flow_set(__flow_use_cases_get) if !__flow_get && __flow_use_cases
+    def self.__flow_set__!
+      __flow_set(__flow_use_cases_get) if !__flow_get__ && __flow_use_cases
     end
 
     def initialize(input)
@@ -112,8 +116,8 @@ module Micro
       raise NotImplementedError
     end
 
-    def call
-      __call
+    def __call__
+      __call!
     end
 
     def __set_result__(result)
@@ -125,15 +129,19 @@ module Micro
 
     private
 
+      # This method was reserved for a new feature
+      def call
+      end
+
       def __setup_use_case(input)
-        self.class.__flow_set!
+        self.class.__flow_set__!
 
         @__input = input
 
         self.attributes = input
       end
 
-      def __call
+      def __call!
         return __call_use_case_flow if __call_use_case_flow?
 
         __call_use_case
@@ -144,15 +152,15 @@ module Micro
 
         return result if result.is_a?(Result)
 
-        raise Error::UnexpectedResult.new(self.class)
+        raise Error::UnexpectedResult.new("#{self.class.name}#call!")
       end
 
       def __call_use_case_flow?
-        self.class.__flow_get
+        self.class.__flow_get__
       end
 
       def __call_use_case_flow
-        self.class.__flow_get.call(@__input)
+        self.class.__flow_get__.call(@__input)
       end
 
       def Success(type = :ok, result: nil)
@@ -177,14 +185,22 @@ module Micro
         __get_result(false, value, type)
       end
 
-      def __result__
+      def __result
         @__result ||= Result.new
       end
 
       def __get_result(is_success, value, type)
-        __result__.__set__(is_success, value, type, self)
+        __result.__set__(is_success, value, type, self)
       end
 
       private_constant :MapFailureType
   end
+
+  def self.case?(arg)
+    (arg.is_a?(Class) && arg < Case) || arg.is_a?(Case)
+  end
+
+  def self.case_or_flow?(arg)
+    case?(arg) || arg.is_a?(Cases::Flow)
+  end
 end

data/lib/micro/case/error.rb

@@ -4,9 +4,11 @@ module Micro
   class Case
     module Error
       class UnexpectedResult < TypeError
-        MESSAGE = '#call! must return an instance of Micro::Case::Result'.freeze
+        MESSAGE = 'must return an instance of Micro::Case::Result'.freeze
 
-        def initialize(klass); super(klass.name + MESSAGE); end
+        def initialize(context)
+          super("#{context} #{MESSAGE}")
+        end
       end
 
       class ResultIsAlreadyDefined < ArgumentError

data/lib/micro/case/result.rb

@@ -11,7 +11,7 @@ module Micro
 
       attr_reader :type, :data, :use_case
 
-      alias_method :value, :data
+      alias value data
 
       def initialize
         @__transitions__ = []
@@ -39,7 +39,7 @@ module Micro
       end
 
       def on_success(expected_type = nil)
-        return self unless success_type?(expected_type)
+        return self unless __success_type?(expected_type)
 
         hook_data = expected_type.nil? ? self : data
 
@@ -49,7 +49,7 @@ module Micro
       end
 
       def on_failure(expected_type = nil)
-        return self unless failure_type?(expected_type)
+        return self unless __failure_type?(expected_type)
 
         hook_data = expected_type.nil? ? self : data
 
@@ -59,7 +59,7 @@ module Micro
       end
 
       def on_exception(expected_exception = nil)
-        return self unless failure_type?(:exception)
+        return self unless __failure_type?(:exception)
 
         if !expected_exception || (Kind.is(Exception, expected_exception) && data.fetch(:exception).is_a?(expected_exception))
           yield(data, @use_case)
@@ -68,27 +68,42 @@ module Micro
         self
       end
 
-      def then(arg = nil, attributes = nil, &block)
+      def then(use_case = nil, attributes = nil, &block)
         can_yield_self = respond_to?(:yield_self)
 
         if block
-          raise Error::InvalidInvocationOfTheThenMethod if arg
+          raise Error::InvalidInvocationOfTheThenMethod if use_case
           raise NotImplementedError if !can_yield_self
 
           yield_self(&block)
         else
-          return yield_self if !arg && can_yield_self
+          return yield_self if !use_case && can_yield_self
 
-          raise Error::InvalidInvocationOfTheThenMethod if !is_a_use_case?(arg)
+          if use_case.is_a?(Proc)
+            return failure? ? self : __call_proc(use_case, expected: 'then(-> {})'.freeze)
+          end
+
+          # TODO: Test the then method with a Micro::Cases.{flow,safe_flow}() instance.
+          raise Error::InvalidInvocationOfTheThenMethod unless ::Micro.case_or_flow?(use_case)
 
           return self if failure?
 
           input = attributes.is_a?(Hash) ? self.data.merge(attributes) : self.data
 
-          arg.__call_and_set_transition__(self, input)
+          use_case.__call_and_set_transition__(self, input)
         end
       end
 
+      def |(arg)
+        return self if failure?
+
+        return __call_proc(arg, expected: '| -> {}'.freeze) if arg.is_a?(Proc)
+
+        raise Error::InvalidInvocationOfTheThenMethod unless ::Micro.case_or_flow?(arg)
+
+        failure? ? self : arg.__call_and_set_transition__(self, data)
+      end
+
       def transitions
         @__transitions__.clone
       end
@@ -102,7 +117,7 @@ module Micro
 
       def __set__(is_success, data, type, use_case)
         raise Error::InvalidResultType unless type.is_a?(Symbol)
-        raise Error::InvalidUseCase if !is_a_use_case?(use_case)
+        raise Error::InvalidUseCase unless ::Micro.case?(use_case)
 
         @success, @type, @use_case = is_success, type, use_case
 
@@ -110,7 +125,7 @@ module Micro
 
         raise Micro::Case::Error::InvalidResult.new(is_success, type, use_case) unless @data
 
-        __set_transition__ unless @@transition_tracking_disabled
+        __set_transition unless @@transition_tracking_disabled
 
         self
       end
@@ -118,39 +133,39 @@ module Micro
       def __set_transitions_accessible_attributes__(attributes_data)
         return attributes_data if @@transition_tracking_disabled
 
-        __set_transitions_accessible_attributes__!(attributes_data)
+        attributes = Utils.symbolize_hash_keys(attributes_data)
+
+        __update_transitions_accessible_attributes(attributes)
       end
 
       private
 
-        def success_type?(expected_type)
-          success? && (expected_type.nil? || expected_type == type)
-        end
+        def __call_proc(arg, expected:)
+          result = arg.arity.zero? ? arg.call : arg.call(data.clone)
 
-        def failure_type?(expected_type)
-          failure? && (expected_type.nil? || expected_type == type)
-        end
+          return result if result.is_a?(Result)
 
-        def is_a_use_case?(arg)
-          (arg.is_a?(Class) && arg < ::Micro::Case) || arg.is_a?(::Micro::Case)
+          raise Error::UnexpectedResult.new("#{Result.name}##{expected}")
         end
 
-        def __set_transitions_accessible_attributes__!(attributes_data)
-          attributes = Utils.symbolize_hash_keys(attributes_data)
+        def __success_type?(expected_type)
+          success? && (expected_type.nil? || expected_type == type)
+        end
 
-          __update_transitions_accessible_attributes__(attributes)
+        def __failure_type?(expected_type)
+          failure? && (expected_type.nil? || expected_type == type)
         end
 
-        def __update_transitions_accessible_attributes__(attributes)
+        def __update_transitions_accessible_attributes(attributes)
           @__transitions_accessible_attributes__.merge!(attributes)
           @__transitions_accessible_attributes__
         end
 
-        def __set_transition__
+        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)
+          __update_transitions_accessible_attributes(use_case_attributes)
 
           result = @success ? :success : :failure
 

data/lib/micro/case/safe.rb

@@ -7,8 +7,8 @@ module Micro
         Cases::Safe::Flow
       end
 
-      def call
-        __call
+      def __call__
+        __call!
       rescue => exception
         raise exception if Error.by_wrong_usage?(exception)
 

data/lib/micro/case/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   class Case
-    VERSION = '3.0.0.rc3'.freeze
+    VERSION = '3.0.0.rc4'.freeze
   end
 end

data/lib/micro/case/with_activemodel_validation.rb

@@ -31,7 +31,7 @@ module Micro
 
         return result if result.is_a?(Result)
 
-        raise Error::UnexpectedResult.new(self.class)
+        raise Error::UnexpectedResult.new("#{self.class.name}#call!")
       end
 
       def failure_by_validation_error(object)

data/lib/micro/cases/flow.rb

@@ -32,55 +32,51 @@ module Micro
       def call(arg = {})
         memo = arg.is_a?(Hash) ? arg.dup : {}
 
-        first_result = first_use_case_result(arg)
+        first_result = __first_use_case_result(arg)
 
         return first_result if @next_use_cases.empty?
 
-        next_use_cases_result(first_result, memo)
+        __next_use_cases_result(first_result, memo)
       end
 
+      alias __call__ call
+
       def to_proc
         Proc.new { |arg| call(arg) }
       end
 
       private
 
-        def is_a_result?(arg)
+        def __is_a_result?(arg)
           arg.is_a?(Case::Result)
         end
 
-        def arg_to_call?(arg)
-          return true if arg.is_a?(::Micro::Case) || arg.is_a?(Flow)
-          return true if arg.is_a?(Class) && arg < ::Micro::Case
-          return false
-        end
-
-        def call_arg(arg)
-          output = arg.call
+        def __call_arg(arg)
+          output = arg.__call__
 
-          is_a_result?(output) ? output.value : output
+          __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)
+        def __first_use_case_input(arg)
+          return __call_arg(arg) if ::Micro.case_or_flow?(arg)
+          return arg.value if __is_a_result?(arg)
 
           arg
         end
 
-        def first_use_case_result(arg)
-          input = first_use_case_input(arg)
+        def __first_use_case_result(arg)
+          input = __first_use_case_input(arg)
 
           result = 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
+        def __next_use_case_result(use_case, result, input)
+          use_case.__new__(result, input).__call__
         end
 
-        def next_use_cases_result(first_result, memo)
+        def __next_use_cases_result(first_result, memo)
           @next_use_cases.reduce(first_result) do |result, use_case|
             break result if result.failure?
 
@@ -88,7 +84,7 @@ module Micro
 
             result.__set_transitions_accessible_attributes__(memo)
 
-            next_use_case_result(use_case, result, memo)
+            __next_use_case_result(use_case, result, memo)
           end
         end
     end

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

@@ -4,9 +4,9 @@ module Micro
   module Cases
     module Safe
       class Flow < Cases::Flow
-        private def next_use_case_result(use_case, result, input)
+        private def __next_use_case_result(use_case, result, input)
           instance = use_case.__new__(result, input)
-          instance.call
+          instance.__call__
         rescue => exception
           raise exception if Case::Error.by_wrong_usage?(exception)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-case
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc3
+  version: 3.0.0.rc4
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2020-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind