ruby-on-rails - mapas - rescue ruby

Aumentar la excepción personalizada con argumentos

Question

Estoy definiendo una excepción personalizada en un modelo en rieles como una especie de envoltura Excepción: ( begin[code]rescue[raise custom exception]end )

Cuando subo la Excepción, me gustaría pasarle algo de información sobre a) la instancia del modelo cuyas funciones internas provocan el error, yb) el error detectado.

Esto se realiza mediante un método de importación automatizada de un modelo que se rellena con una solicitud POST desde un origen de datos externo.

tldr; ¿Cómo se puede pasar argumentos a una excepción, dado que usted mismo define la excepción? Tengo un método de inicialización en esa Excepción, pero la sintaxis de raise parece aceptar solo una clase y un mensaje de Excepción, sin parámetros opcionales que pasan al proceso de creación de instancias.

Answer 1

Solución:

class FooError < StandardError
  attr_reader :foo

  def initialize(foo)
   super
   @foo = foo
  end
end

Esta es la mejor manera si sigue la Guía de estilo de Rubocop y siempre pasa su mensaje como el segundo argumento para raise :

raise FooError.new(''the foo''), ''bar baz''

Usted puede obtener foo así:

rescue FooError => error
  error.foo     # => ''the foo''
  error.message # => ''bar baz''

Si desea definir el mensaje de error en FooError , escriba:

class FooError < StandardError
  attr_reader :foo

  def initialize(foo)
   super
   @foo = foo
  end

  def message
    "The foo is: #{foo}"
  end
end

Explicación:

Pasa tu mensaje como el segundo argumento a raise

Como dice la Guía de estilo de Rubocop , el mensaje y la clase de excepción deben proporcionarse como argumentos separados porque si escribe:

raise FooError.new(''bar baz'')

Y si desea pasar un retroceso para raise , no hay manera de hacerlo sin pasar el mensaje dos veces:

raise FooError.new(''bar baz''), ''bar baz'', other_error.backtrace

Como dice esta respuesta , deberá pasar un paso atrás si desea volver a elevar una excepción como una nueva instancia con el mismo camino hacia atrás y un mensaje o datos diferentes.

En initialize , llamar super , no super(message)

Aquí hay tres formas diferentes de implementar FooError con el código de prueba que puede ejecutar en Pry:

class SuperError < StandardError
  attr_reader :foo

  def initialize(foo)
   super
   @foo = foo
  end
end

class SuperWithMessageError < StandardError
  attr_reader :foo

  def initialize(foo)
   super(message)
   @foo = foo
  end
end

class SuperWithMessageArgumentError < StandardError
  attr_reader :foo

  def initialize(message = nil, foo)
   super(message)
   @foo = foo
  end
end

# All three classes behave the same except in this case:

raise SuperError, ''bar''
_ex_.foo     # => ''bar''
_ex_.message # => ''bar''

raise SuperWithMessageError, ''bar''
_ex_.foo     # => ''bar''
_ex_.message # => ''SuperWithMessageError''

raise SuperWithMessageArgumentError, ''bar''
_ex_.foo     # => ''bar''
_ex_.message # => ''SuperWithMessageArgumentError''

En SuperWithMessageError y SuperWithMessageArgumentError el mensaje no se configura correctamente, por lo que SuperError es la implementación correcta.

Answer 2

Aquí hay un código de ejemplo que agrega un código a un error:

class MyCustomError < StandardError
    attr_reader :code

    def initialize(code)
        @code = code
    end

    def to_s
        "[#{code}] #{super}"
    end
end

Y para elevarlo: raise MyCustomError.new(code), message

Answer 3

Puede crear una nueva instancia de su subclase de Exception , y luego aumentarla. Por ejemplo:

begin
  # do something
rescue => e
  error = MyException.new(e, ''some info'')
  raise error
end

Answer 4

crear una instancia de su excepción con el nuevo:

class CustomException < StandardError
  def initialize(data)
    @data = data
  end
end
# => nil 
raise CustomException.new(bla: "blupp")
# CustomException: CustomException