u-case 3.0.0.rc1

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "micro/case"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/micro/case.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'kind'
+require 'micro/attributes'
+
+require 'micro/case/version'
+
+module Micro
+  class Case
+    require 'micro/case/utils'
+    require 'micro/case/result'
+    require 'micro/case/error'
+    require 'micro/case/safe'
+    require 'micro/case/strict'
+
+    require 'micro/cases'
+
+    include Micro::Attributes.without(:strict_initialize)
+
+    def self.call(options = {})
+      new(options).call
+    end
+
+    def self.to_proc
+      Proc.new { |arg| call(arg) }
+    end
+
+    def self.call!
+      self
+    end
+
+    def self.flow(*args)
+      @__flow_use_cases = args
+    end
+
+    def self.inherited(subclass)
+      subclass.attributes(self.attributes_data({}))
+      subclass.extend ::Micro::Attributes.const_get('Macros::ForSubclasses'.freeze)
+
+      if self.send(:__flow_use_cases) && !subclass.name.to_s.end_with?(FLOW_STEP)
+        raise "Wooo, you can't do this! Inherits from a use case which has an inner flow violates "\
+          "one of the project principles: Solve complex business logic, by allowing the composition of use cases. "\
+          "Instead of doing this, declare a new class/constant with the steps needed.\n\n"\
+          "Related issue: https://github.com/serradura/u-case/issues/19\n"
+      end
+    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
+
+      __new__(result, input).call
+    end
+
+    def self.__flow_builder
+      Cases::Flow
+    end
+
+    def self.__flow_get
+      return @__flow if defined?(@__flow)
+    end
+
+    private_class_method def self.__flow_set(args)
+      return if __flow_get
+
+      def self.use_cases; __flow_get.use_cases; end
+
+      self.class_eval('def use_cases; self.class.use_cases; end')
+
+      @__flow = __flow_builder.build(args)
+    end
+
+    FLOW_STEP = 'Flow_Step'.freeze
+
+    private_constant :FLOW_STEP
+
+    def self.__call!
+      return const_get(FLOW_STEP) if const_defined?(FLOW_STEP, false)
+
+      class_eval("class #{FLOW_STEP} < #{self.name}; private def __call; __call_use_case; end; end")
+    end
+
+    private_class_method def self.__flow_use_cases
+      return @__flow_use_cases if defined?(@__flow_use_cases)
+    end
+
+    private_class_method def self.__flow_use_cases_get
+      Array(__flow_use_cases)
+        .map { |use_case| use_case == self ? self.__call! : use_case }
+    end
+
+    def self.__flow_set!
+      __flow_set(__flow_use_cases_get) if !__flow_get && __flow_use_cases
+    end
+
+    def initialize(input)
+      __setup_use_case(input)
+    end
+
+    def call!
+      raise NotImplementedError
+    end
+
+    def call
+      __call
+    end
+
+    def __set_result__(result)
+      raise Error::InvalidResultInstance unless result.is_a?(Result)
+      raise Error::ResultIsAlreadyDefined if defined?(@__result)
+
+      @__result = result
+    end
+
+    private
+
+      def __setup_use_case(input)
+        self.class.__flow_set!
+
+        @__input = input
+
+        self.attributes = input
+      end
+
+      def __call
+        return __call_use_case_flow if __call_use_case_flow?
+
+        __call_use_case
+      end
+
+      def __call_use_case
+        result = call!
+
+        return result if result.is_a?(Result)
+
+        raise Error::UnexpectedResult.new(self.class)
+      end
+
+      def __call_use_case_flow?
+        self.class.__flow_get
+      end
+
+      def __call_use_case_flow
+        self.class.__flow_get.call(@__input)
+      end
+
+      def Success(type = :ok, result: nil)
+        value = result || type
+
+        __get_result(true, value, type)
+      end
+
+      MapFailureType = -> (value, type) do
+        return type if type != :error
+        return value if value.is_a?(Symbol)
+        return :exception if value.is_a?(Exception)
+
+        type
+      end
+
+      def Failure(type = :error, result: nil)
+        value = result || type
+
+        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)
+      end
+
+      private_constant :MapFailureType
+  end
+end

data/lib/micro/case/error.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Micro
+  class Case
+    module Error
+      class UnexpectedResult < TypeError
+        MESSAGE = '#call! must return an instance of Micro::Case::Result'.freeze
+
+        def initialize(klass); super(klass.name + MESSAGE); end
+      end
+
+      class ResultIsAlreadyDefined < ArgumentError
+        def initialize; super('result is already defined'.freeze); end
+      end
+
+      class InvalidResultType < TypeError
+        def initialize; super('type must be a Symbol'.freeze); end
+      end
+
+      class InvalidResultData < TypeError
+      end
+
+      class InvalidSuccessResult < InvalidResultData
+        def initialize(object)
+          super("Success(result: #{object.inspect}) must be a Hash or Symbol")
+        end
+      end
+
+      class InvalidFailureResult < InvalidResultData
+        def initialize(object)
+          super("Failure(result: #{object.inspect}) must be a Hash, Symbol or an Exception")
+        end
+      end
+
+      class InvalidResultInstance < ArgumentError
+        def initialize; super('argument must be an instance of Micro::Case::Result'.freeze); end
+      end
+
+      class InvalidUseCase < TypeError
+        def initialize; super('use case must be a kind or an instance of Micro::Case'.freeze); end
+      end
+
+      class InvalidInvocationOfTheThenMethod < StandardError
+        def initialize; super('Invalid invocation of the Micro::Case::Result#then method'); end
+      end
+
+      class InvalidAccessToTheUseCaseObject < StandardError
+        def initialize; super('only a failure result can access its use case object'.freeze); end
+      end
+
+      def self.by_wrong_usage?(exception)
+        exception.is_a?(InvalidResultData) || exception.is_a?(Error::UnexpectedResult) || exception.is_a?(ArgumentError)
+      end
+    end
+  end
+end

