what_weve_got_here_is_an_error_to_communicate 0.0.1

data/lib/error_to_communicate/rspec_formatter.rb

@@ -0,0 +1,46 @@
+require 'error_to_communicate'
+require 'error_to_communicate/format'
+require 'rspec/core/formatters/documentation_formatter'
+
+module WhatWeveGotHereIsAnErrorToCommunicate
+  class RSpecFormatter < RSpec::Core::Formatters::DocumentationFormatter
+    # Register for notifications from our parent classes
+    #   http://rspec.info/documentation/3.2/rspec-core/RSpec/Core/Formatters.html
+    #
+    #   Our complete set of notifications can be seen with:
+    #     puts RSpecFormatter.ancestors.flat_map { |ancestor|
+    #       RSpec::Core::Formatters::Loader.formatters.fetch(ancestor, [])
+    #     }
+    RSpec::Core::Formatters.register self
+
+    # Use WhatWeveGotHereIsAnErrorToCommunicate to print error info
+    # rather than default DocumentationFormatter.
+    #
+    # How did we figure out how to implement it?
+    # See "Down the rabbit hole" section in
+    # https://github.com/JoshCheek/what-we-ve-got-here-is-an-error-to-communicate/blob/ede6844/lib/error_to_communicate/rspec_formatter.rb#L68
+    #
+    # FIXME: Needs to respect RSpec.configuration.color_enabled?
+    #        but we can't currently turn colour off in our output
+    def dump_failures(notification)
+      formatted = "\nFailures:\n"
+      notification.failure_notifications.each_with_index do |failure, failure_number|
+        # get the exception with the modified backtrace
+        exception = failure.exception.dup
+        metadata  = failure.example.metadata
+        exception.set_backtrace RSpec.configuration
+                                     .backtrace_formatter
+                                     .format_backtrace(exception.backtrace, metadata)
+
+        # format it with our lib
+        exception_info      = ErrorToCommunicate::CONFIG.parse(exception)
+        formatted_exception = ErrorToCommunicate.format(exception_info)
+
+        # fit it into the larger failure summary
+        formatted << "\n  #{failure_number+1}) #{failure.description}\n"
+        formatted << formatted_exception.chomp.gsub(/^/, '    ')
+      end
+      output.puts formatted
+    end
+  end
+end

data/lib/error_to_communicate/version.rb

@@ -0,0 +1,3 @@
+module WhatWeveGotHereIsAnErrorToCommunicate
+  VERSION = '0.0.1'.freeze
+end

data/lib/what_weve_got_here_is_an_error_to_communicate.rb

@@ -0,0 +1,3 @@
+# exists so that adding it to bundler will turn it on
+# without having to specify the whole name out 2x
+require 'error_to_communicate/at_exit'

data/spec/acceptance/argument_error_spec.rb

@@ -0,0 +1,55 @@
+require 'acceptance/spec_helper'
+
+RSpec.context 'ArgumentError', acceptance: true do
+  it 'Prints heuristics' do
+    # Given a file with three lines in the backtrace that explodes on the third
+    write_file 'argument_error.rb', <<-BODY
+      require 'what_weve_got_here_is_an_error_to_communicate'
+      module Test
+        def self.backtrace1
+        end
+
+        def self.backtrace2
+          backtrace1 123
+        end
+      end
+
+      Test.backtrace2
+    BODY
+
+    invocation = ruby 'argument_error.rb'
+    stderr = strip_color invocation.stderr
+
+    # sanity
+      expect(invocation.stdout).to     eq ''
+      expect(invocation.exitstatus).to eq 1
+
+    # error: It prints the exception class and prints the reworded message
+      expect(stderr).to include 'ArgumentError'
+      expect(stderr).to include 'Wrong number of arguments'
+      expect(stderr).to include '(expected 0, sent 1)'
+
+    # heuristic:
+      # It displays name of the file with the line number of the error
+      expect(stderr).to include 'argument_error.rb:3'
+
+      # It displays the most recent line of code with some context
+      expect(stderr).to include 'self.backtrace1'
+      expect(stderr).to include 'end'
+
+      # It displays the second most recent line of the backtrace with some context around it
+      expect(stderr).to include 'def self.backtrace2'
+      expect(stderr).to include '  backtrace1 123'
+      expect(stderr).to include 'end'
+
+    # backtrace: displays each line of the backtrace with the code from that line
+      expect(stderr).to include 'argument_error.rb:3'
+      expect(stderr).to include 'def self.backtrace1'
+
+      expect(stderr).to include 'argument_error.rb:7'
+      expect(stderr).to include 'def self.backtrace2'
+
+      expect(stderr).to include 'argument_error.rb:11'
+      expect(stderr).to include 'Test.backtrace2'
+  end
+end

