what_weve_got_here_is_an_error_to_communicate 0.0.1 → 0.0.2

data/spec/parsing_exception_info_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+RSpec.describe 'Parsing exceptions to ExceptionInfo', einfo: true do
+  it 'records the class name, message, and backtrace' do
+    exception = FakeException.new message:   'Some message',
+                                  backtrace: ["/Users/someone/a/b/c.rb:123:in `some_method_name'"]
+    einfo = einfo_for exception
+    expect(einfo.classname  ).to eq 'FakeException'
+    expect(einfo.message    ).to eq 'Some message'
+    expect(einfo.backtrace.map &:linenum).to eq [123]
+  end
+
+  describe 'recording the actual exception' do
+    let(:exception) { FakeException.new }
+    let(:einfo)     { einfo_for exception }
+
+    it 'records the exception for informational purposes' do
+      trap_warnings do
+        expect(einfo.exception).to equal exception
+      end
+    end
+
+    it 'warns the first time you try to use it (ie available for debugging, but not for development)' do
+      warnings = trap_warnings { einfo.exception }
+      expect(warnings).to match /debugging/
+
+      warnings = trap_warnings { einfo.exception }
+      expect(warnings).to be_empty
+    end
+  end
+
+  describe 'backtrace' do
+    let :exception do
+      FakeException.new backtrace: [
+        "file.rb:111:in `method1'",
+        "file.rb:222:in `method2'",
+        "file.rb:333:in `method3'",
+      ]
+    end
+
+    def backtrace_for(exception)
+      einfo_for(exception).backtrace
+    end
+
+    it 'records the linenum, and label of each backtrace location' do
+      locations = backtrace_for exception
+      expect(locations.map &:linenum).to eq [111, 222, 333]
+      expect(locations.map &:label).to eq %w[method1 method2 method3]
+    end
+
+    specify 'the successor is the parsed location that was called, or nil for the first' do
+      l1, l2, l3 = locations = backtrace_for(exception)
+      expect(locations.map &:succ).to eq [nil, l1, l2]
+    end
+
+    specify 'the predecessor is the parsed location from the caller, or nil for the last' do
+      l1, l2, l3 = locations = backtrace_for(exception)
+      expect(locations.map &:pred).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 = ErrorToCommunicate::ExceptionInfo::Location.parse(line)
+      assertions.each do |method_name, expected|
+        expected = Pathname.new expected if method_name == :path
+        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
+
+  describe 'ExceptionInfo::Location' do
+    def location_for(attrs)
+      ErrorToCommunicate::ExceptionInfo::Location.new attrs
+    end
+
+    it 'hashes take into account its path, linenum, and label' do
+      loc_base         = location_for(path: 'p', linenum: 123, label: 'l')
+      loc_eq1          = location_for(path: 'p', linenum: 123, label: 'l')
+      loc_eq2          = location_for(path: 'p', linenum: 123, label: 'l', succ: loc_base, pred: loc_base)
+      loc_diff_path    = location_for(path: 'P', linenum: 123, label: 'l')
+      loc_diff_linenum = location_for(path: 'p', linenum: 999, label: 'l')
+      loc_diff_label   = location_for(path: 'p', linenum: 123, label: 'L')
+
+      expect(loc_base.hash).to eq loc_eq1.hash # same values gets same hash
+      expect(loc_base.hash).to eq loc_eq2.hash # succ/pred are excluded from hash
+      expect(loc_base.hash).to_not eq loc_diff_path.hash
+      expect(loc_base.hash).to_not eq loc_diff_linenum.hash
+      expect(loc_base.hash).to_not eq loc_diff_label.hash
+
+      # use this, just to show it works
+      h = {loc_base => :found}
+      expect( h[loc_eq1          ] ).to eq :found
+      expect( h[loc_eq2          ] ).to eq :found
+      expect( h[loc_diff_path    ] ).to eq nil
+      expect( h[loc_diff_linenum ] ).to eq nil
+      expect( h[loc_diff_label   ] ).to eq nil
+    end
+
+
+    # Can't directly check associations for equality or we'll end up in an infinite loop
+    # This was maybe a waste of time, to specify it this precisely, all I want to be able to do is compare two paths -.^
+    it 'is == and eql? to another location, if their paths, linenums, and labels are ==' do
+      # the rest are compared against this
+      loc1            = location_for path: 'p1', linenum: 1, label: 'l1'
+
+      # equivalent
+      loc1_same       = location_for path: 'p1', linenum: 1, label: 'l1'
+      expect(loc1).to eq  loc1_same
+      expect(loc1).to eql loc1_same
+
+      # different path
+      loc1_diff_path  = location_for path: 'p2', linenum: 1, label: 'l1'
+      expect(loc1).to_not eq  loc1_diff_path
+      expect(loc1).to_not eql loc1_diff_path
+
+      # different line
+      loc1_diff_line  = location_for path: 'p1', linenum: 2, label: 'l1'
+      expect(loc1).to_not eq  loc1_diff_line
+      expect(loc1).to_not eql loc1_diff_line
+
+      # different label
+      loc1_diff_label = location_for path: 'p1', linenum: 1, label: 'l2'
+      expect(loc1).to_not eq  loc1_diff_label
+      expect(loc1).to_not eql loc1_diff_label
+
+      # are == when different before
+      loc2_before     = location_for path: 'p2', linenum: 2, label: 'l2'
+      loc2            = location_for path: 'p1', linenum: 1, label: 'l1'
+      loc2.succ, loc2_before.pred = loc2_before, loc2
+      expect(loc1).to eq  loc2
+      expect(loc1).to eql loc2
+
+      # are == when different after
+      loc3            = location_for path: 'p1', linenum:  1, label: 'l1'
+      loc3_after      = location_for path: 'p2', linenum:  2, label: 'l2'
+      loc3.succ, loc3_after.pred = loc3_after, loc3
+      expect(loc1).to eq  loc3
+      expect(loc1).to eql loc3
+    end
+
+    it 'inspects to something that isn\'t obnoxious to look at' do
+      linked_loc = location_for path: 'somepath', linenum:  123, label: 'somelabel'
+      linked_loc.succ, linked_loc.pred = linked_loc, linked_loc
+      expect(linked_loc.inspect).to eq '#<ExInfo::Loc somepath:123:in `somelabel\' pred:true succ:true>'
+
+      unlinked_loc = location_for path: 'anotherpath', linenum: 12, label: 'anotherlabel'
+      expect(unlinked_loc.inspect).to eq '#<ExInfo::Loc anotherpath:12:in `anotherlabel\' pred:false succ:false>'
+    end
+  end
+
+end

