Exception: Exception

Returns a backtrace value for self; the returned value depends on the form of the stored backtrace value:

• Array of ::Thread::Backtrace::Location objects: returns the array of strings given by Exception#backtrace_locations.map {|loc| loc.to_s }. This is the normal case, where the backtrace value was stored by Kernel#raise.

• Array of strings: returns that array. This is the unusual case, where the backtrace value was explicitly stored as an array of strings.

• nil: returns nil.

Example:

begin
  1 / 0
rescue => x
  x.backtrace.take(2)
end
# => ["(irb):132:in `/'", "(irb):132:in `<top (required)>'"]

see Backtraces.

Returns a backtrace value for self; the returned value depends on the form of the stored backtrace value:

• Array of ::Thread::Backtrace::Location objects: returns that array.

• Array of strings or nil: returns nil.

Example:

begin
  1 / 0
rescue => x
  x.backtrace_locations.take(2)
end
# => ["(irb):150:in `/'", "(irb):150:in `<top (required)>'"]

See Backtraces.

Returns the previous value of global variable $!, which may be nil (see Global Variables):

begin
  raise('Boom 0')
rescue => x0
  puts "Exception: #{x0};  $!: #{$!};  cause: #{x0.cause.inspect}."
  begin
    raise('Boom 1')
  rescue => x1
    puts "Exception: #{x1};  $!: #{$!};  cause: #{x1.cause}."
    begin
      raise('Boom 2')
    rescue => x2
      puts "Exception: #{x2};  $!: #{$!};  cause: #{x2.cause}."
    end
  end
end

Output:

Exception: Boom 0;  $!: Boom 0;  cause: nil.
Exception: Boom 1;  $!: Boom 1;  cause: Boom 0.
Exception: Boom 2;  $!: Boom 2;  cause: Boom 1.

Returns the message string with enhancements:

• Includes the exception class name in the first line.

• If the value of keyword highlight is true, includes bolding and underlining ANSI codes (see below) to enhance the appearance of the message.

Examples:

begin
  1 / 0
rescue => x
  p x.message
  p x.detailed_message                  # Class name added.
  p x.detailed_message(highlight: true) # Class name, bolding, and underlining added.
end

Output:

"divided by 0"
"divided by 0 (ZeroDivisionError)"
"\e[1mdivided by 0 (\e[1;4mZeroDivisionError\e[m\e[1m)\e[m"

This method is overridden by some gems in the Ruby standard library to add information:

• DidYouMean::Correctable#detailed_message.

• ErrorHighlight::CoreExt#detailed_message.

• SyntaxSuggest#detailed_message.

An overriding method must be tolerant of passed keyword arguments, which may include (but may not be limited to):

• :highlight.

• :did_you_mean.

• :error_highlight.

• :syntax_suggest.

An overriding method should also be careful with ANSI code enhancements; see Messages.

Returns an exception object of the same class as self; useful for creating a similar exception, but with a different message.

With #message nil, returns self:

x0 = StandardError.new('Boom') # => #<StandardError: Boom>
x1 = x0.exception              # => #<StandardError: Boom>
x0.__id__ == x1.__id__         # => true

With string-convertible object #message (even the same as the original message), returns a new exception object whose class is the same as self, and whose message is the given #message:

x1 = x0.exception('Boom') # => #<StandardError: Boom>
x0..equal?(x1)            # => false

Returns an enhanced message string:

• Includes the exception class name.

• If the value of keyword highlight is true (not nil or false), includes bolding ANSI codes (see below) to enhance the appearance of the message.

• Includes the backtrace:

  • If the value of keyword order is :top (the default), lists the error message and the innermost backtrace entry first.

  • If the value of keyword order is :bottom, lists the error message the the innermost entry last.

Example:

def baz
  begin
    1 / 0
  rescue => x
    pp x.message
    pp x.full_message(highlight: false).split("\n")
    pp x.full_message.split("\n")
  end
end
def bar; baz; end
def foo; bar; end
foo

Output:

"divided by 0"
["t.rb:3:in `/': divided by 0 (ZeroDivisionError)",
 "\tfrom t.rb:3:in `baz'",
 "\tfrom t.rb:10:in `bar'",
 "\tfrom t.rb:11:in `foo'",
 "\tfrom t.rb:12:in `<main>'"]
["t.rb:3:in `/': \e[1mdivided by 0 (\e[1;4mZeroDivisionError\e[m\e[1m)\e[m",
 "\tfrom t.rb:3:in `baz'",
 "\tfrom t.rb:10:in `bar'",
 "\tfrom t.rb:11:in `foo'",
 "\tfrom t.rb:12:in `<main>'"]

An overriding method should be careful with ANSI code enhancements; see Messages.

Returns a string representation of self:

x = RuntimeError.new('Boom')
x.inspect # => "#<RuntimeError: Boom>"
x = RuntimeError.new
x.inspect # => "#<RuntimeError: RuntimeError>"

Returns #to_s.

See Messages.

Sets the backtrace value for self; returns the given +value:

x = RuntimeError.new('Boom')
x.set_backtrace(%w[foo bar baz]) # => ["foo", "bar", "baz"]
x.backtrace                      # => ["foo", "bar", "baz"]

The given value must be an array of strings, a single string, or nil.

Does not affect the value returned by #backtrace_locations.

See Backtraces.

Returns a string representation of self:

x = RuntimeError.new('Boom')
x.to_s # => "Boom"
x = RuntimeError.new
x.to_s # => "RuntimeError"