u-case 2.1.1 → 2.5.0

data/lib/micro/case.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
+require 'kind'
 require 'micro/attributes'
-# frozen_string_literal: true
 
 module Micro
   class Case
     require 'micro/case/version'
+    require 'micro/case/utils'
     require 'micro/case/result'
     require 'micro/case/error'
     require 'micro/case/safe'
@@ -42,35 +43,81 @@ module Micro
       instance
     end
 
-    def self.__get_flow__
-      @__flow
+    def self.__call_and_set_transition__(result, arg)
+      if arg.respond_to?(:keys)
+        result.__set_transitions_accessible_attributes__(arg.keys)
+      end
+
+      __new__(result, arg).call
     end
 
-    private_class_method def self.__set_flow__(reducer, args)
-      def self.use_cases; __get_flow__.use_cases; end
+    FLOW_STEP = 'Flow_Step'.freeze
 
-      self.class_eval('def use_cases; self.class.use_cases; end')
+    private_constant :FLOW_STEP
 
-      reducer.build(args)
-    end
+    def self.__call!
+      return const_get(FLOW_STEP) if const_defined?(FLOW_STEP, false)
 
-    def self.flow(*args)
-      @__flow ||= __set_flow__(Flow::Reducer, args)
+      class_eval("class #{FLOW_STEP} < #{self.name}; private def __call; __call_use_case; end; end")
     end
 
     def self.call!
-      return const_get(:Flow_Step) if const_defined?(:Flow_Step)
+      self
+    end
+
+    def self.inherited(subclass)
+      subclass.attributes(self.attributes_data({}))
+      subclass.extend ::Micro::Attributes.const_get('Macros::ForSubclasses'.freeze)
+
+      if self.send(:__flow_use_cases) && !subclass.name.to_s.end_with?(FLOW_STEP)
+        raise "Wooo, you can't do this! Inherits from a use case which has an inner flow violates "\
+          "one of the project principles: Solve complex business logic, by allowing the composition of use cases. "\
+          "Instead of doing this, declare a new class/constant with the steps needed.\n\n"\
+          "Related issue: https://github.com/serradura/u-case/issues/19\n"
+      end
+    end
+
+    def self.__flow_reducer
+      Flow::Reducer
+    end
+
+    def self.__flow_get
+      return @__flow if defined?(@__flow)
+    end
+
+    private_class_method def self.__flow_use_cases
+      return @__flow_use_cases if defined?(@__flow_use_cases)
+    end
+
+    private_class_method def self.__flow_use_cases_get
+      Array(__flow_use_cases)
+        .map { |use_case| use_case == self ? self.__call! : use_case }
+    end
+
+    private_class_method def self.__flow_use_cases_set(args)
+      @__flow_use_cases = args
+    end
+
+    private_class_method def self.__flow_set(args)
+      return if __flow_get
+
+      def self.use_cases; __flow_get.use_cases; end
+
+      self.class_eval('def use_cases; self.class.use_cases; end')
+
+      @__flow = __flow_reducer.build(args)
+    end
 
-      const_set(:Flow_Step, Class.new(self) do
-        private def __call
-          __call_use_case
-        end
-      end)
+    def self.__flow_set!
+      __flow_set(__flow_use_cases_get) if !__flow_get && __flow_use_cases
+    end
+
+    def self.flow(*args)
+      __flow_use_cases_set(args)
     end
 
     def initialize(input)
-      @__input = input
-      self.attributes = input
+      __setup_use_case(input)
     end
 
     def call!
@@ -83,15 +130,23 @@ module Micro
 
     def __set_result__(result)
       raise Error::InvalidResultInstance unless result.is_a?(Result)
-      raise Error::ResultIsAlreadyDefined if @__result
+      raise Error::ResultIsAlreadyDefined if defined?(@__result)
 
       @__result = result
     end
 
     private
 
+      def __setup_use_case(input)
+        self.class.__flow_set!
+
+        @__input = input
+
+        self.attributes = input
+      end
+
       def __call
-        return self.class.__get_flow__.call(@__input) if self.class.__get_flow__
+        return __call_use_case_flow if __call_use_case_flow?
 
         __call_use_case
       end
@@ -104,21 +159,25 @@ module Micro
         raise Error::UnexpectedResult.new(self.class)
       end
 
+      def __call_use_case_flow?
+        self.class.__flow_get
+      end
+
+      def __call_use_case_flow
+        self.class.__flow_get.call(@__input)
+      end
+
       def Success(arg = :ok)
         value, type = block_given? ? [yield, arg] : [arg, :ok]
 
-        __get_result__.__set__(true, value, type, nil)
+        __get_result_with(true, value, type)
       end
 
       def Failure(arg = :error)
         value = block_given? ? yield : arg
         type = __map_failure_type(value, block_given? ? arg : :error)
 
-        __get_result__.__set__(false, value, type, self)
-      end
-
-      def __get_result__
-        @__result ||= Result.new
+        __get_result_with(false, value, type)
       end
 
       def __map_failure_type(arg, type)
@@ -128,5 +187,13 @@ module Micro
 
         type
       end
+
+      def __get_result__
+        @__result ||= Result.new
+      end
+
+      def __get_result_with(is_success, value, type)
+        __get_result__.__set__(is_success, value, type, self)
+      end
   end
 end

data/lib/micro/case/error.rb

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

data/lib/micro/case/flow.rb

@@ -5,7 +5,7 @@ module Micro
     module Flow
       module ClassMethods
         def __flow__
-          @__flow
+          return @__flow if defined?(@__flow)
         end
 
         def flow(*args)

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

@@ -23,19 +23,18 @@ module Micro
 
         def initialize(use_cases)
           @use_cases = use_cases
