better_errors 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ae01bfc76b45f6af1df26c7268229088f8de251
-  data.tar.gz: f95f617f84e01f1641bf193d735d45d85360b768
+  metadata.gz: d53ee50b3a870061cf9298e5225635771043d6d7
+  data.tar.gz: b4280966bd31d24f4f4cb12ea54c1eea11bccdaa
 SHA512:
-  metadata.gz: 4881b5a147d85c9c7ed116a8838e45745bd95958df71dea8934e0b5601fd32cde2a016bbc419a855f9e29dd8e6bab322fcae8d676a78ede120d134809dac29b7
-  data.tar.gz: 6fb75468216fc264250e8f6726d47689025352441701cb83b2c125b541ac389c491da6ba8b3eeded2759b99be47f5c0cd103b54315122d7a33905261d02d4cca
+  metadata.gz: e068142eaef86037e0cc6088672158a0a9d021e49e7fe9a823c888d1f319181e07b18a03852b46da4a6d9a0db49f6d420ac7359ceb6ec4a35549bb56b403bec5
+  data.tar.gz: 9c184752196c2cf65b7dba20f94cf3b47428c6fd067c880ffa452bca8ed2fa6d3e84e5cd64ae6e295199622fe4e1ff2d6d09979d2a35e0b9bf36d38c6ebfdd33

data/.travis.yml

@@ -2,5 +2,8 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.1.0
-  - 2.0.0
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4

data/Gemfile

@@ -3,8 +3,9 @@ source 'https://rubygems.org'
 gemspec
 
 gem "rake"
-gem "rack"
-gem "rspec", "2.14.1"
+gem "rack", "1.6.4"
+gem "rspec", "3.5.0"
+gem "rspec-its"
 gem "binding_of_caller", platforms: :ruby
 gem "pry", "0.9.12"
 gem "yard"

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-2015 Charlie Somerville
+Copyright (c) 2012-2016 Charlie Somerville
 
 MIT License
 

data/README.md

@@ -6,10 +6,14 @@ Better Errors replaces the standard Rails error page with a much better and more
 
 ## Features
 