data/lib/micro/case/result.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Micro
+  class Case
+    class Result
+      Kind::Types.add(self)
+
+      @@transition_tracking_disabled = false
+
+      def self.disable_transition_tracking
+        @@transition_tracking_disabled = true
+      end
+
+      attr_reader :type, :data
+
+      alias_method :value, :data
+
+      def initialize
+        @__transitions__ = []
+        @__transitions_accessible_attributes__ = {}
+      end
+
+      def to_ary
+        [data, type]
+      end
+
+      def [](key)
+        data[key]
+      end
+
+      def values_at(*keys)
+        data.values_at(*keys)
+      end
+
+      def success?
+        @success
+      end
+
+      def failure?
+        !success?
+      end
+
+      def use_case
+        return @use_case if failure?
+
+        raise Error::InvalidAccessToTheUseCaseObject
+      end
+
+      def on_success(expected_type = nil)
+        yield(data) if success_type?(expected_type)
+
+        self
+      end
+
+      def on_failure(expected_type = nil)
+        return self unless failure_type?(expected_type)
+
+        hook_data = expected_type.nil? ? self : data
+
+        yield(hook_data, @use_case)
+
+        self
+      end
+
+      def on_exception(expected_exception = nil)
+        return self unless failure_type?(:exception)
+
+        if !expected_exception || (Kind.is(Exception, expected_exception) && data.fetch(:exception).is_a?(expected_exception))
+          yield(data, @use_case)
+        end
+
+        self
+      end
+
+      def then(arg = nil, attributes = nil, &block)
+        can_yield_self = respond_to?(:yield_self)
+
+        if block
+          raise Error::InvalidInvocationOfTheThenMethod if arg
+          raise NotImplementedError if !can_yield_self
+
+          yield_self(&block)
+        else
+          return yield_self if !arg && can_yield_self
+
+          raise Error::InvalidInvocationOfTheThenMethod if !is_a_use_case?(arg)
+
+          return self if failure?
+
+          input = attributes.is_a?(Hash) ? self.data.merge(attributes) : self.data
+
+          arg.__call_and_set_transition__(self, input)
+        end
+      end
+
+      def transitions
+        @__transitions__.clone
+      end
+
+      FetchData = -> (data, is_success) do
+        return data if data.is_a?(Hash)
+        return { data => true } if data.is_a?(Symbol)
+        return { exception: data } if data.is_a?(Exception)
+
+        err = is_success ? :InvalidSuccessResult : :InvalidFailureResult
+
+        raise Micro::Case::Error.const_get(err), data
+      end
+
+      def __set__(is_success, data, type, use_case)
+        raise Error::InvalidResultType unless type.is_a?(Symbol)
+        raise Error::InvalidUseCase if !is_a_use_case?(use_case)
+
+        @success, @type, @use_case = is_success, type, use_case
+
+        @data = FetchData.call(data, is_success)
+
+        __set_transition__ unless @@transition_tracking_disabled
+
+        self
+      end
+
+      def __set_transitions_accessible_attributes__(attributes_data)
+        return attributes_data if @@transition_tracking_disabled
+
+        __set_transitions_accessible_attributes__!(attributes_data)
+      end
+
+      private
+
+        def success_type?(expected_type)
+          success? && (expected_type.nil? || expected_type == type)
+        end
+
+        def failure_type?(expected_type)
+          failure? && (expected_type.nil? || expected_type == type)
+        end
+
+        def is_a_use_case?(arg)
+          (arg.is_a?(Class) && arg < ::Micro::Case) || arg.is_a?(::Micro::Case)
+        end
+
+        def __set_transitions_accessible_attributes__!(attributes_data)
+          attributes = Utils.symbolize_hash_keys(attributes_data)
+
+          __update_transitions_accessible_attributes__(attributes)
+        end
+
+        def __update_transitions_accessible_attributes__(attributes)
+          @__transitions_accessible_attributes__.merge!(attributes)
+          @__transitions_accessible_attributes__
+        end
+
+        def __set_transition__
+          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__ << {
+            use_case: { class: use_case_class, attributes: use_case_attributes },
+            result => { type: @type, result: data },
+            accessible_attributes: @__transitions_accessible_attributes__.keys
+          }
+        end
+
+        private_constant :FetchData
+    end
+  end
+end