u-case 4.0.0 → 4.2.2

data/lib/micro/case.rb

@@ -7,6 +7,7 @@ require 'micro/case/version'
 
 module Micro
   class Case
+    require 'micro/cases/utils'
     require 'micro/case/utils'
     require 'micro/case/error'
     require 'micro/case/result'
@@ -16,10 +17,18 @@ module Micro
 
     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?
+
+      result_wrapper = Result::Wrapper.new(result)
+
+      yield(result_wrapper)
+
+      result_wrapper.output
     end
 
     INVALID_INVOCATION_OF_THE_THEN_METHOD =
@@ -47,7 +56,7 @@ module Micro
     end
 
     def self.flow(*args)
-      @__flow_use_cases = args
+      @__flow_use_cases = Cases::Utils.map_use_cases(args)
     end
 
     class << self
@@ -81,6 +90,8 @@ module Micro
       new(input).__set_result__(result)
     end
 
+    private_class_method :new
+
     def self.__flow_builder__
       Cases::Flow
     end
@@ -122,6 +133,28 @@ module Micro
       __flow_set(__flow_use_cases_get) if !__flow_get__ && __flow_use_cases
     end
 
+    InspectKey = :__inspect_key__ # :nodoc:
+
+    def self.inspect
+      ids = (Thread.current[InspectKey] ||= [])
+
+      if ids.include?(object_id)
+        return sprintf('#<%s: ...>', self)
+      end
+
+      begin
+        ids << object_id
+
+        if __flow_use_cases
+          return '<%s (%s) use_cases=%s>' % [self, __flow_builder__, @__flow_use_cases]
+        else
+          return '<%s (%s) attributes=%s>' % [self, self.superclass, attributes]
+        end
+      ensure
+        ids.pop
+      end
+    end
+
     def initialize(input)
       __setup_use_case(input)
     end
@@ -131,7 +164,7 @@ module Micro
     end
 
     def __call__
-      call
+      __call_the_use_case_or_its_flow
     end
 
     def __set_result__(result)
@@ -145,12 +178,21 @@ module Micro
 
     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
@@ -171,11 +213,11 @@ module Micro
         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
 
@@ -201,18 +243,32 @@ module Micro
         __get_result(false, value, type)
       end
 
-      def __result
-        @__result ||= Result.new
+      def __get_result(is_success, value, type)
+        @__result.__set__(is_success, value, type, self)
       end
 
-      def __get_result(is_success, value, type)
-        __result.__set__(is_success, value, type, self)
+      def transaction(adapter = :activerecord)
+        raise NotImplementedError unless adapter == :activerecord
+
+        result = nil
+
+        ActiveRecord::Base.transaction do
+          result = yield
+
+          raise ActiveRecord::Rollback if result.failure?
+        end
+
+        result
       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

data/lib/micro/case/result.rb

@@ -5,6 +5,7 @@ require 'set'
 module Micro
   class Case
     class Result
+      require 'micro/case/result/wrapper'
       require 'micro/case/result/transitions'
 
       Kind::Types.add(self)
@@ -23,15 +24,26 @@ module Micro
       alias value data
 
       def initialize(transitions_mapper = Transitions::MapEverything)
+        enable_transitions = @@transitions_enabled
+
+        @__is_unknown = true
         @__accumulated_data = {}
+        @__tracked_use_cases = Set.new
         @__accessible_attributes = {}
 
-        enable_transitions = @@transitions_enabled
-
         @__transitions = enable_transitions ? [] : Kind::Empty::ARRAY
         @__transitions_mapper = transitions_mapper if enable_transitions
       end
 
+      def inspect
+        pretty_type = @__success ? 'Success' : 'Failure'
+
+        instance_info = '%s (%s) type=:%s data=%s' % [pretty_type, self.class, @type, data]
+        transitions_info = ' transitions=%d' % [@__transitions.size] if Micro::Case::Result.transitions_enabled?
+
+        "#<#{instance_info}#{transitions_info}>"
+      end
+
       def to_ary
         [data, type]
       end
@@ -57,7 +69,7 @@ module Micro
       end
 
       def slice(*keys)
-        Utils.slice_hash(data, keys)
+        Utils::Hashes.slice(data, keys)
       end
 
       def success?
