what_weve_got_here_is_an_error_to_communicate 0.0.1 → 0.0.2

data/lib/error_to_communicate/heuristic/wrong_number_of_arguments.rb

@@ -0,0 +1,73 @@
+require 'error_to_communicate/heuristic'
+
+module ErrorToCommunicate
+  class Heuristic
+    class WrongNumberOfArguments < Heuristic
+      def self.for?(einfo)
+        extract_from einfo
+      end
+
+      attr_accessor :explanation, :num_expected, :num_received
+
+      def initialize(*)
+        super
+        self.num_received, self.num_expected = self.class.extract_from(einfo)
+        self.explanation = 'Wrong number of arguments'
+      end
+
+      def semantic_explanation
+        [ :message,
+          [ [:explanation, explanation],
+            [:context, ' (expected '],
+            [:details, num_expected],
+            [:context, ', sent '],
+            [:details, num_received],
+            [:context, ')'],
+          ]
+        ]
+      end
+
+      def semantic_info
+        if backtrace.length == 0
+          [:context, "Couldn\'t find anything interesting ¯\_(ツ)_/¯\n"]
+        elsif backtrace.length == 1
+          [:heuristic, [:code, {
+            location:  backtrace[0],
+            highlight: backtrace[0].label,
+            context:   (-5..5),
+            emphasis:  :code,
+          }]]
+        else
+          [:heuristic, [
+            [:code, {
+              location:  backtrace[0],
+              highlight: backtrace[0].label,
+              context:   0..5,
+              message:   "EXPECTED #{num_expected}",
+              emphasis:  :code,
+            }],
+
+            [:code, {
+              location:  backtrace[1],
+              highlight: backtrace[0].label,
+              context:   -5..5,
+              message:   "SENT #{num_received}",
+              emphasis:  :code,
+            }],
+          ]]
+        end
+      end
+
+      private
+
+      def self.extract_from(einfo)
+        case einfo.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/lib/error_to_communicate/heuristic.rb

@@ -0,0 +1,54 @@
+module ErrorToCommunicate
+  class Heuristic
+    def self.for?(einfo)
+      raise NotImplementedError, "#{self} needs to implement .for? (subclass responsibility)"
+    end
+
+    attr_accessor :einfo, :project
+
+    def initialize(attributes)
+      self.einfo   = attributes.fetch :einfo
+      self.project = attributes.fetch :project
+    end
+
+    def classname
+      einfo.classname
+    end
+
+    def backtrace
+      einfo.backtrace
+    end
+
+    def explanation
+      einfo.message
+    end
+
+    def semantic_explanation
+      explanation
+    end
+
+    def semantic_summary
+      [:summary, [
+        [:columns,
+          [:classname,   classname],
+          [:explanation, semantic_explanation]]]]
+    end
+
+    def semantic_info
+      [:null]
+    end
+
+    def semantic_backtrace
+      [:backtrace,
+        backtrace.map do |location|
+          [:code, {
+            location:  location,
+            highlight: (location.pred && location.pred.label),
+            context:   0..0,
+            emphasis:  :path,
+          }]
+        end
+      ]
+    end
+  end
+end

data/lib/error_to_communicate/project.rb

@@ -0,0 +1,50 @@
+module ErrorToCommunicate
+  class Project
+    def self.find_rubygems_dir(loaded_features)
+      dir = loaded_features.grep(/\/rubygems\/specification.rb/).first
+      dir && File.dirname(dir)
+    end
+
+    # Things this should possibly deal with?
+    # Gemfile?
+    #   what gems are in it?
+    #   what load paths do these make available?
+    # directory structure
+    #   what paths are in the lib?
+    #   what dirs are in the lib?
+    # home_dir
+    # available_gems
+    # common_gems (maybe they meant to require something from a common gem)
+    # $LOAD_PATH
+    #   What all is in it? Is a dir misspelled?
+
+    attr_accessor :root
+
+    def initialize(attributes={})
+      attributes.each { |name, value| __send__ :"#{name}=", value }
+    end
+
+    def rubygems?
+      !rubygems_dir
+    end
+
+    def loaded_features
+      @loaded_features ||= []
+    end
+
+    def loaded_features=(loaded_features)
+      @loaded_features = loaded_features
+    end
+
+    attr_writer :rubygems_dir
+    def rubygems_dir
+      @rubygems_dir ||= self.class.find_rubygems_dir(loaded_features)
+    end
+
+    private
+
+    def extract(attributes, key, set_default=nil)
+      attributes.delete(key) || __send__(set_default)
+    end
+  end
+end

