u-case 2.6.0 → 3.0.0.rc1

data/lib/micro/case.rb

@@ -3,38 +3,46 @@
 require 'kind'
 require 'micro/attributes'
 
+require 'micro/case/version'
+
 module Micro
   class Case
-    require 'micro/case/version'
     require 'micro/case/utils'
     require 'micro/case/result'
     require 'micro/case/error'
     require 'micro/case/safe'
     require 'micro/case/strict'
-    require 'micro/case/flow/reducer'
-    require 'micro/case/flow'
-    require 'micro/case/safe/flow'
+
+    require 'micro/cases'
 
     include Micro::Attributes.without(:strict_initialize)
 
+    def self.call(options = {})
+      new(options).call
+    end
+
     def self.to_proc
       Proc.new { |arg| call(arg) }
     end
 
-    def self.Flow(args)
-      Flow::Reducer.build(Array(args))
+    def self.call!
+      self
     end
 
-    def self.>>(use_case)
-      Flow([self, use_case])
+    def self.flow(*args)
+      @__flow_use_cases = args
     end
 
-    def self.&(use_case)
-      Safe::Flow([self, use_case])
-    end
+    def self.inherited(subclass)
+      subclass.attributes(self.attributes_data({}))
+      subclass.extend ::Micro::Attributes.const_get('Macros::ForSubclasses'.freeze)
 
-    def self.call(options = {})
-      new(options).call
+      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.__new__(result, arg)
@@ -50,38 +58,32 @@ module Micro
       __new__(result, input).call
     end
 
-    FLOW_STEP = 'Flow_Step'.freeze
+    def self.__flow_builder
+      Cases::Flow
+    end
 
-    private_constant :FLOW_STEP
+    def self.__flow_get
+      return @__flow if defined?(@__flow)
+    end
 
-    def self.__call!
-      return const_get(FLOW_STEP) if const_defined?(FLOW_STEP, false)
+    private_class_method def self.__flow_set(args)
+      return if __flow_get
 
-      class_eval("class #{FLOW_STEP} < #{self.name}; private def __call; __call_use_case; end; end")
-    end
+      def self.use_cases; __flow_get.use_cases; end
 
-    def self.call!
-      self
+      self.class_eval('def use_cases; self.class.use_cases; end')
+
+      @__flow = __flow_builder.build(args)
     end
 
-    def self.inherited(subclass)
-      subclass.attributes(self.attributes_data({}))
-      subclass.extend ::Micro::Attributes.const_get('Macros::ForSubclasses'.freeze)
+    FLOW_STEP = 'Flow_Step'.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
+    private_constant :FLOW_STEP
 
-    def self.__flow_reducer
-      Flow::Reducer
-    end
+    def self.__call!
+      return const_get(FLOW_STEP) if const_defined?(FLOW_STEP, false)
 
-    def self.__flow_get
-      return @__flow if defined?(@__flow)
+      class_eval("class #{FLOW_STEP} < #{self.name}; private def __call; __call_use_case; end; end")
     end
 
     private_class_method def self.__flow_use_cases
@@ -93,28 +95,10 @@ module Micro
         .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
-
     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)
       __setup_use_case(input)
     end
@@ -166,33 +150,36 @@ module Micro
         self.class.__flow_get.call(@__input)
       end
 
-      def Success(arg = :ok)
-        value, type = block_given? ? [yield, arg] : [arg, :ok]
+      def Success(type = :ok, result: nil)
+        value = result || type
 
-        __get_result_with(true, value, type)
+        __get_result(true, value, type)
       end
 
-      def Failure(arg = :error)
-        value = block_given? ? yield : arg
-        type = __map_failure_type(value, block_given? ? arg : :error)
+      MapFailureType = -> (value, type) do
+        return type if type != :error
+        return value if value.is_a?(Symbol)
+        return :exception if value.is_a?(Exception)
 
-        __get_result_with(false, value, type)
+        type
       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)
