Descendents of class Exception are used to communicate between raise methods and rescue statements in begin/end blocks. Exception objects carry information about the exception—its type (the exception’s class name), an optional descriptive string, and optional traceback information. Programs may subclass Exception to add additional information.

Methods
B
E
I
M
N
S
T
Y
Class Public methods
exc.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.

Exception.new(msg = nil) => exception

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

Source: show 

static VALUE
exc_initialize(argc, argv, exc)
    int argc;
    VALUE *argv;
    VALUE exc;
{
    VALUE arg;

    rb_scan_args(argc, argv, "01", &arg);
    rb_iv_set(exc, "mesg", arg);
    rb_iv_set(exc, "bt", Qnil);

    return exc;
}
yaml_new( klass, tag, val )

Source: show 

     # File lib/yaml/rubytypes.rb, line 119
119:     def Exception.yaml_new( klass, tag, val )
120:         o = YAML.object_maker( klass, { 'mesg' => val.delete( 'message' ) } )
121:         val.each_pair do |k,v|
122:             o.instance_variable_set("@#{k}", v)
123:         end
124:         o
125:     end
Instance Public methods
exception.backtrace => array

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

Source: show 

static VALUE
exc_backtrace(exc)
    VALUE exc;
{
    static ID bt;

    if (!bt) bt = rb_intern("bt");
    return rb_attr_get(exc, bt);
}
exc.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.

Source: show 

static VALUE
exc_exception(argc, argv, self)
    int argc;
    VALUE *argv;
    VALUE self;
{
    VALUE exc;

    if (argc == 0) return self;
    if (argc == 1 && self == argv[0]) return self;
    exc = rb_obj_clone(self);
    exc_initialize(argc, argv, exc);

    return exc;
}
exception.inspect => string

Return this exception’s class name an message

Source: show 

static VALUE
exc_inspect(exc)
    VALUE exc;
{
    VALUE str, klass;

    klass = CLASS_OF(exc);
    exc = rb_obj_as_string(exc);
    if (RSTRING(exc)->len == 0) {
        return rb_str_dup(rb_class_name(klass));
    }

    str = rb_str_buf_new2("#<");
    klass = rb_class_name(klass);
    rb_str_buf_append(str, klass);
    rb_str_buf_cat(str, ": ", 2);
    rb_str_buf_append(str, exc);
    rb_str_buf_cat(str, ">", 1);

    return str;
}
exception.message => string exception.to_str => string

Returns the result of invoking exception.to_s. Normally this returns the exception’s message or name. By supplying a to_str method, exceptions are agreeing to be used where Strings are expected.

Source: show 

static VALUE
exc_to_str(exc)
    VALUE exc;
{
    return rb_funcall(exc, rb_intern("to_s"), 0, 0);
}
exc.set_backtrace(array) => array

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

Source: show 

static VALUE
exc_set_backtrace(exc, bt)
    VALUE exc;
    VALUE bt;
{
    return rb_iv_set(exc, "bt", rb_check_backtrace(bt));
}
exception.to_s => string

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

Source: show 

static VALUE
exc_to_s(exc)
    VALUE exc;
{
    VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));

    if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
    if (OBJ_TAINTED(exc)) OBJ_TAINT(mesg);
    return mesg;
}
exception.message => string exception.to_str => string

Returns the result of invoking exception.to_s. Normally this returns the exception’s message or name. By supplying a to_str method, exceptions are agreeing to be used where Strings are expected.

Source: show 

static VALUE
exc_to_str(exc)
    VALUE exc;
{
    return rb_funcall(exc, rb_intern("to_s"), 0, 0);
}
to_yaml( opts = {} )

Source: show 

     # File lib/yaml/rubytypes.rb, line 126
126:         def to_yaml( opts = {} )
127:                 YAML::quick_emit( self, opts ) do |out|
128:             out.map( taguri, to_yaml_style ) do |map|
129:                 map.add( 'message', message )
130:                                 to_yaml_properties.each do |m|
131:                     map.add( m[1..-1], instance_variable_get( m ) )
132:                 end
133:             end
134:         end
135:         end