u-case 3.0.0.rc9 → 4.1.1

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Micro
+  class Case
+    class Result
+      class Transitions
+        MapEverything = -> (result, use_case_attributes) do
+          {
+            use_case: { class: result.use_case.class, attributes: use_case_attributes },
+            result.to_sym => { type: result.type, result: result.data },
+            accessible_attributes: result.accessible_attributes
+          }
+        end
+      end
+    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

@@ -3,12 +3,12 @@
 module Micro
   class Case
     class Safe < ::Micro::Case
-      def self.__flow_builder
+      def self.__flow_builder__
         Cases::Safe::Flow
       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,24 +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.0.0.rc9'.freeze
+    VERSION = '4.1.1'.freeze
   end
 end

data/lib/micro/case/with_activemodel_validation.rb

@@ -37,7 +37,9 @@ module Micro
       def failure_by_validation_error(object)
         errors = object.respond_to?(:errors) ? object.errors : object
 
-        Failure :validation_error, result: { errors: errors }
+        Failure Micro::Case::Config.instance.activemodel_validation_errors_failure, result: {
+          errors: errors
+        }
       end
   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,42 +3,43 @@
 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)
-        return arg.use_cases if arg.is_a?(Flow)
-
-        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
 
       def initialize(use_cases)
-        @use_cases = use_cases
-        @first_use_case = use_cases[0]
-        @next_use_cases = use_cases[1..-1]
+        @use_cases = use_cases.dup.freeze
+        @next_ones = use_cases.dup
+        @first = @next_ones.shift
+      end
+
+      def inspect
+        '<(%s) use_cases=%s>' % [self.class, @use_cases]
       end
 
       def call!(input:, result:)
-        first_result = __next_use_case_result(@first_use_case, result, input)
+        first_result = __call_use_case(@first, result, input)
 
-        return first_result if @next_use_cases.empty?
+        return first_result if @next_ones.empty?
 
-        __next_use_cases_result(first_result)
+        __call_next_use_cases(first_result)
       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
@@ -51,30 +52,42 @@ module Micro
         can_yield_self = respond_to?(:yield_self)
 
         if block
-          raise Error::InvalidInvocationOfTheThenMethod if use_case
+          raise_invalid_invocation_of_the_then_method if use_case
           raise NotImplementedError if !can_yield_self
 
           yield_self(&block)
         else
           return yield_self if !use_case && can_yield_self
 
+          raise_invalid_invocation_of_the_then_method unless ::Micro.case_or_flow?(use_case)
+
           self.call.then(use_case)
         end
       end
 
       private
 
-        def __next_use_case_result(use_case, result, input)
-          use_case.__new__(result, input).__call__
+        def raise_invalid_invocation_of_the_then_method
+          raise Case::Error::InvalidInvocationOfTheThenMethod.new("#{self.class.name}#")
+        end
+
+        def __call_use_case(use_case, result, input)
+          __build_use_case(use_case, result, input).__call__
         end
 
-        def __next_use_cases_result(first_result)
-          @next_use_cases.reduce(first_result) do |result, use_case|
+        def __call_next_use_cases(first_result)
+          @next_ones.reduce(first_result) do |result, use_case|
             break result if result.failure?
 
-            __next_use_case_result(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 __next_use_case_result(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

data/u-case.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Rodrigo Serradura']
   spec.email         = ['rodrigo.serradura@gmail.com']
 
-  spec.summary       = %q{Create simple and powerful use cases as Ruby objects.}
-  spec.description   = %q{Create simple and powerful use cases as Ruby objects.}
+  spec.summary       = %q{Represent use cases in a simple and powerful way while writing modular, expressive and sequentially logical code.}
+  spec.description   = %q{Represent use cases in a simple and powerful way while writing modular, expressive and sequentially logical code.}
   spec.homepage      = 'https://github.com/serradura/u-case'
   spec.license       = 'MIT'
 
@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.2.0'
 
   spec.add_runtime_dependency 'kind', '>= 3.0', '< 5.0'
-  spec.add_runtime_dependency 'u-attributes', '~> 1.1'
+  spec.add_runtime_dependency 'u-attributes', '~> 2.0'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 13.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-case
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc9
+  version: 4.1.1
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-14 00:00:00.000000000 Z
+date: 2020-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -72,7 +72,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: Create simple and powerful use cases as Ruby objects.
+description: Represent use cases in a simple and powerful way while writing modular,
+  expressive and sequentially logical code.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
@@ -95,14 +96,19 @@ files:
 - lib/micro/case/config.rb
 - lib/micro/case/error.rb
 - lib/micro/case/result.rb
+- lib/micro/case/result/transitions.rb
+- lib/micro/case/result/wrapper.rb
 - lib/micro/case/safe.rb
 - lib/micro/case/strict.rb
 - lib/micro/case/utils.rb
 - lib/micro/case/version.rb
 - lib/micro/case/with_activemodel_validation.rb
 - lib/micro/cases.rb
+- lib/micro/cases/error.rb
 - lib/micro/cases/flow.rb
+- lib/micro/cases/map.rb
 - lib/micro/cases/safe/flow.rb
+- lib/micro/cases/utils.rb
 - lib/u-case.rb
 - lib/u-case/with_activemodel_validation.rb
 - test.sh
@@ -122,12 +128,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
-summary: Create simple and powerful use cases as Ruby objects.
+summary: Represent use cases in a simple and powerful way while writing modular, expressive
+  and sequentially logical code.
 test_files: []