class Exception - Documentation for Ruby 3.3

# class Exception

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 to `RuntimeError`.

- `rescue`: defaults to `StandardError`.

## 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:

- `NoMemoryError`

- `ScriptError`

  - LoadError

  - `NotImplementedError`

  - `SyntaxError`

- `SecurityError`

- `SignalException`

  - `Interrupt`

- `StandardError`

  - `ArgumentError`

    - `UncaughtThrowError`

  - `EncodingError`

  - `FiberError`

  - `IOError`

    - `EOFError`

  - `IndexError`

    - `KeyError`

    - `StopIteration`

      - `ClosedQueueError`

  - `LocalJumpError`

  - `NameError`

    - `NoMethodError`

  - `RangeError`

    - `FloatDomainError`

  - `RegexpError`

  - `RuntimeError`

    - `FrozenError`

  - `SystemCallError`

    - Errno::*

  - `ThreadError`

  - `TypeError`

  - `ZeroDivisionError`

- `SystemExit`

- `SystemStackError`

- fatal

### Public Class Methods

exception([string]) → an_exception or 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`.

json_create(object) click to toggle source

See `as_json`.

    # File 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

new(msg = nil) → exception click to toggle source
exception(msg = nil) → exception

Construct a new `Exception` object, optionally passing in a message.

    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);
    }

to_tty? → true or false click to toggle source

Returns `true` if exception messages will be sent to a tty.

    static VALUE
    exc_s_to_tty_p(VALUE self)
    {
        return RBOOL(rb_stderr_tty_p());
    }

### Public Instance Methods

exc == obj → true or false click to toggle source

Equality—If obj is not an `Exception`, returns `false`. Otherwise, returns `true` if exc and obj share same class, messages, and backtrace.

    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);
    }

as_json(*) click to toggle source

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>

    # File ext/json/lib/json/add/exception.rb, line 29
    def as_json(*)
      {
        JSON.create_id => self.class.name,
        'm'            => message,
        'b'            => backtrace,
      }
    end

backtrace → array or nil click to toggle source

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(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;
    }

backtrace_locations → array or nil click to toggle source

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_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;
    }

cause → an_exception or nil click to toggle source

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_cause(VALUE exc)
    {
        return rb_attr_get(exc, id_cause);
    }

detailed_message(highlight: bool, **opt) → string click to toggle source

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_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));
    }

exception([string]) → an_exception or exc click to toggle source

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_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;
    }

full_message(highlight: bool, order: [:top or :bottom]) → string click to toggle source

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_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;
    }

inspect → string click to toggle source

Return this exception’s class name and message.

    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;
    }

message → string click to toggle source

Returns the result of invoking `exception.to_s`. Normally this returns the exception’s message or name.

    static VALUE
    exc_message(VALUE exc)
    {
        return rb_funcallv(exc, idTo_s, 0, 0);
    }

set_backtrace(backtrace) → array click to toggle source

Sets the backtrace information associated with `exc`. The `backtrace` must be an array of `String` objects or a single `String` in the format described in `Exception#backtrace`.

    static VALUE
    exc_set_backtrace(VALUE exc, VALUE bt)
    {
        return rb_ivar_set(exc, id_bt, rb_check_backtrace(bt));
    }

to_json(*args) click to toggle source

Returns a `JSON` string representing `self`:

    require 'json/add/exception'
    puts Exception.new('Foo').to_json

Output:

    {"json_class":"Exception","m":"Foo","b":null}

    # File ext/json/lib/json/add/exception.rb, line 46
    def to_json(*args)
      as_json.to_json(*args)
    end

to_s → string click to toggle source

Returns exception’s message (or the name of the exception if no message is set).

    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);
    }