better_errors 0.0.2 → 0.2.0

data/README.md

@@ -1,28 +1,33 @@
 # 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/O9anD.png)
+![image](http://i.imgur.com/zYOXF.png)
 
 ## Features
 
 * Full stack trace
 * Source code inspection for all stack frames (with highlighting)
 * Local and instance variable inspection
+* 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:
+```ruby
+group :development do
+  gem "better_errors"
+end
+```
 
-    $ bundle
+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:
 
-Or install it yourself as:
+```ruby
+gem "binding_of_caller"
+```
 
-    $ gem install better_errors
+This is an optional dependency however, and Better Errors will work without it.
 
 ## Usage
 
@@ -44,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 class='unavailable'>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,20 +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 = []
-        2.upto(caller.size) do |index|
-          @__better_errors_bindings_stack << binding.of_caller(index) rescue break
+  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
-      ensure
-        Thread.current[:__better_errors_exception_lock] = false
       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

@@ -2,26 +2,62 @@ require "json"
 
 module BetterErrors
   class ErrorPage
-    def self.template_path
-      __FILE__.gsub(/\.rb$/, ".erb")
+    def self.template_path(template_name)
+      File.expand_path("../templates/#{template_name}.erb", __FILE__)
     end
     
-    def self.template
-      Erubis::EscapedEruby.new(File.read(template_path))
+    def self.template(template_name)
+      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
-      self.class.template.result binding
+    def render(template_name = "main")
+      self.class.template(template_name).result binding
+    end
+    
+    def do_variables(opts)
+      index = opts["index"].to_i
+      @frame = backtrace_frames[index]
+      { html: render("variable_info") }
+    end
+    
+    def do_eval(opts)
+      index = opts["index"].to_i
+      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
+    def exception_message
+      if exception.is_a?(SyntaxError) && exception.message =~ /\A.*:\d*: (.*)$/
+        $1
+      else
+        exception.message
+      end
+    end
+
     def real_exception(exception)
       if exception.respond_to? :original_exception
         exception.original_exception
@@ -33,48 +69,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

@@ -1,3 +1,5 @@
+require "json"
+
 module BetterErrors
   class Middleware
     def initialize(app, handler = ErrorPage)
@@ -6,10 +8,47 @@ module BetterErrors
     end
     
     def call(env)
+      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
+    end
+    
+  private
+    def app_call(env)
       @app.call env
     rescue Exception => ex
-      error_page = @handler.new ex, env
-      [500, { "Content-Type" => "text/html; charset=utf-8" }, [error_page.render]]
+      @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
+        return [200, { "Content-Type" => "text/plain; charset=utf-8" }, [JSON.dump(error: "Session expired")]]
+      end
+      
+      response = @error_page.send("do_#{opts[:method]}", JSON.parse(env["rack.input"].read))
+      [200, { "Content-Type" => "text/plain; charset=utf-8" }, [JSON.dump(response)]]
     end
   end
 end

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,29 @@
+module BetterErrors
+  module REPL
+    PROVIDERS = [
+        { impl:   "better_errors/repl/basic",
+          const:  :Basic },
+      ]
+
+    def self.provider
+      @provider ||= const_get detect[:const]
+    end
+    
+    def self.provider=(prov)
+      @provider = prov
+    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/stack_frame.rb

@@ -0,0 +1,124 @@
+module BetterErrors
+  class StackFrame
+    def self.from_exception(exception)
+      idx_offset = 0
+      list = exception.backtrace.each_with_index.map do |frame, 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
+
+        StackFrame.new(md[:file], md[:line].to_i, md[:name], frame_binding)
+      end
+
+      if exception.is_a?(SyntaxError) && exception.to_s =~ /\A(.*):(\d*):/
+        list.unshift StackFrame.new($1, $2.to_i, "")
+      end
+
+      list
+    end
+    
+    attr_reader :filename, :line, :name, :frame_binding
+    
+    def initialize(filename, line, name, frame_binding = nil)
+      @filename       = filename
+      @line           = line
+      @name           = name
+      @frame_binding  = frame_binding
+      
+      set_pretty_method_name if frame_binding
+    end
+    
+    def application?
+      root = BetterErrors.application_root
+      starts_with? filename, root if root
+    end
+    
+    def application_path
+      filename[(BetterErrors.application_root.length+1)..-1]
+    end
+
+    def gem?
+      Gem.path.any? { |path| starts_with? filename, path }
+    end
+    
+    def gem_path
+      Gem.path.each do |path|
+        if starts_with? filename, path
+          return filename.gsub("#{path}/gems/", "(gem) ")
+        end
+      end
+    end
+
+    def class_name
+      @class_name
+    end
+
+    def method_name
+      @method_name || @name
+    end
+    
+    def context
+      if application?
+        :application
+      elsif gem?
+        :gem
+      else
+        :dunno
+      end
+    end
+    
+    def pretty_path
+      case context
+      when :application;  application_path
+      when :gem;          gem_path
+      else                filename
+      end
+    end
+    
+    def local_variables
+      return {} unless frame_binding
+      frame_binding.eval("local_variables").each_with_object({}) do |name, hash|
+        begin
+          hash[name] = frame_binding.eval(name.to_s)
+        rescue NameError => e
+          # local_variables sometimes returns broken variables.
+          # https://bugs.ruby-lang.org/issues/7536
+        end
+      end
+    end
+    
+    def instance_variables
+      return {} unless frame_binding
+      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")
+      return unless method_name = frame_binding.eval("__method__")
+      if recv.is_a? Module
+        @class_name = "#{$1}#{recv}"
+        @method_name = ".#{method_name}"
+      else
+        @class_name = "#{$1}#{recv.class}"
+        @method_name = "##{method_name}"
+      end
+    end
+  
+    def starts_with?(haystack, needle)
+      haystack[0, needle.length] == needle
+    end
+  end
+end