+      def Failure(type = :error, result: nil)
+        value = result || type
 
-        type
+        type = MapFailureType.call(value, type)
+
+        __get_result(false, value, type)
       end
 
-      def __get_result__
+      def __result__
         @__result ||= Result.new
       end
 
-      def __get_result_with(is_success, value, type)
-        __get_result__.__set__(is_success, value, type, self)
+      def __get_result(is_success, value, type)
+        __result__.__set__(is_success, value, type, self)
       end
+
+      private_constant :MapFailureType
   end
 end

data/lib/micro/case/error.rb

@@ -17,6 +17,21 @@ module Micro
         def initialize; super('type must be a Symbol'.freeze); end
       end
 
+      class InvalidResultData < TypeError
+      end
+
+      class InvalidSuccessResult < InvalidResultData
+        def initialize(object)
+          super("Success(result: #{object.inspect}) must be a Hash or Symbol")
+        end
+      end
+
+      class InvalidFailureResult < InvalidResultData
+        def initialize(object)
+          super("Failure(result: #{object.inspect}) must be a Hash, Symbol or an Exception")
+        end
+      end
+
       class InvalidResultInstance < ArgumentError
         def initialize; super('argument must be an instance of Micro::Case::Result'.freeze); end
       end
@@ -25,26 +40,16 @@ module Micro
         def initialize; super('use case must be a kind or an instance of Micro::Case'.freeze); end
       end
 
-      class InvalidUseCases < ArgumentError
-        def initialize; super('argument must be a collection of `Micro::Case` classes'.freeze); end
-      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
-        def self.check(exception)
-          exception.is_a?(Error::UnexpectedResult) || exception.is_a?(ArgumentError)
-        end
+      def self.by_wrong_usage?(exception)
+        exception.is_a?(InvalidResultData) || exception.is_a?(Error::UnexpectedResult) || exception.is_a?(ArgumentError)
       end
     end
   end

data/lib/micro/case/result.rb

@@ -13,34 +13,25 @@ module Micro
         @@transition_tracking_disabled = true
       end
 
-      class Data
-        attr_reader :value, :type
+      attr_reader :type, :data
 
-        def initialize(value, type)
-          @value, @type = value, type
-        end
-
-        def to_ary; [value, type]; end
-      end
-
-      private_constant :Data
-
-      attr_reader :value, :type
+      alias_method :value, :data
 
       def initialize
         @__transitions__ = []
         @__transitions_accessible_attributes__ = {}
       end
 
-      def __set__(is_success, value, type, use_case)
-        raise Error::InvalidResultType unless type.is_a?(Symbol)
-        raise Error::InvalidUseCase if !is_a_use_case?(use_case)
-
-        @success, @value, @type, @use_case = is_success, value, type, use_case
+      def to_ary
+        [data, type]
+      end
 
-        __set_transition__ unless @@transition_tracking_disabled
+      def [](key)
+        data[key]
+      end
 
-        self
+      def values_at(*keys)
+        data.values_at(*keys)
       end
 
       def success?
@@ -58,7 +49,7 @@ module Micro
       end
 
       def on_success(expected_type = nil)
-        yield(value) if success_type?(expected_type)
+        yield(data) if success_type?(expected_type)
 
         self
       end
@@ -66,9 +57,9 @@ module Micro
       def on_failure(expected_type = nil)
         return self unless failure_type?(expected_type)
 
-        data = expected_type.nil? ? Data.new(value, type).tap(&:freeze) : value
+        hook_data = expected_type.nil? ? self : data
 
-        yield(data, @use_case)
+        yield(hook_data, @use_case)
 
         self
       end
@@ -76,8 +67,8 @@ module Micro
       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)
+        if !expected_exception || (Kind.is(Exception, expected_exception) && data.fetch(:exception).is_a?(expected_exception))
+          yield(data, @use_case)
         end
 
         self
@@ -98,7 +89,7 @@ module Micro
 
           return self if failure?
 
