class Micro::Case::Result

Constants

FetchData
INVALID_INVOCATION_OF_THE_THEN_METHOD

Attributes

data[R]
type[R]
use_case[R]
value[R]

Public Class Methods

new(transitions_mapper = Transitions::MapEverything) click to toggle source
# File lib/micro/case/result.rb, line 24
def initialize(transitions_mapper = Transitions::MapEverything)
  enable_transitions = @@transitions_enabled

  @__is_unknown = true
  @__accumulated_data = {}
  @__tracked_use_cases = Set.new
  @__accessible_attributes = {}

  @__transitions = enable_transitions ? [] : Kind::Empty::ARRAY
  @__transitions_mapper = transitions_mapper if enable_transitions
end
transitions_enabled?() click to toggle source
# File lib/micro/case/result.rb, line 16
def self.transitions_enabled?
  @@transitions_enabled
end

Public Instance Methods

[](key) click to toggle source
# File lib/micro/case/result.rb, line 53
def [](key)
  data[key]
end
__set__(is_success, data, type, use_case) click to toggle source
# File lib/micro/case/result.rb, line 160
def __set__(is_success, data, type, use_case)
  raise Error::InvalidResultType unless type.is_a?(Symbol)
  raise Error::InvalidUseCase unless use_case.is_a?(::Micro::Case)

  @__success, @type, @use_case = is_success, type, use_case

  @data = FetchData.call(data).freeze

  raise Micro::Case::Error::InvalidResult.new(is_success, type, use_case) unless @data

  @__accumulated_data.merge!(@data)

  use_case_attributes = Utils::Hashes.symbolize_keys(@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?

  self
end
__set_accessible_attributes__(arg) click to toggle source
# File lib/micro/case/result.rb, line 185
def __set_accessible_attributes__(arg)
  return arg unless arg.is_a?(Hash)

  attributes = Utils::Hashes.symbolize_keys(arg)

  __update_accessible_attributes(attributes)
  __fetch_accessible_attributes
end
accessible_attributes() click to toggle source
# File lib/micro/case/result.rb, line 85
def accessible_attributes
  @__accessible_attributes.keys
end
failure?() click to toggle source
# File lib/micro/case/result.rb, line 77
def failure?
  !success?
end
inspect() click to toggle source
# File lib/micro/case/result.rb, line 36
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
key?(key) click to toggle source
# File lib/micro/case/result.rb, line 61
def key?(key)
  data.key?(key)
end
on_exception(expected_exception = nil) { |data, use_case| ... } click to toggle source
# File lib/micro/case/result.rb, line 111
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))
    @__is_unknown = false

    yield(data, @use_case)
  end

  self
end
on_failure(expected_type = nil) { |hook_data, use_case| ... } click to toggle source
# File lib/micro/case/result.rb, line 100
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)

  self
end
on_success(expected_type = nil) { |hook_data, use_case| ... } click to toggle source
# File lib/micro/case/result.rb, line 89
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)

  self
end
on_unknown() { |self, use_case| ... } click to toggle source
# File lib/micro/case/result.rb, line 123
def on_unknown
  return self unless unknown?

  yield(self, @use_case)

  self
end
slice(*keys) click to toggle source
# File lib/micro/case/result.rb, line 69
def slice(*keys)
  Utils::Hashes.slice(data, keys)
end
success?() click to toggle source
# File lib/micro/case/result.rb, line 73
def success?
  @__success
end
then(use_case = nil, attributes = nil, &block) click to toggle source
# File lib/micro/case/result.rb, line 131
def then(use_case = nil, attributes = 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
    return failure? ? self : __call_use_case(use_case, attributes)
  end
end
to_ary() click to toggle source
# File lib/micro/case/result.rb, line 45
def to_ary
  [data, type]
end
to_sym() click to toggle source
# File lib/micro/case/result.rb, line 49
def to_sym
  @__success ? :success : :failure
end
transitions() click to toggle source
# File lib/micro/case/result.rb, line 149
def transitions
  @__transitions.dup
end
unknown?() click to toggle source
# File lib/micro/case/result.rb, line 81
def unknown?
  @__is_unknown
end
value?(value) click to toggle source
# File lib/micro/case/result.rb, line 65
def value?(value)
  data.value?(value)
end
values_at(*keys) click to toggle source
# File lib/micro/case/result.rb, line 57
def values_at(*keys)
  data.values_at(*keys)
end
|(arg) click to toggle source
# File lib/micro/case/result.rb, line 145
def |(arg)
  failure? ? self : __call_use_case(arg)
end

Private Instance Methods

__call_method(methd, attributes = nil) click to toggle source
# File lib/micro/case/result.rb, line 236
def __call_method(methd, attributes = nil)
  __update_accessible_attributes(attributes ? attributes.merge(@__accumulated_data) : @__accumulated_data)

  result = methd.arity.zero? ? methd.call : methd.call(**__fetch_accessible_attributes)

  return self if result === self

  raise Error::UnexpectedResult.new("#{use_case.class.name}#method(:#{methd.name})")
end
__call_proc(fn, expected) click to toggle source
# File lib/micro/case/result.rb, line 226
def __call_proc(fn, expected)
  __update_accessible_attributes(@__accumulated_data)

  result = fn.arity.zero? ? fn.call : fn.call(__fetch_accessible_attributes)

  return self if result === self

  raise Error::UnexpectedResult.new("#{Result.name}##{expected}")
end
__call_use_case(use_case, attributes = nil) click to toggle source
# File lib/micro/case/result.rb, line 204
def __call_use_case(use_case, attributes = nil)
  case use_case
  when Proc
    __call_proc(use_case, 'then(-> {})'.freeze)
  when Method
    __call_method(use_case, attributes)
  when String, Symbol
    use_case_method = self.use_case.method(use_case)
    __call_method(use_case_method, attributes)
  else
    raise INVALID_INVOCATION_OF_THE_THEN_METHOD unless ::Micro.case_or_flow?(use_case)

    input = attributes.is_a?(Hash) ? self.data.merge(attributes) : self.data

    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
__failure_type?(expected_type) click to toggle source
# File lib/micro/case/result.rb, line 250
def __failure_type?(expected_type)
  failure? && (expected_type.nil? || expected_type == type)
end
__fetch_accessible_attributes() click to toggle source
# File lib/micro/case/result.rb, line 200
def __fetch_accessible_attributes
  @__accessible_attributes.dup
end
__set_transition(use_case_attributes) click to toggle source
# File lib/micro/case/result.rb, line 254
def __set_transition(use_case_attributes)
  @__transitions << @__transitions_mapper.call(self, use_case_attributes)
end
__success_type?(expected_type) click to toggle source
# File lib/micro/case/result.rb, line 246
def __success_type?(expected_type)
  success? && (expected_type.nil? || expected_type == type)
end
__update_accessible_attributes(attributes) click to toggle source
# File lib/micro/case/result.rb, line 196
def __update_accessible_attributes(attributes)
  @__accessible_attributes.merge!(attributes)
end