what_weve_got_here_is_an_error_to_communicate 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 502a20709d4fe294ae357bd9652fa9442c14b851
-  data.tar.gz: 8dabffcbda862538f2f3b3791b00b880ed2e9be5
+  metadata.gz: 12af0343c9c23e6c0e1ac4b5d513417855dbfdea
+  data.tar.gz: 5ad485865fe4165c3962971c33b4e0e1610bd21b
 SHA512:
-  metadata.gz: f499bc2afd237666020abca95c8938f94a57955906f96340be86c0a67a54e1a09d8862329309eb2c672195360282aff51ab8a22a9555deac9bf923ec1f1ad226
-  data.tar.gz: 2bbd0c0bf81e0ed3fd07aa3eef2552468381e3fccd88b42ca0adc477b2eec10cb3ff6edb2070612b4d826820f655547e204fbb2bf5c8f94a29e20ae455a4eb15
+  metadata.gz: ddad810a03f2ad851f9107f6b4eb18a4c0c459da0f91284764507b3a19103d1c60df319a61a45f6cfc56a2b47f30e2e8d7ddc5a6859149cb6bb980ab9247b868
+  data.tar.gz: dd0986ce38c6b8902389aa43f3f4957ccee503575ce14a8fd9cc4cdde5a2591b56c70546ce4c88297449b7786a4210d99763c1e9a8d4471d4134291af77f835b

data/.rspec

@@ -1,5 +1,4 @@
 --colour
---fail-fast
 --require error_to_communicate/at_exit
 --require error_to_communicate/rspec_formatter
 --format WhatWeveGotHereIsAnErrorToCommunicate::RSpecFormatter

data/Rakefile

@@ -1,6 +1,18 @@
 #!/usr/bin/env rake
-require File.join('rspec', 'core', 'rake_task')
+task :default => :spec
 
-RSpec::Core::RakeTask.new(:spec)
+desc 'Run all tests'
+task(:spec) { sh 'rspec' }
 
-task :default => :spec
+namespace :spec do
+  def self.spec(name, tags, description)
+    desc description
+    task(name) { sh "rspec --tag #{tags}" }
+  end
+  spec :config,     'config',          'Test configuration'
+  spec :heuristic,  'heuristic',       'Test the heuristcs'
+  spec :einfo,      'einfo',           'Test exception info'
+  spec :formatters, 'rspec_formatter', 'Test the RSpec formatter'
+  spec :acceptance, 'acceptance',      'Run acceptance tests (expensive)'
+  spec :quick,      '~acceptance',     'Run all specs except the acceptance tests (b/c they\'re slow)'
+end

data/Readme.md

@@ -9,11 +9,26 @@ A screenshot of the code rendering an `ArgumentError`.
 
 ![screenshot](https://s3.amazonaws.com/josh.cheek/images/scratch/better-reuby-commandline-errors.png)
 
+
 This is still early and Rough
 -----------------------------
 
 But I've been using it on its own test suite, and have to say it's compelling!
 
+
+Using this with RSpec or [MRspec](https://github.com/JoshCheek/mrspec)
+----------------------------------------------------------------------
+
+Place this in your .rspec file :)
+
+```
+--colour
+--require error_to_communicate/at_exit
+--require error_to_communicate/rspec_formatter
+--format WhatWeveGotHereIsAnErrorToCommunicate::RSpecFormatter
+```
+
+
 Inspirations:
 -------------
 
@@ -23,6 +38,7 @@ Inspirations:
   and then at Ruby Conf, she created [chatty_exceptions](https://github.com/kerrizor/chatty_exceptions)
   which is in this same domain.
 
+
 Related Projects:
 -----------------
 
@@ -30,6 +46,7 @@ Related Projects:
   gem gives you a nice interface like this for Rails.
 * Koichi's [pretty_backtrace](https://github.com/ko1/pretty_backtrace)
 
+
 License
 --------
 

data/lib/error_to_communicate/config.rb

@@ -8,8 +8,13 @@ module ErrorToCommunicate
   autoload :FormatTerminal, 'error_to_communicate/format_terminal'
 
   class Config
-    # Freezing this to encourage duping it rather than modifying the global default.
+    # If you wind up needing to modify this global list, let me know!
+    # I figure there should be a way to add/remove heuristics on the Config instance,
+    # but I can't quite tell what will be needed or what it should look like.
     # This implies we should provide a way to add/remove heuristics on the config itself.
+    # So I'm intentionally leaving this array unfrozen, to allow modification,
+    # so that anyone wanting to hack in their own heuristic isn't prevented,
+    # but if that happens, tell me so I can figure out how to add that functionality correctly!
     require 'error_to_communicate/heuristic/wrong_number_of_arguments'
     require 'error_to_communicate/heuristic/no_method_error'
     require 'error_to_communicate/heuristic/load_error'
@@ -21,7 +26,7 @@ module ErrorToCommunicate
       Heuristic::LoadError,
       Heuristic::SyntaxError,
       Heuristic::Exception,
-    ].freeze
+    ]
 
     # Should maybe also be an array, b/c there's no great way to add a proc to the blacklist,
     # right now, it would have to check it's thing and then call the next one