data/spec/acceptance/exception_spec.rb

@@ -0,0 +1,29 @@
+require 'acceptance/spec_helper'
+
+RSpec.context 'Exception', acceptance: true do
+  it 'Prints heuristics' do
+    # Given a file with three lines in the backtrace that explodes on the third
+    write_file 'exception.rb', <<-BODY
+      require "what_weve_got_here_is_an_error_to_communicate"
+      raise Exception, "mah message"
+    BODY
+
+    invocation = ruby 'exception.rb'
+    stderr = strip_color invocation.stderr
+
+    # sanity
+    expect(invocation.stdout).to     eq ''
+    expect(invocation.exitstatus).to eq 1
+
+    # error: It prints the exception class and prints the message
+    expect(stderr).to include 'Exception'
+    expect(stderr).to include 'mah message'
+
+    # heuristic displays the line the exception was raised at, and some context
+    expect(stderr).to include 'raise Exception, "mah message"'
+    expect(stderr).to include 'require "what_weve_got_here_is_an_error_to_communicate"'
+
+    # typical backtrace
+    expect(stderr).to include 'exception.rb:2'
+  end
+end

data/spec/acceptance/no_error_spec.rb

@@ -0,0 +1,44 @@
+require 'acceptance/spec_helper'
+
+RSpec.context 'non errors are not captured/reported', acceptance: true do
+  example 'no error is raised' do
+    write_file 'no_error.rb', <<-BODY
+      require 'what_weve_got_here_is_an_error_to_communicate'
+      print "hello, world"
+    BODY
+
+    invocation = ruby 'no_error.rb'
+
+    # No exception
+    expect(invocation.stderr).to     eq ''
+    expect(invocation.stdout).to     eq 'hello, world'
+    expect(invocation.exitstatus).to eq 0
+  end
+
+
+  example 'successful exit' do
+    write_file 'exit_0.rb', <<-BODY
+      require 'what_weve_got_here_is_an_error_to_communicate'
+      exit 0
+    BODY
+    invocation = ruby 'exit_0.rb'
+
+    # No exception
+    expect(invocation.stderr).to     eq ''
+    expect(invocation.stdout).to     eq ''
+    expect(invocation.exitstatus).to eq 0
+  end
+
+  example 'unsuccessful exit' do
+    write_file 'exit_2.rb', <<-BODY
+      require 'what_weve_got_here_is_an_error_to_communicate'
+      exit 2
+    BODY
+    invocation = ruby 'exit_2.rb'
+
+    # No exception
+    expect(invocation.stderr).to     eq ''
+    expect(invocation.stdout).to     eq ''
+    expect(invocation.exitstatus).to eq 2
+  end
+end

data/spec/acceptance/no_methood_error_spec.rb

@@ -0,0 +1,50 @@
+require 'acceptance/spec_helper'
+
+RSpec.describe 'NoMethodError', acceptance: true do
+  it 'Prints heuristics' do
+    # Given a file that throws an error with two lines in the backtrace
+    write_file 'no_method_error.rb', <<-BODY
+      require 'error_to_communicate/at_exit'
+      module Test
+        def self.backtrace1
+        end
+
+        def self.backtrace2
+          Test.backtrace4
+        end
+
+        def self.backtrace3
+        end
+      end
+
+      Test.backtrace2
+    BODY
+
+    invocation = ruby 'no_method_error.rb'
+    stderr = strip_color invocation.stderr
+
+    # sanity
+      expect(invocation.stdout).to     eq ''
+      expect(invocation.exitstatus).to eq 1
+
+    # error: It prints the exception class and message
+      expect(stderr).to include 'NoMethodError'
+      expect(stderr).to include "undefined method `backtrace4'"
+
+    # heuristic:
+      # It displays a hlepful message next to the callsite
+      expect(stderr).to include 'backtrace4 is undefined'
+
+      # It displays the line of the backtrace with the NoMethodError, and some context around it
+      expect(stderr).to include 'def self.backtrace2'
+      expect(stderr).to include '  Test.backtrace4'
+      expect(stderr).to include 'end'
+
+    # backtrace: It displays each line of the backtrace and includes the code from that line
+      expect(stderr).to include 'no_method_error.rb:7'
+      expect(stderr).to include 'backtrace4'
+
+      expect(stderr).to include '14'
+      expect(stderr).to include 'backtrace2'
+  end
+end

