Class Exception and its subclasses are used to communicate between Kernel#raise and rescue statements in begin ... end blocks.
An Exception object carries information about an exception:
-
Its type (the exception’s class).
-
An optional descriptive message.
-
Optional backtrace information.
Some built-in subclasses of Exception have additional methods: e.g., NameError#name.
Defaults
Two Ruby statements have default exception classes:
-
raise: defaults toRuntimeError. -
rescue: defaults toStandardError.
Global Variables
When an exception has been raised but not yet handled (in rescue, ensure, at_exit and END blocks), two global variables are set:
-
$!contains the current exception. -
$@contains its backtrace.
Custom Exceptions
To provide additional or alternate information, a program may create custom exception classes that derive from the built-in exception classes.
A good practice is for a library to create a single “generic” exception class (typically a subclass of StandardError or RuntimeError) and have its other exception classes derive from that class. This allows the user to rescue the generic exception, thus catching all exceptions the library may raise even if future versions of the library add new exception subclasses.
For example:
class MyLibrary class Error < ::StandardError end class WidgetError < Error end class FrobError < Error end end
To handle both MyLibrary::WidgetError and MyLibrary::FrobError the library user can rescue MyLibrary::Error.
Built-In Exception Classes
The built-in subclasses of Exception are:
-
-
LoadError
-
-
fatal
With no argument, or if the argument is the same as the receiver, return the receiver. Otherwise, create a new exception object of the same class as the receiver, but with a message equal to string.to_str.
# File tmp/rubies/ruby-3.4.0-preview1/ext/json/lib/json/add/exception.rb, line 9
def self.json_create(object)
result = new(object['m'])
result.set_backtrace object['b']
result
end
See as_json.
static VALUE
exc_initialize(int argc, VALUE *argv, VALUE exc)
{
VALUE arg;
arg = (!rb_check_arity(argc, 0, 1) ? Qnil : argv[0]);
return exc_init(exc, arg);
}
Construct a new Exception object, optionally passing in a message.
static VALUE
exc_s_to_tty_p(VALUE self)
{
return RBOOL(rb_stderr_tty_p());
}
Returns true if exception messages will be sent to a tty.
static VALUE
exc_equal(VALUE exc, VALUE obj)
{
VALUE mesg, backtrace;
if (exc == obj) return Qtrue;
if (rb_obj_class(exc) != rb_obj_class(obj)) {
int state;
obj = rb_protect(try_convert_to_exception, obj, &state);
if (state || UNDEF_P(obj)) {
rb_set_errinfo(Qnil);
return Qfalse;
}
if (rb_obj_class(exc) != rb_obj_class(obj)) return Qfalse;
mesg = rb_check_funcall(obj, id_message, 0, 0);
if (UNDEF_P(mesg)) return Qfalse;
backtrace = rb_check_funcall(obj, id_backtrace, 0, 0);
if (UNDEF_P(backtrace)) return Qfalse;
}
else {
mesg = rb_attr_get(obj, id_mesg);
backtrace = exc_backtrace(obj);
}
if (!rb_equal(rb_attr_get(exc, id_mesg), mesg))
return Qfalse;
return rb_equal(exc_backtrace(exc), backtrace);
}
Equality—If obj is not an Exception, returns false. Otherwise, returns true if exc and obj share same class, messages, and backtrace.
# File tmp/rubies/ruby-3.4.0-preview1/ext/json/lib/json/add/exception.rb, line 29
def as_json(*)
{
JSON.create_id => self.class.name,
'm' => message,
'b' => backtrace,
}
end
Methods Exception#as_json and Exception.json_create may be used to serialize and deserialize a Exception object; see Marshal.
Method Exception#as_json serializes self, returning a 2-element hash representing self:
require 'json/add/exception' x = Exception.new('Foo').as_json # => {"json_class"=>"Exception", "m"=>"Foo", "b"=>nil}
Method JSON.create deserializes such a hash, returning a Exception object:
Exception.json_create(x) # => #<Exception: Foo>
static VALUE
exc_backtrace(VALUE exc)
{
VALUE obj;
obj = rb_attr_get(exc, id_bt);
if (rb_backtrace_p(obj)) {
obj = rb_backtrace_to_str_ary(obj);
/* rb_ivar_set(exc, id_bt, obj); */
}
return obj;
}
Returns any backtrace associated with the exception. The backtrace is an array of strings, each containing either “filename:lineNo: in ‘method”’ or “filename:lineNo.”
def a raise "boom" end def b a() end begin b() rescue => detail print detail.backtrace.join("\n") end
produces:
prog.rb:2:in `a' prog.rb:6:in `b' prog.rb:10
In the case no backtrace has been set, nil is returned
ex = StandardError.new ex.backtrace #=> nil
static VALUE
exc_backtrace_locations(VALUE exc)
{
VALUE obj;
obj = rb_attr_get(exc, id_bt_locations);
if (!NIL_P(obj)) {
obj = rb_backtrace_to_location_ary(obj);
}
return obj;
}
Returns any backtrace associated with the exception. This method is similar to Exception#backtrace, but the backtrace is an array of Thread::Backtrace::Location.
This method is not affected by Exception#set_backtrace().
static VALUE
exc_cause(VALUE exc)
{
return rb_attr_get(exc, id_cause);
}
Returns the previous exception ($!) at the time this exception was raised. This is useful for wrapping exceptions and retaining the original exception information.
static VALUE
exc_detailed_message(int argc, VALUE *argv, VALUE exc)
{
VALUE opt;
rb_scan_args(argc, argv, "0:", &opt);
VALUE highlight = check_highlight_keyword(opt, 0);
extern VALUE rb_decorate_message(const VALUE eclass, VALUE emesg, int highlight);
return rb_decorate_message(CLASS_OF(exc), rb_get_message(exc), RTEST(highlight));
}
Processes a string returned by message.
It may add the class name of the exception to the end of the first line. Also, when highlight keyword is true, it adds ANSI escape sequences to make the message bold.
If you override this method, it must be tolerant for unknown keyword arguments. All keyword arguments passed to full_message are delegated to this method.
This method is overridden by did_you_mean and error_highlight to add their information.
A user-defined exception class can also define their own detailed_message method to add supplemental information. When highlight is true, it can return a string containing escape sequences, but use widely-supported ones. It is recommended to limit the following codes:
-
Reset (
\e[0m) -
Bold (
\e[1m) -
Underline (
\e[4m) -
Foreground color except white and black
-
Red (
\e[31m) -
Green (
\e[32m) -
Yellow (
\e[33m) -
Blue (
\e[34m) -
Magenta (
\e[35m) -
Cyan (
\e[36m)
-
Use escape sequences carefully even if highlight is true. Do not use escape sequences to express essential information; the message should be readable even if all escape sequences are ignored.
static VALUE
exc_exception(int argc, VALUE *argv, VALUE self)
{
VALUE exc;
argc = rb_check_arity(argc, 0, 1);
if (argc == 0) return self;
if (argc == 1 && self == argv[0]) return self;
exc = rb_obj_clone(self);
rb_ivar_set(exc, id_mesg, argv[0]);
return exc;
}
With no argument, or if the argument is the same as the receiver, return the receiver. Otherwise, create a new exception object of the same class as the receiver, but with a message equal to string.to_str.
static VALUE
exc_full_message(int argc, VALUE *argv, VALUE exc)
{
VALUE opt, str, emesg, errat;
VALUE highlight, order;
rb_scan_args(argc, argv, "0:", &opt);
highlight = check_highlight_keyword(opt, 1);
order = check_order_keyword(opt);
{
if (NIL_P(opt)) opt = rb_hash_new();
rb_hash_aset(opt, sym_highlight, highlight);
}
str = rb_str_new2("");
errat = rb_get_backtrace(exc);
emesg = rb_get_detailed_message(exc, opt);
rb_error_write(exc, emesg, errat, str, opt, highlight, order);
return str;
}
Returns formatted string of exception. The returned string is formatted using the same format that Ruby uses when printing an uncaught exceptions to stderr.
If highlight is true the default error handler will send the messages to a tty.
order must be either of :top or :bottom, and places the error message and the innermost backtrace come at the top or the bottom.
The default values of these options depend on $stderr and its tty? at the timing of a call.
static VALUE
exc_inspect(VALUE exc)
{
VALUE str, klass;
klass = CLASS_OF(exc);
exc = rb_obj_as_string(exc);
if (RSTRING_LEN(exc) == 0) {
return rb_class_name(klass);
}
str = rb_str_buf_new2("#<");
klass = rb_class_name(klass);
rb_str_buf_append(str, klass);
if (RTEST(rb_str_include(exc, rb_str_new2("\n")))) {
rb_str_catf(str, ":%+"PRIsVALUE, exc);
}
else {
rb_str_buf_cat(str, ": ", 2);
rb_str_buf_append(str, exc);
}
rb_str_buf_cat(str, ">", 1);
return str;
}
Return this exception’s class name and message.
static VALUE
exc_message(VALUE exc)
{
return rb_funcallv(exc, idTo_s, 0, 0);
}
Returns the result of invoking exception.to_s. Normally this returns the exception’s message or name.
static VALUE
exc_set_backtrace(VALUE exc, VALUE bt)
{
VALUE btobj = rb_location_ary_to_backtrace(bt);
if (RTEST(btobj)) {
rb_ivar_set(exc, id_bt, btobj);
rb_ivar_set(exc, id_bt_locations, btobj);
return bt;
}
else {
return rb_ivar_set(exc, id_bt, rb_check_backtrace(bt));
}
}
Sets the backtrace information associated with exc. The backtrace must be an array of Thread::Backtrace::Location objects or an array of String objects or a single String in the format described in Exception#backtrace.
# File tmp/rubies/ruby-3.4.0-preview1/ext/json/lib/json/add/exception.rb, line 46
def to_json(*args)
as_json.to_json(*args)
end
Returns a JSON string representing self:
require 'json/add/exception' puts Exception.new('Foo').to_json
Output:
{"json_class":"Exception","m":"Foo","b":null}
static VALUE
exc_to_s(VALUE exc)
{
VALUE mesg = rb_attr_get(exc, idMesg);
if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
return rb_String(mesg);
}
Returns exception’s message (or the name of the exception if no message is set).