better_errors 2.0.0 → 2.8.0

data/spec/better_errors/code_formatter_spec.rb

@@ -1,92 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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
-  end
-end

data/spec/better_errors/middleware_spec.rb

@@ -1,154 +0,0 @@
-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
-
-      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
-
-      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

data/spec/better_errors/raised_exception_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-module BetterErrors
-  describe RaisedException do
-    let(:exception) { RuntimeError.new("whoops") }
-    subject { RaisedException.new(exception) }
-
-    its(:exception) { should == exception }
-    its(:message)   { should == "whoops" }
-    its(:type)      { should == RuntimeError }
-
-    context "when the exception wraps another exception" do
-      let(:original_exception) { RuntimeError.new("something went wrong!") }
-      let(:exception) { double(:original_exception => original_exception) }
-
-      its(:exception) { should == original_exception }
-      its(:message)   { should == "something went wrong!" }
-    end
-
-    context "when the exception is a syntax error" do
-      let(:exception) { SyntaxError.new("foo.rb:123: you made a typo!") }
-
-      its(:message) { should == "you made a typo!" }
-      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
-      end
-    end
-
-    context "when the exception is a HAML syntax error" do
-      before do
-        stub_const("Haml::SyntaxError", Class.new(SyntaxError))
-      end
-
-      let(:exception) {
-        Haml::SyntaxError.new("you made a typo!").tap do |ex|
-          ex.set_backtrace(["foo.rb:123", "haml/internals/blah.rb:123456"])
-        end
-      }
-
-      its(:message) { should == "you made a typo!" }
-      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
-      end
-    end
-  end
-end

data/spec/better_errors/repl/basic_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-require "better_errors/repl/basic"
-require "better_errors/repl/shared_examples"
-
-module BetterErrors
-  module REPL
-    describe Basic do
-      let(:fresh_binding) {
-        local_a = 123
-        binding
-      }
-      
-      let(:repl) { Basic.new fresh_binding }
-
-      it_behaves_like "a REPL provider"
-    end
-  end
-end

data/spec/better_errors/repl/pry_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-require "pry"
-require "better_errors/repl/pry"
-require "better_errors/repl/shared_examples"
-
-module BetterErrors
-  module REPL
-    describe Pry do
-      let(:fresh_binding) {
-        local_a = 123
-        binding
-      }
-
-      let(:repl) { Pry.new fresh_binding }
-
-      it "does line continuation" do
-        output, prompt, filled = repl.send_input ""
-        output.should == "=> nil\n"
-        prompt.should == ">>"
-        filled.should == ""
-
-        output, prompt, filled = repl.send_input "def f(x)"
-        output.should == ""
-        prompt.should == ".."
-        filled.should == "  "
-
-        output, prompt, filled = repl.send_input "end"
-        if RUBY_VERSION >= "2.1.0"
-          output.should == "=> :f\n"
-        else
-          output.should == "=> nil\n"
-        end
-        prompt.should == ">>"
-        filled.should == ""
-      end
-
-      it_behaves_like "a REPL provider"
-    end
-  end
-end

data/spec/better_errors/repl/shared_examples.rb

@@ -1,18 +0,0 @@
-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
-  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 == ">>"
-  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 == ">>"
-  end
-end

data/spec/better_errors/stack_frame_spec.rb

@@ -1,157 +0,0 @@
-require "spec_helper"
-
-module BetterErrors
-  describe StackFrame do
-    context "#application?" do
-      it "is 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 "is 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 "doesn't 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 "is 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 "is 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 "chops 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 "chops 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 == "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"])
-        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"
-      end
-    end
-
-    context "#pretty_path" do
-      it "returns #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 "returns #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 "special cases SyntaxErrors" do
-      begin
-        eval(%{ raise SyntaxError, "you wrote bad ruby!" }, nil, "my_file.rb", 123)
-      rescue SyntaxError => syntax_error
-      end
-      frames = StackFrame.from_exception(syntax_error)
-      frames.first.filename.should == "my_file.rb"
-      frames.first.line.should == 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"])
-      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 "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'"])
-      frames = StackFrame.from_exception(error)
-      frames.count.should == 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"])
-      frames = StackFrame.from_exception(error)
-      frames.first.filename.should == "crap:filename.rb"
-    end
-
-    it "doesn't blow up with a BasicObject as frame binding" do
-      obj = BasicObject.new
-      def obj.my_binding
-        ::Kernel.binding
-      end
-      frame = StackFrame.new("/abc/xyz/app/controllers/crap_controller.rb", 123, "index", obj.my_binding)
-      frame.class_name.should == 'BasicObject'
-    end
-
-    it "sets method names properly" do
-      obj = "string"
-      def obj.my_method
-        begin
-          raise "foo"
-        rescue => err
-          err
-        end
-      end
-
-      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"
-      else
-        frame.method_name.should == "my_method"
-        frame.class_name.should == nil
-      end
-    end
-
-    if RUBY_ENGINE == "java"
-      it "doesn't blow up on a native Java exception" do
-        expect { StackFrame.from_exception(java.lang.Exception.new) }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/better_errors/support/my_source.rb

@@ -1,20 +0,0 @@
-one
-two
-three
-four
-five
-six
-seven
-eight
-nine
-ten
-eleven
-twelve
-thirteen
-fourteen
-fifteen
-sixteen
-seventeen
-eighteen
-nineteen
-twenty