data/lib/error_to_communicate/exception_info.rb

@@ -22,9 +22,9 @@ class ErrorToCommunicate::ExceptionInfo::Location
   def self.parse(line)
     line =~ /^(.*?):(\d+):in `(.*?)'$/ # Are ^ and $ sufficient? Should be \A and (\Z or \z)?
     ErrorToCommunicate::ExceptionInfo::Location.new(
-      path:    $1,
-      linenum: $2.to_i,
-      label:   $3,
+      path:    ($1||""),
+      linenum: ($2||"-1").to_i,
+      label:   ($3||line),
     )
   end
 
@@ -83,14 +83,14 @@ class ErrorToCommunicate::ExceptionInfo
     new exception: exception,
         classname: exception.class.name,
         message:   exception.message,
-        backtrace: parse_backtrace(exception)
+        backtrace: parse_backtrace(exception.backtrace)
   end
 
-  def self.parse_backtrace(exception)
+  def self.parse_backtrace(backtrace)
     # Really, there are better methods, e.g. backtrace_locations,
     # but they're unevenly implemented across versions and implementations
-    (exception.backtrace||[])
-      .map { |line| Location.parse line }
-      .tap { |locs| locs.each_cons(2) { |crnt, pred| crnt.pred, pred.succ = pred, crnt } }
+    backtrace = (backtrace||[]).map { |line| Location.parse line }
+    backtrace.each_cons(2) { |crnt, pred| crnt.pred, pred.succ = pred, crnt }
+    backtrace
   end
 end

data/lib/error_to_communicate/format_terminal.rb

@@ -54,8 +54,6 @@ module ErrorToCommunicate
 
 
     class Code
-      # TODO: Should this highlight the location?
-
       attr_accessor :theme, :cwd
 
       def initialize(attributes)
@@ -72,6 +70,11 @@ module ErrorToCommunicate
         start_index    = bound_num min: 0, num: line_index+attributes.fetch(:context).begin
         message        = attributes.fetch :message, ''
         message_offset = line_index - start_index
+        if attributes.fetch(:mark, true)
+          mark_linenum = location.linenum
+        else
+          mark_linenum = -1
+        end
 
         # first line gives the path
         path_line = [
@@ -86,8 +89,7 @@ module ErrorToCommunicate
           code = File.read(path).lines[start_index..end_index].join("")
           code = remove_indentation       code
           code = theme.syntax_highlight   code
-          code = prefix_linenos_to        code, start_index.next, mark: location.linenum
-          code = theme.indent             code, "  "
+          code = prefix_linenos_to        code, start_index.next, mark: mark_linenum
           code = add_message_to           code, message_offset, theme.screaming_red(message)
           code = theme.highlight_text           code, message_offset, highlight
         else
@@ -124,14 +126,18 @@ module ErrorToCommunicate
       end
 
       def prefix_linenos_to(code, start_linenum, options)
-        line_to_mark  = options.fetch :mark, -1
+        line_to_mark  = options.fetch :mark
         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
+        linenum_width = max_linenum.to_s.length + 4     # 1 for the colon, 3 for the arrow/space
         lines.zip(start_linenum..max_linenum)
              .map { |line, num|
-               formatted_num = "#{num}:".ljust(linenum_width)
-               formatted_num = theme.mark_linenum formatted_num if line_to_mark == num
+               if line_to_mark == num
+                 formatted_num = "-> #{num}:".ljust(linenum_width)
+                 formatted_num = theme.mark_linenum formatted_num
+               else
+                 formatted_num = "   #{num}:".ljust(linenum_width)
+               end
                theme.color_linenum(formatted_num) << " " << line
              }.join("")
       end

data/lib/error_to_communicate/heuristic.rb

@@ -4,7 +4,7 @@ module ErrorToCommunicate
       raise NotImplementedError, "#{self} needs to implement .for? (subclass responsibility)"
     end
 
-    attr_accessor :einfo, :project
+    attr_accessor :project, :einfo
 
     def initialize(attributes)
       self.einfo   = attributes.fetch :einfo
@@ -19,14 +19,24 @@ module ErrorToCommunicate
       einfo.backtrace
     end
 
-    def explanation
+    def message
       einfo.message
     end
 
+    # Is this really a thing that should be in toplevel heuristic?
+    def explanation
+      message
+    end
+
     def semantic_explanation
       explanation
     end
 
+    # The responsibility of structuring should move to the heuristic
+    # Then, the classname and explanation can be separated from the
+    # summary and columns. Which allows us to compose heuristics
+    # by composing their columnal information, and placing it in our own
+    # structural format
     def semantic_summary
       [:summary, [
         [:columns,
@@ -46,6 +56,7 @@ module ErrorToCommunicate
             highlight: (location.pred && location.pred.label),
             context:   0..0,
             emphasis:  :path,
+            mark:      false,
           }]
         end
       ]

data/lib/error_to_communicate/heuristic/load_error.rb

@@ -10,7 +10,7 @@ module ErrorToCommunicate
       end
 
       def path
-        @path ||= Pathname.new einfo.message.split(' -- ', 2).last
+        @path ||= Pathname.new message.split(' -- ', 2).last
       end
 
       def semantic_info

data/lib/error_to_communicate/heuristic/no_method_error.rb

@@ -6,11 +6,11 @@ module ErrorToCommunicate
       def self.for?(einfo)
         ( einfo.classname == 'NoMethodError' ||
           einfo.classname == 'NameError'
-        ) && parse_undefined_name(einfo)
+        ) && parse_undefined_name(einfo.message)
       end
 
       def undefined_method_name
-        self.class.parse_undefined_name einfo
+        self.class.parse_undefined_name message
       end
 
       def semantic_info
@@ -27,8 +27,8 @@ module ErrorToCommunicate
 
       private
 
-      def self.parse_undefined_name(einfo)
-        einfo.message[/`(.*)'/, 1]
+      def self.parse_undefined_name(message)
+        message[/`(.*)'/, 1]
       end
     end
   end

data/lib/error_to_communicate/heuristic/syntax_error.rb

@@ -15,7 +15,7 @@ module ErrorToCommunicate
         self.reported_file ,
         self.reported_line ,
         self.unexpected    ,
-        self.expected      = self.class.parse_message(einfo.message)
+        self.expected      = self.class.parse_message(message)
         self.invalid_loc   = ExceptionInfo::Location.new \
                                path:    reported_file,
                                linenum: reported_line,

data/lib/error_to_communicate/heuristic/wrong_number_of_arguments.rb

@@ -4,14 +4,14 @@ module ErrorToCommunicate
   class Heuristic
     class WrongNumberOfArguments < Heuristic
       def self.for?(einfo)
-        extract_from einfo
+        extract_from einfo.message
       end
 
       attr_accessor :explanation, :num_expected, :num_received
 
       def initialize(*)
         super
-        self.num_received, self.num_expected = self.class.extract_from(einfo)
+        self.num_received, self.num_expected = self.class.extract_from(message)
         self.explanation = 'Wrong number of arguments'
       end
 
@@ -60,8 +60,8 @@ module ErrorToCommunicate
 
       private
 
-      def self.extract_from(einfo)
-        case einfo.message
+      def self.extract_from(message)
+        case 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

data/lib/error_to_communicate/rspec_formatter.rb

@@ -2,6 +2,58 @@ require 'error_to_communicate'
 require 'rspec/core/formatters/documentation_formatter'
 
 module ErrorToCommunicate
+  class Heuristic::RSpecFailure < Heuristic
+    attr_accessor :failure, :failure_number, :config
+    attr_accessor :semantic_summary, :semantic_info
+
+    def initialize(attributes)
+      self.failure_number = attributes.fetch :failure_number
+      self.failure        = attributes.fetch :failure
+      self.config         = attributes.fetch :config
+
+      # initialize the heuristic
+      ExceptionInfo.parse(failure.exception).tap do |einfo|
+        einfo.backtrace = ExceptionInfo.parse_backtrace failure.formatted_backtrace
+        super einfo: einfo, project: config.project
+      end
+
+      if assertion?
+        # format it with our lib
+        self.semantic_info =
+          [:heuristic, [ # ":heuristic" is dumb, it's not a heuristic, it's an error message, Maybe we need a :section or something?
+            [:message, message.sub(/\A\n*/, "")],
+            *backtrace.take(1).map { |loc|
+              [:code, {location: loc, context: (-5..5), emphasis: :code}]
+            }
+          ]]
+
+        self.semantic_summary =
+          [:summary, [
+            [:columns,
+              [:classname, failure_number],        # TODO: not classname
+              [:classname, failure.description]]]] # TODO: not classname
+      else
+        # wrap the heuristic that would otherwise be chosen
+        heuristic             = config.heuristic_for einfo
+        self.semantic_info    = heuristic.semantic_info
+        self.semantic_summary =
+          [:summary, [
+            [:columns,
+              [:classname,   failure_number],      # TODO: not classname
+              [:classname,   failure.description], # TODO: not classname
+              [:classname,   heuristic.classname], # TODO: not classname
+              [:explanation, heuristic.semantic_explanation]]]]
+      end
+    end
+
+    def assertion?
+      # RSpec differentiates failures from assertions by whether RSpec is in the name:
+      # https://github.com/JoshCheek/mrspec/blob/2761ba2180eb5f71a9262f6d59ce20d7cc8a47c3/lib/mrspec/minitest_assertion_for_rspec.rb
+      classname =~ /RSpec/
+    end
+  end
+
+
   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
@@ -22,24 +74,15 @@ module ErrorToCommunicate
     # FIXME: Needs to respect RSpec.configuration.color_enabled?
     #        but we can't currently turn colour off in our output
     def dump_failures(notification)
-      result = "\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
-        heuristic = ErrorToCommunicate::Config.default.heuristic_for exception
-        formatted = ErrorToCommunicate::Config.default.format heuristic, Dir.pwd
-
-        # fit it into the larger failure summary
-        result << "\n  #{failure_number+1}) #{failure.description}\n"
-        result << formatted.chomp.gsub(/^/, '    ')
+      output.puts "\nFailures:\n"
+      notification.failure_notifications.each.with_index(1) do |failure, failure_number|
+        heuristic = Heuristic::RSpecFailure.new \
+          config:         Config.default,
+          failure:        failure,
+          failure_number: failure_number
+        formatted = Config.default.format heuristic, Dir.pwd
+        output.puts formatted.chomp.gsub(/^/, '  ')
       end
-      output.puts result
     end
   end
 end

data/lib/error_to_communicate/version.rb

@@ -1,3 +1,3 @@
 module ErrorToCommunicate
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.0.3'.freeze
 end

data/spec/heuristic/wrong_number_of_arguments_spec.rb

@@ -1,6 +1,6 @@
 require 'heuristic/spec_helper'
 
-RSpec.describe 'heuristics for the WrongNumberOfArguments', t:true, heuristic: true do
+RSpec.describe 'heuristics for the WrongNumberOfArguments', heuristic: true do
   def heuristic_class
     ErrorToCommunicate::Heuristic::WrongNumberOfArguments
   end

data/spec/heuristic_spec.rb

@@ -14,10 +14,6 @@ RSpec.describe 'Heuristic', heuristic: true do
     expect { subclass.for? nil }.to raise_error NotImplementedError, /subclass/
   end
 
-  it 'records the exception info as einfo' do
-    expect(instance.einfo).to equal einfo
-  end
-
   it 'delegates classname, and backtrace to einfo' do
     expect(instance.classname).to eq 'the classname'
     expect(instance.backtrace.map { |loc| [loc.linenum] }).to eq [[12]]
@@ -29,7 +25,7 @@ RSpec.describe 'Heuristic', heuristic: true do
 
   describe 'semantic methods' do
     specify 'semantic_explanation defaults to the explanation' do
-      def instance.explanation; "!#{einfo.message}!"; end
+      def instance.explanation; "!#{message}!"; end
       expect(instance.semantic_explanation).to eq "!the message!"
     end
 

data/spec/parsing_exception_info_spec.rb

@@ -83,6 +83,33 @@ RSpec.describe 'Parsing exceptions to ExceptionInfo', einfo: true do
       assert_parses_line line, label:   "method1"
     end
 
+    context 'fake backtraces (eg RSpec renders text in the `formatted_backtrace` to get it to print messages there)' do
+      it 'has an empty path, linenum of -1, the entire string is the label' do
+        a, b, c = parsed = ErrorToCommunicate::ExceptionInfo.parse_backtrace([
+          "/Users/josh/.gem/ruby/2.1.1/gems/rspec-core-3.2.3/lib/rspec/core/runner.rb:29:in `block in autorun'",
+          "",
+          "  Showing full backtrace because every line was filtered out.",
+        ])
+
+        expect(parsed.map(&:path).map(&:to_s)).to eq [
+          "/Users/josh/.gem/ruby/2.1.1/gems/rspec-core-3.2.3/lib/rspec/core/runner.rb",
+          "",
+          "",
+        ]
+
+        expect(parsed.map &:linenum).to eq [29, -1, -1]
+
+        expect(parsed.map &:label).to eq [
+          "block in autorun",
+          "",
+          "  Showing full backtrace because every line was filtered out.",
+        ]
+
+        expect(parsed.map &:pred).to eq [b, c, nil]
+        expect(parsed.map &:succ).to eq [nil, a, b]
+      end
+    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'