data/lib/error_to_communicate/rspec_formatter.rb

@@ -1,8 +1,7 @@
 require 'error_to_communicate'
-require 'error_to_communicate/format'
 require 'rspec/core/formatters/documentation_formatter'
 
-module WhatWeveGotHereIsAnErrorToCommunicate
+module ErrorToCommunicate
   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
@@ -13,7 +12,7 @@ module WhatWeveGotHereIsAnErrorToCommunicate
     #     }
     RSpec::Core::Formatters.register self
 
-    # Use WhatWeveGotHereIsAnErrorToCommunicate to print error info
+    # Use ErrorToCommunicate to print error info
     # rather than default DocumentationFormatter.
     #
     # How did we figure out how to implement it?
@@ -23,7 +22,7 @@ module WhatWeveGotHereIsAnErrorToCommunicate
     # 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"
+      result = "\nFailures:\n"
       notification.failure_notifications.each_with_index do |failure, failure_number|
         # get the exception with the modified backtrace
         exception = failure.exception.dup
@@ -33,14 +32,14 @@ module WhatWeveGotHereIsAnErrorToCommunicate
                                      .format_backtrace(exception.backtrace, metadata)
 
         # format it with our lib
-        exception_info      = ErrorToCommunicate::CONFIG.parse(exception)
-        formatted_exception = ErrorToCommunicate.format(exception_info)
+        heuristic = ErrorToCommunicate::Config.default.heuristic_for exception
+        formatted = ErrorToCommunicate::Config.default.format heuristic, Dir.pwd
 
         # fit it into the larger failure summary
-        formatted << "\n  #{failure_number+1}) #{failure.description}\n"
-        formatted << formatted_exception.chomp.gsub(/^/, '    ')
+        result << "\n  #{failure_number+1}) #{failure.description}\n"
+        result << formatted.chomp.gsub(/^/, '    ')
       end
-      output.puts formatted
+      output.puts result
     end
   end
 end

data/lib/error_to_communicate/theme.rb

