example - Clases de error personalizadas de Ruby: herencia del atributo del mensaje

java custom exception best practice

Question

Parece que no puedo encontrar mucha información sobre clases de excepciones personalizadas.

Lo que sí sé

Puede declarar su clase de error personalizada y dejarla heredar de StandardError , para que pueda ser rescue d:

class MyCustomError < StandardError
end

Esto te permite subirlo usando:

raise MyCustomError, "A message"

y luego, recibe ese mensaje cuando rescatas

rescue MyCustomError => e
  puts e.message # => "A message"

Lo que no sé

Quiero dar a mi excepción algunos campos personalizados, pero quiero heredar el atributo del message de la clase principal. Descubrí leyendo sobre este tema que @message no es una variable de instancia de la clase de excepción, así que me preocupa que mi herencia no funcione.

¿Alguien puede darme más detalles sobre esto? ¿Cómo implementaría una clase de error personalizada con un atributo de object ? Es el siguiente correcto:

class MyCustomError < StandardError
  attr_reader :object
  def initialize(message, object)
    super(message)
    @object = object
  end
end

Y entonces:

raise MyCustomError.new(anObject), "A message"

Llegar:

rescue MyCustomError => e
  puts e.message # => "A message"
  puts e.object # => anObject

¿Funcionará, y si lo hace, es esta la forma correcta de hacer las cosas?

Answer 1

Dado lo que es la documentación de Ruby core de Exception , de la cual todos los otros errores heredan, estados sobre #message

Devuelve el resultado de invocar exception.to_s. Normalmente esto devuelve el mensaje o nombre de la excepción. Al suministrar un método to_str, las excepciones acuerdan ser utilizadas donde se esperan cadenas.

http://ruby-doc.org/core-1.9.3/Exception.html#method-i-message

to_s por redefinir to_s / to_str o el inicializador. Aquí hay un ejemplo en el que queremos saber, en una forma legible en su mayoría humanos, cuando un servicio externo no ha podido hacer algo.

NOTA: La segunda estrategia a continuación utiliza los métodos de cadenas bonitas de rieles, como demodualize , que pueden ser un poco complicados y, por lo tanto, potencialmente imprudentes en una excepción. También podría agregar más argumentos a la firma del método, si lo necesita.

Anulando la estrategia #to_s no #to_str, funciona de manera diferente

module ExternalService

  class FailedCRUDError < ::StandardError
    def to_s
      ''failed to crud with external service''
    end
  end

  class FailedToCreateError < FailedCRUDError; end
  class FailedToReadError < FailedCRUDError; end
  class FailedToUpdateError < FailedCRUDError; end
  class FailedToDeleteError < FailedCRUDError; end
end

Salida de consola

begin; raise ExternalService::FailedToCreateError; rescue => e; e.message; end
# => "failed to crud with external service"

begin; raise ExternalService::FailedToCreateError, ''custom message''; rescue => e; e.message; end
# => "failed to crud with external service"

begin; raise ExternalService::FailedToCreateError.new(''custom message''); rescue => e; e.message; end
# => "failed to crud with external service"

raise ExternalService::FailedToCreateError
# ExternalService::FailedToCreateError: failed to crud with external service

Anulación de la estrategia #initialize

Esta es la estrategia más cercana a las implementaciones que he usado en los rieles. Como se indicó anteriormente, utiliza los demodualize , underscore y humanize ActiveSupport . Pero esto podría eliminarse fácilmente, como en la estrategia anterior.

module ExternalService
  class FailedCRUDError < ::StandardError
    def initialize(service_model=nil)
      super("#{self.class.name.demodulize.underscore.humanize} using #{service_model.class}")
    end
  end

  class FailedToCreateError < FailedCRUDError; end
  class FailedToReadError < FailedCRUDError; end
  class FailedToUpdateError < FailedCRUDError; end
  class FailedToDeleteError < FailedCRUDError; end
end

Salida de consola

begin; raise ExternalService::FailedToCreateError; rescue => e; e.message; end
# => "Failed to create error using NilClass"

begin; raise ExternalService::FailedToCreateError, Object.new; rescue => e; e.message; end
# => "Failed to create error using Object"

begin; raise ExternalService::FailedToCreateError.new(Object.new); rescue => e; e.message; end
# => "Failed to create error using Object"

raise ExternalService::FailedCRUDError
# ExternalService::FailedCRUDError: Failed crud error using NilClass

raise ExternalService::FailedCRUDError.new(Object.new)
# RuntimeError: ExternalService::FailedCRUDError using Object

Herramienta de demostración

Esta es una demostración para mostrar el rescate y los mensajes de la implementación anterior. La clase que plantea las excepciones es una API falsa para Cloudinary. Simplemente descargue una de las estrategias anteriores en la consola de sus rieles, seguido de esto.

require ''rails'' # only needed for second strategy 

module ExternalService
  class FailedCRUDError < ::StandardError
    def initialize(service_model=nil)
      @service_model = service_model
      super("#{self.class.name.demodulize.underscore.humanize} using #{@service_model.class}")
    end
  end

  class FailedToCreateError < FailedCRUDError; end
  class FailedToReadError < FailedCRUDError; end
  class FailedToUpdateError < FailedCRUDError; end
  class FailedToDeleteError < FailedCRUDError; end
end

# Stub service representing 3rd party cloud storage
class Cloudinary

  def initialize(*error_args)
    @error_args = error_args.flatten
  end

  def create_read_update_or_delete
    begin
      try_and_fail
    rescue ExternalService::FailedCRUDError => e
      e.message
    end
  end

  private def try_and_fail
    raise *@error_args
  end
end

errors_map = [
  # Without an arg
  ExternalService::FailedCRUDError,
  ExternalService::FailedToCreateError,
  ExternalService::FailedToReadError,
  ExternalService::FailedToUpdateError,
  ExternalService::FailedToDeleteError,
  # Instantiated without an arg
  ExternalService::FailedCRUDError.new,
  ExternalService::FailedToCreateError.new,
  ExternalService::FailedToReadError.new,
  ExternalService::FailedToUpdateError.new,
  ExternalService::FailedToDeleteError.new,
  # With an arg
  [ExternalService::FailedCRUDError, Object.new],
  [ExternalService::FailedToCreateError, Object.new],
  [ExternalService::FailedToReadError, Object.new],
  [ExternalService::FailedToUpdateError, Object.new],
  [ExternalService::FailedToDeleteError, Object.new],
  # Instantiated with an arg
  ExternalService::FailedCRUDError.new(Object.new),
  ExternalService::FailedToCreateError.new(Object.new),
  ExternalService::FailedToReadError.new(Object.new),
  ExternalService::FailedToUpdateError.new(Object.new),
  ExternalService::FailedToDeleteError.new(Object.new),
].inject({}) do |errors, args|
  begin 
    errors.merge!( args => Cloudinary.new(args).create_read_update_or_delete)
  rescue => e
    binding.pry
  end
end

if defined?(pp) || require(''pp'')
  pp errors_map
else
  errors_map.each{ |set| puts set.inspect }
end

Answer 2

Tu idea es correcta, pero la forma en que la llamas es incorrecta. Debería ser

raise MyCustomError.new(an_object, "A message")

Answer 3

Yo quería hacer algo similar. Quería pasar un objeto a #new y configurar el mensaje en función de algún procesamiento del objeto pasado. Los siguientes trabajos.

class FooError < StandardError
  attr_accessor :message # this is critical!
  def initialize(stuff)
    @message = stuff.reverse
  end
end

begin
  raise FooError.new("!dlroW olleH")
rescue FooError => e
  puts e.message #=> Hello World!
end

Tenga en cuenta que si no declara attr_accessor :message entonces no funcionará. Al abordar el problema del OP, también puede pasar el mensaje como un argumento adicional y almacenar lo que quiera. La parte crucial parece ser anular el #mensaje.

Answer 4

raise ya establece el mensaje para que no tengas que pasarlo al constructor:

class MyCustomError < StandardError
  attr_reader :object

  def initialize(object)
    @object = object
  end
end

begin
  raise MyCustomError.new("an object"), "a message"
rescue MyCustomError => e
  puts e.message # => "a message"
  puts e.object # => "an object"
end

He reemplazado la rescue Exception de rescue MyCustomError con el rescue MyCustomError , mira ¿Por qué es un estilo malo ''rescatar Exception => e` en Ruby? .