data/spec/rspec_formatter_spec.rb

@@ -74,18 +74,10 @@ RSpec.describe ErrorToCommunicate::RSpecFormatter, rspec_formatter: true do
     formatter = new_formatter
     run_specs_against formatter, 'GroupName' do
       example('hello') { fail }
-      example('world') { fail }
+      example('world') { expect(1).to eq 2 }
     end
-    expect(get_printed formatter).to match /1\)\s*GroupName\s*hello/
-    expect(get_printed formatter).to match /2\)\s*GroupName\s*world/
-  end
-
-  it 'respects the backtrace formatter (ie the --backtrace flag)' do
-    # only need to check a failing example to show it uses RSpec's backtrace formatter
-    formatter = new_formatter
-    run_specs_against(formatter) { example { fail } }
-    expect(get_printed formatter)
-      .to_not include substring_that_would_only_be_in_full_backtrace
+    expect(get_printed formatter).to match /1\s*\|\s*GroupName\s*hello/
+    expect(get_printed formatter).to match /2\s*\|\s*GroupName\s*world/
   end
 
   it 'respects colour enabling/disabling' do
@@ -94,4 +86,118 @@ RSpec.describe ErrorToCommunicate::RSpecFormatter, rspec_formatter: true do
     pending 'We don\'t yet have the ability to turn color printing on/off'
     fail
   end
+
+
+  mock_failure_notification = Struct.new :exception, :formatted_backtrace, :description
+
+  define_method :failure_for do |attrs|
+    message   = attrs.fetch :message, "ZOMG!"
+    exception = attrs.fetch :exception do
+      case attrs.fetch :type, :assertion
+      when :assertion
+        RSpec::Expectations::ExpectationNotMetError.new message
+      when :argument_error
+        ArgumentError.new message
+      else raise "uhm: #{attrs.inspect}"
+      end
+    end
+
+    mock_failure_notification.new \
+      exception,
+      attrs.fetch(:formatted_backtrace) { ["/a:1:in `b'"] },
+      attrs.fetch(:description, "default-description")
+  end
+
+  context 'when the failure is an error' do
+    it 'prints the backtrace, respecting the backtrace formatter (ie the --backtrace flag)' do
+      # only need to check a failing example to show it uses RSpec's backtrace formatter
+      formatter = new_formatter
+      run_specs_against(formatter) { example { fail } }
+      expect(get_printed formatter)
+        .to_not include substring_that_would_only_be_in_full_backtrace
+    end
+
+    specify 'the summary is the failure number and description' do
+      config    = ErrorToCommunicate::Config.new
+      heuristic = ErrorToCommunicate::Heuristic::RSpecFailure.new \
+        config:         ErrorToCommunicate::Config.default,
+        failure:        failure_for(description: 'DESC', type: :assertion),
+        failure_number: 999
+      summaryname, ((columnsname, *columns)) = heuristic.semantic_summary
+      expect(summaryname).to eq :summary
+      expect(columnsname).to eq :columns
+      expect(columns.map &:last).to eq [999, 'DESC']
+    end
+
+    specify 'the info is the error message and first line from the backtrace with some context' do
+      config    = ErrorToCommunicate::Config.new
+      heuristic = ErrorToCommunicate::Heuristic::RSpecFailure.new \
+        config:   ErrorToCommunicate::Config.default,
+        failure: failure_for(type: :assertion, message: 'MESSAGE', formatted_backtrace: ["/file:123:in `method'"]),
+        failure_number: 999
+      heuristicname, ((messagename, message), (codename, codeattrs), *rest) = heuristic.semantic_info
+      expect(heuristicname).to eq :heuristic
+      expect(messagename  ).to eq :message
+      expect(message      ).to eq 'MESSAGE'
+      expect(codename     ).to eq :code
+      expect(codeattrs[:location].path.to_s).to eq '/file'
+      expect(codeattrs[:context]).to eq (-5..5)
+      expect(codeattrs[:emphasis]).to eq :code
+      expect(rest).to be_empty
+    end
+
+    specify 'it omits the backtrace line, if it DNE' do
+      config    = ErrorToCommunicate::Config.new
+      heuristic = ErrorToCommunicate::Heuristic::RSpecFailure.new \
+        config:         ErrorToCommunicate::Config.default,
+        failure_number: 999,
+        failure:        failure_for(type: :assertion, message: 'MESSAGE', formatted_backtrace: [])
+      heuristicname, ((messagename, message), *rest) = heuristic.semantic_info
+      expect(heuristicname).to eq :heuristic
+      expect(messagename  ).to eq :message
+      expect(message      ).to eq 'MESSAGE'
+      expect(rest).to be_empty
+    end
+  end
+
+
+  context 'when the failure is an assertion' do
+    it 'prints the backtrace, respecting the backtrace formatter (ie the --backtrace flag)' do
+      # only need to check a failing example to show it uses RSpec's backtrace formatter
+      formatter = new_formatter
+      run_specs_against(formatter) { example { expect(1).to eq 2 } }
+      expect(get_printed formatter)
+        .to_not include substring_that_would_only_be_in_full_backtrace
+    end
+
+
+    specify 'summary is the failure number, description, classname and semantic_explanation from the correct handler' do
+      expect_any_instance_of(ErrorToCommunicate::Heuristic::WrongNumberOfArguments)
+        .to receive(:semantic_explanation).and_return("SEMANTICEXPLANATION")
+
+      heuristic = ErrorToCommunicate::Heuristic::RSpecFailure.new \
+        config:  ErrorToCommunicate::Config.new,
+        failure: failure_for(message:     "wrong number of arguments (1 for 0)",
+                             description: 'DESC',
+                             type:        :argument_error),
+        failure_number: 999
+      summaryname, ((columnsname, *columns)) = heuristic.semantic_summary
+      expect(summaryname).to eq :summary
+      expect(columnsname).to eq :columns
+      expect(columns.map &:last).to eq [999, 'DESC', 'ArgumentError', 'SEMANTICEXPLANATION']
+    end
+
+
+    it 'delegates the heuristic to the correct handler' do
+      expect_any_instance_of(ErrorToCommunicate::Heuristic::WrongNumberOfArguments)
+        .to receive(:semantic_info).and_return("SEMANTICINFO")
+
+      heuristic = ErrorToCommunicate::Heuristic::RSpecFailure.new \
+        config:  ErrorToCommunicate::Config.new,
+        failure: failure_for(message: "wrong number of arguments (1 for 0)", type: :argument_error),
+        failure_number: 999
+
+      expect(heuristic.semantic_info).to eq "SEMANTICINFO"
+    end
+  end
 end

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.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Josh Cheek
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-29 00:00:00.000000000 Z
+date: 2015-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rouge