lib/micro/case.rb in u-case-4.0.0 vs lib/micro/case.rb in u-case-4.1.0

@@ -5,23 +5,28 @@
 
 require 'micro/case/version'
 
 module Micro
   class Case
+    require 'micro/cases/utils'
     require 'micro/case/utils'
     require 'micro/case/error'
     require 'micro/case/result'
     require 'micro/case/safe'
     require 'micro/case/strict'
     require 'micro/case/config'
 
     require 'micro/cases'
 
-    include Micro::Attributes.with(:initialize, :diff)
+    include Micro::Attributes
 
-    def self.call(options = Kind::Empty::HASH)
-      new(options).__call__
+    def self.call(input = Kind::Empty::HASH)
+      result = __new__(Result.new, input).__call__
+
+      return result unless block_given?
+
+      yield Result::Wrapper.new(result)
     end
 
     INVALID_INVOCATION_OF_THE_THEN_METHOD =
       Error::InvalidInvocationOfTheThenMethod.new("#{self.name}.")
 
@@ -45,11 +50,11 @@
     def self.to_proc
       Proc.new { |arg| call(arg) }
     end
 
     def self.flow(*args)
-      @__flow_use_cases = args
+      @__flow_use_cases = Cases::Utils.map_use_cases(args)
     end
 
     class << self
       alias __call__ call
 
@@ -79,10 +84,12 @@
       input = result.__set_accessible_attributes__(arg)
 
       new(input).__set_result__(result)
     end
 
+    private_class_method :new
+
     def self.__flow_builder__
       Cases::Flow
     end
 
     def self.__flow_get__
@@ -120,20 +127,28 @@
 
     def self.__flow_set__!
       __flow_set(__flow_use_cases_get) if !__flow_get__ && __flow_use_cases
     end
 
+    def self.inspect
+      if __flow_use_cases
+        '<%s (%s) use_cases=%s>' % [self, __flow_builder__, @__flow_use_cases]
+      else
+        '<%s (%s) attributes=%s>' % [self, self.superclass, attributes]
+      end
+    end
+
     def initialize(input)
       __setup_use_case(input)
     end
 
     def call!
       raise NotImplementedError
     end
 
     def __call__
-      call
+      __call_the_use_case_or_its_flow
     end
 
     def __set_result__(result)
       raise Error::InvalidResultInstance unless result.is_a?(Result)
       raise Error::ResultIsAlreadyDefined if defined?(@__result)
@@ -143,16 +158,25 @@
       self
     end
 
     private
 
+      def call(use_case, defaults = Kind::Empty::HASH)
+        raise Error::InvalidUseCase unless ::Micro.case_or_flow?(use_case)
+
+        input =
+          defaults.empty? ? attributes : attributes.merge(Utils::Hashes.stringify_keys(defaults))
+
+        use_case.__new__(@__result, input).__call__
+      end
+
       def apply(name)
         method(name)
       end
 
-      def call
-        return __call_use_case_flow if __call_use_case_flow?
+      def __call_the_use_case_or_its_flow
+        return __call_the_use_case_flow if __call_the_use_case_flow?
 
         __call_use_case
       end
 
       def __setup_use_case(input)
@@ -169,15 +193,15 @@
         return result if result.is_a?(Result)
 
         raise Error::UnexpectedResult.new("#{self.class.name}#call!")
       end
 
-      def __call_use_case_flow?
+      def __call_the_use_case_flow?
         self.class.__flow_get__
       end
 
-      def __call_use_case_flow
+      def __call_the_use_case_flow
         self.class.__flow_get__.call(@__input)
       end
 
       def Success(type = :ok, result: nil)
         value = result || type
@@ -199,20 +223,20 @@
         type = MapFailureType.call(value, type)
 
         __get_result(false, value, type)
       end
 
-      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, :INVALID_INVOCATION_OF_THE_THEN_METHOD
   end
 
+  def self.case?(arg)
+    arg.is_a?(Class) && arg < Case
+  end
+
   def self.case_or_flow?(arg)
-    (arg.is_a?(Class) && arg < Case) || arg.is_a?(Cases::Flow)
+    case?(arg) || arg.is_a?(Cases::Flow)
   end
 end