better_errors 0.0.4 → 0.1.0

data/README.md

@@ -1,33 +1,31 @@
 # Better Errors
 
-Better Errors replaces the standard Rails error page with a much better and more useful error page. It is also usable outside of Rails.
+Better Errors replaces the standard Rails error page with a much better and more useful error page. It is also usable outside of Rails in any Rack app as Rack middleware.
 
-![image](http://i.imgur.com/quHUZ.png)
+![image](http://i.imgur.com/urVDW.png)
 
 ## Features
 
 * Full stack trace
 * Source code inspection for all stack frames (with highlighting)
 * Local and instance variable inspection
-* Ruby console on every stack frame
+* Live REPL on every stack frame
 
 ## Installation
 
 Add this line to your application's Gemfile (under the **development** group):
 
-    gem 'better_errors'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install better_errors
+```ruby
+group :development do
+  gem "better_errors"
+end
+```
 
-If you would like to use Better Errors' **advanced features**, you need to install the `binding_of_caller` gem:
+If you would like to use Better Errors' **advanced features** (REPL, local/instance variable inspection, pretty stack frame names), you need to add the [`binding_of_caller`](https://github.com/banister/binding_of_caller) gem to your Gemfile:
 
-    $ gem install binding_of_caller
+```ruby
+gem "binding_of_caller"
+```
 
 This is an optional dependency however, and Better Errors will work without it.
 
@@ -51,6 +49,19 @@ get "/" do
 end
 ```
 
+## Compatibility
+
+* **Supported**
+  * MRI 1.9.2, 1.9.3
+  * JRuby (1.9 mode) - *advanced features unsupported*
+  * Rubinius (1.9 mode) - *advanced features unsupported*
+* **Coming soon**
+  * MRI 2.0.0 - the official API for grabbing caller bindings is slated for MRI 2.0.0, but it has not been implemented yet
+
+## Known issues
+
+* Calling `yield` from the REPL segfaults MRI 1.9.x.
+
 ## Contributing
 
 1. Fork it

data/better_errors.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.version       = BetterErrors::VERSION
   s.authors       = ["Charlie Somerville"]
   s.email         = ["charlie@charliesomerville.com"]
-  s.description   = %q{Better Errors gives Rails a better error page.}
-  s.summary       = %q{Better Errors gives Rails a better error page}
+  s.description   = %q{Provides a better error page for Rails and other Rack apps. Includes source code inspection, a live REPL and local/instance variable inspection for all stack frames.}
+  s.summary       = %q{Better error page for Rails and other Rack apps}
   s.homepage      = "https://github.com/charliesome/better_errors"
   s.license       = "MIT"
 
@@ -19,8 +19,10 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rake"
   
-  s.add_dependency "erubis"
-  s.add_dependency "coderay"
-  # optional dependency:
+  s.add_dependency "erubis", ">= 2.7.0"
+  s.add_dependency "coderay", ">= 1.0.0"
+
+  # optional dependencies:
   # s.add_dependency "binding_of_caller"
+  # s.add_dependency "pry"
 end

data/lib/better_errors/code_formatter.rb

@@ -0,0 +1,60 @@
+module BetterErrors
+  class CodeFormatter
+    FILE_TYPES = {
+      ".rb"   => :ruby,
+      ""      => :ruby,
+      ".html" => :html,
+      ".erb"  => :erb,
+      ".haml" => :haml
+    }
+    
+    attr_reader :filename, :line, :context
+    
+    def initialize(filename, line, context = 5)
+      @filename = filename
+      @line     = line
+      @context  = context
+    end
+    
+    def html
+      %{<div class="code">#{formatted_lines.join}</div>}
+    rescue Errno::ENOENT, Errno::EINVAL
+      source_unavailable
+    end
+    
+    def source_unavailable
+      "<p>Source unavailable</p>"
+    end
+    
+    def coderay_scanner
+      ext = File.extname(filename)
+      FILE_TYPES[ext] || :text
+    end
+    
+    def formatted_lines
+      line_range.zip(highlighted_lines).map do |current_line, str|
+        class_name = current_line == line ? "highlight" : ""
+        sprintf '<pre class="%s">%5d %s</pre>', class_name, current_line, str
+      end
+    end
+    
+    def highlighted_lines
+      CodeRay.scan(context_lines.join, coderay_scanner).div(wrap: nil).lines
+    end
+    
+    def context_lines
+      range = line_range
+      source_lines[(range.begin - 1)..(range.end - 1)] or raise Errno::EINVAL
+    end
+    
+    def source_lines
+      @source_lines ||= File.readlines(filename)
+    end
+    
+    def line_range
+      min = [line - context, 1].max
+      max = [line + context, source_lines.count].min
+      min..max
+    end
+  end
+end

data/lib/better_errors/core_ext/exception.rb

@@ -1,17 +1,21 @@
 class Exception
-  attr_reader :__better_errors_bindings_stack
-  
   original_initialize = instance_method(:initialize)
   
-  define_method :initialize do |*args|
-    unless Thread.current[:__better_errors_exception_lock]
-      Thread.current[:__better_errors_exception_lock] = true
-      begin
-        @__better_errors_bindings_stack = binding.callers.drop(1)
-      ensure
-        Thread.current[:__better_errors_exception_lock] = false
+  if BetterErrors.binding_of_caller_available?
+    define_method :initialize do |*args|
+      unless Thread.current[:__better_errors_exception_lock]
+        Thread.current[:__better_errors_exception_lock] = true
+        begin
+          @__better_errors_bindings_stack = binding.callers.drop(1)
+        ensure
+          Thread.current[:__better_errors_exception_lock] = false
+        end
       end
+      original_initialize.bind(self).call(*args)
     end
-    original_initialize.bind(self).call(*args)
   end
-end
+  
+  def __better_errors_bindings_stack
+    @__better_errors_bindings_stack || []
+  end
+end

data/lib/better_errors/error_page.rb

@@ -10,12 +10,13 @@ module BetterErrors
       Erubis::EscapedEruby.new(File.read(template_path(template_name)))
     end
     
-    attr_reader :exception, :env
+    attr_reader :exception, :env, :repls
     
     def initialize(exception, env)
       @exception = real_exception(exception)
       @env = env
       @start_time = Time.now.to_f
+      @repls = []
     end
     
     def render(template_name = "main")
@@ -30,13 +31,22 @@ module BetterErrors
     
     def do_eval(opts)
       index = opts["index"].to_i
-      response =  begin
-                    result = backtrace_frames[index].frame_binding.eval(opts["source"])
-                    { result: result.inspect }
-                  rescue Exception => e
-                    { error: (e.inspect rescue e.class.name rescue "Exception") }
-                  end
-      response.merge(highlighted_input: CodeRay.scan(opts["source"], :ruby).div(wrap: nil))
+      code = opts["source"]
+      
+      unless binding = backtrace_frames[index].frame_binding
+        return { error: "REPL unavailable in this stack frame" }
+      end
+      
+      result, prompt =
+        (@repls[index] ||= REPL.provider.new(binding)).send_input(code)
+      
+      { result: result,
+        prompt: prompt,
+        highlighted_input: CodeRay.scan(code, :ruby).div(wrap: nil) }
+    end
+
+    def backtrace_frames
+      @backtrace_frames ||= StackFrame.from_exception(exception)
     end
     
   private
@@ -51,48 +61,9 @@ module BetterErrors
     def request_path
       env["REQUEST_PATH"]
     end
-  
-    def backtrace_frames
-      @backtrace_frames ||= ErrorFrame.from_exception(exception)
-    end
-    
-    def coderay_scanner_for_ext(ext)
-      case ext
-      when "rb";    :ruby
-      when "html";  :html
-      when "erb";   :erb
-      when "haml";  :haml
-      end
-    end
-    
-    def file_extension(filename)
-      filename.split(".").last
-    end
-    
-    def code_extract(frame, lines_of_context = 5)
-      lines = File.readlines(frame.filename)
-      min_line = [1, frame.line - lines_of_context].max - 1
-      max_line = [frame.line + lines_of_context, lines.count + 1].min - 1
-      [min_line, max_line, lines[min_line..max_line].join]
-    end
     
     def highlighted_code_block(frame)
-      ext = file_extension(frame.filename)
-      scanner = coderay_scanner_for_ext(ext)
-      min_line, max_line, code = code_extract(frame)
-      highlighted_code = CodeRay.scan(code, scanner).div wrap: nil
-      "".tap do |html|
-        html << "<div class='code'>"
-        highlighted_code.each_line.each_with_index do |str, index|
-          if min_line + index + 1 == frame.line
-            html << "<pre class='highlight'>"
-          else
-            html << "<pre>"
-          end
-          html << sprintf("%5d", min_line + index + 1) << " " << str << "</pre>"
-        end
-        html << "</div>"
-      end
+      CodeFormatter.new(frame.filename, frame.line).html
     end
   end
 end

data/lib/better_errors/middleware.rb

@@ -8,8 +8,11 @@ module BetterErrors
     end
     
     def call(env)
-      if env["REQUEST_PATH"] =~ %r{\A/__better_errors/(?<oid>\d+)/(?<method>\w+)\z}
+      case env["PATH_INFO"]
+      when %r{\A/__better_errors/(?<oid>\d+)/(?<method>\w+)\z}
         internal_call env, $~
+      when %r{\A/__better_errors/?\z}
+        show_error_page env
       else
         app_call env
       end
@@ -20,8 +23,24 @@ module BetterErrors
       @app.call env
     rescue Exception => ex
       @error_page = @handler.new ex, env
+      log_exception
+      show_error_page(env)
+    end
+    
+    def show_error_page(env)
       [500, { "Content-Type" => "text/html; charset=utf-8" }, [@error_page.render]]
     end
+    
+    def log_exception
+      return unless BetterErrors.logger
+      
+      message = "\n#{@error_page.exception.class} - #{@error_page.exception.message}:\n"
+      @error_page.backtrace_frames.each do |frame|
+        message << "  #{frame}\n"
+      end
+      
+      BetterErrors.logger.fatal message
+    end
   
     def internal_call(env, opts)
       if opts[:oid].to_i != @error_page.object_id

data/lib/better_errors/rails.rb

@@ -1,10 +1,11 @@
 module BetterErrors
   class Railtie < Rails::Railtie
     initializer "better_errors.configure_rails_initialization" do
-      middleware = Rails.application.middleware
-      middleware.use BetterErrors::Middleware
-      
-      BetterErrors.application_root = Rails.root.to_s
+      unless Rails.env.production?
+        Rails.application.middleware.use BetterErrors::Middleware
+        BetterErrors.logger = Rails.logger
+        BetterErrors.application_root = Rails.root.to_s
+      end
     end
   end
 end

data/lib/better_errors/repl/basic.rb

@@ -0,0 +1,20 @@
+module BetterErrors
+  module REPL
+    class Basic
+      def initialize(binding)
+        @binding = binding
+      end
+    
+      def send_input(str)
+        [execute(str), ">>"]
+      end
+    
+    private
+      def execute(str)
+        "=> #{@binding.eval(str).inspect}\n"
+      rescue Exception => e
+        "!! #{e.inspect rescue e.class.to_s rescue "Exception"}\n"
+      end
+    end
+  end
+end

data/lib/better_errors/repl/pry.rb

@@ -0,0 +1,67 @@
+require "fiber"
+require "pry"
+
+module BetterErrors
+  module REPL
+    class Pry
+      class Input
+        def readline
+          Fiber.yield
+        end
+      end
+      
+      class Output
+        def initialize
+          @buffer = ""
+        end
+        
+        def puts(*args)
+          args.each do |arg|
+            @buffer << "#{arg.chomp}\n"
+          end
+        end
+        
+        def tty?
+          false
+        end
+        
+        def read_buffer
+          @buffer
+        ensure
+          @buffer = ""
+        end
+      end
+      
+      def initialize(binding)
+        @fiber = Fiber.new do
+          @pry.repl binding
+        end
+        @input = Input.new
+        @output = Output.new
+        @pry = ::Pry.new input: @input, output: @output
+        @pry.hooks.clear_all
+        @continued_expression = false
+        @pry.hooks.add_hook :after_read, "better_errors hacky hook" do
+          @continued_expression = false
+        end
+        @fiber.resume
+      end
+      
+      def pry_indent
+        @pry.instance_variable_get(:@indent)
+      end
+    
+      def send_input(str)
+        old_pry_config_color = ::Pry.config.color
+        ::Pry.config.color = false
+        @continued_expression = true
+        @fiber.resume "#{str}\n"
+        # TODO - indent with `pry_indent.current_prefix`
+        # TODO - use proper pry prompt
+        [@output.read_buffer, @continued_expression ? ".." : ">>"]
+      ensure
+        ::Pry.config.color = old_pry_config_color
+      end
+    end
+  end
+end

data/lib/better_errors/repl.rb

@@ -0,0 +1,27 @@
+module BetterErrors
+  module REPL
+    PROVIDERS = [
+        { impl:   "better_errors/repl/pry",
+          const:  :Pry },
+        { impl:   "better_errors/repl/basic",
+          const:  :Basic },
+      ]
+    
+    def self.provider
+      @provider ||= const_get detect[:const]
+    end
+    
+    def self.detect
+      PROVIDERS.find do |prov|
+        test_provider prov
+      end
+    end
+    
+    def self.test_provider(provider)
+      require provider[:impl]
+      true
+    rescue LoadError
+      false
+    end
+  end
+end

data/lib/better_errors/{error_frame.rb → stack_frame.rb}

@@ -1,12 +1,18 @@
 module BetterErrors
-  class ErrorFrame
+  class StackFrame
     def self.from_exception(exception)
+      idx_offset = 0
       exception.backtrace.each_with_index.map { |frame, idx|
-        next unless frame =~ /\A(.*):(\d*):in `(.*)'\z/
-        if BetterErrors.binding_of_caller_available?
-          b = exception.__better_errors_bindings_stack[idx]
+        frame_binding = exception.__better_errors_bindings_stack[idx - idx_offset]
+        md = /\A(?<file>.*):(?<line>\d*):in `(?<name>.*)'\z/.match(frame)
+
+        # prevent mismatching frames in the backtrace with the binding stack
+        if frame_binding and frame_binding.eval("__FILE__") != md[:file]
+          idx_offset += 1
+          frame_binding = nil
         end
-        ErrorFrame.new($1, $2.to_i, $3, b)
+
+        StackFrame.new(md[:file], md[:line].to_i, md[:name], frame_binding)
       }.compact
     end
     
@@ -22,7 +28,8 @@ module BetterErrors
     end
     
     def application?
-      starts_with? filename, BetterErrors.application_root if BetterErrors.application_root
+      root = BetterErrors.application_root
+      starts_with? filename, root if root
     end
     
     def application_path
@@ -73,14 +80,20 @@ module BetterErrors
     
     def instance_variables
       return {} unless frame_binding
-      Hash[frame_binding.eval("instance_variables").map { |x| [x, frame_binding.eval(x.to_s)] }]
+      Hash[frame_binding.eval("instance_variables").map { |x|
+        [x, frame_binding.eval(x.to_s)]
+      }]
+    end
+    
+    def to_s
+      "#{pretty_path}:#{line}:in `#{name}'"
     end
     
   private
     def set_pretty_method_name
       name =~ /\A(block (\([^)]+\) )?in )?/
       recv = frame_binding.eval("self")
-      method = frame_binding.eval("__method__")
+      return unless method = frame_binding.eval("__method__")
       @name = if recv.is_a? Module
                 "#{$1}#{recv}.#{method}"
               else

data/lib/better_errors/templates/main.erb

@@ -105,6 +105,7 @@
         font-family:Monaco, Incosolata, Consolas, monospace;
         font-size:14px;
         margin-bottom:4px;
+        word-wrap:break-word;
     }
     .location {
         color:#888888;
@@ -243,15 +244,22 @@
                 <div class="location"><span class="filename"><%= frame.pretty_path %></span>, line <span class="line"><%= frame.line %></span></div>
                 <%== highlighted_code_block frame %>
                 
-                <div class="repl">
-                    <h3>REPL</h3>
-                    <div class="console">
-                        <pre></pre>
-                        <div class="prompt">&gt;&gt; <input/></div>
+                <% if BetterErrors.binding_of_caller_available? %>
+                    <div class="repl">
+                        <h3>REPL</h3>
+                        <div class="console">
+                            <pre></pre>
+                            <div class="prompt"><span>&gt;&gt;</span> <input/></div>
+                        </div>
                     </div>
-                </div>
-                
-                <div class="variable_info"></div>
+
+                    <div class="variable_info"></div>
+                <% else %>
+                    <h3>Advanced features unavailable</h3>
+                    <p class="error">
+                        You must add <code>gem "binding_of_caller"</code> to your Gemfile to enable the REPL and local/instance variable inspection.
+                    </p>
+                <% end %>
             </div>
         <% end %>
         <div style="clear:both"></div>
@@ -259,19 +267,16 @@
 </body>
 <script>
 (function() {
-    var oid = <%== object_id.to_s.inspect %>;
+    var OID = <%== object_id.to_s.inspect %>;
     
-    var previous = null;
+    var previousFrame = null;
     var previousFrameInfo = null;
-    var frames = document.querySelectorAll("ul.frames li");
-    var frameInfos = document.querySelectorAll(".frame_info");
-    
-    var header = document.querySelector("header");
-    var headerHeight = header.offsetHeight;
-    
-    apiCall = function(method, opts, cb) {
+    var allFrames = document.querySelectorAll("ul.frames li");
+    var allFrameInfos = document.querySelectorAll(".frame_info");
+
+    function apiCall(method, opts, cb) {
         var req = new XMLHttpRequest();
-        req.open("POST", "/__better_errors/" + oid + "/" + method, true);
+        req.open("POST", "/__better_errors/" + OID + "/" + method, true);
         req.setRequestHeader("Content-Type", "application/json");
         req.send(JSON.stringify(opts));
         req.onreadystatechange = function() {
@@ -286,11 +291,118 @@
         return html.replace(/&/, "&amp;").replace(/</g, "&lt;");
     }
     
-    function selectFrameInfo(index) {
-        var el = document.getElementById("frame_info_" + index);
+    function REPL(index) {
+        this.index = index;
+        
+        this.previousCommands = [];
+        this.previousCommandOffset = 0;
+    }
+    
+    REPL.all = [];
+    
+    REPL.prototype.install = function(containerElement) {
+        this.container = containerElement;
+    
+        this.promptElement  = this.container.querySelector(".prompt span");
+        this.inputElement   = this.container.querySelector("input");
+        this.outputElement  = this.container.querySelector("pre");
+    
+        this.inputElement.onkeydown = this.onKeyDown.bind(this);
+    
+        this.setPrompt(">>");
+        
+        REPL.all[this.index] = this;
+    }
+    
+    REPL.prototype.focus = function() {
+        this.inputElement.focus();
+    };
+    
+    REPL.prototype.setPrompt = function(prompt) {
+        this._prompt = prompt;
+        this.promptElement.innerHTML = escapeHTML(prompt);
+    };
+    
+    REPL.prototype.getInput = function() {
+        return this.inputElement.value;
+    };
+    
+    REPL.prototype.setInput = function(text) {
+        this.inputElement.value = text;
+        
+        if(this.inputElement.setSelectionRange) {
+            // set cursor to end of input
+            this.inputElement.setSelectionRange(text.length, text.length);
+        }
+    };
+    
+    REPL.prototype.writeRawOutput = function(output) {
+        this.outputElement.innerHTML += output;
+        this.outputElement.scrollTop = this.outputElement.scrollHeight;
+    };
+    
+    REPL.prototype.writeOutput = function(output) {
+        this.writeRawOutput(escapeHTML(output));
+    };
+    
+    REPL.prototype.sendInput = function(line) {
+        var self = this;
+        apiCall("eval", { "index": this.index, source: line }, function(response) {
+            if(response.error) {
+                self.writeOutput(response.error + "\n");
+            }
+            self.writeOutput(self._prompt + " ");
+            self.writeRawOutput(response.highlighted_input + "\n");
+            self.writeOutput(response.result);
+            self.setPrompt(response.prompt);
+        });
+    };
+    
+    REPL.prototype.onEnterKey = function() {
+        var text = this.getInput();
+        if(text != "" && text !== undefined) {
+            this.previousCommandOffset = this.previousCommands.push(text);
+        }
+        this.setInput("");
+        this.sendInput(text);
+    };
+    
+    REPL.prototype.onNavigateHistory = function(direction) {
+        this.previousCommandOffset += direction;
+        
+        if(this.previousCommandOffset < 0) {
+            this.previousCommandOffset = -1;
+            this.setInput("");
+            return;
+        }
+        
+        if(this.previousCommandOffset >= this.previousCommands.length) {
+            this.previousCommandOffset = this.previousCommands.length;
+            this.setInput("");
+            return;
+        }
         
+        this.setInput(this.previousCommands[this.previousCommandOffset]);
+    };
+    
+    REPL.prototype.onKeyDown = function(ev) {
+        if(ev.keyCode == 13) {
+            this.onEnterKey();
+        } else if(ev.keyCode == 38) {
+            // the user pressed the up arrow.
+            this.onNavigateHistory(-1);
+            return false;
+        } else if(ev.keyCode == 40) {
+            // the user pressed the down arrow.
+            this.onNavigateHistory(1);
+            return false;
+        }
+    };
+    
+    function populateVariableInfo(index) {
+        var el = allFrameInfos[index];
         var varInfo = el.querySelector(".variable_info");
-        if(varInfo.innerHTML == "") {
+        if(varInfo && varInfo.innerHTML == "") {
             apiCall("variables", { "index": index }, function(response) {
                 if(response.error) {
                     varInfo.innerHTML = "<span class='error'>" + escapeHTML(response.error) + "</span>";
@@ -299,75 +411,69 @@
                 }
             });
         }
+    }
+    
+    function selectFrameInfo(index) {
+        populateVariableInfo(index);
         
         if(previousFrameInfo) {
             previousFrameInfo.style.display = "none";
         }
-        previousFrameInfo = el;
+        previousFrameInfo = allFrameInfos[index];
         previousFrameInfo.style.display = "block";
         
-        el.querySelector(".repl input").focus();
+        if(REPL.all[index]) {
+            REPL.all[index].focus();
+        }
     }
     
-    for(var i = 0; i < frames.length; i++) {
-        (function(index, el, frameInfo) {
+    for(var i = 0; i < allFrames.length; i++) {
+        (function(i, el) {
+            var el = allFrames[i];
             el.onclick = function() {
-                if(previous) {
-                    previous.className = "";
+                if(previousFrame) {
+                    previousFrame.className = "";
                 }
                 el.className = "selected";
-                previous = el;
+                previousFrame = el;
                 
                 selectFrameInfo(el.attributes["data-index"].value);
             };
-            var replPre = frameInfo.querySelector(".repl pre");
-            var replInput = frameInfo.querySelector(".repl input");
-            replInput.onkeydown = function(ev) {
-                if(ev.keyCode == 13) {
-                    var text = replInput.value;
-                    replInput.value = "";
-                    apiCall("eval", { "index": index, source: text }, function(response) {
-                        replPre.innerHTML += ">> " + response.highlighted_input + "\n";
-                        if(response.error) {
-                            replPre.innerHTML += "!! " + escapeHTML(response.error) + "\n";
-                        } else {
-                            replPre.innerHTML += "=> " + escapeHTML(response.result) + "\n";
-                        }
-                        replPre.scrollTop = replPre.offsetHeight;
-                    });
-                }
-            };
-        })(i, frames[i], frameInfos[i]);
+            var repl = allFrameInfos[i].querySelector(".repl .console");
+            if(repl) {
+                new REPL(i).install(repl);
+            }
+        })(i);
     }
     
-    document.querySelector(".frames li:first-child").click();
+    allFrames[0].click();
     
-    var applicationFrames = document.getElementById("application_frames");
-    var allFrames = document.getElementById("all_frames");
+    var applicationFramesButton = document.getElementById("application_frames");
+    var allFramesButton = document.getElementById("all_frames");
     
-    applicationFrames.onclick = function() {
-        allFrames.className = "";
-        applicationFrames.className = "selected";
-        for(var i = 0; i < frames.length; i++) {
-            if(frames[i].attributes["data-context"].value == "application") {
-                frames[i].style.display = "block";
+    applicationFramesButton.onclick = function() {
+        allFramesButton.className = "";
+        applicationFramesButton.className = "selected";
+        for(var i = 0; i < allFrames.length; i++) {
+            if(allFrames[i].attributes["data-context"].value == "application") {
+                allFrames[i].style.display = "block";
             } else {
-                frames[i].style.display = "none";
+                allFrames[i].style.display = "none";
             }
         }
         return false;
     };
     
-    allFrames.onclick = function() {
-        applicationFrames.className = "";
-        allFrames.className = "selected";
-        for(var i = 0; i < frames.length; i++) {
-            frames[i].style.display = "block";
+    allFramesButton.onclick = function() {
+        applicationFramesButton.className = "";
+        allFramesButton.className = "selected";
+        for(var i = 0; i < allFrames.length; i++) {
+            allFrames[i].style.display = "block";
         }
         return false;
     };
     
-    applicationFrames.click();
+    applicationFramesButton.click();
 })();
 </script>
 </html>

data/lib/better_errors/version.rb

@@ -1,3 +1,3 @@
 module BetterErrors
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/lib/better_errors.rb

@@ -4,11 +4,13 @@ require "coderay"
 
 require "better_errors/version"
 require "better_errors/error_page"
-require "better_errors/error_frame"
+require "better_errors/stack_frame"
 require "better_errors/middleware"
+require "better_errors/code_formatter"
+require "better_errors/repl"
 
 class << BetterErrors
-  attr_accessor :application_root, :binding_of_caller_available
+  attr_accessor :application_root, :binding_of_caller_available, :logger
   
   alias_method :binding_of_caller_available?, :binding_of_caller_available
 end

data/spec/better_errors/code_formatter_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+module BetterErrors
+  describe CodeFormatter do
+    let(:filename) { File.expand_path("../support/my_source.rb", __FILE__) }
+    
+    let(:formatter) { CodeFormatter.new(filename, 8) }
+    
+    it "should pick an appropriate scanner" do
+      formatter.coderay_scanner.should == :ruby
+    end
+    
+    it "should show 5 lines of context" do
+      formatter.line_range.should == (3..13)
+      
+      formatter.context_lines.should == [
+          "three\n",
+          "four\n",
+          "five\n",
+          "six\n",
+          "seven\n",
+          "eight\n",
+          "nine\n",
+          "ten\n",
+          "eleven\n",
+          "twelve\n",
+          "thirteen\n"
+        ]
+    end
+    
+    it "should highlight the erroring line" do
+      formatter.html.should =~ /highlight.*eight/
+    end
+    
+    it "should work when the line is right on the edge" do
+      formatter = CodeFormatter.new(filename, 20)
+      formatter.line_range.should == (15..20)
+      formatter.html.should_not == formatter.source_unavailable
+    end
+    
+    it "should not barf when the lines don't make any sense" do
+      formatter = CodeFormatter.new(filename, 999)
+      formatter.html.should == formatter.source_unavailable
+    end
+    
+    it "should not barf when the file doesn't exist" do
+      formatter = CodeFormatter.new("fkdguhskd7e l", 1)
+      formatter.html.should == formatter.source_unavailable
+    end
+  end
+end

data/spec/better_errors/error_page_spec.rb

@@ -7,6 +7,16 @@ module BetterErrors
     let(:error_page) { ErrorPage.new exception, { "REQUEST_PATH" => "/some/path" } }
     
     let(:response) { error_page.render }
+    
+    let(:empty_binding) {
+      local_a = :value_for_local_a
+      local_b = :value_for_local_b
+      
+      @inst_c = :value_for_inst_c
+      @inst_d = :value_for_inst_d
+      
+      binding
+    }
   
     it "should include the error message" do
       response.should include("you divided by zero you silly goose!")
@@ -20,26 +30,31 @@ module BetterErrors
       response.should include("ZeroDivisionError")
     end
     
-    context "when showing source code" do
-      before do
-        exception.stub!(:backtrace).and_return([
-          "#{File.expand_path("../support/my_source.rb", __FILE__)}:8:in `some_method'"
-        ])
-      end
+    context "variable inspection" do
+      let(:exception) { empty_binding.eval("raise") rescue $! }
       
-      it "should show the line where the exception was raised" do
-        response.should include("8 eight")
+      it "should show local variables" do
+        html = error_page.do_variables("index" => 0)[:html]
+        html.should include("local_a")
+        html.should include(":value_for_local_a")
+        html.should include("local_b")
+        html.should include(":value_for_local_b")
       end
       
-      it "should show five lines of context" do
-        response.should include("3 three")
-        response.should include("13 thirteen")
-      end
-      
-      it "should not show more than five lines of context" do
-        response.should_not include("2 two")
-        response.should_not include("14 fourteen")
+      it "should show instance variables" do
+        html = error_page.do_variables("index" => 0)[:html]
+        html.should include("inst_c")
+        html.should include(":value_for_inst_c")
+        html.should include("inst_d")
+        html.should include(":value_for_inst_d")
       end
     end
+    
+    it "should not die if the source file is not a real filename" do
+      exception.stub!(:backtrace).and_return([
+        "<internal:prelude>:10:in `spawn_rack_application'"
+      ])
+      response.should include("Source unavailable")
+    end
   end
 end

data/spec/better_errors/middleware_spec.rb

@@ -21,6 +21,14 @@ module BetterErrors
         
         headers["Content-Type"].should == "text/html; charset=utf-8"
       end
+      
+      it "should log the exception" do
+        logger = Object.new
+        logger.should_receive :fatal
+        BetterErrors.stub!(:logger).and_return(logger)
+        
+        app.call({})
+      end
     end
   end
 end

data/spec/better_errors/repl/basic_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "better_errors/repl/basic"
+
+module BetterErrors
+  module REPL
+    describe Basic do
+      let(:fresh_binding) {
+        local_a = 123
+        binding
+      }
+      
+      let(:repl) { Basic.new fresh_binding }
+      
+      it "should evaluate ruby code in a given context" do
+        repl.send_input("local_a = 456")
+        fresh_binding.eval("local_a").should == 456
+      end
+      
+      it "should return a tuple of output and the new prompt" do
+        output, prompt = repl.send_input("1 + 2")
+        output.should == "=> 3\n"
+        prompt.should == ">>"
+      end
+      
+      it "should not barf if the code throws an exception" do
+        output, prompt = repl.send_input("raise Exception")
+        output.should == "!! #<Exception: Exception>\n"
+        prompt.should == ">>"
+      end
+    end
+  end
+end

data/spec/better_errors/{error_frame_spec.rb → stack_frame_spec.rb}

@@ -1,24 +1,24 @@
 require "spec_helper"
 
 module BetterErrors
-  describe ErrorFrame do
+  describe StackFrame do
     context "#application?" do
       it "should be true for application filenames" do
         BetterErrors.stub!(:application_root).and_return("/abc/xyz")
-        frame = ErrorFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
+        frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
         
         frame.application?.should be_true
       end
       
       it "should be false for everything else" do
         BetterErrors.stub!(:application_root).and_return("/abc/xyz")
-        frame = ErrorFrame.new("/abc/nope", 123, "foo")
+        frame = StackFrame.new("/abc/nope", 123, "foo")
         
         frame.application?.should be_false
       end
       
       it "should not care if no application_root is set" do
-        frame = ErrorFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
+        frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
         
         frame.application?.should be_false
       end
@@ -27,14 +27,14 @@ module BetterErrors
     context "#gem?" do
       it "should be true for gem filenames" do
         Gem.stub!(:path).and_return(["/abc/xyz"])
-        frame = ErrorFrame.new("/abc/xyz/gems/whatever-1.2.3/lib/whatever.rb", 123, "foo")
+        frame = StackFrame.new("/abc/xyz/gems/whatever-1.2.3/lib/whatever.rb", 123, "foo")
         
         frame.gem?.should be_true
       end
       
       it "should be false for everything else" do
         Gem.stub!(:path).and_return(["/abc/xyz"])
-        frame = ErrorFrame.new("/abc/nope", 123, "foo")
+        frame = StackFrame.new("/abc/nope", 123, "foo")
         
         frame.gem?.should be_false
       end
@@ -43,7 +43,7 @@ module BetterErrors
     context "#application_path" do
       it "should chop off the application root" do
         BetterErrors.stub!(:application_root).and_return("/abc/xyz")
-        frame = ErrorFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
+        frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
         
         frame.application_path.should == "app/controllers/crap_controller.rb"
       end
@@ -52,7 +52,7 @@ module BetterErrors
     context "#gem_path" do
       it "should chop of the gem path and stick (gem) there" do
         Gem.stub!(:path).and_return(["/abc/xyz"])
-        frame = ErrorFrame.new("/abc/xyz/gems/whatever-1.2.3/lib/whatever.rb", 123, "foo")
+        frame = StackFrame.new("/abc/xyz/gems/whatever-1.2.3/lib/whatever.rb", 123, "foo")
         
         frame.gem_path.should == "(gem) whatever-1.2.3/lib/whatever.rb"
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_errors
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-09 00:00:00.000000000 Z
+date: 2012-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.7.0
 - !ruby/object:Gem::Dependency
   name: coderay
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,8 +58,10 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
-description: Better Errors gives Rails a better error page.
+        version: 1.0.0
+description: Provides a better error page for Rails and other Rack apps. Includes
+  source code inspection, a live REPL and local/instance variable inspection for all
+  stack frames.
 email:
 - charlie@charliesomerville.com
 executables: []
@@ -73,17 +75,23 @@ files:
 - Rakefile
 - better_errors.gemspec
 - lib/better_errors.rb
+- lib/better_errors/code_formatter.rb
 - lib/better_errors/core_ext/exception.rb
-- lib/better_errors/error_frame.rb
 - lib/better_errors/error_page.rb
 - lib/better_errors/middleware.rb
 - lib/better_errors/rails.rb
+- lib/better_errors/repl.rb
+- lib/better_errors/repl/basic.rb
+- lib/better_errors/repl/pry.rb
+- lib/better_errors/stack_frame.rb
 - lib/better_errors/templates/main.erb
 - lib/better_errors/templates/variable_info.erb
 - lib/better_errors/version.rb
-- spec/better_errors/error_frame_spec.rb
+- spec/better_errors/code_formatter_spec.rb
 - spec/better_errors/error_page_spec.rb
 - spec/better_errors/middleware_spec.rb
+- spec/better_errors/repl/basic_spec.rb
+- spec/better_errors/stack_frame_spec.rb
 - spec/better_errors/support/my_source.rb
 - spec/spec_helper.rb
 homepage: https://github.com/charliesome/better_errors
@@ -110,11 +118,12 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Better Errors gives Rails a better error page
+summary: Better error page for Rails and other Rack apps
 test_files:
-- spec/better_errors/error_frame_spec.rb
+- spec/better_errors/code_formatter_spec.rb
 - spec/better_errors/error_page_spec.rb
 - spec/better_errors/middleware_spec.rb
+- spec/better_errors/repl/basic_spec.rb
+- spec/better_errors/stack_frame_spec.rb
 - spec/better_errors/support/my_source.rb
 - spec/spec_helper.rb
-has_rdoc: