u-case 3.0.0.rc1 → 3.0.0.rc6

data/lib/micro/case.rb

@@ -12,27 +12,51 @@ module Micro
     require 'micro/case/error'
     require 'micro/case/safe'
     require 'micro/case/strict'
+    require 'micro/case/config'
 
     require 'micro/cases'
 
     include Micro::Attributes.without(:strict_initialize)
 
-    def self.call(options = {})
-      new(options).call
+    def self.call(options = Kind::Empty::HASH)
+      new(options).__call__
     end
 
-    def self.to_proc
-      Proc.new { |arg| call(arg) }
+    def self.then(use_case = nil, &block)
+      can_yield_self = respond_to?(:yield_self)
+
+      if block
+        raise Error::InvalidInvocationOfTheThenMethod if use_case
+        raise NotImplementedError if !can_yield_self
+
+        yield_self(&block)
+      else
+        return yield_self if !use_case && can_yield_self
+
+        self.call.then(use_case)
+      end
     end
 
-    def self.call!
-      self
+    def self.to_proc
+      Proc.new { |arg| call(arg) }
     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)
@@ -46,41 +70,36 @@ module Micro
     end
 
     def self.__new__(result, arg)
-      instance = new(arg)
+      input = result.__set_transitions_accessible_attributes__(arg)
+
+      instance = new(input)
       instance.__set_result__(result)
       instance
     end
 
-    def self.__call_and_set_transition__(result, arg)
-      input =
-        arg.is_a?(Hash) ? result.__set_transitions_accessible_attributes__(arg) : arg
-
-      __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
+    FLOW_STEP = 'Self'.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")
@@ -92,11 +111,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)
@@ -107,8 +126,8 @@ module Micro
       raise NotImplementedError
     end
 
-    def call
-      __call
+    def __call__
+      __call!
     end
 
     def __set_result__(result)
@@ -120,15 +139,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
@@ -139,15 +162,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)
@@ -172,14 +195,18 @@ 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_or_flow?(arg)
+    (arg.is_a?(Class) && arg < Case) || arg.is_a?(Cases::Flow)
+  end
 end

data/lib/micro/case/config.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Micro
+  class Case
+    class Config
+      include Singleton
+
+      def enable_activemodel_validation=(value)
+        return unless Kind::Of::Boolean(value)
+
+        require 'micro/case/with_activemodel_validation'
+      end
+
+      def enable_transitions=(value)
+        Micro::Case::Result.class_variable_set(
+          :@@transition_tracking_enabled, Kind::Of::Boolean(value)
+        )
+      end
+    end
+  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
@@ -17,18 +19,21 @@ module Micro
         def initialize; super('type must be a Symbol'.freeze); end
       end
 
-      class InvalidResultData < TypeError
-      end
+      class InvalidResult < TypeError
+        def initialize(is_success, type, use_case)
+          base =
+            "The result returned from #{use_case.class.name}#call! must be a Hash."
 
-      class InvalidSuccessResult < InvalidResultData
-        def initialize(object)
-          super("Success(result: #{object.inspect}) must be a Hash or Symbol")
-        end
-      end
+          result = is_success ? 'Success'.freeze : 'Failure'.freeze
 
-      class InvalidFailureResult < InvalidResultData
-        def initialize(object)
-          super("Failure(result: #{object.inspect}) must be a Hash, Symbol or an Exception")
+          example =
+            if type === :ok || type === :error || type === :exception
+              "#{result}(result: { key: 'value' })"
+            else
+              "#{result}(:#{type}, result: { key: 'value' })"
+            end
+
+          super("#{base}\n\nExample:\n  #{example}")
         end
       end
 
@@ -44,12 +49,8 @@ module Micro
         def initialize; super('Invalid invocation of the Micro::Case::Result#then method'); end
       end
 
-      class InvalidAccessToTheUseCaseObject < StandardError
-        def initialize; super('only a failure result can access its use case object'.freeze); end
-      end
-
       def self.by_wrong_usage?(exception)
-        exception.is_a?(InvalidResultData) || exception.is_a?(Error::UnexpectedResult) || exception.is_a?(ArgumentError)
+        exception.is_a?(InvalidResult) || exception.is_a?(UnexpectedResult) || exception.is_a?(ArgumentError)
       end
     end
   end

data/lib/micro/case/result.rb

@@ -7,19 +7,16 @@ module Micro
     class Result
       Kind::Types.add(self)
 
-      @@transition_tracking_disabled = false
+      @@transition_tracking_enabled = true
 
-      def self.disable_transition_tracking
-        @@transition_tracking_disabled = true
-      end
-
-      attr_reader :type, :data
+      attr_reader :type, :data, :use_case
 
-      alias_method :value, :data
+      alias value data
 
       def initialize