-          input = attributes.is_a?(Hash) ? self.value.merge(attributes) : self.value
+          input = attributes.is_a?(Hash) ? self.data.merge(attributes) : self.data
 
           arg.__call_and_set_transition__(self, input)
         end
@@ -108,6 +99,29 @@ module Micro
         @__transitions__.clone
       end
 
+      FetchData = -> (data, is_success) do
+        return data if data.is_a?(Hash)
+        return { data => true } if data.is_a?(Symbol)
+        return { exception: data } if data.is_a?(Exception)
+
+        err = is_success ? :InvalidSuccessResult : :InvalidFailureResult
+
+        raise Micro::Case::Error.const_get(err), data
+      end
+
+      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)
+
+        @success, @type, @use_case = is_success, type, use_case
+
+        @data = FetchData.call(data, is_success)
+
+        __set_transition__ unless @@transition_tracking_disabled
+
+        self
+      end
+
       def __set_transitions_accessible_attributes__(attributes_data)
         return attributes_data if @@transition_tracking_disabled
 
@@ -116,17 +130,6 @@ module Micro
 
       private
 
-        def __set_transitions_accessible_attributes__!(attributes_data)
-          attributes = Utils.symbolize_hash_keys(attributes_data)
-
-          __update_transitions_accessible_attributes__(attributes)
-        end
-
-        def __update_transitions_accessible_attributes__(attributes)
-          @__transitions_accessible_attributes__.merge!(attributes)
-          @__transitions_accessible_attributes__
-        end
-
         def success_type?(expected_type)
           success? && (expected_type.nil? || expected_type == type)
         end
@@ -139,6 +142,17 @@ module Micro
           (arg.is_a?(Class) && arg < ::Micro::Case) || arg.is_a?(::Micro::Case)
         end
 
+        def __set_transitions_accessible_attributes__!(attributes_data)
+          attributes = Utils.symbolize_hash_keys(attributes_data)
+
+          __update_transitions_accessible_attributes__(attributes)
+        end
+
+        def __update_transitions_accessible_attributes__(attributes)
+          @__transitions_accessible_attributes__.merge!(attributes)
+          @__transitions_accessible_attributes__
+        end
+
         def __set_transition__
           use_case_class = @use_case.class
           use_case_attributes = Utils.symbolize_hash_keys(@use_case.attributes)
@@ -149,10 +163,12 @@ module Micro
 
           @__transitions__ << {
             use_case: { class: use_case_class, attributes: use_case_attributes },
-            result => { type: @type, value: @value },
+            result => { type: @type, result: data },
             accessible_attributes: @__transitions_accessible_attributes__.keys
           }
         end
+
+        private_constant :FetchData
     end
   end
 end

data/lib/micro/case/safe.rb

@@ -3,12 +3,16 @@
 module Micro
   class Case
     class Safe < ::Micro::Case
+      def self.__flow_builder
+        Cases::Safe::Flow
+      end
+
       def call
         __call
       rescue => exception
-        raise exception if Error::ByWrongUsage.check(exception)
+        raise exception if Error.by_wrong_usage?(exception)
 
-        Failure(exception)
+        Failure(result: exception)
       end
     end
   end

data/lib/micro/case/version.rb

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

data/lib/micro/case/with_activemodel_validation.rb

@@ -35,7 +35,7 @@ module Micro
       def failure_by_validation_error(object)
         errors = object.respond_to?(:errors) ? object.errors : object
 
-        Failure(:validation_error) { { errors: errors } }
+        Failure :validation_error, result: { errors: errors }
       end
   end
 end

data/lib/micro/cases.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'micro/cases/flow'
+require 'micro/cases/safe/flow'
+
+module Micro
+  module Cases
+    def self.flow(args)
+      Flow.build(args)
+    end
+
+    def self.safe_flow(args)
+      Safe::Flow.build(args)
+    end
+  end
+end