u-case 3.1.0 → 4.2.1

data/lib/micro/case/error.rb

@@ -52,7 +52,10 @@ module Micro
       end
 
       def self.by_wrong_usage?(exception)
-        exception.is_a?(InvalidResult) || exception.is_a?(UnexpectedResult) || exception.is_a?(ArgumentError)
+        case exception
+        when Kind::Error, ArgumentError, InvalidResult, UnexpectedResult then true
+        else false
+        end
       end
     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)
@@ -22,20 +23,35 @@ module Micro
 
       alias value data
 
-      def initialize(transitions_mapper = nil)
+      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 || Transitions::MapEverything if enable_transitions
+        @__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
 
+      def to_sym
+        @__success ? :success : :failure
+      end
+
       def [](key)
         data[key]
       end
@@ -53,7 +69,7 @@ module Micro
       end
 
       def slice(*keys)
-        Utils.slice_hash(data, keys)
+        Utils::Hashes.slice(data, keys)
       end
 
       def success?
@@ -64,6 +80,10 @@ module Micro
         !success?
       end
 
+      def unknown?
+        @__is_unknown
+      end
+
       def accessible_attributes
         @__accessible_attributes.keys
       end
@@ -71,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)
@@ -81,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)
@@ -98,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)
 
@@ -159,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?
 
@@ -171,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

@@ -5,11 +5,9 @@ module Micro
     class Result
       class Transitions
         MapEverything = -> (result, use_case_attributes) do
-          result_track = result.success? ? :success : :failure
-
           {
             use_case: { class: result.use_case.class, attributes: use_case_attributes },
-            result_track => { type: result.type, result: result.data },
+            result.to_sym => { type: result.type, result: result.data },
             accessible_attributes: result.accessible_attributes
           }
         end
@@ -17,4 +15,3 @@ module Micro
     end
   end
 end
-

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Micro
+  class Case
+    class Result
+      class Wrapper
+        def initialize(result)
+          @__is_unknown = true
+
+          @result = result
+        end
+
+        def failure(type = nil)
+          return if @result.success?
+
+          if result_type?(type)
+            @__is_unknown = false
+
+            yield(@result)
+          end
+        end
+
+        def success(type = nil)
+          return if @result.failure?
+
+          if result_type?(type)
+            @__is_unknown = false
+
+            yield(@result)
+          end
+        end
+
+        def unknown
+          return yield(@result) if @__is_unknown
+        end
+
+        private
+
+          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/strict.rb

@@ -3,10 +3,10 @@
 module Micro
   class Case
     class Strict < ::Micro::Case
-      include Micro::Attributes::Features::StrictInitialize
+      include Micro::Attributes::Features::Initialize::Strict
 
       class Safe < ::Micro::Case::Safe
-        include Micro::Attributes::Features::StrictInitialize
+        include Micro::Attributes::Features::Initialize::Strict
       end
     end
   end

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 = '3.1.0'.freeze
+    VERSION = '4.2.1'.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,11 @@ 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?
+
+        yield ::Micro::Case::Result::Wrapper.new(result)
       end
 
       alias __call__ call
@@ -68,17 +71,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

data/lib/micro/cases/map.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Micro
+  module Cases
+    class Map
+      IsAUseCaseOrFlowWithDefaults = -> arg { arg.is_a?(Array) && Micro.case_or_flow?(arg[0]) && arg[1].is_a?(Hash) }
+      IsAUseCaseOrFlow = -> arg { Micro.case_or_flow?(arg) || IsAUseCaseOrFlowWithDefaults[arg] }
+      HasValidArgs = -> (args) { Kind.of(Array, args).all?(&IsAUseCaseOrFlow) }
+
+      attr_reader :use_cases
+
+      def self.build(args)
+        raise Error::InvalidUseCases unless HasValidArgs[args]
+
+        new(args)
+      end
+
+      def initialize(use_cases)
+        @use_cases = use_cases
+      end
+
+      GetUseCaseResult = -> (hash) do
+        -> (use_case) do
+          return use_case.call(hash) unless use_case.is_a?(Array)
+
+          use_case[0].call(hash.merge(use_case[1]))
+        end
+      end
+
+      def call(arg = {})
+        hash = Kind.of(Hash, arg)
+
+        use_cases.map(&GetUseCaseResult[hash])
+      end
+
+      private_constant :HasValidArgs, :IsAUseCaseOrFlow, :IsAUseCaseOrFlowWithDefaults, :GetUseCaseResult
+    end
+  end
+end

data/lib/micro/cases/safe/flow.rb

@@ -4,8 +4,8 @@ module Micro
   module Cases
     module Safe
       class Flow < Cases::Flow
-        private def __case_use_case(use_case, result, input)
-          instance = use_case.__new__(result, input)
+        private def __call_use_case(use_case, result, input)
+          instance = __build_use_case(use_case, result, input)
           instance.__call__
         rescue => exception
           raise exception if Case::Error.by_wrong_usage?(exception)

data/lib/micro/cases/utils.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Micro
+  module Cases
+
+    module Utils
+      def self.map_use_cases(args)
+        collection = args.is_a?(Array) && args.size == 1 ? args[0] : args
+
+        Array(collection).each_with_object([]) do |arg, memo|
+          if arg.is_a?(Flow)
+            arg.use_cases.each { |use_case| memo << use_case }
+          else
+            memo << arg
+          end
+        end
+      end
+    end
+
+  end
+end