what_weve_got_here_is_an_error_to_communicate 0.0.1

data/lib/error_to_communicate.rb

@@ -0,0 +1,3 @@
+require 'error_to_communicate/config'
+ErrorToCommunicate = WhatWeveGotHereIsAnErrorToCommunicate
+ErrorToCommunicate::CONFIG = ErrorToCommunicate::Config.new

data/lib/error_to_communicate/at_exit.rb

@@ -0,0 +1,11 @@
+require 'error_to_communicate'
+require 'error_to_communicate/format'
+
+module WhatWeveGotHereIsAnErrorToCommunicate
+  at_exit do
+    exception = $!
+    next unless CONFIG.parse? exception
+    $stderr.puts format CONFIG.parse exception
+    exit! 1 # there has got to be a better way to clear an exception, this could break other at_exit hooks -.^
+  end
+end

data/lib/error_to_communicate/config.rb

@@ -0,0 +1,32 @@
+require 'error_to_communicate/version'
+require 'error_to_communicate/parse/registry'
+require 'error_to_communicate/parse/exception'
+require 'error_to_communicate/parse/no_method_error'
+require 'error_to_communicate/parse/wrong_number_of_arguments'
+
+module WhatWeveGotHereIsAnErrorToCommunicate
+  class Config
+    attr_accessor :registry
+
+    def initialize
+      self.registry = Parse::Registry.new(
+        dont_parse: lambda { |exception|
+          exception.kind_of? SystemExit
+        },
+        parsers: [
+          Parse::WrongNumberOfArguments,
+          Parse::NoMethodError,
+          Parse::Exception,
+        ]
+      )
+    end
+
+    def parse?(exception)
+      registry.parse?(exception)
+    end
+
+    def parse(exception)
+      registry.parse(exception)
+    end
+  end
+end

data/lib/error_to_communicate/exception_info.rb

@@ -0,0 +1,41 @@
+module WhatWeveGotHereIsAnErrorToCommunicate
+  class ExceptionInfo
+    attr_accessor :classname, :explanation, :backtrace
+    attr_accessor :exception # for dev info only, parse out additional info rather than interacting with it direclty
+    def initialize(attributes)
+      self.exception   = attributes.fetch :exception, nil
+      self.classname   = attributes.fetch :classname
+      self.explanation = attributes.fetch :explanation
+      self.backtrace   = attributes.fetch :backtrace
+    end
+  end
+
+  class ExceptionInfo::Location
+    # TODO: rename linenum -> line_number
+    attr_accessor :path, :linenum, :label, :pred, :succ
+    def initialize(attributes)
+      self.path    = attributes.fetch :path
+      self.linenum = attributes.fetch :linenum
+      self.label   = attributes.fetch :label
+      self.pred    = attributes.fetch :pred, nil
+      self.succ    = attributes.fetch :succ, nil
+    end
+  end
+
+  class ExceptionInfo::WrongNumberOfArguments < ExceptionInfo
+    attr_accessor :num_expected, :num_received
+    def initialize(attributes)
+      self.num_expected = attributes.fetch :num_expected
+      self.num_received = attributes.fetch :num_received
+      super
+    end
+  end
+
+  class ExceptionInfo::NoMethodError < ExceptionInfo
+    attr_accessor :undefined_method_name
+    def initialize(attributes)
+      self.undefined_method_name = attributes.fetch :undefined_method_name
+      super
+    end
+  end
+end

data/lib/error_to_communicate/format.rb

@@ -0,0 +1,132 @@
+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/format/terminal_helpers.rb

@@ -0,0 +1,97 @@
+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/parse/backtrace.rb

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

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

data/lib/error_to_communicate/parse/no_method_error.rb

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

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

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