raise: Reactivate a Handled Error

Sometimes you may want to keep an exception “alive” even after it has been trapped in an exception-handling block. You can do this, for example, to defer the handling of the exception, say by passing it on to some other method. You can do this using the raise method. You need to be aware, however, that, once raised, an exception needs to be rehandled; otherwise, it may cause your program to crash. Here is a simple example of raising a ZeroDivisionError exception and passing on the exception to a method called, in this case, handleError:

raise.rb

begin
    divbyzero
rescue Exception => e
    puts( "A problem just occurred. Please wait..." )
    x = 0
    begin
        raise
    rescue
        handleError( e )
    end
end

Here divbyzero is the name of a method in which the divide-by-zero operation takes place, and handleError is a method that prints more detailed information on the exception:

def handleError( e )
    puts( "Error of type: #{e.class}" )
    puts( e )
    puts( "Here is a backtrace: " )
    puts( e.backtrace )
end

Notice that this uses the backtrace method, which displays an array of strings showing the filenames and line numbers where the error occurred and, in this case, the line that called the error-producing divbyzero method. This is an example of this program’s output:

A problem just occurred. Please wait...
Error of type: ZeroDivisionError
divided by 0
Here is a backtrace:
C:/Huw/programming/bookofruby/ch9/raise.rb:11:in `/'
C:/Huw/programming/bookofruby/ch9/raise.rb:11:in `divbyzero'
C:/Huw/programming/bookofruby/ch9/raise.rb:15:in `<main>'

You can also specifically raise your exceptions to force an error condition even when the program code has not caused an exception. Calling raise on its own raises an exception of the type RuntimeError (or whatever exception is in the global variable $!):

raise         # raises RuntimeError

By default, this will have no descriptive message associated with it. You can add a message as a parameter, like this:

raise "An unknown exception just occurred!"

You can raise a specific type of error:

raise ZeroDivisionError

You can also create an object of a specific exception type and initialize it with a custom message:

raise ZeroDivisionError.new( "I'm afraid you divided by Zero" )

This is a simple example:

raise2.rb

begin
    raise ZeroDivisionError.new( "I'm afraid you divided by Zero" )
rescue Exception => e
    puts( e.class )
    puts( "message: " + e.to_s )
end

This outputs the following:

ZeroDivisionError
message: I'm afraid you divided by Zero

If the standard exception types don’t meet your requirements, you can, of course, create new ones just by subclassing existing exceptions. Provide your classes with a to_str method in order to give them a default message.

raise3.rb

class NoNameError < Exception
    def to_str
        "No Name given!"
    end
end

Here is an example of how you might raise a custom exception:

def sayHello( aName )
    begin
        if (aName == "") or (aName == nil) then
             raise NoNameError
        end
    rescue Exception => e
        puts( e.class )
        puts( "error message: " + e.to_s )
        puts( e.backtrace )
    else
        puts( "Hello #{aName}" )
    end
end

If you now enter sayHello( nil ), this would be the output:

NoNameError
error message: NoNameError
C:/Huw/programming/bookofruby/ch9/raise3.rb:12:in `sayHello'
C:/Huw/programming/bookofruby/ch9/raise3.rb:23:in `<main>'

Digging Deeper

When trapping exceptions, the begin keyword may, in some circumstances, be omitted. Here you will learn about this syntax. I will also clarify some potential confusion about catch and throw.

Omitting begin and end

You can optionally omit begin and end when trapping exceptions inside a method, a class, or a module. For example, all the following are legal:

omit_begin_end.rb

def calc
        result = 1/0
    rescue Exception => e
        puts( e.class )
        puts( e )
        result = nil
    return result
end

class X
        @@x = 1/0
    rescue Exception => e
        puts( e.class )
        puts( e )
end

module Y
        @@x = 1/0
    rescue Exception => e
        puts( e.class )
        puts( e )
end

In all the previous cases, the exception-handling will also work if you place the begin and end keywords at the start and end of the exception-handling code in the usual way.

catch..throw

In some languages, exceptions are trapped using the keyword catch and may be raised using the keyword throw. Although Ruby provides catch and throw methods, these are not directly related to its exception handling. Instead, catch and throw are used to break out of a defined block of code when some condition is met. You could, of course, use catch and throw to break out of a block of code when an exception occurs (though this may not be the most elegant way of handling errors). For example, this code will exit the block delimited by curly brackets if a ZeroDivisionError occurs:

catch_except.rb

catch( :finished) {
   print( 'Enter a number: ' )
   num = gets().chomp.to_i
   begin
      result = 100 / num
   rescue Exception => e
      throw :finished        # jump to end of block
   end
   puts( "The result of that calculation is #{result}" )
}     # end of :finished catch block

See Chapter 6 for more on catch and throw.