better_errors 0.0.2 → 0.3.0

data/lib/better_errors/templates/variable_info.erb

@@ -0,0 +1,69 @@
+<header class="trace_info">
+    <div class="title">
+        <h2 class="name"><%= @frame.name %></h2>
+        <div class="location"><span class="filename"><a href="<%= editor_url(@frame) %>"><%= @frame.pretty_path %></a></span></div>
+    </div>
+    
+    <%== highlighted_code_block @frame %>
+
+    <% if BetterErrors.binding_of_caller_available? && @frame.frame_binding %>
+        <div class="repl">
+            <div class="console">
+                <pre></pre>
+                <div class="prompt"><span>&gt;&gt;</span> <input/></div>
+            </div>
+        </div>
+    <% end %>
+</header>
+
+<% if BetterErrors.binding_of_caller_available? && @frame.frame_binding %>
+    <div class="hint">
+        This a live shell. Type in here.
+    </div>
+
+    <div class="variable_info"></div>
+<% end %>
+
+<% unless BetterErrors.binding_of_caller_available? %>
+    <div class="hint">
+        <strong>Tip:</strong> add <code>gem "binding_of_caller"</code> to your Gemfile to enable the REPL and local/instance variable inspection.
+    </div>
+<% end %>
+
+<div class="sub">
+    <h3>Request info</h3>
+    <div class='inset variables'>
+        <table class="var_table">
+            <% if rails_params %>
+                <tr><td class="name">Request parameters</td><td><pre><%== inspect_value rails_params %></pre></td></tr>
+            <% end %>
+            <% if rack_session %>
+                <tr><td class="name">Rack session</td><td><pre><%== inspect_value rack_session %></pre></td></tr>
+            <% end %>
+        </table>
+    </div>
+</div>
+
+<div class="sub">
+    <h3>Local Variables</h3>
+    <div class='inset variables'>
+        <table class="var_table">
+            <% @frame.local_variables.each do |name, value| %>
+                <tr><td class="name"><%= name %></td><td><pre><%== inspect_value value %></pre></td></tr>
+            <% end %>
+        </table>
+    </div>
+</div>
+
+<div class="sub">
+    <h3>Instance Variables</h3>
+    <div class="inset variables">
+        <table class="var_table">
+            <% @frame.instance_variables.each do |name, value| %>
+                <tr><td class="name"><%= name %></td><td><pre><%== inspect_value value %></pre></td></tr>
+            <% end %>
+        </table>
+    </div>
+</div>
+
+<!-- <%= Time.now.to_f - @var_start_time %> seconds -->

data/lib/better_errors/version.rb

@@ -1,3 +1,3 @@
 module BetterErrors
-  VERSION = "0.0.2"
+  VERSION = "0.3.0"
 end

data/lib/better_errors.rb

@@ -1,31 +1,119 @@
 require "pp"
 require "erubis"
 require "coderay"
+require "uri"
 
 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/disable_logging_middleware"
+require "better_errors/code_formatter"
+require "better_errors/repl"
 
-class << BetterErrors
-  attr_accessor :application_root, :binding_of_caller_available
+module BetterErrors
+  class << self
+    # The path to the root of the application. Better Errors uses this property
+    # to determine if a file in a backtrace should be considered an application
+    # frame. If you are using Better Errors with Rails, you do not need to set
+    # this attribute manually.
+    # 
+    # @return [String]
+    attr_accessor :application_root
+    
+    # The logger to use when logging exception details and backtraces. If you
+    # are using Better Errors with Rails, you do not need to set this attribute
+    # manually. If this attribute is `nil`, nothing will be logged.
+    # 
+    # @return [Logger, nil]
+    attr_accessor :logger
+
+    # @private
+    attr_accessor :binding_of_caller_available
+    
+    # @private
+    alias_method :binding_of_caller_available?, :binding_of_caller_available
+  end
+  
+  # Returns a proc, which when called with a filename and line number argument,
+  # returns a URL to open the filename and line in the selected editor.
+  # 
+  # Generates TextMate URLs by default.
+  # 
+  #   BetterErrors.editor["/some/file", 123]
+  #     # => txmt://open?url=file:///some/file&line=123
+  # 
+  # @return [Proc]
+  def self.editor
+    @editor
+  end
   