@@ -68,6 +80,10 @@ module Micro
         !success?
       end
 
+      def unknown?
+        @__is_unknown
+      end
+
       def accessible_attributes
         @__accessible_attributes.keys
       end
@@ -75,6 +91,7 @@ module Micro
       def on_success(expected_type = nil)
         return self unless __success_type?(expected_type)
 
+        @__is_unknown = false
         hook_data = expected_type.nil? ? self : data
 
         yield(hook_data, @use_case)
@@ -85,6 +102,7 @@ module Micro
       def on_failure(expected_type = nil)
         return self unless __failure_type?(expected_type)
 
+        @__is_unknown = false
         hook_data = expected_type.nil? ? self : data
 
         yield(hook_data, @use_case)
@@ -102,6 +120,14 @@ module Micro
         self
       end
 
+      def on_unknown
+        return self unless unknown?
+
+        yield(self, @use_case)
+
+        self
+      end
+
       def then(use_case = nil, attributes = nil, &block)
         can_yield_self = respond_to?(:yield_self)
 
@@ -163,9 +189,13 @@ module Micro
 
         @__accumulated_data.merge!(@data)
 
-        use_case_attributes = Utils.symbolize_hash_keys(@use_case.attributes)
+        use_case_attributes = Utils::Hashes.symbolize_keys(@use_case.attributes)
 
-        __update_accessible_attributes(use_case_attributes)
+        unless @__tracked_use_cases.member?(use_case_class = @use_case.class)
+          @__tracked_use_cases.add(use_case_class)
+
+          __update_accessible_attributes(use_case_attributes)
+        end
 
         __set_transition(use_case_attributes) unless @__transitions.frozen?
 
@@ -175,7 +205,7 @@ module Micro
       def __set_accessible_attributes__(arg)
         return arg unless arg.is_a?(Hash)
 
-        attributes = Utils.symbolize_hash_keys(arg)
+        attributes = Utils::Hashes.symbolize_keys(arg)
 
         __update_accessible_attributes(attributes)
         __fetch_accessible_attributes

data/lib/micro/case/result/transitions.rb

@@ -15,4 +15,3 @@ module Micro
     end
   end
 end
-

data/lib/micro/case/result/wrapper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Micro
+  class Case
+    class Result
+      class Wrapper
+        attr_reader :output
+
+        def initialize(result)
+          @result = result
+          @output = ::Kind::Undefined
+
+          @__is_unknown = true
+        end
+
+        def failure(type = nil)
+          return if @result.success? || !undefined_output?
+
+          set_output(yield(@result)) if result_type?(type)
+        end
+
+        def success(type = nil)
+          return if @result.failure? || !undefined_output?
+
+          set_output(yield(@result)) if result_type?(type)
+        end
+
+        def unknown
+          @output = yield(@result) if @__is_unknown && undefined_output?
+        end
+
+        private
+
+          def set_output(value)
+            @__is_unknown = false
+
+            @output = value
+          end
+
+          def undefined_output?
+            ::Kind::Undefined == @output
+          end
+
+          def result_type?(type)
+            type.nil? || @result.type == type
+          end
+      end
+    end
+  end
+end

data/lib/micro/case/safe.rb

@@ -8,7 +8,7 @@ module Micro
       end
 
       def __call__
-        call
+        __call_the_use_case_or_its_flow
       rescue => exception
         raise exception if Error.by_wrong_usage?(exception)
 

data/lib/micro/case/utils.rb

@@ -3,25 +3,34 @@
 module Micro
   class Case
     module Utils
-      def self.symbolize_hash_keys(hash)
-        if Kind::Of::Hash(hash).respond_to?(:transform_keys)
-          hash.transform_keys { |key| key.to_sym rescue key }
-        else
+
+      module Hashes
+        def self.respond_to?(hash, method)
+          Kind.of(Hash, hash).respond_to?(method)
+        end
+
+        def self.symbolize_keys(hash)
+          return hash.transform_keys { |key| key.to_sym rescue key } if respond_to?(hash, :transform_keys)
+
           hash.each_with_object({}) do |(k, v), memo|
             key = k.to_sym rescue k
-
             memo[key] = v
           end
         end
-      end
 