+          @first_use_case = use_cases[0]
+          @next_use_cases = use_cases[1..-1]
         end
 
         def call(arg = {})
           memo = arg.is_a?(Hash) ? arg.dup : {}
 
-          @use_cases.reduce(initial_result(arg)) do |result, use_case|
-            break result if result.failure?
+          first_result = first_use_case_result(arg)
 
-            value = result.value
-            input = value.is_a?(Hash) ? memo.tap { |data| data.merge!(value) } : value
+          return first_result if @next_use_cases.empty?
 
-            use_case_result(use_case, result, input)
-          end
+          next_use_cases_result(first_result, memo)
         end
 
         def >>(arg)
@@ -52,16 +51,8 @@ module Micro
 
         private
 
-          def use_case_result(use_case, result, input)
-            use_case.__new__(result, input).call
-          end
-
-          def initial_result(arg)
-            return arg.call if arg_to_call?(arg)
-            return arg if arg.is_a?(Micro::Case::Result)
-
-            result = ::Micro::Case::Result.new
-            result.__set__(true, arg, :ok, nil)
+          def is_a_result?(arg)
+            arg.is_a?(Micro::Case::Result)
           end
 
           def arg_to_call?(arg)
@@ -69,6 +60,44 @@ module Micro
             return true if arg.is_a?(Class) && (arg < ::Micro::Case || arg < ::Micro::Case::Flow)
             return false
           end
+
+          def call_arg(arg)
+            output = arg.call
+
+            is_a_result?(output) ? output.value : output
+          end
+
+          def first_use_case_input(arg)
+            return call_arg(arg) if arg_to_call?(arg)
+            return arg.value if is_a_result?(arg)
+
+            arg
+          end
+
+          def first_use_case_result(arg)
+            input = first_use_case_input(arg)
+
+            result = ::Micro::Case::Result.new
+
+            @first_use_case.__call_and_set_transition__(result, input)
+          end
+
+          def next_use_case_result(use_case, result, input)
+            use_case.__new__(result, input).call
+          end
+
+          def next_use_cases_result(first_result, memo)
+            @next_use_cases.reduce(first_result) do |result, use_case|
+              break result if result.failure?
+
+              value = result.value
+              input = value.is_a?(Hash) ? memo.tap { |data| data.merge!(value) } : value
+
+              result.__set_transitions_accessible_attributes__(memo.keys)
+
+              next_use_case_result(use_case, result, input)
+            end
+          end
       end
     end
   end

data/lib/micro/case/result.rb

@@ -1,8 +1,18 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Micro
   class Case
     class Result
+      Kind::Types.add(self)
+
+      @@transition_tracking_disabled = false
+
+      def self.disable_transition_tracking
+        @@transition_tracking_disabled = true
+      end
+
       class Data
         attr_reader :value, :type
 
@@ -17,12 +27,19 @@ module Micro
 
       attr_reader :value, :type
 
+      def initialize
+        @__transitions__ = {}
+        @__transitions_accessible_attributes__ = Set.new
+      end
+
       def __set__(is_success, value, type, use_case)
         raise Error::InvalidResultType unless type.is_a?(Symbol)
-        raise Error::InvalidUseCase if !is_success && !is_a_use_case?(use_case)
+        raise Error::InvalidUseCase if !is_a_use_case?(use_case)
 
         @success, @value, @type, @use_case = is_success, value, type, use_case
 
+        __set_transition__ unless @@transition_tracking_disabled
+
         self
       end
 
@@ -41,7 +58,9 @@ module Micro
       end
 
       def on_success(expected_type = nil)
-        self.tap { yield(value) if success_type?(expected_type) }
+        yield(value) if success_type?(expected_type)
+
+        self
       end
 
       def on_failure(expected_type = nil)
@@ -49,11 +68,62 @@ module Micro
 
         data = expected_type.nil? ? Data.new(value, type).tap(&:freeze) : value
 
-        self.tap { yield(data, @use_case) }
+        yield(data, @use_case)
+
+        self
+      end
+
+      def on_exception(expected_exception = nil)
+        return self unless failure_type?(:exception)
+
+        if !expected_exception || (Kind.is(Exception, expected_exception) && value.is_a?(expected_exception))
+          yield(value, @use_case)
+        end
+
+        self
+      end
+
+      def then(arg = nil, &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_and_set_transition__(self, self.value)
+        end
+      end
+
+      def transitions
+        return [] if @__transitions__.empty?
+
+        @__transitions__.map { |_use_case, transition| transition }
+      end
+
+      def __set_transitions_accessible_attributes__(attribute_names)
+        return if @@transition_tracking_disabled
+
+        __set_transitions_accessible_attributes__!(
+          attribute_names.map!(&:to_sym)
+        )
       end
 
       private
 
+        def __set_transitions_accessible_attributes__!(attribute_names)
+          @__transitions_accessible_attributes__.merge(
+            attribute_names
+          )
+        end
+
         def success_type?(expected_type)
           success? && (expected_type.nil? || expected_type == type)
         end
@@ -65,6 +135,22 @@ module Micro
         def is_a_use_case?(arg)
           (arg.is_a?(Class) && arg < ::Micro::Case) || arg.is_a?(::Micro::Case)
         end
+
+        def __set_transition__
+          use_case_class = @use_case.class
+          use_case_attributes = Utils.symbolize_hash_keys(@use_case.attributes)
+
+          __set_transitions_accessible_attributes__!(use_case_attributes.keys)
+
+          result = @success ? :success : :failure
+          transition = {
+            use_case: { class: use_case_class, attributes: use_case_attributes },
+            result => { type: @type, value: @value },
+            accessible_attributes: @__transitions_accessible_attributes__.to_a
+          }
+
+          @__transitions__[use_case_class] = transition
+        end
     end
   end
 end