-        @__transitions__ = []
-        @__transitions_accessible_attributes__ = {}
+        @__transitions = []
+        @__transitions_accumulated_data = {}
+        @__transitions_accessible_attributes = {}
       end
 
       def to_ary
@@ -34,6 +31,18 @@ module Micro
         data.values_at(*keys)
       end
 
+      def key?(key)
+        data.key?(key)
+      end
+
+      def value?(value)
+        data.value?(value)
+      end
+
+      def slice(*keys)
+        Utils.slice_hash(data, keys)
+      end
+
       def success?
         @success
       end
@@ -42,20 +51,18 @@ module Micro
         !success?
       end
 
-      def use_case
-        return @use_case if failure?
+      def on_success(expected_type = nil)
+        return self unless __success_type?(expected_type)
 
-        raise Error::InvalidAccessToTheUseCaseObject
-      end
+        hook_data = expected_type.nil? ? self : data
 
-      def on_success(expected_type = nil)
-        yield(data) if success_type?(expected_type)
+        yield(hook_data, @use_case)
 
         self
       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
 
@@ -65,7 +72,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)
@@ -74,97 +81,136 @@ 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
+          return failure? ? self : __call_proc(use_case, 'then(-> {})'.freeze) if use_case.is_a?(Proc)
+          return failure? ? self : __call_method(use_case, attributes) if use_case.is_a?(Method)
 
-          raise Error::InvalidInvocationOfTheThenMethod if !is_a_use_case?(arg)
+          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)
+          if use_case.is_a?(::Micro::Cases::Flow)
+            use_case.call!(input: input, result: self)
+          else
+            use_case.__new__(self, input).__call__
+          end
         end
       end
 
+      def |(arg)
+        return self if failure?
+
+        return __call_proc(arg, '| -> {}'.freeze) if arg.is_a?(Proc)
+        return __call_method(arg) if arg.is_a?(Method)
+
+        raise Error::InvalidInvocationOfTheThenMethod unless ::Micro.case_or_flow?(arg)
+
+        failure? ? self : arg.__new__(self, data).__call__
+      end
+
       def transitions
-        @__transitions__.clone
+        @__transitions.clone
       end
 
-      FetchData = -> (data, is_success) do
+      FetchData = -> (data) 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
+        { exception: data } if data.is_a?(Exception)
       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)
+        raise Error::InvalidUseCase unless use_case.is_a?(::Micro::Case)
 
         @success, @type, @use_case = is_success, type, use_case
 
-        @data = FetchData.call(data, is_success)
+        @data = FetchData.call(data)
+
+        raise Micro::Case::Error::InvalidResult.new(is_success, type, use_case) unless @data
 
-        __set_transition__ unless @@transition_tracking_disabled
+        if @@transition_tracking_enabled
+          @__transitions_accumulated_data.merge!(@data)
+
+          __set_transition
+        end
 
         self
       end
 
-      def __set_transitions_accessible_attributes__(attributes_data)
-        return attributes_data if @@transition_tracking_disabled
+      def __set_transitions_accessible_attributes__(arg)
+        return arg unless @@transition_tracking_enabled
 
-        __set_transitions_accessible_attributes__!(attributes_data)
+        if arg.is_a?(Hash)
+          attributes = Utils.symbolize_hash_keys(arg)
+
+          __update_transitions_accessible_attributes(attributes)
+        end
       end
 
       private
 
-        def success_type?(expected_type)
-          success? && (expected_type.nil? || expected_type == type)
+        def __call_with_accumulated_data(fn, opt = nil)
+          input =
+            __update_transitions_accessible_attributes(
+              opt ? opt.merge(@__transitions_accumulated_data) : @__transitions_accumulated_data
+            )
+
+          fn.arity.zero? ? fn.call : fn.call(input)
         end
 
-        def failure_type?(expected_type)
-          failure? && (expected_type.nil? || expected_type == type)
+        def __call_proc(fn, expected)
+          result = __call_with_accumulated_data(fn)
+
+          return self if result === self
+
+          raise Error::UnexpectedResult.new("#{Result.name}##{expected}")
         end
 
-        def is_a_use_case?(arg)
-          (arg.is_a?(Class) && arg < ::Micro::Case) || arg.is_a?(::Micro::Case)
+        def __call_method(methd, attributes = nil)
+          result = __call_with_accumulated_data(methd, attributes)
+
+          return self if result === self
+
+          raise Error::UnexpectedResult.new("#{use_case.class.name}#method(:#{methd.name})")
         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)
-          @__transitions_accessible_attributes__.merge!(attributes)
-          @__transitions_accessible_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
 
-          @__transitions__ << {
+          @__transitions << {
             use_case: { class: use_case_class, attributes: use_case_attributes },
             result => { type: @type, result: data },
-            accessible_attributes: @__transitions_accessible_attributes__.keys
+            accessible_attributes: @__transitions_accessible_attributes.keys
           }
         end