bijou 0.1.0

data/lib/bijou/diagnostics.rb

@@ -0,0 +1,87 @@
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# diagnostics.rb - Classes related to error handling
+#
+require 'bijou/common'
+
+module Bijou::Parse
+end
+
+class Bijou::Parse::Message
+  def initialize
+    @line = nil
+    @column = nil
+    @prefix = nil
+    @text = ''
+  end
+
+  attr_reader :line, :column
+
+  def at(line, column)
+    @line = line
+    @column = column
+  end
+
+  def <<(s)
+    @text << s.to_s
+  end
+  
+  def text
+    result = ''
+    result << @prefix if @prefix
+    result << "(#{@line}, #{@column || 0})" if @line
+    result << ": " + @text
+    result
+  end
+end
+
+class Bijou::Parse::Warning < Bijou::Parse::Message
+  def initialize
+    super()
+    @prefix = 'warning'
+  end
+end
+
+class Bijou::Parse::Error < Bijou::Parse::Message
+  def initialize
+    super()
+    @prefix = 'error'
+  end
+end
+
+class Bijou::Parse::Diagnostics
+  def initialize
+    @log = []
+    @messages = []
+    @messages = []
+    @warnings = []
+    @errors = []
+  end
+
+  attr_reader :errors, :warnings, :messages
+
+  def add_message(msg)
+    @messages.push(msg)
+    @log.push(msg)
+  end
+
+  def add_warning(msg)
+    @warnings.push(msg)
+    @log.push(msg)
+  end
+
+  def add_error(msg)
+    @errors.push(msg)
+    @log.push(msg)
+  end
+
+  def text
+    result = ''
+    @log.each { |s|
+      result << s.text
+      result << "\n"
+    }
+    result
+  end
+end

data/lib/bijou/errorformatter.rb

