better_errors-creditkudos 2.1.1

data/lib/better_errors/templates/text.erb

@@ -0,0 +1,21 @@
+<%== text_heading("=", "%s at %s" % [exception_type, request_path]) %>
+
+> <%== exception_message %>
+<% if backtrace_frames.any? %>
+
+<%== text_heading("-", "%s, line %i" % [first_frame.pretty_path, first_frame.line]) %>
+
+``` ruby
+<%== text_formatted_code_block(first_frame) %>```
+
+App backtrace
+-------------
+
+<%== application_frames.map { |s| " - #{s}" }.join("\n") %>
+
+Full backtrace
+--------------
+
+<%== backtrace_frames.map { |s| " - #{s}" }.join("\n") %>
+
+<% end %>

data/lib/better_errors/templates/variable_info.erb

@@ -0,0 +1,72 @@
+<header class="trace_info clearfix">
+    <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>
+    <div class="code_block clearfix">
+        <%== html_formatted_code_block @frame %>
+    </div>
+
+    <% 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 is 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>
+
+<% if BetterErrors.binding_of_caller_available? && @frame.frame_binding %>
+    <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 -->
+<% end %>

data/lib/better_errors/version.rb

@@ -0,0 +1,3 @@
+module BetterErrors
+  VERSION = "2.1.1"
+end

data/spec/better_errors/code_formatter_spec.rb

@@ -0,0 +1,92 @@
+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 "picks an appropriate scanner" do
+      formatter.coderay_scanner.should == :ruby
+    end
+
+    it "shows 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 "works when the line is right on the edge" do
+      formatter = CodeFormatter.new(filename, 20)
+      formatter.line_range.should == (15..20)
+    end
+
+    describe CodeFormatter::HTML do
+      it "highlights the erroring line" do
+        formatter = CodeFormatter::HTML.new(filename, 8)
+        formatter.output.should =~ /highlight.*eight/
+      end
+
+      it "works when the line is right on the edge" do
+        formatter = CodeFormatter::HTML.new(filename, 20)
+        formatter.output.should_not == formatter.source_unavailable
+      end
+
+      it "doesn't barf when the lines don't make any sense" do
+        formatter = CodeFormatter::HTML.new(filename, 999)
+        formatter.output.should == formatter.source_unavailable
+      end
+
+      it "doesn't barf when the file doesn't exist" do
+        formatter = CodeFormatter::HTML.new("fkdguhskd7e l", 1)
+        formatter.output.should == formatter.source_unavailable
+      end
+    end
+
+    describe CodeFormatter::Text do
+      it "highlights the erroring line" do
+        formatter = CodeFormatter::Text.new(filename, 8)
+        formatter.output.should == <<-TEXT.gsub(/^        /, "")
+            3   three
+            4   four
+            5   five
+            6   six
+            7   seven
+        >   8   eight
+            9   nine
+           10   ten
+           11   eleven
+           12   twelve
+           13   thirteen
+        TEXT
+      end
+
+      it "works when the line is right on the edge" do
+        formatter = CodeFormatter::Text.new(filename, 20)
+        formatter.output.should_not == formatter.source_unavailable
+      end
+
+      it "doesn't barf when the lines don't make any sense" do
+        formatter = CodeFormatter::Text.new(filename, 999)
+        formatter.output.should == formatter.source_unavailable
+      end
+
+      it "doesn't barf when the file doesn't exist" do
+        formatter = CodeFormatter::Text.new("fkdguhskd7e l", 1)
+        formatter.output.should == formatter.source_unavailable
+      end
+    end
+  end
+end

data/spec/better_errors/error_page_spec.rb

@@ -0,0 +1,122 @@
+require "spec_helper"
+
+module BetterErrors
+  describe ErrorPage do
+    let!(:exception) { raise ZeroDivisionError, "you divided by zero you silly goose!" rescue $! }
+
+    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 "includes the error message" do
+      response.should include("you divided by zero you silly goose!")
+    end
+
+    it "includes the request path" do
+      response.should include("/some/path")
+    end
+
+    it "includes the exception class" do
+      response.should include("ZeroDivisionError")
+    end
+
+    context "variable inspection" do
+      let(:exception) { empty_binding.eval("raise") rescue $! }
+
+      if BetterErrors.binding_of_caller_available?
+        it "shows 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
+      else
+        it "tells the user to add binding_of_caller to their gemfile to get fancy features" do
+          html = error_page.do_variables("index" => 0)[:html]
+          html.should include(%{gem "binding_of_caller"})
+        end
+      end
+
+      it "shows 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
+
+      it "shows filter instance variables" do
+        BetterErrors.stub(:ignored_instance_variables).and_return([ :@inst_d ])
+        html = error_page.do_variables("index" => 0)[:html]
+        html.should include("inst_c")
+        html.should include(":value_for_inst_c")
+        html.should_not include('<td class="name">@inst_d</td>')
+        html.should_not include("<pre>:value_for_inst_d</pre>")
+      end
+    end
+
+    it "doesn't 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
+
+    context 'with an exception with blank lines' do
+      class SpacedError < StandardError
+        def initialize(message = nil)
+          message = "\n\n#{message}" if message
+          super
+        end
+      end
+
+      let!(:exception) { raise SpacedError, "Danger Warning!" rescue $! }
+
+      it 'should not include leading blank lines from exception_message' do
+        exception.message.should =~ /\A\n\n/
+        error_page.exception_message.should_not =~ /\A\n\n/
+      end
+    end
+
+    context 'with an inspect size limit set' do
+      before { BetterErrors.maximum_variable_inspect_size = 50_000 }
+
+      it "shows variables with inspects that are below the inspect size threshold" do
+        content = 'AAAAA'
+        empty_binding.instance_variable_set('@small', content)
+
+        html = error_page.do_variables("index" => 0)[:html]
+        html.should_not include "object too large"
+      end
+
+
+      it "hides variables with inspects that are above the inspect size threshold" do
+        content = 'A' * (BetterErrors.maximum_variable_inspect_size)
+        empty_binding.instance_variable_set('@big', content)
+
+        html = error_page.do_variables("index" => 0)[:html]
+        html.should include "object too large"
+      end
+
+      it "shows variables with large inspects if max inspect size is disabled" do
+        content = 'A' * (BetterErrors.maximum_variable_inspect_size)
+        BetterErrors.maximum_variable_inspect_size = nil
+        empty_binding.instance_variable_set('@big', content)
+
+        html = error_page.do_variables("index" => 0)[:html]
+        html.should_not include "object too large"
+      end
+    end
+  end
+end

data/spec/better_errors/middleware_spec.rb