-      def self.slice_hash(hash, keys)
-        if Kind::Of::Hash(hash).respond_to?(:slice)
-          hash.slice(*keys)
-        else
+        def self.stringify_keys(hash)
+          return hash.transform_keys(&:to_s) if respond_to?(hash, :transform_keys)
+
+          hash.each_with_object({}) { |(k, v), memo| memo[k.to_s] = v }
+        end
+
+        def self.slice(hash, keys)
+          return hash.slice(*keys) if respond_to?(hash, :slice)
+
           hash.select { |key, _value| keys.include?(key) }
         end
       end
+
     end
   end
 end

data/lib/micro/case/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   class Case
-    VERSION = '4.0.0'.freeze
+    VERSION = '4.2.2'.freeze
   end
 end

data/lib/micro/cases.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require 'micro/cases/utils'
+require 'micro/cases/error'
 require 'micro/cases/flow'
 require 'micro/cases/safe/flow'
+require 'micro/cases/map'
 
 module Micro
   module Cases
@@ -12,5 +15,9 @@ module Micro
     def self.safe_flow(args)
       Safe::Flow.build(args)
     end
+
+    def self.map(args)
+      Map.build(args)
+    end
   end
 end

data/lib/micro/cases/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Micro
+  module Cases
+
+    module Error
+      class InvalidUseCases < ArgumentError
+        def initialize; super('argument must be a collection of `Micro::Case` classes'.freeze); end
+      end
+    end
+
+  end
+end

data/lib/micro/cases/flow.rb

@@ -3,20 +3,15 @@
 module Micro
   module Cases
     class Flow
-      class InvalidUseCases < ArgumentError
-        def initialize; super('argument must be a collection of `Micro::Case` classes'.freeze); end
-      end
+      IsAUseCaseWithDefaults = -> arg { arg.is_a?(Array) && Micro.case?(arg[0]) && arg[1].is_a?(Hash) }
+      IsAValidUseCase = -> use_case { Micro.case?(use_case) || IsAUseCaseWithDefaults[use_case] }
 
       attr_reader :use_cases
 
-      def self.map_use_cases(arg)
-        arg.is_a?(Flow) ? arg.use_cases : Array(arg)
-      end
-
       def self.build(args)
-        use_cases = Array(args).flat_map { |arg| map_use_cases(arg) }
+        use_cases = Utils.map_use_cases(args)
 
-        raise InvalidUseCases if use_cases.any? { |klass| !(klass < ::Micro::Case) }
+        raise Error::InvalidUseCases if use_cases.none?(&IsAValidUseCase)
 
         new(use_cases)
       end
@@ -27,8 +22,12 @@ module Micro
         @first = @next_ones.shift
       end
 
+      def inspect
+        '#<(%s) use_cases=%s>' % [self.class, @use_cases]
+      end
+
       def call!(input:, result:)
-        first_result = __case_use_case(@first, result, input)
+        first_result = __call_use_case(@first, result, input)
 
         return first_result if @next_ones.empty?
 
@@ -36,7 +35,15 @@ module Micro
       end
 
       def call(input = Kind::Empty::HASH)
-        call!(input: input, result: Case::Result.new)
+        result = call!(input: input, result: Case::Result.new)
+
+        return result unless block_given?
+
+        result_wrapper = ::Micro::Case::Result::Wrapper.new(result)
+
+        yield(result_wrapper)
+
+        result_wrapper.output
       end
 
       alias __call__ call
@@ -68,17 +75,23 @@ module Micro
           raise Case::Error::InvalidInvocationOfTheThenMethod.new("#{self.class.name}#")
         end
 
-        def __case_use_case(use_case, result, input)
-          use_case.__new__(result, input).__call__
+        def __call_use_case(use_case, result, input)
+          __build_use_case(use_case, result, input).__call__
         end
 
         def __call_next_use_cases(first_result)
           @next_ones.reduce(first_result) do |result, use_case|
             break result if result.failure?
 
-            __case_use_case(use_case, result, result.data)
+            __call_use_case(use_case, result, result.data)
           end
         end
+
+        def __build_use_case(use_case, result, input)
+          return use_case.__new__(result, input) unless use_case.is_a?(Array)
+
+          use_case[0].__new__(result, input.merge(use_case[1]))
+        end
     end
   end
 end