@@ -0,0 +1,322 @@
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# errorformatter.rb - Classes used to corelate Ruby errors with Bijou files
+#
+require 'cgi'
+require 'bijou/common'
+require 'bijou/exception'
+
+module Bijou
+  #
+  # The error formatter is used at runtime to locate the origin of errors 
+  # with respect to the source Bijou file. During processing, the text in a
+  # Bijou file is turned into Ruby code and cached as a separate file.
+  # It is the class contained in this file that is the runtime representation
+  # of a Bijou component. When a runtime error occurs, the exception refers
+  # to a location in the cached file. The ErrorFormatter class is used to 
+  # find the location in the original Bijou file by referring to #line comments
+  # embedded in the cached file and back tracking from there.
+  #
+  class ErrorFormatter
+    attr_accessor :title, :error, :errors, :warnings, :stack
+
+    def initialize
+      @title = ''
+      @error = nil
+      @errors = []
+      @warnings = []
+      @stack = []
+      @adjacent_lines = 0
+
+      # Context information
+      @filename = ''
+      @context_lines = []
+      @error_line = 0
+      @error_column = 0
+      @context = nil
+    end
+
+    def set_context(filename, lines, context, error_line, error_column)
+      @filename = filename
+      @context_lines = lines
+      @context = context
+      @error_line = error_line
+      @error_column = error_column
+    end
+
+    def format
+      raise StandardException, "Invalid error formatter"
+    end
+
+    def self.format_error(format, adjacent_lines, context=nil)
+      if format == :html
+        formatter = ErrorFormatterHTML.new
+      else
+        formatter = ErrorFormatterText.new
+      end
+
+      @context = context
+
+      result = ''
+
+      error_line = 0
+      error_column = 0
+
+      error = $!
+
+      if $!.kind_of?(Bijou::ParseError)
+        formatter.title = $!.to_s
+
+        filename = error.filename
+
+        formatter.errors.replace(error.diagnostics.errors)
+        formatter.warnings.replace(error.diagnostics.warnings)
+
+        if error.diagnostics.errors
+          # We use the first error as the origin.
+          selected_error = error.diagnostics.errors[0]
+          error_line = selected_error.line
+          error_column = selected_error.column
+        end
+      else
+        if $!.kind_of?(Bijou::EvalError)
+          formatter.error = error.cause
+          filename = error.filename
+          cachename = error.cachename
+        else
+          formatter.error = $!
+
+          # REVIEW: Are there any cases where the context would override
+          # the EvalError location?
+          if context
+            filename = context.source_filename
+            cachename = context.cache_filename
+          elsif error.respond_to?('filename')
+            filename = error.filename
+            cachename = error.cachename
+          end
+        end
+
+        # First, look for '(eval):#' in the error itself.
+        eval_line = self.find_eval_line(formatter.error)
+        if eval_line == 0
+          # If not found, walk the stack.
+          $@.each {|err|
+            eval_line = self.find_eval_line(err)
+            if eval_line > 0
+              break
+            end
+          }
+        end
+
+        # Find the location in the original source using the line numbers 
+        # in the cache.
+        if eval_line > 0 && cachename
+          error_line = self.get_source_file_line(cachename, eval_line)
+        end
+      end
+        
+      if filename && File.exists?(filename) && error_line > 0
+        lines = self.get_file_context(filename, error_line, adjacent_lines)
+        
+        formatter.set_context(filename, lines, adjacent_lines,
+                              error_line, error_column)
+      else
+        # TODO: Provide a default message using the best available info.
+      end
+
+      formatter.stack.replace($@)      
+
+      result = formatter.format
+
+      return result
+    end
+
+    def self.get_file_context(filename, line, adjacent_lines)
+      file = File.new(filename, "r")
+
+      min = line > adjacent_lines ? line - adjacent_lines : 1
+      counter = 1;
+      list = []
+
+      while line = file.gets
+        line.chomp!
+
+        if counter >= min
+          list.push({ 'number' => counter, 'text' => line })
+          if counter >= min + 2 * adjacent_lines
+            break
+          end
+        end
+
+        counter += 1
+      end
+
+      file.close
+
+      return list
+    end
+
+    def self.get_source_file_line(cachename, eval_line)
+      file = File.new(cachename, "r")
+      counter = 1
+      most_recent_line = 0
+      while line = file.gets
+        line.chomp!
+        
+        if line =~ /\#line\s+(\d+)/
+            most_recent_line = $1.to_i
+            # Start back by one to account for the comment line.
+            most_recent_line -= 1
+        else
+            most_recent_line += 1
+        end
+
+        if counter >= eval_line
+          return most_recent_line
+        end
+
+        counter += 1
+      end
+      file.close
+      return 0
+    end
+
+    def self.find_eval_line(error)
+      line = 0
+
+      #
+      # This section requires a heuristic to find the most likely line that
+      # is the origin of the error.
+      #
+      if error.to_s =~ /\(eval\)\:(\d+)\: parse error/
+        return $1.to_i
+      elsif error.to_s =~ /\(eval\)\:(\d+)\:/
+        # Any eval line
+        return $1.to_i
+      end
+      return 0
+    end
+  end
+
+  class ErrorFormatterText < ErrorFormatter
+    def format
+      result = ''
+
+      # Lead with the error message.
+      result << $!.to_s
+
+      #
+      # The error description.
+      #
+      result << "\n\n"
+      if @error # This should be $! if set.
+        result << error
+      end
+
+      # Print a list of errors and warnings.
+      errors.each {|m|
+        result << m.text + "\n"
+      }
+      warnings.each {|m|
+        result << m.text + "\n"
+      }
+
+      if @error_line && @context_lines.length > 0
+        # Show where it occurred
+        result << "\nContext\n"
+
+        digits = Integer(Math.log10(@error_line + @adjacent_lines) + 1)
+
+        @context_lines.each {|line|
+          result << sprintf("%*d: %s\n", digits, line['number'], line['text'])
+          if @error_line == line['number']
+            if @error_column > 0
+              result << sprintf("%*s\n", digits + 1 + @error_column, '^')
+            end
+          end
+        }
+      end
+
+      result << "\nStack:\n"
+      result << @stack.join("\n")
+      
+      return result
+    end
+  end
+
+  class ErrorFormatterHTML < ErrorFormatter
+    def format
+      result = ''
+
+      # Lead with the error message.
+      result << "<h3>Message</h3>\n"
+      result << "<pre>"
+      result << ::CGI::escapeHTML($!.to_s)
+      result << "</pre>\n"
+
+      #
+      # The error description.
+      #
+#      result << "\n\n"
+#      if @error # This should be $! if set.
+#        result << "<pre>"
+#        result << error
+#        result << "</pre>\n"
+#      end
+
+      errors.each {|m|
+        result << "<div>"
+        result << ::CGI::escapeHTML(m.text)
+        result << "</div>\n"
+      }
+      warnings.each {|m|
+        result << "<div>"
+        result << ::CGI::escapeHTML(m.text)
+        result << "</div>\n"
+      }
+
+      if @error_line && @context_lines.length > 0
+        # Show where it occurred
+        result << "<h3>Context</h3>\n"
+        result << "<pre>\n"
+
+        digits = Integer(Math.log10(@error_line + @adjacent_lines) + 1)
+
+        @context_lines.each {|line|
+          if @error_line == line['number']
+            result << '<strong>'
+          end
+          result << sprintf("%*d: %s\n", digits, line['number'], 
+                            ::CGI::escapeHTML(line['text']))
+          if @error_line == line['number']
+            result << "</strong>"
+            if @error_column > 0
+              result << sprintf("%*s\n", digits + 1 + @error_column, '^')
+            end
+          end
+        }
+
+        result << "</pre>\n"
+      end
+
+      result << "<h3>Stack</h3>\n"
+      stack.each {|m|
+        result << "<div>"
+        result << ::CGI::escapeHTML(m.to_s)
+        result << "</div>\n"
+      }
+      
+      return result
+    end
+
+    def self.style
+      return "
+body { font-family: Arial,sans-serif; }
+pre { font-family: Courier New,monospace; }
+pre strong { color: red; }
+"
+    end
+  end
+end

data/lib/bijou/exception.rb

@@ -0,0 +1,39 @@
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# exception.rb - Definitions of Bijou-specific exception classes
+#
+require 'bijou/common'
+
+module Bijou
+  class FileNotFound < IOError
+    def initialize(filename)
+      @filename = filename
+    end
+  end
+
+  class EndRequest < Exception
+  end
+
+  class ParseError < Exception
+
+    attr_reader :filename, :diagnostics
+
+    def initialize(filename, diagnostics)
+      @filename = filename
+      @diagnostics = diagnostics
+    end
+  end
+
+  class EvalError < Exception
+
+    attr_reader :filename, :cachename, :cause
+    
+    # The cause is used to capture the text of the originating exeception.
+    def initialize(filename, cachename, cause)
+      @filename = filename
+      @cachename = cachename
+      @cause = cause
+    end
+  end
+end