+For screenshots of these features, [see the wiki](https://github.com/charliesome/better_errors/wiki).
+
 * Full stack trace
 * Source code inspection for all stack frames (with highlighting)
 * Local and instance variable inspection
-* Live REPL on every stack frame
+* Live shell (REPL) on every stack frame
+* Links directly to the source line in your editor
+* Useful information in non-HTML requests
 
 ## Installation
 
@@ -95,6 +99,14 @@ in `development`. Another option would be to use Webrick, Mongrel, Thin,
 or another single-process server as your `rails server`, when you are trying
 to troubleshoot an issue in development.
 
+##Specify editor to open files in
+
+```ruby
+# e.g. in config/initializers/better_errors.rb
+# Other preset values are [:mvim, :macvim, :textmate, :txmt, :tm, :sublime, :subl, :st]
+BetterErrors.editor = :mvim
+```
+
 ## 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!

data/lib/better_errors/error_page.rb

@@ -58,6 +58,14 @@ module BetterErrors
       exception.backtrace
     end
 
+    def exception_type
+      exception.type
+    end
+
+    def exception_message
+      exception.message.lstrip
+    end
+
     def application_frames
       backtrace_frames.select(&:application?)
     end

data/lib/better_errors/middleware.rb

@@ -100,7 +100,7 @@ module BetterErrors
       end
 
       status_code = 500
-      if defined? ActionDispatch::ExceptionWrapper
+      if defined?(ActionDispatch::ExceptionWrapper) && exception
         status_code = ActionDispatch::ExceptionWrapper.new(env, exception).status_code
       end
 
@@ -115,7 +115,7 @@ module BetterErrors
     def log_exception
       return unless BetterErrors.logger
 
-      message = "\n#{@error_page.exception.type} - #{@error_page.exception.message}:\n"
+      message = "\n#{@error_page.exception_type} - #{@error_page.exception_message}:\n"
       @error_page.backtrace_frames.each do |frame|
         message << "  #{frame}\n"
       end

data/lib/better_errors/raised_exception.rb

@@ -4,7 +4,9 @@ module BetterErrors
     attr_reader :exception, :message, :backtrace
 
     def initialize(exception)
-      if exception.respond_to?(:original_exception) && exception.original_exception
+      if exception.respond_to?(:cause)
+        exception = exception.cause if exception.cause
+      elsif exception.respond_to?(:original_exception) && exception.original_exception
         exception = exception.original_exception
       end
 

data/lib/better_errors/templates/main.erb

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title><%= exception.type %> at <%= request_path %></title>
+    <title><%= exception_type %> at <%= request_path %></title>
 </head>
 <body>
     <%# Stylesheets are placed in the <body> for Turbolinks compatibility. %>
@@ -731,8 +731,8 @@
 
     <div class='top'>
         <header class="exception">
-            <h2><strong><%= exception.type %></strong> <span>at <%= request_path %></span></h2>
-            <p><%= exception.message %></p>
+            <h2><strong><%= exception_type %></strong> <span>at <%= request_path %></span></h2>
+            <p><%= exception_message %></p>
         </header>
     </div>
 

data/lib/better_errors/templates/text.erb

@@ -1,6 +1,6 @@
-<%== text_heading("=", "%s at %s" % [exception.type, request_path]) %>
+<%== text_heading("=", "%s at %s" % [exception_type, request_path]) %>
 
-> <%== exception.message %>
+> <%== exception_message %>
 <% if backtrace_frames.any? %>
 
 <%== text_heading("-", "%s, line %i" % [first_frame.pretty_path, first_frame.line]) %>

data/lib/better_errors/templates/variable_info.erb

@@ -45,26 +45,28 @@
     </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>
+<% 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>
 
-<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 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>
-</div>
 
-<!-- <%= Time.now.to_f - @var_start_time %> seconds -->
+    <!-- <%= Time.now.to_f - @var_start_time %> seconds -->
+<% end %>

data/lib/better_errors/version.rb

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

data/spec/better_errors/code_formatter_spec.rb

@@ -7,13 +7,13 @@ module BetterErrors
     let(:formatter) { CodeFormatter.new(filename, 8) }
 
     it "picks an appropriate scanner" do
-      formatter.coderay_scanner.should == :ruby
+      expect(formatter.coderay_scanner).to eq(:ruby)
     end
 
     it "shows 5 lines of context" do
-      formatter.line_range.should == (3..13)
+      expect(formatter.line_range).to eq(3..13)
 
-      formatter.context_lines.should == [
+      expect(formatter.context_lines).to eq([
           "three\n",
           "four\n",
           "five\n",
@@ -25,40 +25,40 @@ module BetterErrors
           "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)
+      expect(formatter.line_range).to eq(15..20)
     end
 
     describe CodeFormatter::HTML do
       it "highlights the erroring line" do
         formatter = CodeFormatter::HTML.new(filename, 8)
-        formatter.output.should =~ /highlight.*eight/
+        expect(formatter.output).to match(/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
+        expect(formatter.output).not_to eq(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
+        expect(formatter.output).to eq(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
+        expect(formatter.output).to eq(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(/^        /, "")
+        expect(formatter.output).to eq <<-TEXT.gsub(/^        /, "")
             3   three
             4   four
             5   five
@@ -75,17 +75,17 @@ module BetterErrors
 
       it "works when the line is right on the edge" do
         formatter = CodeFormatter::Text.new(filename, 20)
-        formatter.output.should_not == formatter.source_unavailable
+        expect(formatter.output).not_to eq(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
+        expect(formatter.output).to eq(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
+        expect(formatter.output).to eq(formatter.source_unavailable)
       end
     end
   end

data/spec/better_errors/error_page_spec.rb

@@ -19,15 +19,15 @@ module BetterErrors
     }
 
     it "includes the error message" do
-      response.should include("you divided by zero you silly goose!")
+      expect(response).to include("you divided by zero you silly goose!")
     end
 
     it "includes the request path" do
-      response.should include("/some/path")
+      expect(response).to include("/some/path")
     end
 
     it "includes the exception class" do
-      response.should include("ZeroDivisionError")
+      expect(response).to include("ZeroDivisionError")
     end
 
     context "variable inspection" do
@@ -36,41 +36,57 @@ module BetterErrors
       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")
+          expect(html).to include("local_a")
+          expect(html).to include(":value_for_local_a")
+          expect(html).to include("local_b")
+          expect(html).to 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"})
+          expect(html).to 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")
+        expect(html).to include("inst_c")
+        expect(html).to include(":value_for_inst_c")
+        expect(html).to include("inst_d")
+        expect(html).to include(":value_for_inst_d")
       end
 
       it "shows filter instance variables" do
-        BetterErrors.stub(:ignored_instance_variables).and_return([ :@inst_d ])
+        allow(BetterErrors).to receive(: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>")
+        expect(html).to include("inst_c")
+        expect(html).to include(":value_for_inst_c")
+        expect(html).not_to include('<td class="name">@inst_d</td>')
+        expect(html).not_to 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([
+      allow(exception).to receive(:backtrace).and_return([
         "<internal:prelude>:10:in `spawn_rack_application'"
       ])
-      response.should include("Source unavailable")
+      expect(response).to 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
+        expect(exception.message).to match(/\A\n\n/)
+        expect(error_page.exception_message).not_to match(/\A\n\n/)
+      end
     end
   end
 end

data/spec/better_errors/middleware_spec.rb

@@ -6,42 +6,42 @@ module BetterErrors
     let(:exception) { RuntimeError.new("oh no :(") }
 
     it "passes non-error responses through" do
-      app.call({}).should == ":)"
+      expect(app.call({})).to eq(":)")
     end
 
     it "calls the internal methods" do
-      app.should_receive :internal_call
+      expect(app).to 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
+      expect(app).to 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
+      expect(app).to 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
+      expect(app).to 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
+      expect(app).not_to 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
+      expect(app).to 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
+      expect(app).not_to receive :better_errors_call
       app.call(
         "REMOTE_ADDR"          => "127.0.0.1",
         "HTTP_X_FORWARDED_FOR" => "1.2.3.4",
@@ -61,12 +61,20 @@ module BetterErrors
 
       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./
+        expect(body.join).to match /No errors have been recorded yet./
+      end
+
+      it 'does not attempt to use ActionDispatch::ExceptionWrapper with a nil exception' do
+        ad_ew = double("ActionDispatch::ExceptionWrapper")
+        stub_const('ActionDispatch::ExceptionWrapper', ad_ew)
+        ad_ew.should_not_receive :new
+
+        status, headers, body = app.call("PATH_INFO" => "/__better_errors")
       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./
+        expect(body.join).to match /No errors have been recorded yet./
       end
     end
 
@@ -76,76 +84,102 @@ module BetterErrors
       it "returns status 500" do
         status, headers, body = app.call({})
 
-        status.should == 500
+        expect(status).to eq(500)
       end
 
-      context "original_exception" do
-        class OriginalExceptionException < Exception
-          attr_reader :original_exception
+      if Exception.new.respond_to?(:cause)
+        context "cause" do
+          class OtherException < Exception
+            def initialize(message)
+              super(message)
+            end
+          end
 
-          def initialize(message, original_exception = nil)
-            super(message)
-            @original_exception = original_exception
+          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({})
+
+            expect(status).to eq(500)
+            expect(body.join).not_to match(/\n> Other Exception\n/)
+            expect(body.join).to 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"))
-          })
+          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, _, body = app.call({})
 
-          status.should == 500
-          body.join.should_not match(/Other Exception/)
-          body.join.should match(/Original Exception/)
-        end
+            expect(status).to eq(500)
+            expect(body.join).not_to match(/Other Exception/)
+            expect(body.join).to 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")
-          })
+          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, _, body = app.call({})
 
-          status.should == 500
-          body.join.should match(/Other Exception/)
+            expect(status).to eq(500)
+            expect(body.join).to 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) }
+        allow(ad_ew).to receive('new').with({}, exception) { double("ExceptionWrapper", status_code: 404) }
         stub_const('ActionDispatch::ExceptionWrapper', ad_ew)
 
         status, headers, body = app.call({})
 
-        status.should == 404
+        expect(status).to eq(404)
       end
 
       it "returns UTF-8 error pages" do
         status, headers, body = app.call({})
 
-        headers["Content-Type"].should match /charset=utf-8/
+        expect(headers["Content-Type"]).to match /charset=utf-8/
       end
 
       it "returns text pages by default" do
         status, headers, body = app.call({})
 
-        headers["Content-Type"].should match /text\/plain/
+        expect(headers["Content-Type"]).to 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/
+        expect(headers["Content-Type"]).to match /text\/html/
       end
 
       it "logs the exception" do
         logger = Object.new
-        logger.should_receive :fatal
-        BetterErrors.stub(:logger).and_return(logger)
+        expect(logger).to receive :fatal
+        allow(BetterErrors).to receive(:logger).and_return(logger)
 
         app.call({})
       end

data/spec/better_errors/raised_exception_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+require "rspec/its"
 
 module BetterErrors
   describe RaisedException do
@@ -24,8 +25,8 @@ module BetterErrors
       its(:type)    { should == SyntaxError }
 
       it "has the right filename and line number in the backtrace" do
-        subject.backtrace.first.filename.should == "foo.rb"
-        subject.backtrace.first.line.should == 123
+        expect(subject.backtrace.first.filename).to eq("foo.rb")
+        expect(subject.backtrace.first.line).to eq(123)
       end
     end
 
@@ -44,8 +45,8 @@ module BetterErrors
       its(:type)    { should == Haml::SyntaxError }
 
       it "has the right filename and line number in the backtrace" do
-        subject.backtrace.first.filename.should == "foo.rb"
-        subject.backtrace.first.line.should == 123
+        expect(subject.backtrace.first.filename).to eq("foo.rb")
+        expect(subject.backtrace.first.line).to eq(123)
       end
     end
 
@@ -64,8 +65,8 @@ module BetterErrors
       its(:type)    { should == Sprockets::Coffeelint::Error }
 
       it "has the right filename and line number in the backtrace" do
-        subject.backtrace.first.filename.should == "app/assets/javascripts/files/index.coffee"
-        subject.backtrace.first.line.should == 11
+        expect(subject.backtrace.first.filename).to eq("app/assets/javascripts/files/index.coffee")
+        expect(subject.backtrace.first.line).to eq(11)
       end
     end
   end

data/spec/better_errors/repl/pry_spec.rb

@@ -15,23 +15,23 @@ module BetterErrors
 
       it "does line continuation" do
         output, prompt, filled = repl.send_input ""
-        output.should == "=> nil\n"
-        prompt.should == ">>"
-        filled.should == ""
+        expect(output).to eq("=> nil\n")
+        expect(prompt).to eq(">>")
+        expect(filled).to eq("")
 
         output, prompt, filled = repl.send_input "def f(x)"
-        output.should == ""
-        prompt.should == ".."
-        filled.should == "  "
+        expect(output).to eq("")
+        expect(prompt).to eq("..")
+        expect(filled).to eq("  ")
 
         output, prompt, filled = repl.send_input "end"
         if RUBY_VERSION >= "2.1.0"
-          output.should == "=> :f\n"
+          expect(output).to eq("=> :f\n")
         else
-          output.should == "=> nil\n"
+          expect(output).to eq("=> nil\n")
         end
-        prompt.should == ">>"
-        filled.should == ""
+        expect(prompt).to eq(">>")
+        expect(filled).to eq("")
       end
 
       it_behaves_like "a REPL provider"

data/spec/better_errors/repl/shared_examples.rb

@@ -1,18 +1,18 @@
 shared_examples_for "a REPL provider" do
   it "evaluates ruby code in a given context" do
     repl.send_input("local_a = 456")
-    fresh_binding.eval("local_a").should == 456
+    expect(fresh_binding.eval("local_a")).to eq(456)
   end
 
   it "returns a tuple of output and the new prompt" do
     output, prompt = repl.send_input("1 + 2")
-    output.should == "=> 3\n"
-    prompt.should == ">>"
+    expect(output).to eq("=> 3\n")
+    expect(prompt).to eq(">>")
   end
 
   it "doesn't barf if the code throws an exception" do
     output, prompt = repl.send_input("raise Exception")
-    output.should include "Exception: Exception"
-    prompt.should == ">>"
+    expect(output).to include "Exception: Exception"
+    expect(prompt).to eq(">>")
   end
 end

data/spec/better_errors/stack_frame_spec.rb

@@ -4,80 +4,80 @@ module BetterErrors
   describe StackFrame do
     context "#application?" do
       it "is true for application filenames" do
-        BetterErrors.stub(:application_root).and_return("/abc/xyz")
+        allow(BetterErrors).to receive(:application_root).and_return("/abc/xyz")
         frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
 
-        frame.should be_application
+        expect(frame).to be_application
       end
 
       it "is false for everything else" do
-        BetterErrors.stub(:application_root).and_return("/abc/xyz")
+        allow(BetterErrors).to receive(:application_root).and_return("/abc/xyz")
         frame = StackFrame.new("/abc/nope", 123, "foo")
 
-        frame.should_not be_application
+        expect(frame).not_to be_application
       end
 
       it "doesn't care if no application_root is set" do
         frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index")
 
-        frame.should_not be_application
+        expect(frame).not_to be_application
       end
     end
 
     context "#gem?" do
       it "is true for gem filenames" do
-        Gem.stub(:path).and_return(["/abc/xyz"])
+        allow(Gem).to receive(:path).and_return(["/abc/xyz"])
         frame = StackFrame.new("/abc/xyz/gems/whatever-1.2.3/lib/whatever.rb", 123, "foo")
 
-        frame.should be_gem
+        expect(frame).to be_gem
       end
 
       it "is false for everything else" do
-        Gem.stub(:path).and_return(["/abc/xyz"])
+        allow(Gem).to receive(:path).and_return(["/abc/xyz"])
         frame = StackFrame.new("/abc/nope", 123, "foo")
 
-        frame.should_not be_gem
+        expect(frame).not_to be_gem
       end
     end
 
     context "#application_path" do
       it "chops off the application root" do
-        BetterErrors.stub(:application_root).and_return("/abc/xyz")
+        allow(BetterErrors).to receive(: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"
+        expect(frame.application_path).to eq("app/controllers/crap_controller.rb")
       end
     end
 
     context "#gem_path" do
       it "chops of the gem path and stick (gem) there" do
-        Gem.stub(:path).and_return(["/abc/xyz"])
+        allow(Gem).to receive(:path).and_return(["/abc/xyz"])
         frame = StackFrame.new("/abc/xyz/gems/whatever-1.2.3/lib/whatever.rb", 123, "foo")
 
-        frame.gem_path.should == "whatever (1.2.3) lib/whatever.rb"
+        expect(frame.gem_path).to eq("whatever (1.2.3) lib/whatever.rb")
       end
 
       it "prioritizes gem path over application path" do
-        BetterErrors.stub(:application_root).and_return("/abc/xyz")
-        Gem.stub(:path).and_return(["/abc/xyz/vendor"])
+        allow(BetterErrors).to receive(:application_root).and_return("/abc/xyz")
+        allow(Gem).to receive(: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 == "whatever (1.2.3) lib/whatever.rb"
+        expect(frame.gem_path).to eq("whatever (1.2.3) lib/whatever.rb")
       end
     end
 
     context "#pretty_path" do
       it "returns #application_path for application paths" do
-        BetterErrors.stub(:application_root).and_return("/abc/xyz")
+        allow(BetterErrors).to receive(: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
+        expect(frame.pretty_path).to eq(frame.application_path)
       end
 
       it "returns #gem_path for gem paths" do
-        Gem.stub(:path).and_return(["/abc/xyz"])
+        allow(Gem).to receive(: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
+        expect(frame.pretty_path).to eq(frame.gem_path)
       end
     end
 
@@ -87,36 +87,36 @@ module BetterErrors
       rescue SyntaxError => syntax_error
       end
       frames = StackFrame.from_exception(syntax_error)
-      frames.first.filename.should == "my_file.rb"
-      frames.first.line.should == 123
+      expect(frames.first.filename).to eq("my_file.rb")
+      expect(frames.first.line).to eq(123)
     end
 
     it "doesn't blow up if no method name is given" do
       error = StandardError.allocate
 
-      error.stub(:backtrace).and_return(["foo.rb:123"])
+      allow(error).to receive(:backtrace).and_return(["foo.rb:123"])
       frames = StackFrame.from_exception(error)
-      frames.first.filename.should == "foo.rb"
-      frames.first.line.should == 123
+      expect(frames.first.filename).to eq("foo.rb")
+      expect(frames.first.line).to eq(123)
 
-      error.stub(:backtrace).and_return(["foo.rb:123: this is an error message"])
+      allow(error).to receive(: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
+      expect(frames.first.filename).to eq("foo.rb")
+      expect(frames.first.line).to eq(123)
     end
 
     it "ignores a backtrace line if its format doesn't make any sense at all" do
       error = StandardError.allocate
-      error.stub(:backtrace).and_return(["foo.rb:123:in `foo'", "C:in `find'", "bar.rb:123:in `bar'"])
+      allow(error).to receive(: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
+      expect(frames.count).to eq(2)
     end
 
     it "doesn't blow up if a filename contains a colon" do
       error = StandardError.allocate
-      error.stub(:backtrace).and_return(["crap:filename.rb:123"])
+      allow(error).to receive(:backtrace).and_return(["crap:filename.rb:123"])
       frames = StackFrame.from_exception(error)
-      frames.first.filename.should == "crap:filename.rb"
+      expect(frames.first.filename).to eq("crap:filename.rb")
     end
 
     it "doesn't blow up with a BasicObject as frame binding" do
@@ -125,7 +125,7 @@ module BetterErrors
         ::Kernel.binding
       end
       frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index", obj.my_binding)
-      frame.class_name.should == 'BasicObject'
+      expect(frame.class_name).to eq('BasicObject')
     end
 
     it "sets method names properly" do
@@ -140,11 +140,11 @@ module BetterErrors
 
       frame = StackFrame.from_exception(obj.my_method).first
       if BetterErrors.binding_of_caller_available?
-        frame.method_name.should == "#my_method"
-        frame.class_name.should == "String"
+        expect(frame.method_name).to eq("#my_method")
+        expect(frame.class_name).to eq("String")
       else
-        frame.method_name.should == "my_method"
-        frame.class_name.should == nil
+        expect(frame.method_name).to eq("my_method")
+        expect(frame.class_name).to eq(nil)
       end
     end
 

data/spec/better_errors_spec.rb

@@ -3,38 +3,38 @@ require "spec_helper"
 describe BetterErrors do
   context ".editor" do
     it "defaults to textmate" do
-      subject.editor["foo.rb", 123].should == "txmt://open?url=file://foo.rb&line=123"
+      expect(subject.editor["foo.rb", 123]).to eq("txmt://open?url=file://foo.rb&line=123")
     end
 
     it "url escapes the filename" do
-      subject.editor["&.rb", 0].should == "txmt://open?url=file://%26.rb&line=0"
+      expect(subject.editor["&.rb", 0]).to eq("txmt://open?url=file://%26.rb&line=0")
     end
 
     [:emacs, :emacsclient].each do |editor|
       it "uses emacs:// scheme when set to #{editor.inspect}" do
         subject.editor = editor
-        subject.editor[].should start_with "emacs://"
+        expect(subject.editor[]).to start_with "emacs://"
       end
     end
 
     [:macvim, :mvim].each do |editor|
       it "uses mvim:// scheme when set to #{editor.inspect}" do
         subject.editor = editor
-        subject.editor[].should start_with "mvim://"
+        expect(subject.editor[]).to start_with "mvim://"
       end
     end
 
     [:sublime, :subl, :st].each do |editor|
       it "uses subl:// scheme when set to #{editor.inspect}" do
         subject.editor = editor
-        subject.editor[].should start_with "subl://"
+        expect(subject.editor[]).to start_with "subl://"
       end
     end
 
     [:textmate, :txmt, :tm].each do |editor|
       it "uses txmt:// scheme when set to #{editor.inspect}" do
         subject.editor = editor
-        subject.editor[].should start_with "txmt://"
+        expect(subject.editor[]).to start_with "txmt://"
       end
     end
 
@@ -42,7 +42,7 @@ describe BetterErrors do
       it "uses emacs:// scheme when EDITOR=#{editor}" do
         ENV["EDITOR"] = editor
         subject.editor = subject.default_editor
-        subject.editor[].should start_with "emacs://"
+        expect(subject.editor[]).to start_with "emacs://"
       end
     end
 
@@ -50,15 +50,15 @@ describe BetterErrors do
       it "uses mvim:// scheme when EDITOR=#{editor}" do
         ENV["EDITOR"] = editor
         subject.editor = subject.default_editor
-        subject.editor[].should start_with "mvim://"
+        expect(subject.editor[]).to start_with "mvim://"
       end
     end
 
     ["subl -w", "/Applications/Sublime Text 2.app/Contents/SharedSupport/bin/subl"].each do |editor|
-      it "uses mvim:// scheme when EDITOR=#{editor}" do
+      it "uses subl:// scheme when EDITOR=#{editor}" do
         ENV["EDITOR"] = editor
         subject.editor = subject.default_editor
-        subject.editor[].should start_with "subl://"
+        expect(subject.editor[]).to start_with "subl://"
       end
     end
 
@@ -66,7 +66,7 @@ describe BetterErrors do
       it "uses txmt:// scheme when EDITOR=#{editor}" do
         ENV["EDITOR"] = editor
         subject.editor = subject.default_editor
-        subject.editor[].should start_with "txmt://"
+        expect(subject.editor[]).to start_with "txmt://"
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: better_errors
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Charlie Somerville
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2017-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubis
@@ -70,6 +70,15 @@ files:
 - README.md
 - Rakefile
 - better_errors.gemspec
+- feature-screenshots/1-application-error.jpg
+- feature-screenshots/2-other-application-frame.jpg
+- feature-screenshots/3-live-shell.jpg
+- feature-screenshots/4-other-frames.jpg
+- feature-screenshots/5-open-editor.jpg
+- feature-screenshots/6-local-variables.jpg
+- feature-screenshots/7-non-html-requests.jpg
+- feature-screenshots/8-xhr-shows-text-error.jpg
+- feature-screenshots/9-xhr-error-in-manual-console.jpg
 - lib/better_errors.rb
 - lib/better_errors/code_formatter.rb
 - lib/better_errors/code_formatter/html.rb
@@ -119,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Better error page for Rails and other Rack apps