class Micro::Case

Constants

FLOW_STEP
INVALID_INVOCATION_OF_THE_THEN_METHOD
MapFailureType
VERSION

Public Class Methods

__call__(input = Kind::Empty::HASH)
Alias for: call
__call__!() click to toggle source
# File lib/micro/case.rb, line 117
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
__flow_builder__() click to toggle source
# File lib/micro/case.rb, line 95
def self.__flow_builder__
  Cases::Flow
end
__flow_get__() click to toggle source
# File lib/micro/case.rb, line 99
def self.__flow_get__
  return @__flow if defined?(@__flow)
end
__flow_set__!() click to toggle source
# File lib/micro/case.rb, line 132
def self.__flow_set__!
  __flow_set(__flow_use_cases_get) if !__flow_get__ && __flow_use_cases
end
__new__(result, arg) click to toggle source
# File lib/micro/case.rb, line 87
def self.__new__(result, arg)
  input = result.__set_accessible_attributes__(arg)

  new(input).__set_result__(result)
end
auto_validation_disabled?() click to toggle source
# File lib/micro/case/with_activemodel_validation.rb, line 11
def self.auto_validation_disabled?
  return @disable_auto_validation if defined?(@disable_auto_validation)
end
call(input = Kind::Empty::HASH) { |result_wrapper| ... } click to toggle source
# File lib/micro/case.rb, line 22
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
Also aliased as: __call__
call!() click to toggle source
# File lib/micro/case.rb, line 69
def call!
  self
end
config() { |instance| ... } click to toggle source
# File lib/micro/case.rb, line 65
def config
  yield(Config.instance)
end
disable_auto_validation() click to toggle source
# File lib/micro/case/with_activemodel_validation.rb, line 15
def self.disable_auto_validation
  @disable_auto_validation = true
end
flow(*args) click to toggle source
# File lib/micro/case.rb, line 58
def self.flow(*args)
  @__flow_use_cases = Cases::Utils.map_use_cases(args)
end
inherited(subclass) click to toggle source
# File lib/micro/case.rb, line 74
def self.inherited(subclass)
  subclass.__attributes_set_after_inherit__(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
inspect() click to toggle source
# File lib/micro/case.rb, line 138
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
new(input) click to toggle source
# File lib/micro/case.rb, line 158
def initialize(input)
  __setup_use_case(input)
end
then(use_case = nil, &block) click to toggle source
# File lib/micro/case.rb, line 37
def self.then(use_case = nil, &block)
  can_yield_self = respond_to?(:yield_self)

  if block
    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
to_proc() click to toggle source
# File lib/micro/case.rb, line 54
def self.to_proc
  Proc.new { |arg| call(arg) }
end
use_cases() click to toggle source
# File lib/micro/case.rb, line 106
def self.use_cases; __flow_get__.use_cases; end

Private Class Methods

__flow_set(args) click to toggle source
# File lib/micro/case.rb, line 103
                     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_use_cases() click to toggle source
# File lib/micro/case.rb, line 123
                     def self.__flow_use_cases
  return @__flow_use_cases if defined?(@__flow_use_cases)
end
__flow_use_cases_get() click to toggle source
# File lib/micro/case.rb, line 127
                     def self.__flow_use_cases_get
  Array(__flow_use_cases)
    .map { |use_case| use_case == self ? self.__call__! : use_case }
end

Public Instance Methods

__call__() click to toggle source
# File lib/micro/case.rb, line 166
def __call__
  __call_the_use_case_or_its_flow
end
__set_result__(result) click to toggle source
# File lib/micro/case.rb, line 170
def __set_result__(result)
  raise Error::InvalidResultInstance unless result.is_a?(Result)
  raise Error::ResultIsAlreadyDefined if defined?(@__result)

  @__result = result

  self
end
call!() click to toggle source
# File lib/micro/case.rb, line 162
def call!
  raise NotImplementedError
end

Private Instance Methods

Check(type = nil, result: nil, on: Kind::Empty::HASH) click to toggle source
# File lib/micro/case.rb, line 247
def Check(type = nil, result: nil, on: Kind::Empty::HASH)
  result_key = type || :check

  if value
    result = on[:success] || { result_key => true }

    Success(type || :ok, result: result)
  else
    result = on[:failure] || { result_key => false }

    Failure(type || :error, result: result)
  end
end
Failure(type = :error, result: nil) click to toggle source
# File lib/micro/case.rb, line 238
def Failure(type = :error, result: nil)
  value = result || type

  type = MapFailureType.call(value, type)

  __get_result(false, value, type)
end
Success(type = :ok, result: nil) click to toggle source
# File lib/micro/case.rb, line 224
def Success(type = :ok, result: nil)
  value = result || type

  __get_result(true, value, type)
end
__call_the_use_case_flow() click to toggle source
# File lib/micro/case.rb, line 220
def __call_the_use_case_flow
  self.class.__flow_get__.call(@__input)
end
__call_the_use_case_flow?() click to toggle source
# File lib/micro/case.rb, line 216
def __call_the_use_case_flow?
  self.class.__flow_get__
end
__call_the_use_case_or_its_flow() click to toggle source
# File lib/micro/case.rb, line 194
def __call_the_use_case_or_its_flow
  return __call_the_use_case_flow if __call_the_use_case_flow?

  __call_use_case
end
__call_use_case() click to toggle source
# File lib/micro/case.rb, line 208
def __call_use_case
  result = call!

  return result if result.is_a?(Result)

  raise Error::UnexpectedResult.new("#{self.class.name}#call!")
end
__get_result(is_success, value, type) click to toggle source
# File lib/micro/case.rb, line 261
def __get_result(is_success, value, type)
  @__result.__set__(is_success, value, type, self)
end
__setup_use_case(input) click to toggle source
# File lib/micro/case.rb, line 200
def __setup_use_case(input)
  self.class.__flow_set__!

  @__input = input

  self.attributes = input
end
apply(name) click to toggle source
# File lib/micro/case.rb, line 190
def apply(name)
  method(name)
end
call(use_case, defaults = Kind::Empty::HASH) click to toggle source
# File lib/micro/case.rb, line 181
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
failure_by_validation_error(object) click to toggle source
# File lib/micro/case/with_activemodel_validation.rb, line 31
def failure_by_validation_error(object)
  errors = object.respond_to?(:errors) ? object.errors : object

  Failure Micro::Case::Config.instance.activemodel_validation_errors_failure, result: {
    errors: errors
  }
end
transaction(adapter = :activerecord) { || ... } click to toggle source
# File lib/micro/case.rb, line 265
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