PrettyException 0.9.5

data/PrettyException-CHANGES

@@ -0,0 +1,12 @@
+- 0.9.5
+    + Removed dependency on mw-template, now code uses rdoc/template instead.
+      Patch by Michael Neumann, thanks man.
+- 0.9.3
+    + Now properly escapes HTML characters inside code (reported by Patrick Gundlach)
+    + Fixed source line counting issue with heredoc strings (reported by Patrick Gundlach)
+    + Fixed crash with errors raised near the end of file (reported by Mikael Brockman)
+- 0.9.2
+    + Ruby sources are inserted in the backtrace table
+    + Added source highlightning based on Simon Strandgaard's Ruby lexer
+    + Fixed bug with Mozilla rendering engine
+    + Fixed license to be LGPL

data/lib/PrettyException.rb

@@ -0,0 +1,1091 @@
+###################################################
+# # # # # # # # # # # # # # # # # # # # # # # # # #
+#
+# = lib/PrettyException.rb
+#
+# PrettyPrint for Exceptions
+#
+# Author:: Dmitry V. Sabanin <sdmitry@lrn.ru>
+# Revision:: $Date: 2004/12/20 05:11:50 $ $Revision: 1.16 $
+# License:: LGPL
+#
+# Modified to use rdoc's templating by Michael Neumann (mneumann@ntecs.de).
+# 
+# # # # # # # # # # # # # # # # # # # # # # # # # #
+###################################################
+
+require 'rdoc/template'
+require 'rbconfig'
+require 'cgi'
+
+###################################################
+# Web PrettyPrint for Exceptions
+#
+class PrettyException
+
+  attr_writer :message
+  
+  ###################################################
+  def initialize(exception, tplpath = nil)
+    @tplpath = tplpath
+    @exception = exception
+    @message = nil
+  end
+  ###################################################
+  
+  ###################################################
+  def build_template
+    tmpl = 
+    if @tplpath and File.exists?(@tplpath)
+      File.read(@tplpath)
+    else
+      tplfile = File.readlines(__FILE__)
+      start = nil
+      tplfile.each_with_index do |line,idx|
+        if line =~ /^__END__\s*$/
+          start = idx + 1
+          break
+        end
+      end
+      tplfile[start..-1].join('')
+    end
+
+    return TemplatePage.new(tmpl)
+  end
+  ###################################################
+  
+  ###################################################
+  def gen_source(file, line, mark_line = true)
+    source = File.readlines(file)
+    source = hilite_source(source)
+    line = line.to_i
+    if mark_line
+      show = 3
+      begin_from = line - show
+      end_at = line + show 
+      begin_from = begin_from > 0 ? begin_from : 0
+      work_with = source[begin_from..end_at]
+    else
+      work_with = [ source[line-1] ]
+    end
+    work_with ||= []
+    res = []
+    work_with.each do |i, l|
+      l = ('<span class="hl_lineno">%.3d:</span>%s' % [i,"  "]) + l
+      if i == line and mark_line
+        buf = '<div class="current_line">' + l + '</div>'
+      else
+        buf = l + "\n"
+      end
+      res << buf
+    end
+    res.join
+  end
+  ###################################################
+
+  ###################################################
+  def hilite_source(src)
+    lx = LexerRuby::LexerOld.new
+    src.each do |sline|
+      lx.lex_line(sline)
+    end
+    res = []
+    lineno = 0
+    this_line = []
+    hc = false
+    heredoc_buf = nil
+    lx.result.each do |text, token|
+      if hc
+        lineno += 1
+        res << [lineno, this_line.join]        
+        this_line = []
+        hc = false
+      end
+      if token != :heredoc and heredoc_buf and token != :any
+        heredoc = heredoc_buf.split(/\n/)
+        heredoc.each do |hd_line|
+          res << [lineno, ('<span class="hl_heredoc">%s</span>' % [hd_line.to_s])]
+          lineno += 1
+        end
+        this_line = []
+        heredoc_buf = nil
+      end
+      case token
+        when :keyword, :ident, :punct, 
+              :comment, :ivar, :dot, 
+              :string, :command, :number,
+              :gvar, :literal, :symbol
+          if token == :comment
+            hc = true
+          end
+          text = CGI.escapeHTML(text)
+          this_line << ('<span class="hl_%s">%s</span>' % [token.to_s, text.rstrip])
+        when :heredoc
+          text = CGI.escapeHTML(text)
+          heredoc_buf ||= ''
+          heredoc_buf << text
+        when :any
+          if text =~ /^\s*\n$/
+            lineno += 1
+            res << [lineno, this_line.join]
+            this_line = []
+          else
+            this_line << text
+          end
+        else
+          this_line << CGI.escapeHTML(text)
+        end
+    end
+    res << [lineno+1, this_line.join] if this_line.length > 0
+    res
+  end
+  ###################################################
+    
+  ###################################################
+  def print
+    tpl = build_template
+    contents = {}
+    contents['message'] = CGI::escapeHTML(@exception.message).to_s
+    contents['exception'] = @exception.class.to_s
+    contents['time'] = Time.now.to_s
+    bt = []
+    @exception.backtrace.each_with_index do |str,idx| 
+      file,text = str.scan(/^(.+):(.+)(?::(.+))?$/).flatten;
+      file,line = file.split(/:/)
+      unless line
+        line = text
+        text = nil
+      end
+      is_stdlib = false
+      paths = [Config::CONFIG['rubylibdir'], Config::CONFIG['sitedir']]
+      paths.each do |dir| 
+        is_stdlib = true if (file =~ /#{Regexp::escape(dir)}/)
+      end
+      data = { 'file' => file, 'line' => line, 'text' => text, 'from_stdlib' => is_stdlib }
+      if idx == 0
+        data['source'] = gen_source(file, line)
+      else
+        data['source'] = gen_source(file, line)
+      end
+      data['iteration_id'] = idx.to_s
+      bt << data
+    end
+    contents['backtrace'] = bt
+    tpl.write_html_on(output='', contents)
+    output
+  end
+  ###################################################
+  
+  alias_method :to_s, :print
+  
+end
+
+class LexerBase
+	def initialize
+		@states = []
+		@result = []
+		@result_endofline = nil
+	end
+	attr_reader :states, :result, :result_endofline
+
+	def set_states(states)
+		@states = states
+	end
+	def set_result(result)
+		@result = result
+	end
+	def format(text, state_output)
+		@result << [text, state_output]
+	end
+	def format_end(state_output)
+		@result_endofline = state_output
+	end
+	def match(regexp, output)
+		m = regexp.match(@text)
+		return false unless m
+		txt = @text.slice!(0, m.end(0))
+		format(txt, output)
+		true
+	end
+	def lex_line(text)
+		raise "derived class #{self.class} must overload #lex_line."
+	end
+	def self.profile
+		lines = IO.readlines(__FILE__)
+		lexer = self.new
+		puts "profiling the #{self.inspect} lexer (this may take some time)"
+		require 'profiler'
+		Profiler__.start_profile
+		lines.each do |line|
+			lexer.set_states([])
+			lexer.set_result([])
+			lexer.lex_line(line)
+		end
+		Profiler__.print_profile(STDOUT)
+	end
+	def self.benchmark
+		n = 10000
+		puts "benchmarking the lexers (computing #{n} lines " +
+			"with GC disabled)"
+		require 'benchmark'
+		Benchmark.bm(20) do |b|
+			lexer = LexerRuby::LexerOld.new
+#=begin
+			lines = IO.readlines(__FILE__)
+			GC.disable
+			b.report("#{lexer.class}") do
+				n.times do |i|
+					lexer.set_states([])
+					lexer.set_result([])
+					lexer.lex_line(lines[i%lines.size].clone)
+				end
+			end
+#=begin
+			GC.enable
+			GC.start
+			lines = IO.readlines(__FILE__)
+			lexer = LexerRuby::LexerNew.new
+			GC.disable
+			b.report("#{lexer.class}") do
+				n.times do |i|
+					lexer.set_states([])
+					lexer.set_result([])
+					lexer.lex_line(lines[i%lines.size])
+				end
+			end
+=begin
+=end
+			GC.enable
+			GC.start
+			lines = IO.readlines(__FILE__)
+			lexer = LexerRuby::Lexer3.new
+			GC.disable
+			b.report("#{lexer.class}") do
+				n.times do |i|
+					lexer.set_states([])
+					lexer.set_result([])
+					lexer.lex_line(lines[i%lines.size])
+				end
+			end
+			GC.enable
+		end
+	end
+end
+
+module LexerText
+
+class Lexer < LexerBase
+	RE_TAB = /\A\t+/  
+	RE_NOTTAB = /\A[^\t]+/  
+	def lex_line(text)
+		@text = text
+		until @text.empty?
+			if match(RE_TAB, :tab)
+			else
+				match(RE_NOTTAB, :text)
+			end
+		end
+	end
+end # class Lexer
+
+end # module LexerText
+
+module LexerRuby
+
+module State
+
+class Base
+end
+
+class Heredoc < Base
+	def initialize(begin_tag, ignore_leading_spaces, interpolate=true)
+		@begin_tag = begin_tag
+		@ignore_leading_spaces = ignore_leading_spaces
+		@interpolate = interpolate
+	end
+	attr_reader :begin_tag, :ignore_leading_spaces, :interpolate
+	def ==(other)
+		(self.class == other.class) and
+		(@begin_tag == other.begin_tag) and 
+		(@ignore_leading_spaces == other.ignore_leading_spaces) and
+		(@interpolate == other.interpolate)
+	end
+end
+
+class Comment < Base
+	def ==(other)
+		(self.class == other.class)
+	end
+end
+
+class Endoffile < Base
+	def ==(other)
+		(self.class == other.class)
+	end
+end
+
+end # module State
+
+class NewerRubyLexer
+	RE_TOKENIZE = Regexp.new([
+		# TODO: @ivar
+		# TODO: @@cvar
+		# TODO: $gvar
+		# TODO: %literals  %w(a b c)  %Q|'"|
+		# TODO: :symbol
+		# TODO: ?x  chars
+		# TODO: 0b01001  binary data
+		# TODO: 0x234af  hex data
+		# TODO: keywords  =begin  defined?
+		# TODO: ruby puncturation  ..  ...  &&  ||
+		# TODO: /regexp/
+		# TODO: __END__ tag
+		# TODO: illegal ruby heredoc which has space after end-tag
+		# TODO: illegal ruby puncturation  &&&  ||| 
+		# TODO: illegal ruby numbers  0x23Yab
+		'#.*',                        # # blah  ## !?!  comment
+		'<<-?[[:alpha:]]+',           # <<HTML  <<-XML  heredoc
+		'<<-?\'[[:alpha:]]+\'',       # <<'eof' <<-'X'  heredoc single quoted
+		'<<-?"[[:alpha:]]+"',         # <<"eof" <<-"X"  heredoc double quoted
+		'\.[[:alpha:]][[:alnum:]_]*', # .method .dup2   method call
+		'[[:alpha:]][[:alnum:]_]*',   # value   pix2_3  identifier
+		'\'(?:[^\\\\]|\\\\.)*?\'',    # '\'x\\' ''      string single quoted
+		'"(?:[^\\\\]|\\\\.)*?"',      # "ab"    ""      string double quoted
+		'\d+\.\d+',                   # 0.123   32.10   number as float
+		'\d+',                        # 42      999     number as integer
+		'.'                           # *       +       fallthrough
+	].join('|'))
+	def initialize
+		@char_to_symbol_hash = {
+			" "  => :space,
+			"\t" => :tab
+		}
+		@char_to_symbol_hash.default = :should_not_happen
+	end
+	def tokenize(string)
+		string.scan(RE_TOKENIZE)
+	end
+	def lex(string)
+		tokens = tokenize(string)
+		states = tokens.map do |token|
+			# TODO: by inserting 2 parentesises in the TOKENIZER
+			# then I can destinguish between good/bad tokens.
+			# 'ab'.scan(/(a)(b)/) do |(good, bad)|
+			case token
+			when /\A(?:"|')./
+				:string
+			when /\A<<-?(?:"|'|)[[:alpha:]]/
+				:heredoc
+			when /\A\.[[:alpha:]]/
+				:method
+			when /\A[[:alpha:]]/
+				:ident
+			when /\A#/
+				:comment
+			when /\A[[:punct:]]/
+				:punct
+			when /\A[[:digit:]]/
+				:number
+			else
+				@char_to_symbol_hash[token]
+			end
+		end
+		[tokens, states]
+	end
+end
+
+class Lexer3 < LexerBase
+	def initialize
+		@rl = NewerRubyLexer.new
+		super
+	end
+	def what_to_output(hash)
+		@rl.what_to_output(hash)
+	end
+	def lex_line(text)
+		tokens, states = @rl.lex(text)
+		tokens.each_with_index do |token, index|
+			format(token, states[index])
+		end
+		true
+	end
+end
+
+
+class RubyLexer
+	def initialize
+		@result = []
+	end
+	attr_reader :result
+	PUNCT = ['(', ')'] + 
+		%w(=== ==  =~  =>  =   !=  !~  !) +
+		%w(<<  <=> <=  <   >=  >) +
+		%w({   }   [   ]) +
+		%w(::  :   ... ..) +
+		%w(+=  +   -=  -   **  *   /   %) +
+		%w(||  |   &&  &) +
+		%w(,   ;) 
+	RE_NUMBER = /\d[\d\.]*/
+	RE_PUNCT = Regexp.new('(?:' + 
+		PUNCT.map{|i| Regexp.escape(i)}.join('|') + ')')
+	RE_IDENT = /[[:alpha:]][\w\!]*/
+	RE_STRING = /".*?"|'.*?'/
+	RE_COMMENT = /#.*/
+	RE_COMMAND = /\.[[:alnum:]_]*[[:alnum:]_\?\!]/
+	RE_SPACE = /\x20+/
+	RE_NEWLINE = /\n+/
+	RE_TABS = /\t+/
+	def scan_index(string, regexp, prio, symbol)
+		string.scan(regexp) do
+			@result << [$~.begin(0), prio, $~.end(0), symbol]
+		end
+	end
+	def lex(string)
+		scan_index(string, RE_COMMENT, 0, :comment)
+		scan_index(string, RE_STRING, 1, :string)
+		scan_index(string, RE_COMMAND, 2, :command)
+		scan_index(string, RE_IDENT, 3, :ident)
+		scan_index(string, RE_NUMBER, 4, :number)
+		scan_index(string, RE_PUNCT, 5, :punct)
+		scan_index(string, RE_SPACE, 6, :space)
+		scan_index(string, RE_NEWLINE, 7, :newline)
+		scan_index(string, RE_TABS, 8, :tabs)
+	end
+	def result
+		# primary key = string begin position
+		# secondary key = priority
+		@result.sort!
+		# collect the highest precedens data
+		ary = [0]
+		@result.each do |i1, prio, i2, symbol|
+			next if ary.last > i1 # discard low precedens data
+			if ary.last < i1
+				ary << :any
+				ary << i1
+			end
+			ary << symbol
+			ary << i2
+		end
+		#p ary
+		ary
+	end
+	def self.mk(*symbols)
+		symbols.each do |symbol|
+			class_eval %{
+				def #{symbol.to_s}
+					res = []
+					@result.each do |i1, prio, i2, sym|
+						if sym == :#{symbol.to_s}
+							res << [i1, i2]
+						end
+					end
+					res
+				end
+			}
+		end
+	end
+	mk :number, :ident, :string, :punct 
+	mk :comment, :command, :space, :newline, :tabs
+end
+
+class LexerNew < LexerBase
+	def lex_line(text)
+		#puts("-"*40)
+		#puts "text=#{text.inspect}"
+		rl = RubyLexer.new
+		rl.lex(text)
+		res = rl.result
+		#puts "res=#{res.inspect}"
+		i1 = res.shift
+		while res.size > 1
+			symbol = res.shift
+			i2 = res.shift
+			format(text[i1, (i2-i1)], symbol)
+			i1 = i2
+		end
+		#puts "result=#{@result.inspect}"
+		true
+	end
+end
+
+class LexerOld < LexerBase
+	RE_COMMENT = /^#.*/m  
+
+	RE_TAB = /^\t+/  
+
+	RE_SPACE = /^\x20+/  
+
+	KEYWORDS = %w(alias and begin BEGIN break case class) +
+		%w(defined? def do else elsif end END ensure for if loop) +
+		%w(module next nil not or raise redo require rescue) +
+		%w(retry return self super then true false undef) +
+		%w(unless until yield when while)
+	RE_KEYWORD = Regexp.new(
+		'\A(?:' +
+		KEYWORDS.map{|txt|Regexp.escape(txt)}.join('|') + 
+		')(?!\w)'
+	)
+
+	RE_SYMBOL = /\A:[[:alpha:]_][[:alnum:]_]*/
+
+	RE_STRING = /^("|\')(?:[^\\]|\\.)*?\1/
+	RE_STRING_INTERPOL = /\A   ((?:[^\\]|\\.)*?)   (\#\{ .*? \}) /x
+	# TODO: interpolated code can nest (hint: recursion is necessary)
+	def match_string
+		m = RE_STRING.match(@text)
+		return false unless m
+		txt = @text.slice!(0, m.end(0))
+		if m[1] == '\''
+			format(txt, :string)
+			return true
+		end
+		# double quoted strings may contain interpolated code
+		until txt.empty?
+			m = RE_STRING_INTERPOL.match(txt)
+			unless m
+				format(txt, :string)
+				break
+			end
+			format(m[1], :string) unless m[1].empty?
+			format(m[2], :string1)
+			txt.slice!(0, m.end(0))
+		end
+		true
+	end
+
+	RE_REGEXP = /\A\/(.*?[^\\])?\//
+	
+	RE_IVAR = /\A@[[:alnum:]_]+/  
+
+	RE_DOT = /\A\.[[:alnum:]_]*[[:alnum:]_\?\!]/
+
+	RE_IDENTIFIER = /\A(?:[[:alnum:]_]+|\S+)/
+
+	RE_NUMBER = Regexp.new(
+		'\A(?:' + [
+			'0x[_a-fA-F0-9]+',
+			'0b[_01]+',
+			'\d[0-9_]*(?:\.[0-9_]*)?',
+			'\?.'
+		].join('|') + 
+		')'
+	)
+
+	PUNCT = ['(', ')'] + 
+		%w(=== ==  =~  =>  =   !=  !~  !) +
+		%w(<<  <=> <=  <   >=  >) +
+		%w({   }   [   ]) +
+		%w(::  :   ... ..) +
+		%w(+=  +   -=  -   **  *   /   %) +
+		%w(||  |   &&  &) +
+		%w(,   ;) 
+	RE_PUNCT = Regexp.new(
+		'\A(?:' + 
+		PUNCT.map{|txt|Regexp.escape(txt)}.join('|') + 
+		')'
+	)
+
+	VAR_GLOBALS = %q(_~*$!@/\\;,.=:<>"-&`'+1234567890).split(//)
+	RE_GVAR = Regexp.new(
+		'\A\$(?:' +
+		VAR_GLOBALS.map{|txt|Regexp.escape(txt)}.join('|') +  
+		'|[[:alnum:]_]+' +
+		')'
+	)
+
+	# TODO: deal with multiline literals
+	RE_LITERAL = Regexp.new(
+		'\A%[Qqwrx]?(?:' + [
+		'\(.*?\)',   # TODO: must count pairs
+		'\{.*?\}',   # TODO: must count pairs
+		'\<.*?\>',   # TODO: must count pairs
+		'\[.*?\]',   # TODO: must count pairs
+		'([^\(\{\<\[]).*?\1'
+		].join('|') + ')'
+	)
+
+	RE_BEGIN = /\A=begin$\n?\x20*\z/   # eat tailing space
+	def match_comment_begin
+		m = RE_BEGIN.match(@text)
+		return false unless m
+		#puts "comments"
+		@states << State::Comment.new
+		txt = @text.slice!(0, m.end(0))
+		format(txt, :mcomment)
+		format_end(:mcomment_end)
+		true
+	end 
+	RE_HEREDOC = /\A<<(-)?('|"|)(\w+)\2/
+	def match_heredoc_begin
+		m = RE_HEREDOC.match(@text)
+		return false unless m
+		ignore_leading_space = (m[1] != nil)
+		interpolate = (m[2] != "'")
+		begin_pattern = m[3]
+		@states << State::Heredoc.new(
+			begin_pattern, 
+			ignore_leading_space,
+			interpolate
+		)
+		txt = @text.slice!(0, m.end(0))
+		format(txt, :heredoc)
+		true
+	end
+	RE_END = /\A__END__$\n?\x20*\z/   # eat tailing space 
+	def match_endoffile
+		m = RE_END.match(@text)
+		return false unless m
+		#puts "propagate __END__"
+		@states << State::Endoffile.new
+		txt = @text.slice!(0, m.end(0))
+		format(txt, :endoffile)
+		format_end(:endoffile_end)
+		true
+	end
+	def lex_line_normal(text)
+		@text = text
+		return if match_comment_begin
+		return if match_endoffile
+		until @text.empty?
+			if match(RE_COMMENT, :comment)
+				format_end(:comment_end)
+			elsif match(RE_REGEXP, :regexp)
+			elsif match_heredoc_begin
+			elsif match(RE_LITERAL, :literal)
+            elsif match(RE_KEYWORD, :keyword)			
+			elsif match(RE_SYMBOL, :symbol)
+			elsif match(RE_PUNCT, :punct)
+			elsif match(RE_GVAR, :gvar)
+			elsif match_string
+			elsif match(RE_NUMBER, :number)
+			elsif match(RE_IVAR, :ivar)
+			elsif match(RE_DOT, :dot)
+			elsif match(RE_IDENTIFIER, :ident)
+			elsif match(RE_TAB, :tab)
+			elsif match(RE_SPACE, :space)
+			else 
+				#@text.slice!(0, 1)
+				txt = @text.slice!(0, 1)
+				format(txt, :any)
+			end
+		end
+	end
+	def match_heredoc_end(regexp)
+		m = regexp.match(@text)
+		return false unless m
+		#puts "end of heredoc"
+		@states.shift
+		txt = @text.slice!(0, m.end(0))
+		format(txt, :heredoc)
+		format_end(:heredoc_end2)
+		true
+	end
+	def lex_line_heredoc(text)
+		# TODO: color interpolated code  #{code}
+		@text = text
+		format_end(:heredoc_end)
+		hd_end = nil
+		state = @states[0]
+		hd_end = /\A#{state.begin_tag}$\n?\x20*\z/
+		return if match_heredoc_end(hd_end)
+		# continue lexing
+		ign_lead_spc = state.ignore_leading_spaces
+		until @text.empty?
+			if match(RE_TAB, :heredoc_tab)
+			elsif ign_lead_spc and match_heredoc_end(hd_end)
+			else
+				txt = @text.slice!(0, 1)
+				format(txt, :heredoc)
+			end
+		end
+	end
+	def match_comment_end
+		m = /\A\=end\b.*?$\n?\x20*\z/.match(@text)
+		return false unless m
+		#puts "comment end"
+		@states.shift
+		txt = @text.slice!(0, m.end(0))
+		format(txt, :mcomment)
+		true
+	end
+	def lex_line_comment(text)
+		@text = text
+		format_end(:mcomment_end)
+		return if match_comment_end
+		until @text.empty?
+			if match(RE_TAB, :mcomment_tab)
+			else
+				txt = @text.slice!(0, 1)
+				format(txt, :mcomment)
+			end
+		end
+	end
+	def lex_line_endoffile(text)
+		@text = text
+		format_end(:endoffile_end)
+		until @text.empty?
+			if match(RE_TAB, :endoffile_tab)
+			else
+				txt = @text.slice!(0, 1)
+				format(txt, :endoffile)
+			end
+		end
+	end
+	def lex_line(text)
+		if @states.empty? 
+			return lex_line_normal(text) 
+		end
+		state = @states[0]
+		case state
+		when State::Heredoc: lex_line_heredoc(text)
+		when State::Comment: lex_line_comment(text)
+		when State::Endoffile: lex_line_endoffile(text)
+		else
+			raise "unknown state #{state.class}"
+		end
+	end
+end
+
+# TODO: make the new lexer work!
+Lexer = LexerOld  # slow
+#Lexer = LexerNew  # slow
+#Lexer = Lexer3     # fastest
+
+end # module LexerRuby
+
+__END__
+<html>
+  <head>
+    <title>Oops!</title>
+    <style>
+    .data { 
+      border-style: dotted; 
+      padding: 4px; }
+    .trace_header { 
+      border-style: dotted; 
+      border-width: thin; 
+      background-color: #CCCCCC; 
+      text-align: center; }
+    .normal_trace_entry {
+      border-style: dotted; 
+      border-width: thin; 
+      text-align: center; 
+      padding: 6px; }
+    .stdlib_trace_entry {
+      border-style: dotted; 
+      border-width: thin; 
+      text-align: right; 
+      padding: 6px; } 
+    .source {
+      width: 100%;
+      background-color: #F4F4F4;
+      display: none;
+    }
+    span.hl_lineno {
+      font-weight: bold;
+    }    
+    pre {
+    	width: 80%;
+    	padding: 0px;
+    	margin: 0px;
+    }
+    div.current_line {
+      color: red;
+      background-color: #F4DADA;
+    }
+    span.hl_keyword {
+    	font-weight: bold;
+    }
+    span.hl_punct {
+    	font-weight: bold;
+    	color: darkblue;
+    }
+    span.hl_ident {
+    }
+    span.hl_command {
+    	font-weight: bold;
+    }
+    span.hl_number {
+    	color: darkgreen;
+    }
+    span.hl_string {
+    	color: darkgreen;
+    }    
+    span.hl_comment {
+    	color: grey;
+    }
+    span.hl_ivar {
+    	font-weight: bold;
+    	color: darkred;
+    }
+    span.hl_dot {
+    	font-weight: bold;
+    }
+    span.hl_literal {
+    	color: green;
+    }
+    span.hl_gvar {
+    	font-weight: bold;
+    }
+    span.hl_symbol {
+    	color: blue;
+    }
+    span.hl_regexp {
+    	color: green;
+    }
+    tr {
+    	background-color: white;
+    }
+    </style>  
+<script type="text/javascript"  language="javascript">
+	function toggleCode( id ) {
+		if ( document.getElementById )
+			elem = document.getElementById( id );
+		else if ( document.all )
+			elem = eval( "document.all." + id );
+		else
+			return false;
+
+		elemStyle = elem.style;
+		
+		if ( elemStyle.display != "block" ) {
+			elemStyle.display = "block"
+		} else {
+			elemStyle.display = "none"
+		}
+
+		return true;
+	}
+
+    var isDOM      = (typeof(document.getElementsByTagName) != 'undefined'
+                      && typeof(document.createElement) != 'undefined')
+                   ? 1 : 0;
+    var isIE4      = (typeof(document.all) != 'undefined'
+                      && parseInt(navigator.appVersion) >= 4)
+                   ? 1 : 0;
+    var isNS4      = (typeof(document.layers) != 'undefined')
+                   ? 1 : 0;
+    var capable    = (isDOM || isIE4 || isNS4)
+                   ? 1 : 0;
+    // Uggly fix for Opera and Konqueror 2.2 that are half DOM compliant
+    if (capable) {
+        if (typeof(window.opera) != 'undefined') {
+            var browserName = ' ' + navigator.userAgent.toLowerCase();
+            if ((browserName.indexOf('konqueror 7') == 0)) {
+                capable = 0;
+            }
+        } else if (typeof(navigator.userAgent) != 'undefined') {
+            var browserName = ' ' + navigator.userAgent.toLowerCase();
+            if ((browserName.indexOf('konqueror') > 0) && (browserName.indexOf('konqueror/3') == 0)) {
+                capable = 0;
+            }
+        } // end if... else if...
+    } // end if
+    
+    /**
+ * This array is used to remember mark status of rows in browse mode
+ */
+var marked_row = new Array;
+
+
+/**
+ * Sets/unsets the pointer and marker in browse mode
+ *
+ * @param   object    the table row
+ * @param   integer  the row number
+ * @param   string    the action calling this script (over, out or click)
+ * @param   string    the default background color
+ * @param   string    the color to use for mouseover
+ * @param   string    the color to use for marking a row
+ *
+ * @return  boolean  whether pointer is set or not
+ */
+function setPointer(theRow, theRowNum, theAction, theDefaultColor, thePointerColor, theMarkColor)
+{
+    var theCells = null;
+
+    // 1. Pointer and mark feature are disabled or the browser can't get the
+    //    row -> exits
+    if ((thePointerColor == '' && theMarkColor == '')
+        || typeof(theRow.style) == 'undefined') {
+        return false;
+    }
+
+    // 2. Gets the current row and exits if the browser can't get it
+    if (typeof(document.getElementsByTagName) != 'undefined') {
+        theCells = theRow.getElementsByTagName('td');
+    }
+    else if (typeof(theRow.cells) != 'undefined') {
+        theCells = theRow.cells;
+    }
+    else {
+        return false;
+    }
+
+    // 3. Gets the current color...
+    var rowCellsCnt  = theCells.length;
+    var domDetect    = null;
+    var currentColor = null;
+    var newColor     = null;
+    // 3.1 ... with DOM compatible browsers except Opera that does not return
+    //         valid values with "getAttribute"
+    if (typeof(window.opera) == 'undefined'
+        && typeof(theCells[0].getAttribute) != 'undefined') {
+        currentColor = theCells[0].getAttribute('bgcolor');
+        domDetect    = true;
+    }
+    // 3.2 ... with other browsers
+    else {
+        currentColor = theCells[0].style.backgroundColor;
+        domDetect    = false;
+    } // end 3
+
+    // 3.3 ... Opera changes colors set via HTML to rgb(r,g,b) format so fix it
+    if (currentColor.indexOf("rgb") >= 0)
+    {
+        var rgbStr = currentColor.slice(currentColor.indexOf('(') + 1,
+                                     currentColor.indexOf(')'));
+        var rgbValues = rgbStr.split(",");
+        currentColor = "#";
+        var hexChars = "0123456789ABCDEF";
+        for (var i = 0; i < 3; i++)
+        {
+            var v = rgbValues[i].valueOf();
+            currentColor += hexChars.charAt(v/16) + hexChars.charAt(v%16);
+        }
+    }
+
+    // 4. Defines the new color
+    // 4.1 Current color is the default one
+    if (currentColor == ''
+        || currentColor.toLowerCase() == theDefaultColor.toLowerCase()) {
+        if (theAction == 'over' && thePointerColor != '') {
+            newColor              = thePointerColor;
+        }
+        else if (theAction == 'click' && theMarkColor != '') {
+            newColor              = theMarkColor;
+            marked_row[theRowNum] = true;
+            // Garvin: deactivated onclick marking of the checkbox because it's also executed
+            // when an action (like edit/delete) on a single item is performed. Then the checkbox
+            // would get deactived, even though we need it activated. Maybe there is a way
+            // to detect if the row was clicked, and not an item therein...
+            // document.getElementById('id_rows_to_delete' + theRowNum).checked = true;
+        }
+    }
+    // 4.1.2 Current color is the pointer one
+    else if (currentColor.toLowerCase() == thePointerColor.toLowerCase()
+             && (typeof(marked_row[theRowNum]) == 'undefined' || !marked_row[theRowNum])) {
+        if (theAction == 'out') {
+            newColor              = theDefaultColor;
+        }
+        else if (theAction == 'click' && theMarkColor != '') {
+            newColor              = theMarkColor;
+            marked_row[theRowNum] = true;
+            // document.getElementById('id_rows_to_delete' + theRowNum).checked = true;
+        }
+    }
+    // 4.1.3 Current color is the marker one
+    else if (currentColor.toLowerCase() == theMarkColor.toLowerCase()) {
+        if (theAction == 'click') {
+            newColor              = (thePointerColor != '')
+                                  ? thePointerColor
+                                  : theDefaultColor;
+            marked_row[theRowNum] = (typeof(marked_row[theRowNum]) == 'undefined' || !marked_row[theRowNum])
+                                  ? true
+                                  : null;
+            // document.getElementById('id_rows_to_delete' + theRowNum).checked = false;
+        }
+    } // end 4
+
+    // 5. Sets the new color...
+    if (newColor) {
+        var c = null;
+        // 5.1 ... with DOM compatible browsers except Opera
+        if (domDetect) {
+            for (c = 0; c < rowCellsCnt; c++) {
+                theCells[c].setAttribute('bgcolor', newColor, 0);
+            } // end for
+        }
+        // 5.2 ... with other browsers
+        else {
+            for (c = 0; c < rowCellsCnt; c++) {
+                theCells[c].style.backgroundColor = newColor;
+            }
+        }
+    } // end 5
+
+    return true;
+} // end of the 'setPointer()' function
+    
+    
+ /**
+ * getElement
+ */
+function getElement(e,f){
+    if(document.layers){
+        f=(f)?f:self;
+        if(f.document.layers[e]) {
+            return f.document.layers[e];
+        }
+        for(W=0;i<f.document.layers.length;W++) {
+            return(getElement(e,fdocument.layers[W]));
+        }
+    }
+    if(document.all) {
+        return document.all[e];
+    }
+    return document.getElementById(e);
+}
+ </script>    
+  </head>
+  <body bgcolor="white">
+    <table cellspacing="4" width ="80%" align="center">
+      <tr>
+        <td colspan="3" align="left" class="normal_trace_entry">
+            <p class="data" style="font-size: large; margin: 0px; border-color: red;"><b>Exception raised!</b><br />          
+              <b>%exception%</b>: <b>%message%</b><br />
+              Time: <b>%time%</b>
+            </p>
+        </td>
+      </tr>
+      <tr>
+        <td class="trace_header"><b>File</b></td>
+        <td class="trace_header"><b>Line</b></td>
+        <td class="trace_header"><b>Info</b></td>
+      </tr>
+START:backtrace
+IFNOT:from_stdlib
+      <tr bgcolor="white" onmouseover="setPointer(this, %iteration_id%, 'over', 'white', '#CCFFCC', '#FFB2B2');"  onmouseout="setPointer(this, %iteration_id%, 'out', 'white', '#CCFFCC', '#FFB2B2');"  onmousedown="toggleCode('src%iteration_id%'); setPointer(this, %iteration_id%, 'click', 'white', '#CCFFCC', '#FFB2B2');">
+IF:text
+        <td bgcolor="white" class="normal_trace_entry">%file%</td>
+        <td bgcolor="white" class="normal_trace_entry">%line%</td>
+        <td bgcolor="white" class="normal_trace_entry">%text%</td>
+ENDIF:text
+IFNOT:text
+        <td bgcolor="white" class="normal_trace_entry">%file%</td>
+        <td bgcolor="white" class="normal_trace_entry" colspan="2">%line%</td>  
+ENDIF:text
+IF:source
+    	</tr>
+    	<tr> 
+    		<td colspan="3"><div id="src%iteration_id%" class="source"><tt><pre>%source%</pre></tt></div></td>
+ENDIF:source
+ENDIF:from_stdlib
+IF:from_stdlib
+      <tr bgcolor="white" onmouseover="setPointer(this, %iteration_id%, 'over', 'white', '#CCFFCC', '#FFB2B2');"  onmouseout="setPointer(this, %iteration_id%, 'out', 'white', '#CCFFCC', '#FFB2B2');"  onmousedown="setPointer(this, %iteration_id%, 'click', 'white', '#CCFFCC', '#FFB2B2');">
+IF:text
+        <td bgcolor="white" class="stdlib_trace_entry">%file%</td>
+        <td bgcolor="white" class="stdlib_trace_entry">%line%</td>
+        <td bgcolor="white" class="stdlib_trace_entry">%text%</td>
+ENDIF:text
+IFNOT:text
+        <td bgcolor="white" class="stdlib_trace_entry">%file%</td>
+        <td bgcolor="white" class="stdlib_trace_entry" colspan="2">%line%</td>  
+ENDIF:text
+ENDIF:from_stdlib
+      </tr>
+      
+END:backtrace
+    </table>
+  </body>
+</html>

metadata

@@ -0,0 +1,37 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: PrettyException
+version: !ruby/object:Gem::Version 
+  version: 0.9.5
+date: 2004-12-20
+summary: PrettyException is a library to output pretty html output for raised exceptions.
+require_paths: 
+  - lib
+author: Dmitry V. Sabanin
+email: sdmitry@muravey.net
+homepage: http://muravey-tools.rubyforge.org
+rubyforge_project: muravey-tools
+description: 
+autorequire: PrettyException
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib/PrettyException.rb
+  - PrettyException-CHANGES
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []