what_weve_got_here_is_an_error_to_communicate 0.0.1 → 0.0.2

data/lib/error_to_communicate/parse/no_method_error.rb

@@ -1,27 +0,0 @@
-require 'error_to_communicate/exception_info'
-require 'error_to_communicate/parse/backtrace'
-
-module WhatWeveGotHereIsAnErrorToCommunicate
-  module Parse
-    module NoMethodError
-      def self.parse?(exception)
-        exception.kind_of? ::NoMethodError
-      end
-
-      def self.parse(exception)
-        ExceptionInfo::NoMethodError.new(
-          exception:             exception,
-          classname:             exception.class.to_s,
-          explanation:           exception.message[/^[^\(]*/].strip,
-          backtrace:             Backtrace.parse(exception),
-          undefined_method_name: extract_method_name(exception.message),
-        )
-      end
-
-      def self.extract_method_name(message)
-        words = message.split(/\s+/)
-        words[2][1...-1]
-      end
-    end
-  end
-end

data/lib/error_to_communicate/parse/registry.rb

@@ -1,30 +0,0 @@
-module WhatWeveGotHereIsAnErrorToCommunicate
-  module Parse
-    class Registry
-      def initialize(options)
-        @dont_parse = options.fetch :dont_parse
-        @parsers    = options.fetch :parsers
-      end
-
-      def <<(parser)
-        @parsers << parser
-        self
-      end
-
-      def parser_for(exception)
-        return nil if @dont_parse.call exception
-        @parsers.find { |parser| parser.parse? exception }
-      end
-
-      def parse?(exception)
-        !!parser_for(exception)
-      end
-
-      def parse(exception)
-        parser = @parsers.find { |parser| parser.parse? exception }
-        return parser.parse exception if parser
-        raise ::ArgumentError.new, "No parser found for #{exception.inspect}"
-      end
-    end
-  end
-end

data/lib/error_to_communicate/parse/wrong_number_of_arguments.rb

@@ -1,35 +0,0 @@
-require 'error_to_communicate/exception_info'
-require 'error_to_communicate/parse/backtrace'
-
-module WhatWeveGotHereIsAnErrorToCommunicate
-  module Parse
-    module WrongNumberOfArguments
-      def self.parse?(exception)
-        exception.respond_to?(:message) && extract_from(exception)
-      end
-
-      def self.parse(exception)
-        num_received, num_expected = extract_from(exception)
-        ExceptionInfo::WrongNumberOfArguments.new(
-          exception:    exception,
-          classname:    exception.class.to_s,
-          explanation:  'Wrong number of arguments',
-          backtrace:    Backtrace.parse(exception),
-          num_expected: num_expected,
-          num_received: num_received,
-        )
-      end
-
-      private
-
-      def self.extract_from(exception)
-        case exception.message
-        when /^wrong number of arguments.*?\((\d+) for (\d+)\)$/ # MRI / JRuby
-          num_received, num_expected = $1.to_i, $2.to_i
-        when /^method '.*?': given (\d+).*? expected (\d+)$/ # RBX
-          num_received, num_expected = $1.to_i, $2.to_i
-        end
-      end
-    end
-  end
-end

data/spec/parse/backtrace_spec.rb

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

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

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

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

data/spec/parse/spec_helper.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples 'an exception parser' do |attributes|
-  let(:message)     { attributes.fetch :sample_message }
-  let(:explanation) { attributes.fetch :sample_explanation, message }
-
-  let :exception do
-    FakeException.new message:   message,
-                      backtrace: ["/Users/someone/a/b/c.rb:123:in `some_method_name'"]
-  end
-
-  it 'records the exception, class name, and explanation comes from the message' do
-    info = parse exception
-    expect(info.exception  ).to equal exception
-    expect(info.classname  ).to eq 'FakeException'
-    expect(info.explanation).to eq explanation
-  end
-
-  it 'records the backtrace locations' do
-    info = parse exception
-    expect(info.backtrace.map &:linenum).to eq [123]
-  end
-end

data/spec/parse/wrong_number_of_arguments_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'parse/spec_helper'
-require 'error_to_communicate/parse/wrong_number_of_arguments'
-
-RSpec.describe 'parsing wrong number of arguments', parse: true do
-  def parse(exception)
-    WhatWeveGotHereIsAnErrorToCommunicate::Parse::WrongNumberOfArguments.parse(exception)
-  end
-
-  it_behaves_like 'an exception parser',
-    sample_message:     "wrong number of arguments (1 for 0) (ArgumentError)",
-    sample_explanation: "Wrong number of arguments"
-
-  describe 'parse?' do
-    def will_parse?(exception)
-      WhatWeveGotHereIsAnErrorToCommunicate::Parse::WrongNumberOfArguments.parse?(exception)
-    end
-
-    def will_parse!(exception)
-      expect(will_parse? exception).to be_truthy
-    end
-
-    def wont_parse!(exception)
-      expect(will_parse? exception).to be_falsy
-    end
-
-    it 'is true when given an MRI style wrong number of arguments message' do
-      will_parse! ArgumentError.new "wrong number of arguments (1 for 0)"
-    end
-
-    it 'is true when given an RBX style wrong number of arguments message' do
-      will_parse! ArgumentError.new "method 'a': given 1, expected 0"
-    end
-
-    it 'is true when given an JRuby style wrong number of arguments message' do
-      will_parse! ArgumentError.new "wrong number of arguments calling `a` (1 for 0)"
-    end
-
-    it 'is true when given an MRI style wrong number of arguments message' do
-      will_parse! ArgumentError.new "wrong number of arguments (1 for 0)"
-    end
-
-    it 'is false for ArgumentErrors that are not "wrong number of arguments"' do
-      wont_parse!  ArgumentError.new "Some other kind of ArgumentError"
-    end
-
-    it 'is false when the message is contained within some other message (not overeager)' do
-      wont_parse! RSpec::Expectations::ExpectationNotMetError.new(<<-MESSAGE)
-       expected: "wrong number of arguments (1 for 0) (ArgumentError)"
-            got: "Wrong number of arguments"
-
-            (compared using ==)
-      MESSAGE
-    end
-  end
-
-  describe 'parse' do
-    let(:mri_message) { "wrong number of arguments (1 for 0)" }
-    let(:mri_parsed)  { parse FakeException.new(message: mri_message) }
-
-    let(:rbx_message) { "method 'a': given 1, expected 0" }
-    let(:rbx_parsed)  { parse FakeException.new(message: rbx_message) }
-
-    let(:jruby_message) { "wrong number of arguments calling `a` (1 for 0)" }
-    let(:jruby_parsed)  { parse FakeException.new(message: "wrong number of arguments calling `a` (1 for 0)") }
-
-    it 'extracts the number of arguments that were passed' do
-      expect(rbx_parsed.num_expected).to eq 0
-      expect(mri_parsed.num_expected).to eq 0
-    end
-
-    it 'extracts the number of arguments that were received' do
-      expect(rbx_parsed.num_received).to eq 1
-      expect(mri_parsed.num_received).to eq 1
-    end
-  end
-end