@@ -0,0 +1,137 @@
+module ErrorToCommunicate
+  class Theme
+    # -----  Semantic  -----
+    # TODO: Not good enough, see note on FormatTerminal#format
+
+    def columns(*content)
+      content.join(' | ') + "\n"
+    end
+
+    def classname(classname)
+      "#{white}#{classname}#{none}"
+    end
+
+    def message(message)
+      "#{bri_red}#{message}#{none}"
+    end
+
+    def explanation(explanation)
+      "#{bri_red}#{explanation}#{none}"
+    end
+
+    def context(context)
+      "#{dim_red}#{context}#{none}"
+    end
+
+    def details(details)
+      "#{white}#{details}#{none}"
+    end
+
+    def mark_linenum(linenum)
+      "#{bri_red}#{linenum}#{none}"
+    end
+
+    # --------------------------------
+
+    def separator_line
+      ("="*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 invert(text)
+      "\e[7m#{text}\e[27m"
+    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
+
+    # For a list of themes:
+    # https://github.com/JoshCheek/what-we-ve-got-here-is-an-error-to-communicate/issues/36#issuecomment-91200262
+    def syntax_highlight(raw_code)
+      formatter = Rouge::Formatters::Terminal256.new theme: 'github'
+      lexer     = Rouge::Lexers::Ruby.new
+      tokens    = lexer.lex raw_code
+      formatted = formatter.format(tokens)
+      formatted << "\n" unless formatted.end_with? "\n"
+      remove_ansi_codes_after_last_newline(formatted)
+    end
+
+    def remove_ansi_codes_after_last_newline(text)
+      *neck, ass = text.lines # ... kinda like head/tail :P
+      return text unless neck.any? && ass[/^(\e\[(\d+;?)*m)*$/]
+      neck.join("").chomp << ass
+    end
+
+    def highlight_text(code, index, text)
+      lines = code.lines
+      return code unless text && lines[index]
+      lines[index].gsub! text, invert(text)
+      lines.join("")
+    end
+
+    def indent(str, indentation_str)
+      str.gsub /^/, indentation_str
+    end
+
+    # TODO: rename these to all imply foreground
+    def white
+      fg_rgb 5, 5, 5
+    end
+
+    def bri_red
+      fg_rgb 5, 0, 0
+    end
+
+    def dim_red
+      fg_rgb 3, 0, 0
+    end
+
+    def none
+      "\e[39m"
+    end
+
+    # Each of r, g, b, can have a value 0-5.
+    # If you want to do 0-255, you need to pass 255 as max.
+    # The terminal cans till only display 0-5,
+    # but you can pass your rgb values in, and we'll translate them here
+    def rgb(red, green, blue, max=6)
+      max = max.to_f
+      n   = 6
+
+      # translate each colour to 0-5
+      r = (n * red   / max).to_i
+      g = (n * green / max).to_i
+      b = (n * blue  / max).to_i
+
+      # move them to their offsets, I think the first 16 are for the system colors
+      16 + r*(n**2) + g*(n**1) + b*(n**0)
+    end
+
+    def fg_rgb(red, green, blue, max=6)
+      "\e[38;5;#{rgb red, green, blue, max}m"
+    end
+  end
+end

data/lib/error_to_communicate/version.rb

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

data/lib/error_to_communicate.rb

@@ -1,3 +1,5 @@
 require 'error_to_communicate/config'
-ErrorToCommunicate = WhatWeveGotHereIsAnErrorToCommunicate
-ErrorToCommunicate::CONFIG = ErrorToCommunicate::Config.new
+
+# We will use the shorthand for convenience,
+# but include the pattern-based name, for politeness :)
+WhatWeveGotHereIsAnErrorToCommunicate = ErrorToCommunicate

data/spec/acceptance/exception_spec.rb

@@ -2,22 +2,20 @@ 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
+    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'
+    expect(stderr).to match /Exception.*?mah message/
 
     # heuristic displays the line the exception was raised at, and some context
     expect(stderr).to include 'raise Exception, "mah message"'

data/spec/acceptance/load_error_spec.rb

@@ -0,0 +1,23 @@
+require 'acceptance/spec_helper'
+
+RSpec.context 'LoadError', acceptance: true do
+  it 'Prints heuristics' do
+    write_file 'load_error.rb', <<-BODY
+      require "what_weve_got_here_is_an_error_to_communicate"
+      require "not/a/real/dir"
+    BODY
+
+    invocation = ruby 'load_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 message
+    expect(stderr).to match %r(LoadError.*?load.*?not/a/real/dir)
+
+    # heuristic displays the line the exception was raised at, and some context
+    expect(stderr).to match %r(2:.*?require "not/a/real/dir".*?Couldn't find "not/a/real/dir")
+  end
+end

data/spec/acceptance/name_error_spec.rb

@@ -0,0 +1,46 @@
+require 'acceptance/spec_helper'
+
+RSpec.describe 'NameError', acceptance: true do
+  it 'Prints heuristics' do
+    write_file 'name_error.rb', <<-BODY
+      require 'error_to_communicate/at_exit'
+      module Test
+        def self.backtrace1
+        end
+
+        def self.backtrace2
+          backtrace4
+        end
+
+        def self.backtrace3
+        end
+      end
+
+      Test.backtrace2
+    BODY
+
+    invocation = ruby 'name_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 match /NameError.*?undefined local variable or method `backtrace4'/
+
+    # heuristic:
+      # It displays a helpful message next to the callsite
+      expect(stderr).to match /backtrace4.*?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 '  backtrace4'
+      expect(stderr).to include 'end'
+      expect(stderr).to_not include 'error_to_communicate/at_exit'
+
+    # backtrace: It displays each line of the backtrace and includes the code from that line
+      expect(stderr).to match /name_error\.rb:7\n.*?backtrace4/
+      expect(stderr).to match /name_error\.rb:14\n.*?Test.backtrace2/
+  end
+end

data/spec/acceptance/no_methood_error_spec.rb

@@ -2,7 +2,7 @@ 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
+    # 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
@@ -32,19 +32,17 @@ RSpec.describe 'NoMethodError', acceptance: true do
       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 a helpful message next to the callsite
+      expect(stderr).to match /Test\.backtrace4.*?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'
+      expect(stderr).to_not include 'error_to_communicate/at_exit'
 
     # 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'
+      expect(stderr).to match /no_method_error\.rb:7\n.*?backtrace4/
+      expect(stderr).to match /no_method_error\.rb:14\n.*?Test.backtrace2/
   end
 end

data/spec/acceptance/runtime_error_spec.rb

@@ -0,0 +1,27 @@
+require 'acceptance/spec_helper'
+
+RSpec.describe 'RuntimeError', acceptance: true do
+  it 'Prints heuristics' do
+    write_file 'runtime_error.rb', <<-BODY
+      require 'error_to_communicate/at_exit'
+      raise 'omg'
+      1
+    BODY
+
+    invocation = ruby 'runtime_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 match /RuntimeError.*?omg/
+
+    # heuristic:
+      # it displays the error and some context
+      expect(stderr).to match /1:.*?require 'error_to_communicate\/at_exit'/
+      expect(stderr).to match /2:.*?raise 'omg'/
+      expect(stderr).to match /3:.*?1/
+  end
+end

data/spec/acceptance/short_and_long_require_spec.rb

@@ -0,0 +1,29 @@
+require 'acceptance/spec_helper'
+
+RSpec.context 'Short and long require statements', acceptance: true do
+  it 'can require error_to_communicate' do
+    write_file 'require_shorthand.rb', <<-BODY
+      require 'error_to_communicate/at_exit'
+      ErrorToCommunicate
+      ErrorToCommunicate
+    BODY
+
+    invocation = ruby 'load_shorthand.rb'
+    expect(invocation.stdout).to     eq ''
+    expect(invocation.stdout).to     eq ''
+    expect(invocation.exitstatus).to eq 1
+  end
+
+  it 'can require what_weve_got_here_is_an_error_to_communicate' do
+    write_file 'require_longhand.rb', <<-BODY
+      require 'what_weve_got_here_is_an_error_to_communicate'
+      ErrorToCommunicate
+      ErrorToCommunicate
+    BODY
+
+    invocation = ruby 'load_longhand.rb'
+    expect(invocation.stdout).to     eq ''
+    expect(invocation.stdout).to     eq ''
+    expect(invocation.exitstatus).to eq 1
+  end
+end

data/spec/acceptance/spec_helper.rb

@@ -17,10 +17,11 @@ module AcceptanceSpecHelpers
     File.join root_dir, 'proving_grounds'
   end
 
-  def ruby(filename)
+  def ruby(*args)
     # 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)
+      out, err, status = Open3.capture3 ENV, 'ruby', '-I', lib_dir, *args
+      Haiti::CommandLineHelpers::Invocation.new out, err, status
     end
   end
 
@@ -37,5 +38,5 @@ end
 RSpec.configure do |config|
   # Helpers for acceptance tests
   config.before(acceptance: true) { make_proving_grounds }
-  config.include AcceptanceSpecHelpers,     acceptance: true
+  config.include AcceptanceSpecHelpers, acceptance: true
 end

data/spec/acceptance/syntax_error_spec.rb

@@ -0,0 +1,32 @@
+require 'acceptance/spec_helper'
+
+RSpec.describe 'SyntaxError', acceptance: true do
+  it 'Prints heuristics' do
+    write_file 'simple_syntax_error.rb', <<-BODY
+      100
+      "abc" 200
+      300
+    BODY
+
+    write_file 'requires_simple_sintax_error.rb', <<-BODY
+      require "what_weve_got_here_is_an_error_to_communicate"
+      require_relative 'simple_syntax_error'
+    BODY
+
+    invocation = ruby 'requires_simple_sintax_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 match /SyntaxError.*?unexpected.*?expected/i
+
+    # heuristic:
+      # it displays the error and some context
+      expect(stderr).to match /1:.*?100/
+      expect(stderr).to match /2:.*"abc" 200.*?unexpected/
+      expect(stderr).to match /3:.*?300/
+  end
+end

data/spec/acceptance/{argument_error_spec.rb → wrong_number_of_arguments_spec.rb}

@@ -1,6 +1,6 @@
 require 'acceptance/spec_helper'
 
-RSpec.context 'ArgumentError', acceptance: true do
+RSpec.context 'WrongNumberOfArguments', 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