u-case 3.0.0.rc4 → 3.0.0.rc9

data/lib/micro/case.rb

@@ -18,10 +18,25 @@ module Micro
 
     include Micro::Attributes.without(:strict_initialize)
 
-    def self.call(options = {})
+    def self.call(options = Kind::Empty::HASH)
       new(options).__call__
     end
 
+    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.to_proc
       Proc.new { |arg| call(arg) }
     end
@@ -55,16 +70,9 @@ module Micro
     end
 
     def self.__new__(result, arg)
-      instance = new(arg)
-      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
+      input = result.__set_transitions_accessible_attributes__(arg)
 
-      __new__(result, input).__call__
+      new(input).__set_result__(result)
     end
 
     def self.__flow_builder__
@@ -85,7 +93,7 @@ module Micro
       @__flow = __flow_builder__.build(args)
     end
 
-    FLOW_STEP = 'Flow_Step'.freeze
+    FLOW_STEP = 'Self'.freeze
 
     private_constant :FLOW_STEP
 
@@ -125,6 +133,8 @@ module Micro
       raise Error::ResultIsAlreadyDefined if defined?(@__result)
 
       @__result = result
+
+      self
     end
 
     private
@@ -196,11 +206,7 @@ module Micro
       private_constant :MapFailureType
   end
 
-  def self.case?(arg)
-    (arg.is_a?(Class) && arg < Case) || arg.is_a?(Case)
-  end
-
   def self.case_or_flow?(arg)
-    case?(arg) || arg.is_a?(Cases::Flow)
+    (arg.is_a?(Class) && arg < Case) || arg.is_a?(Cases::Flow)
   end
 end

data/lib/micro/case/config.rb

@@ -15,7 +15,7 @@ module Micro
 
       def enable_transitions=(value)
         Micro::Case::Result.class_variable_set(
-          :@@transition_tracking_disabled, !Kind::Of::Boolean(value)
+          :@@transitions_enabled, Kind::Of::Boolean(value)
         )
       end
     end

data/lib/micro/case/result.rb

@@ -7,15 +7,20 @@ module Micro
     class Result
       Kind::Types.add(self)
 
-      @@transition_tracking_disabled = false
+      @@transitions_enabled = true
+
+      def self.transitions_enabled?
+        @@transitions_enabled
+      end
 
       attr_reader :type, :data, :use_case
 
       alias value data
 
       def initialize
-        @__transitions__ = []
-        @__transitions_accessible_attributes__ = {}
+        @__transitions = []
+        @__transitions_accumulated_data = {}
+        @__transitions_accessible_attributes = {}
       end
 
       def to_ary
@@ -30,6 +35,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
@@ -78,34 +95,36 @@ module Micro
           yield_self(&block)
         else
           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)
 
-          if use_case.is_a?(Proc)
-            return failure? ? self : __call_proc(use_case, expected: 'then(-> {})'.freeze)
-          end
-
-          # TODO: Test the then method with a Micro::Cases.{flow,safe_flow}() instance.
           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
 
-          use_case.__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, expected: '| -> {}'.freeze) if arg.is_a?(Proc)
+        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.__call_and_set_transition__(self, data)
+        failure? ? self : arg.__new__(self, data).__call__
       end
 
       def transitions
-        @__transitions__.clone
+        @__transitions.clone
       end
 
       FetchData = -> (data) do
@@ -117,7 +136,7 @@ module Micro
 
       def __set__(is_success, data, type, use_case)
         raise Error::InvalidResultType unless type.is_a?(Symbol)
-        raise Error::InvalidUseCase unless ::Micro.case?(use_case)
+        raise Error::InvalidUseCase unless use_case.is_a?(::Micro::Case)
 
         @success, @type, @use_case = is_success, type, use_case
 
@@ -125,29 +144,53 @@ module Micro
 
         raise Micro::Case::Error::InvalidResult.new(is_success, type, use_case) unless @data
 
-        __set_transition unless @@transition_tracking_disabled
+        @__transitions_accumulated_data.merge!(@data)
+
+        use_case_attributes = Utils.symbolize_hash_keys(@use_case.attributes)
+
+        __update_transitions_accessible_attributes(use_case_attributes)
+
+        __set_transition(use_case_attributes) if @@transitions_enabled
 
         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 arg.is_a?(Hash)
 
-        attributes = Utils.symbolize_hash_keys(attributes_data)
+        attributes = Utils.symbolize_hash_keys(arg)
 
         __update_transitions_accessible_attributes(attributes)
       end
 
       private
 
-        def __call_proc(arg, expected:)
-          result = arg.arity.zero? ? arg.call : arg.call(data.clone)
+        def __fetch_accumulated_data(opt = nil)
+          __update_transitions_accessible_attributes(
+            opt ? opt.merge(@__transitions_accumulated_data) : @__transitions_accumulated_data
+          )
+        end
+
+        def __call_proc(fn, expected)
+          input = __fetch_accumulated_data
+
+          result = fn.arity.zero? ? fn.call : fn.call(input)
 