data/spec/acceptance/spec_helper.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'haiti/command_line_helpers'
+
+module AcceptanceSpecHelpers
+  extend self
+  include Haiti::CommandLineHelpers
+
+  def root_dir
+    File.expand_path '../../..', __FILE__
+  end
+
+  def lib_dir
+    File.join root_dir, 'lib'
+  end
+
+  def proving_grounds_dir
+    File.join root_dir, 'proving_grounds'
+  end
+
+  def ruby(filename)
+    # workaround for JRuby bug (capture3 calls open3 with invalid args, needs to splat an array, but doesn't)
+    in_proving_grounds do
+      Haiti::CommandLineHelpers::Invocation.new *Open3.capture3(ENV, 'ruby', '-I', lib_dir, filename)
+    end
+  end
+
+  def strip_color(string)
+    string.gsub(/\e\[\d+(;\d+)*?m/, '')
+  end
+end
+
+# Commandline invocation
+Haiti.configure do |config|
+  config.proving_grounds_dir = AcceptanceSpecHelpers.proving_grounds_dir
+end
+
+RSpec.configure do |config|
+  # Helpers for acceptance tests
+  config.before(acceptance: true) { make_proving_grounds }
+  config.include AcceptanceSpecHelpers,     acceptance: true
+end

data/spec/parse/backtrace_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'error_to_communicate/parse/backtrace'
+
+RSpec.describe 'parsing an ArgumentError', parse: true do
+  let :exception do
+    FakeException.new backtrace: [
+      "file.rb:111:in `method1'",
+      "file.rb:222:in `method2'",
+      "file.rb:333:in `method3'"
+    ]
+  end
+
+  def parse(exception)
+    WhatWeveGotHereIsAnErrorToCommunicate::Parse::Backtrace.parse(exception)
+  end
+
+  it 'records the linenum, and label of each backtrace location' do
+    locations = parse exception
+    expect(locations.map &:linenum).to eq [111, 222, 333]
+    expect(locations.map &:label).to eq %w[method1 method2 method3]
+  end
+
+  specify 'the predecessor is the parsed location from the previous index, or nil for the first' do
+    l1, l2, l3 = locations = parse(exception)
+    expect(locations.map &:pred).to eq [nil, l1, l2]
+  end
+
+  specify 'the successor is the parsed locations from the next index, or nil for the last' do
+    l1, l2, l3 = locations = parse(exception)
+    expect(locations.map &:succ).to eq [l2, l3, nil]
+  end
+
+  # it 'records the absolute filepath if it can find the file'
+  # it 'records the relative filepath if it can find the file'
+  # it 'records the relative filepath if it cannot fild the file'
+
+  def assert_parses_line(line, assertions)
+    parsed = WhatWeveGotHereIsAnErrorToCommunicate::Parse::Backtrace.parse_backtrace_line(line)
+    assertions.each do |method_name, expected|
+      actual = parsed.__send__ method_name
+      expect(actual).to eq expected
+    end
+  end
+
+  it 'records the path whether its absolute or relative' do
+    assert_parses_line "file.rb:111:in `method1'",  path: "file.rb"
+    assert_parses_line "/file.rb:111:in `method1'", path: "/file.rb"
+  end
+
+  it 'does not get confused by numbers in directories, filenames, or method names' do
+    line = "/a1/b2/c3123/file123.rb:111:in `method1'"
+    assert_parses_line line, path:    "/a1/b2/c3123/file123.rb"
+    assert_parses_line line, linenum: 111
+    assert_parses_line line, label:   "method1"
+  end
+
+  context 'random ass colons in the middle of like files and directories and shit' do
+    # $ mkdir 'a:b'
+    # $ echo 'begin; define_method("a:b") { |arg| }; send "a:b"; rescue Exception; p $!.backtrace; end' > 'a:b/c:d.rb'
+
+    # $ chruby-exec 2.2 -- ruby -v
+    # > ruby 2.2.0p0 (2014-12-25 revision 49005) [x86_64-darwin13]
+    #
+    # $ chruby-exec 2.2 -- ruby 'a:b/c:d.rb'
+    # > ["a:b/c:d.rb:1:in `block in <main>'", "a:b/c:d.rb:1:in `<main>'"]
+    it 'does not get confused with MRI style results' do
+      line = "a:b/c:d.rb:1:in `block in <main>'"
+      assert_parses_line line, path:    "a:b/c:d.rb"
+      assert_parses_line line, linenum: 1
+      assert_parses_line line, label:   "block in <main>"
+    end
+
+    # $ chruby-exec rbx -- ruby -v
+    # > rubinius 2.5.0 (2.1.0 50777f41 2015-01-17 3.5.0 JI) [x86_64-darwin14.1.0]
+    #
+    # $ chruby-exec rbx -- ruby 'a:b/c:d.rb'
+    # > ["a:b/c:d.rb:1:in `__script__'",
+    #    "kernel/delta/code_loader.rb:66:in `load_script'",
+    #    "kernel/delta/code_loader.rb:152:in `load_script'",
+    #    "kernel/loader.rb:645:in `script'",
+    #    "kernel/loader.rb:799:in `main'"]
+    it 'does not get confused with RBX style results' do
+      line = "a:b/c:d.rb:1:in `__script__'"
+      assert_parses_line line, path:    "a:b/c:d.rb"
+      assert_parses_line line, linenum: 1
+      assert_parses_line line, label:   "__script__"
+    end
+
+    # $ chruby-exec jruby -- ruby -v
+    # > jruby 1.7.16 (1.9.3p392) 2014-09-25 575b395 on Java HotSpot(TM) 64-Bit Server VM 1.7.0_51-b13 +jit [darwin-x86_64]
+    #
+    # $ chruby-exec jruby -- ruby 'a:b/c:d.rb'
+    # > ["a:b/c:d.rb:1:in `(root)'"]
+    it 'does not get confused by Jruby style results' do
+      line = "a:b/c:d.rb:1:in `(root)'"
+      assert_parses_line line, path:    "a:b/c:d.rb"
+      assert_parses_line line, linenum: 1
+      assert_parses_line line, label:   "(root)"
+    end
+  end
+end

data/spec/parse/exception_spec.rb

@@ -0,0 +1,14 @@
+require 'parse/spec_helper'
+require 'error_to_communicate/parse/exception'
+
+RSpec.describe 'parsing an Exception', parse: true do
+  def parse(exception)
+    WhatWeveGotHereIsAnErrorToCommunicate::Parse::Exception.parse(exception)
+  end
+
+  it_behaves_like 'an exception parser', sample_message: 'literally anything'
+
+  # Going to wait on implementing these as they may not be correct,
+  # e.g. anyone can raise an argument error for any reason.
+  it 'extracts the name of the method that was called'
+end

data/spec/parse/no_method_error_spec.rb

@@ -0,0 +1,23 @@
+require 'parse/spec_helper'
+require 'error_to_communicate/parse/no_method_error'
+
+RSpec.describe 'parsing a NoMethodError', parse: true do
+  def error_class
+    WhatWeveGotHereIsAnErrorToCommunicate::Parse::NoMethodError
+  end
+
+  def parse(exception)
+    error_class.parse(exception)
+  end
+
+  it_behaves_like 'an exception parser', sample_message: "undefined method `<' for nil:NilClass"
+
+  def extracts_method_name!(expected, message)
+    actual = error_class.extract_method_name(message)
+    expect(actual).to eq expected
+  end
+
+  it 'extracts the name of the method that was called' do
+    extracts_method_name! '<', "undefined method `<' for nil:NilClass"
+  end
+end

data/spec/parse/registered_parsers_spec.rb

@@ -0,0 +1,68 @@
+require 'error_to_communicate/config'
+
+RSpec.describe 'registered parsers', parse: true do
+  p = WhatWeveGotHereIsAnErrorToCommunicate::Parse
+
+  def capture
+    yield
+    raise 'NO EXCEPTION WAS RAISED!'
+  rescue Exception
+    return $!
+  end
+
+  describe 'selected parsers' do
+    def parser_for(exception)
+      WhatWeveGotHereIsAnErrorToCommunicate::Config
+        .new.registry.parser_for(exception)
+    end
+
+    it 'doesn\'t parse nil' do
+      expect(parser_for nil).to eq nil
+    end
+
+    it 'doesn\'t parse a SystemExit' do
+      err = capture { exit }
+      expect(parser_for err).to eq nil
+
+      err = capture { exit 1 }
+      expect(parser_for err).to eq nil
+    end
+
+    it 'parses wrong number of arguments' do
+      err = capture { lambda { }.call :arg }
+      expect(parser_for err).to eq p::WrongNumberOfArguments
+    end
+
+    it 'parses NoMethodErrors' do
+      err = capture { sdfsdfsdf() }
+      expect(parser_for err).to eq p::NoMethodError
+    end
+
+    it 'lets ArgumentErrors that are not wrong number of arguments fall through', t:true do
+      err = capture { raise ArgumentError, "zomg" }
+      expect(parser_for err).to eq p::Exception
+    end
+
+    it 'parses Exception' do
+      err = capture { raise Exception, "wat" }
+      expect(parser_for err).to eq p::Exception
+    end
+  end
+
+  describe 'config.parse' do
+    def parse(exception)
+      WhatWeveGotHereIsAnErrorToCommunicate::Config
+        .new.parse(exception)
+    end
+
+    it 'parses the exception if anything is willing to do it' do
+      exception      = capture { sdfsdfsdf() }
+      exception_info = parse exception
+      expect(exception_info.exception).to equal exception
+    end
+
+    it 'raises an ArgumentError if there are no parsers for this exception' do
+      expect { parse "not an error" }.to raise_error ArgumentError, /"not an error"/
+    end
+  end
+end