data/spec/rspec_formatter_spec.rb

@@ -1,7 +1,7 @@
 require 'stringio'
 require 'spec_helper'
 
-RSpec.describe ErrorToCommunicate::RSpecFormatter, formatter: true do
+RSpec.describe ErrorToCommunicate::RSpecFormatter, rspec_formatter: true do
   let(:substring_that_would_only_be_in_full_backtrace) { 'lib/rspec/core' }
 
   def formatter_for(attributes)
@@ -53,6 +53,7 @@ RSpec.describe ErrorToCommunicate::RSpecFormatter, formatter: true do
   end
 
   it 'uses our lib to print the details of failing examples.' do
+    # does print
     formatter = new_formatter
     context_around_failure = this_line_of_code
     run_specs_against formatter do
@@ -60,6 +61,7 @@ RSpec.describe ErrorToCommunicate::RSpecFormatter, formatter: true do
     end
     expect(get_printed formatter).to include context_around_failure
 
+    # does not print
     formatter = new_formatter
     context_around_success = this_line_of_code
     run_specs_against formatter do

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 class FakeException
   attr_reader :message, :backtrace
 
-  def initialize(attributes)
+  def initialize(attributes={})
     @message   = attributes.fetch :message, 'default message'
     @backtrace = attributes.fetch(:backtrace, [])
   end
@@ -11,7 +11,34 @@ class FakeException
   end
 end
 
+module SpecHelpers
+  def einfo_for(exception)
+    ErrorToCommunicate::ExceptionInfo.parse exception
+  end
+
+  def trap_warnings
+    initial_stderr = $stderr
+    mock_stderr    = StringIO.new
+    $stderr        = mock_stderr
+    yield
+  ensure
+    $stderr  = initial_stderr
+    warnings = mock_stderr.string
+    return warnings unless $! # don't swallow exceptions
+  end
+
+  def capture
+    yield
+    raise 'NO EXCEPTION WAS RAISED!'
+  rescue Exception
+    return $!
+  end
+end
+
+
 RSpec.configure do |config|
+  config.include SpecHelpers
+
   # Stop testing after first failure
   config.fail_fast = true
 

data/what_weve_got_here_is_an_error_to_communicate.gemspec

@@ -1,7 +1,7 @@
 require_relative 'lib/error_to_communicate/version'
 Gem::Specification.new do |s|
   s.name        = 'what_weve_got_here_is_an_error_to_communicate'
-  s.version     = WhatWeveGotHereIsAnErrorToCommunicate::VERSION
+  s.version     = ErrorToCommunicate::VERSION
   s.licenses    = ['MIT']
   s.summary     = "Readable, helpful error messages"
   s.description = "Hooks into program lifecycle to display error messages to you in a helpufl way, with inlined code, colour, and helpful heuristics about what might be the cause."