-          return result if result.is_a?(Result)
+          return self if result === self
 
           raise Error::UnexpectedResult.new("#{Result.name}##{expected}")
         end
 
+        def __call_method(methd, attributes = nil)
+          input = __fetch_accumulated_data(attributes)
+
+          result = methd.arity.zero? ? methd.call : methd.call(**input)
+
+          return self if result === self
+
+          raise Error::UnexpectedResult.new("#{use_case.class.name}#method(:#{methd.name})")
+        end
+
         def __success_type?(expected_type)
           success? && (expected_type.nil? || expected_type == type)
         end
@@ -157,22 +200,19 @@ module Micro
         end
 
         def __update_transitions_accessible_attributes(attributes)
-          @__transitions_accessible_attributes__.merge!(attributes)
-          @__transitions_accessible_attributes__
+          @__transitions_accessible_attributes.merge!(attributes)
+          @__transitions_accessible_attributes
         end
 
-        def __set_transition
+        def __set_transition(use_case_attributes)
           use_case_class = @use_case.class
-          use_case_attributes = Utils.symbolize_hash_keys(@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
 

data/lib/micro/case/utils.rb

@@ -14,6 +14,13 @@ module Micro
           end
         end
       end
+      def self.slice_hash(hash, keys)
+        if Kind::Of::Hash(hash).respond_to?(:slice)
+          hash.slice(*keys)
+        else
+          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.rc4'.freeze
+    VERSION = '3.0.0.rc9'.freeze
   end
 end

data/lib/micro/cases/flow.rb

@@ -29,14 +29,16 @@ module Micro
         @next_use_cases = use_cases[1..-1]
       end
 
-      def call(arg = {})
-        memo = arg.is_a?(Hash) ? arg.dup : {}
-
-        first_result = __first_use_case_result(arg)
+      def call!(input:, result:)
+        first_result = __next_use_case_result(@first_use_case, result, input)
 
         return first_result if @next_use_cases.empty?
 
-        __next_use_cases_result(first_result, memo)
+        __next_use_cases_result(first_result)
+      end
+
+      def call(input = Kind::Empty::HASH)
+        call!(input: input, result: Case::Result.new)
       end
 
       alias __call__ call
@@ -45,46 +47,32 @@ module Micro
         Proc.new { |arg| call(arg) }
       end
 
-      private
-
-        def __is_a_result?(arg)
-          arg.is_a?(Case::Result)
-        end
-
-        def __call_arg(arg)
-          output = arg.__call__
+      def then(use_case = nil, &block)
+        can_yield_self = respond_to?(:yield_self)
 
-          __is_a_result?(output) ? output.value : output
-        end
+        if block
+          raise Error::InvalidInvocationOfTheThenMethod if use_case
+          raise NotImplementedError if !can_yield_self
 
-        def __first_use_case_input(arg)
-          return __call_arg(arg) if ::Micro.case_or_flow?(arg)
-          return arg.value if __is_a_result?(arg)
+          yield_self(&block)
+        else
+          return yield_self if !use_case && can_yield_self
 
-          arg
+          self.call.then(use_case)
         end
+      end
 
-        def __first_use_case_result(arg)
-          input = __first_use_case_input(arg)
-
-          result = Case::Result.new
-
-          @first_use_case.__call_and_set_transition__(result, input)
-        end
+      private
 
         def __next_use_case_result(use_case, result, input)
           use_case.__new__(result, input).__call__
         end
 
-        def __next_use_cases_result(first_result, memo)
+        def __next_use_cases_result(first_result)
           @next_use_cases.reduce(first_result) do |result, use_case|
             break result if result.failure?
 
-            memo.merge!(result.value)
-
-            result.__set_transitions_accessible_attributes__(memo)
-
-            __next_use_case_result(use_case, result, memo)
+            __next_use_case_result(use_case, result, result.data)
           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 objects.}
-  spec.description   = %q{Create simple and powerful use cases as objects.}
+  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.homepage      = 'https://github.com/serradura/u-case'
   spec.license       = 'MIT'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-case
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc4
+  version: 3.0.0.rc9
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-02 00:00:00.000000000 Z
+date: 2020-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind
@@ -72,7 +72,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: Create simple and powerful use cases as objects.
+description: Create simple and powerful use cases as Ruby objects.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
@@ -87,6 +87,7 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- README.pt-BR.md
 - Rakefile
 - bin/console
 - bin/setup
@@ -128,5 +129,5 @@ requirements: []
 rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
-summary: Create simple and powerful use cases as objects.
+summary: Create simple and powerful use cases as Ruby objects.
 test_files: []