better_errors 0.0.2 → 0.3.0

data/.gitignore

@@ -1,3 +1,6 @@
 *.gem
 tmp
 Gemfile.lock
+coverage
+.yardoc
+doc

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --no-private

data/CONTRIBUTING.md

@@ -0,0 +1,9 @@
+# Contributing to Better Errors
+
+Please make sure to follow these guidelines when contributing code to Better Errors. They will improve the chances of your pull request being merged and they will make my life easier.
+
+* If you are contributing a large-ish change, please split your changes up into small, logical commits. This is so I have the option of merging in some but not all of your commits. If you just give me one huge commit and there are things that I don't want to merge in, I won't.
+
+* Whitespace at the end of lines of code is not OK, but empty lines with indentation is fine. Please do not remove these when sending in changes.
+
+* Don't change things that are unrelated to your main changes unnecessarily. Send another pull request for these changes - don't try to sneak them in.

data/README.md

@@ -1,28 +1,35 @@
 # 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):
+Add this to your Gemfile:
 
-    gem 'better_errors'
+```ruby
+group :development do
+  gem "better_errors"
+end
+```
 
-And then execute:
+**NOTE:** It is *critical* you put better\_errors in the **development** section. **Do NOT run better_errors in production, or on Internet facing hosts.**
 
-    $ 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 by [@banisterfiend](http://twitter.com/banisterfiend) 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 +51,23 @@ 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.
+
+## Get in touch!
+
+If you're using better_errors, I'd love to hear from you. Drop me a line and tell me what you think!
+
 ## 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"
 
@@ -18,9 +18,15 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.12.0"
+  s.add_development_dependency "binding_of_caller"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "yard"
   
-  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,61 @@
+module BetterErrors
+  # @private
+  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/disable_logging_middleware.rb

@@ -0,0 +1,16 @@
+module BetterErrors
+  # @private
+  class DisableLoggingMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      original_level = BetterErrors.logger.level
+      BetterErrors.logger.level = Logger::ERROR if env['PATH_INFO'].index("/__better_errors") == 0
+      @app.call(env)
+    ensure
+      BetterErrors.logger.level = original_level
+    end
+  end
+end

data/lib/better_errors/error_page.rb

@@ -1,27 +1,82 @@
+require "cgi"
 require "json"
 
 module BetterErrors
+  # @private
   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]
+      @var_start_time = Time.now.to_f
+      { 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 editor_url(frame)
+      BetterErrors.editor[frame.filename, frame.line]
+    end
+    
+    def rack_session
+      env['rack.session']
+    end
+
+    def rails_params
+      env['action_dispatch.request.parameters']
+    end
+
+    def uri_prefix
+      env["SCRIPT_NAME"] || ""
+    end
+  
+    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
@@ -31,50 +86,19 @@ module BetterErrors
     end
   
     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]
+      env["PATH_INFO"]
     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
+
+    def inspect_value(obj)
+      CGI.escapeHTML(obj.inspect)
+    rescue NoMethodError
+      "<span class='unsupported'>(object doesn't support inspect)</span>"
+    rescue Exception => e
+      "<span class='unsupported'>(exception was raised in inspect)</span>"
     end
   end
 end

data/lib/better_errors/middleware.rb

@@ -1,15 +1,90 @@
+require "json"
+
 module BetterErrors
+  # Better Errors' error handling middleware. Including this in your middleware
+  # stack will show a Better Errors error page for exceptions raised below this
+  # middleware.
+  # 
+  # If you are using Ruby on Rails, you do not need to manually insert this 
+  # middleware into your middleware stack.
+  # 
+  # @example Sinatra
+  #   require "better_errors"
+  # 
+  #   if development?
+  #     use BetterErrors::Middleware
+  #   end
+  #
+  # @example Rack
+  #   require "better_errors"
+  #   if ENV["RACK_ENV"] == "development"
+  #     use BetterErrors::Middleware
+  #   end
+  # 
   class Middleware
+    # A new instance of BetterErrors::Middleware
+    # 
+    # @param app      The Rack app/middleware to wrap with Better Errors
+    # @param handler  The error handler to use.
     def initialize(app, handler = ErrorPage)
       @app      = app
       @handler  = handler
     end
     
+    # Calls the Better Errors middleware
+    # 
+    # @param [Hash] env
+    # @return [Array]
     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)
+      content = if @error_page
+        @error_page.render
+      else
+        "<h1>No errors</h1><p>No errors have been recorded yet.</p><hr>" +
+        "<code>Better Errors v#{BetterErrors::VERSION}</code>"
+      end
+
+      [500, { "Content-Type" => "text/html; charset=utf-8" }, [content]]
+    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,13 @@
 module BetterErrors
+  # @private
   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
+        Rails.application.middleware.insert_before Rails::Rack::Logger, BetterErrors::DisableLoggingMiddleware
+        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,77 @@
+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)
+        local ::Pry.config, color: false, pager: false do
+          @continued_expression = true
+          @fiber.resume "#{str}\n"
+          [@output.read_buffer, @continued_expression ? ".." : ">>"]
+        end
+      end
+      
+    private
+      def local(obj, attrs)
+        old_attrs = {}
+        attrs.each do |k, v|
+          old_attrs[k] = obj.send k
+          obj.send "#{k}=", v
+        end
+        yield
+      ensure
+        old_attrs.each do |k, v|
+          obj.send "#{k}=", v
+        end
+      end
+    end
+  end
+end

data/lib/better_errors/repl.rb

@@ -0,0 +1,30 @@
+module BetterErrors
+  # @private
+  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