-  alias_method :binding_of_caller_available?, :binding_of_caller_available
+  # Configures how Better Errors generates open-in-editor URLs.
+  # 
+  # @overload BetterErrors.editor=(sym)
+  #   Uses one of the preset editor configurations. Valid symbols are:
+  #
+  #   * `:textmate`, `:txmt`, `:tm`
+  #   * `:sublime`, `:subl`, `:st`
+  #   * `:macvim`
+  # 
+  #   @param [Symbol] sym
+  # 
+  # @overload BetterErrors.editor=(str)
+  #   Uses `str` as the format string for generating open-in-editor URLs.
+  # 
+  #   Use `%{file}` and `%{line}` as placeholders for the actual values.
+  # 
+  #   @example
+  #     BetterErrors.editor = "my-editor://open?url=%{file}&line=%{line}"
+  # 
+  #   @param [String] str
+  # 
+  # @overload BetterErrors.editor=(proc)
+  #   Uses `proc` to generate open-in-editor URLs. The proc will be called
+  #   with `file` and `line` parameters when a URL needs to be generated.
+  # 
+  #   Your proc should take care to escape `file` appropriately with
+  #   `URI.encode_www_form_component` (please note that `URI.escape` is **not**
+  #   a suitable substitute.)
+  # 
+  #   @example
+  #     BetterErrors.editor = proc { |file, line|
+  #       "my-editor://open?url=#{URI.encode_www_form_component file}&line=#{line}"
+  #     }
+  #   
+  #   @param [Proc] proc
+  # 
+  def self.editor=(editor)
+    case editor
+    when :textmate, :txmt, :tm
+      self.editor = "txmt://open?url=file://%{file}&line=%{line}"
+    when :sublime, :subl, :st
+      self.editor = "subl://open?url=file://%{file}&line=%{line}"
+    when :macvim, :mvim
+      self.editor = "mvim://open?url=file://%{file}&line=%{line}"
+    when String
+      self.editor = proc { |file, line| editor % { file: URI.encode_www_form_component(file), line: line } }
+    else
+      if editor.respond_to? :call
+        @editor = editor
+      else
+        raise TypeError, "Expected editor to be a valid editor key, a format string or a callable."
+      end
+    end
+  end
+  
+  BetterErrors.editor = :textmate
 end
 
 begin
+  $:.unshift "/Users/charlie/code/binding_of_caller/lib"
   require "binding_of_caller"
   BetterErrors.binding_of_caller_available = true
 rescue LoadError => e
   BetterErrors.binding_of_caller_available = false
 end
 
-if BetterErrors.binding_of_caller_available?
-  require "better_errors/core_ext/exception"
-else
-  warn "BetterErrors: binding_of_caller gem unavailable, cannot display local variables on error pages."
-  warn "Add 'binding_of_caller' to your Gemfile to make this warning go away."
-  warn ""
-end
+require "better_errors/core_ext/exception"
 
 require "better_errors/rails" if defined? Rails::Railtie

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

@@ -2,11 +2,21 @@ require "spec_helper"
 
 module BetterErrors
   describe ErrorPage do
-    let(:exception) { raise ZeroDivisionError, "you divided by zero you silly goose!" rescue $! }
+    let!(:exception) { raise ZeroDivisionError, "you divided by zero you silly goose!" rescue $! }
   