@@ -0,0 +1,180 @@
+require "spec_helper"
+
+module BetterErrors
+  describe Middleware do
+    let(:app) { Middleware.new(->env { ":)" }) }
+    let(:exception) { RuntimeError.new("oh no :(") }
+
+    it "passes non-error responses through" do
+      app.call({}).should == ":)"
+    end
+
+    it "calls the internal methods" do
+      app.should_receive :internal_call
+      app.call("PATH_INFO" => "/__better_errors/1/preform_awesomness")
+    end
+
+    it "calls the internal methods on any subfolder path" do
+      app.should_receive :internal_call
+      app.call("PATH_INFO" => "/any_sub/folder/path/__better_errors/1/preform_awesomness")
+    end
+
+    it "shows the error page" do
+      app.should_receive :show_error_page
+      app.call("PATH_INFO" => "/__better_errors/")
+    end
+
+    it "shows the error page on any subfolder path" do
+      app.should_receive :show_error_page
+      app.call("PATH_INFO" => "/any_sub/folder/path/__better_errors/")
+    end
+
+    it "doesn't show the error page to a non-local address" do
+      app.should_not_receive :better_errors_call
+      app.call("REMOTE_ADDR" => "1.2.3.4")
+    end
+
+    it "shows to a whitelisted IP" do
+      BetterErrors::Middleware.allow_ip! '77.55.33.11'
+      app.should_receive :better_errors_call
+      app.call("REMOTE_ADDR" => "77.55.33.11")
+    end
+
+    it "respects the X-Forwarded-For header" do
+      app.should_not_receive :better_errors_call
+      app.call(
+        "REMOTE_ADDR"          => "127.0.0.1",
+        "HTTP_X_FORWARDED_FOR" => "1.2.3.4",
+      )
+    end
+
+    it "doesn't blow up when given a blank REMOTE_ADDR" do
+      expect { app.call("REMOTE_ADDR" => " ") }.to_not raise_error
+    end
+
+    it "doesn't blow up when given an IP address with a zone index" do
+      expect { app.call("REMOTE_ADDR" => "0:0:0:0:0:0:0:1%0" ) }.to_not raise_error
+    end
+
+    context "when requesting the /__better_errors manually" do
+      let(:app) { Middleware.new(->env { ":)" }) }
+
+      it "shows 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
+
+      it "shows that no errors have been recorded on any subfolder path" do
+        status, headers, body = app.call("PATH_INFO" => "/any_sub/folder/path/__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 exception }) }
+
+      it "returns status 500" do
+        status, headers, body = app.call({})
+
+        status.should == 500
+      end
+
+      if Exception.new.respond_to?(:cause)
+        context "cause" do
+          class OtherException < Exception
+            def initialize(message)
+              super(message)
+            end
+          end
+
+          it "shows Original Exception if it responds_to and has an cause" do
+            app = Middleware.new(->env {
+              begin
+                raise "Original Exception"
+              rescue
+                raise OtherException.new("Other Exception")
+              end
+            })
+
+            status, _, body = app.call({})
+
+            status.should == 500
+            body.join.should_not match(/\n> Other Exception\n/)
+            body.join.should match(/\n> Original Exception\n/)
+          end
+        end
+      else
+        context "original_exception" do
+          class OriginalExceptionException < Exception
+            attr_reader :original_exception
+
+            def initialize(message, original_exception = nil)
+              super(message)
+              @original_exception = original_exception
+            end
+          end
+
+          it "shows Original Exception if it responds_to and has an original_exception" do
+            app = Middleware.new(->env {
+              raise OriginalExceptionException.new("Other Exception", Exception.new("Original Exception"))
+            })
+
+            status, _, body = app.call({})
+
+            status.should == 500
+            body.join.should_not match(/Other Exception/)
+            body.join.should match(/Original Exception/)
+          end
+
+          it "won't crash if the exception responds_to but doesn't have an original_exception" do
+            app = Middleware.new(->env {
+              raise OriginalExceptionException.new("Other Exception")
+            })
+
+            status, _, body = app.call({})
+
+            status.should == 500
+            body.join.should match(/Other Exception/)
+          end
+        end
+      end
+
+      it "returns ExceptionWrapper's status_code" do
+        ad_ew = double("ActionDispatch::ExceptionWrapper")
+        ad_ew.stub('new').with({}, exception ){ double("ExceptionWrapper", status_code: 404) }
+        stub_const('ActionDispatch::ExceptionWrapper', ad_ew)
+
+        status, headers, body = app.call({})
+
+        status.should == 404
+      end
+
+      it "returns UTF-8 error pages" do
+        status, headers, body = app.call({})
+
+        headers["Content-Type"].should match /charset=utf-8/
+      end
+
+      it "returns text pages by default" do
+        status, headers, body = app.call({})
+
+        headers["Content-Type"].should match /text\/plain/
+      end
+
+      it "returns HTML pages by default" do
+        # Chrome's 'Accept' header looks similar this.
+        status, headers, body = app.call("HTTP_ACCEPT" => "text/html,application/xhtml+xml;q=0.9,*/*")
+
+        headers["Content-Type"].should match /text\/html/
+      end
+
+      it "logs the exception" do
+        logger = Object.new
+        logger.should_receive :fatal
+        BetterErrors.stub(:logger).and_return(logger)
+
+        app.call({})
+      end
+    end
+  end
+end