@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.files       = `git ls-files`.split("\n")
   s.homepage    = 'https://github.com/JoshCheek/what-we-ve-got-here-is-an-error-to-communicate'
 
-  s.add_runtime_dependency 'coderay', '~> 1.1'
+  s.add_runtime_dependency 'rouge', '~> 1.8'
 
   s.add_development_dependency 'rspec', '~> 3.2'
   s.add_development_dependency 'haiti', '< 0.3',  '>= 0.2.0'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: what_weve_got_here_is_an_error_to_communicate
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Josh Cheek
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-08 00:00:00.000000000 Z
+date: 2015-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: coderay
+  name: rouge
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -110,33 +110,43 @@ files:
 - experiments/formatting/5_potential_structure_dsls.rb
 - experiments/formatting/half_thoughtout_dsl_for_toplevel_structure_of_argument_error.rb
 - experiments/formatting/haml_like_structure.rb
+- experiments/formatting/other_resources
 - experiments/formatting/other_structures
 - lib/error_to_communicate.rb
 - lib/error_to_communicate/at_exit.rb
 - lib/error_to_communicate/config.rb
 - lib/error_to_communicate/exception_info.rb
-- lib/error_to_communicate/format.rb
-- lib/error_to_communicate/format/terminal_helpers.rb
-- lib/error_to_communicate/parse/backtrace.rb
-- lib/error_to_communicate/parse/exception.rb
-- lib/error_to_communicate/parse/no_method_error.rb
-- lib/error_to_communicate/parse/registry.rb
-- lib/error_to_communicate/parse/wrong_number_of_arguments.rb
+- lib/error_to_communicate/format_terminal.rb
+- lib/error_to_communicate/heuristic.rb
+- lib/error_to_communicate/heuristic/exception.rb
+- lib/error_to_communicate/heuristic/load_error.rb
+- lib/error_to_communicate/heuristic/no_method_error.rb
+- lib/error_to_communicate/heuristic/syntax_error.rb
+- lib/error_to_communicate/heuristic/wrong_number_of_arguments.rb
+- lib/error_to_communicate/project.rb
 - lib/error_to_communicate/rspec_formatter.rb
+- lib/error_to_communicate/theme.rb
 - lib/error_to_communicate/version.rb
 - lib/what_weve_got_here_is_an_error_to_communicate.rb
 - screenshot.png
-- spec/acceptance/argument_error_spec.rb
 - spec/acceptance/exception_spec.rb
+- spec/acceptance/load_error_spec.rb
+- spec/acceptance/name_error_spec.rb
 - spec/acceptance/no_error_spec.rb
 - spec/acceptance/no_methood_error_spec.rb
+- spec/acceptance/runtime_error_spec.rb
+- spec/acceptance/short_and_long_require_spec.rb
 - spec/acceptance/spec_helper.rb
-- spec/parse/backtrace_spec.rb
-- spec/parse/exception_spec.rb
-- spec/parse/no_method_error_spec.rb
-- spec/parse/registered_parsers_spec.rb
-- spec/parse/spec_helper.rb
-- spec/parse/wrong_number_of_arguments_spec.rb
+- spec/acceptance/syntax_error_spec.rb
+- spec/acceptance/wrong_number_of_arguments_spec.rb
+- spec/config_spec.rb
+- spec/heuristic/exception_spec.rb
+- spec/heuristic/load_error_spec.rb
+- spec/heuristic/no_method_error_spec.rb
+- spec/heuristic/spec_helper.rb
+- spec/heuristic/wrong_number_of_arguments_spec.rb
+- spec/heuristic_spec.rb
+- spec/parsing_exception_info_spec.rb
 - spec/rspec_formatter_spec.rb
 - spec/spec_helper.rb
 - what_weve_got_here_is_an_error_to_communicate.gemspec

data/lib/error_to_communicate/format/terminal_helpers.rb