-    let(:error_page) { ErrorPage.new exception, { "REQUEST_PATH" => "/some/path" } }
+    let(:error_page) { ErrorPage.new exception, { "PATH_INFO" => "/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

@@ -2,10 +2,30 @@ require "spec_helper"
 
 module BetterErrors
   describe Middleware do
+    let(:app) { Middleware.new(->env { ":)" }) }
+
     it "should pass non-error responses through" do
-      app = Middleware.new(->env { ":)" })
       app.call({}).should == ":)"
     end
+
+    it "should call the internal methods" do
+      app.should_receive :internal_call
+      app.call("PATH_INFO" => "/__better_errors/1/preform_awesomness")
+    end
+
+    it "should show the error page" do
+      app.should_receive :show_error_page
+      app.call("PATH_INFO" => "/__better_errors/")
+    end
+
+    context "when requesting the /__better_errors manually" do
+      let(:app) { Middleware.new(->env { ":)" }) }
+      
+      it "should show that no errors have been recorded" do
+        status, headers, body = app.call("PATH_INFO" => "/__better_errors")
+        body.join.should match /No errors have been recorded yet./
+      end
+    end
     
     context "when handling an error" do
       let(:app) { Middleware.new(->env { raise "oh no :(" }) }
@@ -21,6 +41,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/stack_frame_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+module BetterErrors
+  describe StackFrame do
+    context "#application?" do
+      it "should be true for application filenames" do
+        BetterErrors.stub!(:application_root).and_return("/abc/xyz")
+        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 = StackFrame.new("/abc/nope", 123, "foo")
+        
+        frame.application?.should be_false
+      end
+      
+      it "should not care if no application_root is set" do
+        frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
+        
+        frame.application?.should be_false
+      end
+    end
+    
+    context "#gem?" do
+      it "should be true for gem filenames" do
+        Gem.stub!(:path).and_return(["/abc/xyz"])
+        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 = StackFrame.new("/abc/nope", 123, "foo")
+        
+        frame.gem?.should be_false
+      end
+    end
+    
+    context "#application_path" do
+      it "should chop off the application root" do
+        BetterErrors.stub!(:application_root).and_return("/abc/xyz")
+        frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
+        
+        frame.application_path.should == "app/controllers/crap_controller.rb"
+      end
+    end
+    
+    context "#gem_path" do
+      it "should chop of the gem path and stick (gem) there" do
+        Gem.stub!(:path).and_return(["/abc/xyz"])
+        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
+      
+      it "should prioritize gem path over application path" do
+        BetterErrors.stub!(:application_root).and_return("/abc/xyz")
+        Gem.stub!(:path).and_return(["/abc/xyz/vendor"])
+        frame = StackFrame.new("/abc/xyz/vendor/gems/whatever-1.2.3/lib/whatever.rb", 123, "foo")
+        
+        frame.gem_path.should == "(gem) whatever-1.2.3/lib/whatever.rb"
+      end
+    end
+    
+    context "#pretty_path" do
+      it "should return #application_path for application paths" do
+        BetterErrors.stub!(:application_root).and_return("/abc/xyz")
+        frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
+        frame.pretty_path.should == frame.application_path
+      end
+      
+      it "should return #gem_path for gem paths" do
+        Gem.stub!(:path).and_return(["/abc/xyz"])
+        frame = StackFrame.new("/abc/xyz/gems/whatever-1.2.3/lib/whatever.rb", 123, "foo")
+        
+        frame.pretty_path.should == frame.gem_path
+      end
+    end
+
+    it "should special case SyntaxErrors" do
+      syntax_error = SyntaxError.new "my_file.rb:123: you wrote bad ruby!"
+      syntax_error.stub!(:backtrace).and_return([])
+      frames = StackFrame.from_exception(syntax_error)
+      frames.count.should == 1
+      frames.first.filename.should == "my_file.rb"
+      frames.first.line.should == 123
+    end
+    
+    it "should not blow up if no method name is given" do
+      error = StandardError.new
+      
+      error.stub!(:backtrace).and_return(["foo.rb:123"])
+      frames = StackFrame.from_exception(error)
+      frames.first.filename.should == "foo.rb"
+      frames.first.line.should == 123
+      
+      error.stub!(:backtrace).and_return(["foo.rb:123: this is an error message"])
+      frames = StackFrame.from_exception(error)
+      frames.first.filename.should == "foo.rb"
+      frames.first.line.should == 123
+    end
+    
+    it "should ignore a backtrace line if its format doesn't make any sense at all" do
+      error = StandardError.new
+      error.stub!(:backtrace).and_return(["foo.rb:123:in `foo'", "C:in `find'", "bar.rb:123:in `bar'"])
+      frames = StackFrame.from_exception(error)
+      frames.count.should == 2
+    end
+    
+    it "should not blow up if a filename contains a colon" do
+      error = StandardError.new
+      error.stub!(:backtrace).and_return(["crap:filename.rb:123"])
+      frames = StackFrame.from_exception(error)
+      frames.first.filename.should == "crap:filename.rb"
+    end
+  end
+end

data/spec/better_errors_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe BetterErrors do
+  context ".editor" do
+    it "should default to textmate" do
+      subject.editor["foo.rb", 123].should == "txmt://open?url=file://foo.rb&line=123"
+    end
+    
+    it "should url escape the filename" do
+      subject.editor["&.rb", 0].should == "txmt://open?url=file://%26.rb&line=0"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
+require "simplecov"
+SimpleCov.start
+
 $: << File.expand_path("../../lib", __FILE__)
 require "better_errors"
 require "ostruct"