module Caze::ClassMethods

Attributes

transaction_handler[RW]

Public Instance Methods

export(method_name, options = {}) click to toggle source
# File lib/caze.rb, line 45
def export(method_name, options = {})
  method_to_define = options.fetch(:as) { method_name }

  define_singleton_method(method_to_define, Proc.new { |*args|
    use_case_object = args.empty? ? new : new(*args)
    use_case_object.send(method_name)
  })
end
has_use_case(use_case_name, use_case_class, options = {}) click to toggle source
# File lib/caze.rb, line 13
def has_use_case(use_case_name, use_case_class, options = {})
  transactional = options.fetch(:transactional) { false }
  raise_use_case_exception = options.fetch(:raise_use_case_exception) { false }

  define_singleton_method(use_case_name, Proc.new do |*args|
    use_case = get_use_case_class(use_case_class)

    begin
      if transactional
        handler = self.transaction_handler

        unless handler
          raise NoTransactionMethodError,
            "This action should be executed inside a transaction. But no transaction handler was configured."
        end

        handler.transaction { use_case.send(use_case_name, *args) }
      else
        use_case.send(use_case_name, *args)
      end
    rescue NoTransactionMethodError
      raise
    rescue => e
      if raise_use_case_exception
        raise raise_use_case_error(use_case, e)
      else
        raise e
      end
    end
  end)
end

Private Instance Methods

define_use_case_error(use_case, name) click to toggle source
# File lib/caze.rb, line 76
def define_use_case_error(use_case, name)
  unless use_case.const_defined?(name, false)
    klass = Class.new(StandardError)
    use_case.const_set(name, klass)
  end
  use_case.const_get(name)
end
get_use_case_class(use_case_class) click to toggle source
# File lib/caze.rb, line 56
def get_use_case_class(use_case_class)
  if use_case_class.respond_to?(:upcase)
    return Object.const_get(use_case_class)
  end

  use_case_class
end
raise_use_case_error(use_case, error) click to toggle source

This method intends to inject the error inside the context of the use case, so we can identify the use case from it was raised

# File lib/caze.rb, line 66
def raise_use_case_error(use_case, error)
  name = error.class.name.split('::').last

  klass = define_use_case_error(use_case, name)
  wrapped = klass.new(error.message)
  wrapped.set_backtrace(error.backtrace)

  raise wrapped
end