Things You Didn't Know About Exceptions

If at first you don't succeed…

tries   = 0
success = false
while(!success && tries < 3) 
  puts "Trying #{tries}..."
  return if success
  tries += 1
end
puts "Giving up."

Trying 0...
Trying 1...
Trying 2...
Giving up.

tries = 0
begin
  tries += 1
  puts "Trying #{tries}..."
  raise "Didn't work"
rescue
  retry if tries < 3
  puts "I give up"
end

Trying 1...
Trying 2...
Trying 3...
I give up

require 'English'
puts $!.inspect
begin
  raise "Oops"
rescue
  puts $!.inspect
  puts $ERROR_INFO.inspect
end
puts $!.inspect

nil
#<RuntimeError: Oops>
#<RuntimeError: Oops>
nil

at_exit do
  if $!
    open('crash.log', 'a')  do |log|
      error = {
        :timestamp => Time.now,
        :message   => $!.message,
        :backtrace => $!.backtrace,
        :gems      => Gem.loaded_specs.inject({}){
          |m, (n,s)| m.merge(n => s.version)
        }
      }
      YAML.dump(error, log)
    end
  end
end

require 'English'
class MyError < StandardError
  attr_reader :original
  def initialize(msg, original=$ERROR_INFO)
    super(msg)
    @original = original
  end
end

begin  
  begin
    raise "Error A"
  rescue => error
    raise MyError, "Error B"
  end
rescue => error
  puts "Rescued: #{error.inspect}"
  puts "Original: #{error.original.inspect}"
end

Rescued: #<MyError: Error B>
Original: #<RuntimeError: Error A>

Playing Hot Potato with exceptions.

data = []
open('datafile') do |f|
  data << eval(f.gets) until f.eof?
end

SyntaxError: (eval):1:in `irb_binding': compile error
(eval):1: syntax error, unexpected $undefined

data = []
open('datafile') do |f|
  begin
    data << eval(f.gets) until f.eof?
  rescue Exception => e
    raise e, "[At #{f.path}:#{f.lineno}] #{e.message}"
  end
end

SyntaxError: [At datafile:3] (eval):1:in `irb_binding': compile error
(eval):1: syntax error, unexpected $undefined

Get out your best monkeypatching hammer!

Make exceptions instantly fatal:

module RaiseExit
  def raise(msg_or_exc, 
            msg=msg_or_exc, 
            trace=caller)
    warn msg.to_s
    exit! 1
  end
end

class Object
  include RaiseExit
end

An error console for ruby: http://github.com/avdi/hammertime

require 'hammertime'
raise "Oh no!"

=== Stop! Hammertime. ===
    An error has occurred at example.rb:2:in 
`raise_runtime_error'
    The error is: #<RuntimeError: Oh no!>
    1. Continue (process the exception normally)
    2. Ignore (proceed without raising an exception)
    [...]
    5. Backtrace (show the call stack leading up to 
the error)
    6. Debug (start a debugger)
    7. Console (start an IRB session)

Like #to_s only for exceptions.

def raise(klass, message, backtrace)
  error = klass.new(message) # Nope!
  # ...
end

def raise(error_class_or_obj, message, backtrace)
  error = error_class_or_obj.exception(message)
  # ...
end

• Exception.exception
  Equivalent to calling Exception.new().

• Exception#exception
  
  • With no arguments, returns self.
    
  • With a message, returns a new exception.
    

class Net::HTTPResponse
  def exception(message="HTTP Error")
    RuntimeError.new("#{message}: #{code}")
  end
end

# ...
response = Net::HTTP.get_response(url)
raise response

exception_method.rb:11: HTTP Error: 404 (RuntimeError)

Getting picky about what to rescue.

# case
case obj
when Numeric, String, NilClass, FalseClass, TrueClass
  puts "scalar"
# ...
end

# rescue
rescue SystemCallError, IOError, SignalException 
  # handle exception...
end

def ignore_exceptions(*exceptions)
   yield
 rescue *exceptions => e
   puts "IGNORED: '#{e}'"
 end

 puts "Doing risky operation"
 ignore_exceptions(IOError, SystemCallError) do
   open("NOTEXIST")
 end
 puts "Carrying on..."

Doing risky operation
IGNORED: 'No such file or directory - NOTEXIST'
Carrying on...

def errors_matching(&block)
  m = Module.new
  (class << m; self; end).instance_eval do
    define_method(:===, &block)
  end
  m
end

begin
  raise RetryableError.new("Connection timeout", 2)
rescue errors_matching{|e| e.num_tries < 3} => e
  puts "Ignoring #{e.message}"
end

It's the end of the program as we know it.

begin
  puts "Terminating program..."
  exit
rescue Exception => e
  puts "Rescued: #{e.inspect}, status: #{e.status}"
end
puts "Continuing on..."

Terminating program...
Rescued: #<SystemExit: exit>, status: 0
Continuing on...

begin
  abort "Aborting..."
rescue Exception => e
  puts "Rescued: #{e.inspect}, status: #{e.status}"
end

Rescued: #<SystemExit: Aborting...>, status: 1

begin
  puts "Terminating for real"
  exit!
rescue Exceptions => e
  # will never get here
  # no crash logger either
  puts "Rescued: #{e.inspect}"
end

LA LA LA I CAN'T HEAR YOU

def whiny_method
  puts "Before raising"
  raise "Pay attention to me!"
  puts "After raising"
end

begin
  whiny_method
rescue => e
  puts "Ignoring '#{e}'"
  e.ignore
end

Before raising
Ignoring 'Pay attention to me!'
After raising

OK, maybe not out of the box.

class Exception
  attr_accessor :continuation
  def ignore
    continuation.call
  end
end

require 'continuation' # Ruby 1.9
module RaiseWithIgnore
  def raise(*args)
    callcc do |continuation|
      begin
        super
      rescue Exception => e
        e.continuation = continuation
        super(e)
      end
    end
  end
end

class Object
  include RaiseWithIgnore
end

begin
  whiny_method
rescue => e
  puts "Ignoring '#{e}'"
  e.ignore
end

Before raising
Ignoring 'Pay attention to me!'
After raising

• Book!
  
  • exceptionalruby.com
  • Code: ROCKYMTNRUBY

• Rate!
  
  • http://spkr8.com/t/8225

• Contact!
  avdi.org / @avdi

• Favor!
  Tweet "Thank you @taboulichic!"