@@ -1,97 +0,0 @@
-module WhatWeveGotHereIsAnErrorToCommunicate
-  module Format
-    module TerminalHelpers
-      def separator
-        ("="*70) << "\n"
-      end
-
-      def color_path(str)
-        "\e[38;5;36m#{str}\e[39m" # fg r:0, g:3, b:2 (out of 0..5)
-      end
-
-      def color_linenum(linenum)
-        "\e[34m#{linenum}\e[39m"
-      end
-
-      def path_to_dir(from, to)
-        to.relative_path_from(from).dirname
-      rescue ArgumentError
-        return to # eg rbx's core code
-      end
-
-      def white
-        "\e[38;5;255m"
-      end
-
-      def bri_red
-        "\e[38;5;196m"
-      end
-
-      def dim_red
-        "\e[38;5;124m"
-      end
-
-      def none
-        "\e[39m"
-      end
-
-      def bound_num(attributes)
-        num = attributes.fetch :num
-        min = attributes.fetch :min
-        num < min ? min : num
-      end
-
-      def remove_indentation(code)
-        indentation = code.scan(/^\s*/).min_by(&:length)
-        code.gsub(/^#{indentation}/, "")
-      end
-
-      def prefix_linenos_to(code, start_linenum)
-        lines         = code.lines
-        max_linenum   = lines.count + start_linenum - 1 # 1 to translate to indexes
-        linenum_width = max_linenum.to_s.length + 1     # 1 for the colon
-        lines.zip(start_linenum..max_linenum)
-             .map { |line, num|
-               formatted_num = "#{num}:".ljust(linenum_width)
-               color_linenum(formatted_num) << " " << line
-             }.join("")
-      end
-
-      def add_message_to(code, offset, message)
-        lines = code.lines
-        lines[offset].chomp! << " " << message << "\n"
-        lines.join("")
-      end
-
-      def highlight_text(code, index, text)
-        lines = code.lines
-        return code unless lines[index]
-        lines[index].gsub!(text, "\e[7m#{text}\e[27m") # invert
-        lines.join("")
-      end
-
-      def indent(str, indentation_str)
-        str.gsub /^/, indentation_str
-      end
-
-      def screaming_red(text)
-        return "" if text.empty?
-        "\e[38;5;255;48;5;88m #{text} \e[39;49m" # bright white on medium red
-      end
-
-      def underline(str)
-        "\e[4m#{str}\e[24m"
-      end
-
-      def color_filename(str)
-        "\e[38;5;49;1m#{str}\e[39m" # fg r:0, g:5, b:3 (out of 0..5)
-      end
-
-      def desaturate(str)
-        nocolor = str.gsub(/\e\[[\d;]+?m/, "")
-        allgray = nocolor.gsub(/^(.*?)\n?$/, "\e[38;5;240m\\1\e[39m\n")
-        allgray
-      end
-    end
-  end
-end

data/lib/error_to_communicate/format.rb

@@ -1,132 +0,0 @@
-require 'coderay'
-require 'pathname'
-require 'error_to_communicate/format/terminal_helpers'
-
-module WhatWeveGotHereIsAnErrorToCommunicate
-  extend Format::TerminalHelpers
-  def self.format(info)
-    cwd = Dir.pwd
-
-    # FIXME:
-    # Something else should set this?
-    #   I'd say heuristic, but fact is that it needs formatting info.
-    #   Maybe initially, heuristic contains both extracted info and formatting info?
-    # Or maybe we want polymorphism at the formatter level?
-    display_class_and_message = lambda do |info|
-      if info.classname == 'ArgumentError'
-        "#{white}#{info.classname} | "\
-        "#{bri_red}#{info.explanation} "\
-        "#{dim_red}(expected #{white}#{info.num_expected},"\
-        "#{dim_red} sent #{white}#{info.num_received}"\
-        "#{dim_red})"\
-        "#{none}"
-      else
-        "#{white}#{info.classname} | "\
-        "#{bri_red}#{info.explanation} "\
-        "#{none}"
-      end
-    end
-
-    display_location = lambda do |attributes|
-      location       = attributes.fetch :location
-      cwd            = Pathname.new attributes.fetch(:cwd)
-      path           = Pathname.new location.path
-      line_index     = location.linenum - 1
-      highlight      = attributes.fetch :highlight, location.label
-      end_index      = bound_num min: 0, num: line_index+attributes.fetch(:context).end
-      start_index    = bound_num min: 0, num: line_index+attributes.fetch(:context).begin
-      message        = attributes.fetch :message, ''
-      message_offset = line_index - start_index
-
-      # first line gives the path
-      path_line = ""
-      path_line << color_path("#{path_to_dir cwd, path}/")
-      path_line << color_filename(path.basename)
-      path_line << ":" << color_linenum(location.linenum)
-
-      # then display the code
-      if path.exist?
-        code = File.read(path).lines[start_index..end_index].join("")
-        code = remove_indentation code
-        code = CodeRay.encode     code, :ruby, :terminal
-        code = prefix_linenos_to  code, start_index.next
-        code = indent             code, "  "
-        code = add_message_to     code, message_offset, screaming_red(message)
-        code = highlight_text     code, message_offset, highlight
-      else
-        code = "Can't find code\n"
-      end
-
-      # adjust for emphasization
-      if attributes.fetch(:emphasisis) == :path
-        path_line = underline path_line
-        code = indent         code, "      "
-        code = desaturate     code
-        code = highlight_text code, message_offset, highlight # b/c desaturate really strips color
-      end
-
-      # all together
-      path_line << "\n" << code
-    end
-
-
-    # Display the ArgumentError
-    display = ""
-    display << separator
-    display << display_class_and_message.call(info) << "\n"
-
-    # Display the Heuristic
-    display << separator
-
-    # FIXME: Some sort of polymorphism or normalization would be way better here, too
-    # And, at the very least, not switching on classname, but some more abstract piece of info,
-    # b/c classnames are not completely consistent across the implementations
-    # (eg: https://github.com/JoshCheek/seeing_is_believing/blob/cc93b4ee3a83145509c235f64d9454dc3e12d8c9/lib/seeing_is_believing/event_stream/producer.rb#L54-55)
-    if info.classname == 'ArgumentError'
-      display << display_location.call(location:   info.backtrace[0],
-                                       highlight:  info.backtrace[0].label,
-                                       context:    0..5,
-                                       message:    "EXPECTED #{info.num_expected}",
-                                       emphasisis: :code,
-                                       cwd:        cwd)
-      display << "\n"
-      display << display_location.call(location:   info.backtrace[1],
-                                       highlight:  info.backtrace[0].label,
-                                       context:    -5..5,
-                                       message:    "SENT #{info.num_received}",
-                                       emphasisis: :code,
-                                       cwd:        cwd)
-    elsif info.classname == 'NoMethodError'
-      display << display_location.call(location:   info.backtrace[0],
-                                       highlight:  info.backtrace[0].label,
-                                       context:    -5..5,
-                                       message:    "#{info.undefined_method_name} is undefined",
-                                       emphasisis: :code,
-                                       cwd:        cwd)
-    else
-      display << display_location.call(location:   info.backtrace[0],
-                                       highlight:  info.backtrace[0].label,
-                                       context:    -5..5,
-                                       emphasisis: :code,
-                                       cwd:        cwd)
-    end
-
-    # display the backtrace
-    display << separator
-    display << display_location.call(location:   info.backtrace[0],
-                                     highlight:  info.backtrace[0].label,
-                                     context:    0..0,
-                                     emphasisis: :path,
-                                     cwd:        cwd)
-
-    display << info.backtrace.each_cons(2).map { |next_loc, crnt_loc|
-      display_location.call location:   crnt_loc,
-                            highlight:  next_loc.label,
-                            context:    0..0,
-                            emphasisis: :path,
-                            cwd:        cwd
-    }.join("")
-
-    display
-  end
-end

data/lib/error_to_communicate/parse/backtrace.rb

@@ -1,34 +0,0 @@
-require 'error_to_communicate/exception_info'
-
-module WhatWeveGotHereIsAnErrorToCommunicate
-  module Parse
-    module Backtrace
-      def self.parse?(exception)
-        # Really, there are better methods, e.g. backtrace_locations,
-        # but they're unevenly implemented across versions and implementations
-        exception.respond_to? :backtrace
-      end
-
-      def self.parse(exception)
-        locations = exception.backtrace.map &method(:parse_backtrace_line)
-        locations.each_cons(2) do |crnt, succ|
-          succ.pred = crnt
-          crnt.succ = succ
-        end
-        locations
-      end
-
-      # TODO: What if the line doesn't match for some reason?
-      # Raise an exception?
-      # Use some reasonable default? (is there one?)
-      def self.parse_backtrace_line(line)
-        line =~ /^(.*?):(\d+):in `(.*?)'$/ # Are ^ and $ sufficient? Should be \A and (\Z or \z)?
-        ExceptionInfo::Location.new(
-          path:    $1,
-          linenum: $2.to_i,
-          label:   $3,
-        )
-      end
-    end
-  end
-end

data/lib/error_to_communicate/parse/exception.rb

@@ -1,21 +0,0 @@
-require 'error_to_communicate/exception_info'
-require 'error_to_communicate/parse/backtrace'
-
-module WhatWeveGotHereIsAnErrorToCommunicate
-  module Parse
-    module Exception
-      def self.parse?(exception)
-        exception.respond_to?(:message) && Backtrace.parse?(exception)
-      end
-
-      def self.parse(exception)
-        ExceptionInfo.new(
-          exception:   exception,
-          classname:   exception.class.to_s,
-          explanation: exception.message,
-          backtrace:   Backtrace.parse(exception),
-        )
-      end
-    end
-  end
-end