mentor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ae3511e3b6d5760ea27f80381bec9c917f3c49fe
+  data.tar.gz: 0ce7c1629a9530f2e4b2f8435f331c20cc521dbb
+SHA512:
+  metadata.gz: ecc7a4768849f6cef68ea37a90b805ece2db7e01bfd401e4968077169c6bd89c70eabc61958494e5b6e0ce2603bd7fa530154eaad5587c204e0ce02b1662ad6c
+  data.tar.gz: df14fccab379150b55c91f6298eac72e9d9adcfb10098fdd71996f8ca6f0efb26e0bfeba346b2258008c99105baae0bda994748fbc7e444814b32f7f823094c4

data/.gitignore

@@ -0,0 +1 @@
+/Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Guardfile

@@ -0,0 +1,3 @@
+guard :minitest do
+  watch(/lib|test|\./) { 'test/mentor_test.rb' }
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Sean Lerner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Mentor
+
+Mentor is a command line application for new Ruby developers. It gives descriptive error messages and where possible provides suggestions on how to best fix errors.
+
+Instead of using Ruby to run your ruby programs like so:
+
+```
+ruby my_ruby_program.rb
+```
+
+Use Mentor:
+
+```
+mentor my_ruby_program.rb
+```
+
+## Installation
+
+From your command line, type:
+
+```
+gem install mentor
+```
+
+## Usage
+
+From your command line, type:
+
+```
+mentor my_ruby_program.rb
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitLab at https://gitlab.com/seanlerner/mentor.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Credits
+
+Mentor was created by Sean Lerner.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+task default: :test
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/*_test.rb'
+end

data/bin/mentor

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'mentor'
+Mentor.enable
+require_relative Dir.pwd + '/' + ARGV.first

data/lib/errors/mentor_error.rb

@@ -0,0 +1,52 @@
+module Mentor
+
+  class MentorError < StandardError
+
+    include Outputs, Colorize
+
+    def self.find
+      error_classes.find(&:can_handle?)
+    end
+
+    def self.can_handle?
+      Mentor.tp.raised_exception.class == RuntimeError
+    end
+
+    def output
+      puts
+      sections_formatted.each do |section|
+        puts section
+        puts
+      end
+    end
+
+    private
+
+    def self.error_classes
+      [
+        NoMethodDidYouMeanSuggestionError,
+        MentorNoMethodError,
+        MentorError
+      ]
+    end
+
+    def sections
+      [
+        Header.new,
+        RubyErrorComplete.new,
+        RelativePath.new,
+        LinesOfCode.new
+      ]
+    end
+
+    def sections_formatted
+      sections.map do |section|
+        section.lines.map do |line|
+          colorize line
+        end
+      end
+    end
+
+  end
+
+end

data/lib/errors/mentor_no_method_error.rb

@@ -0,0 +1,24 @@
+module Mentor
+
+  class MentorNoMethodError < MentorError
+
+    extend Outputs, Colorize
+
+    def self.can_handle?
+      Mentor.tp.raised_exception.class == NoMethodError
+    end
+
+    private
+
+    def sections
+      [
+        Header.new,
+        RubyErrorComplete.new,
+        RelativePath.new,
+        LinesOfCode.new
+      ]
+    end
+
+  end
+
+end

data/lib/errors/no_method_did_you_mean_suggestion_error.rb

@@ -0,0 +1,32 @@
+module Mentor
+
+  class NoMethodDidYouMeanSuggestionError < MentorNoMethodError
+
+    def self.can_handle?
+      super && Mentor.tp.raised_exception&.corrections.any?
+    end
+
+    def sections
+      [
+        Header.new,
+        RubyErrorComplete.new,
+        RelativePath.new,
+        LinesOfCode.new,
+        ErrorClassSpecificHelp.new(error_class_specific_help),
+        Suggestion.new("Try changing the method #{method_name} to #{did_you_mean_word} on #{var_for_method}.")
+      ]
+    end
+
+    private
+
+    def error_class_specific_help
+      [
+        "#{var_for_method} does not have the method #{method_name}.",
+        '',
+        'You may have made a typo.'
+      ]
+    end
+
+  end
+
+end

data/lib/helpers/colorize.rb

@@ -0,0 +1,156 @@
+module Mentor
+
+  module Colorize
+
+    def colorize(line)
+
+      if line_of_code?(line)
+        line = syntax_highlight(line)
+      elsif backtrace?(line)
+        return rainbow(line, :backtrace_line)
+      end
+
+      apply_colors(line)
+    end
+
+    def colorize_section
+      @lines.map! do |line|
+        line = rainbow(line, :suggestion)
+        colorize(line)
+      end
+    end
+
+    private
+
+    def backtrace?(line)
+      line['from ']
+    end
+
+    def line_of_code?(line)
+      line[padded_lineno_with_colon_regex]
+    end
+
+    def apply_colors(line)
+
+      line = color_pattern(line, error_lineno,     "#{file_name}:#{error_lineno}", :error_lineno)
+      line = color_pattern(line, ruby_error_class, "(#{ruby_error_class})", :ruby_error_class)
+      line = color_pattern(line, ruby_error_class, " #{ruby_error_class} ", :ruby_error_class)
+
+      output_types = %i(
+        did_you_mean_text  did_you_mean_word
+        message            horizontal_line    ruby_error_text
+        calling_method     method_class       method_name        var_for_method
+        absolute_base_dir  relative_base_dir  app_dir  file_name
+      )
+
+      output_types.reduce(line) do |line, output_type|
+        color_text(line, send(output_type), output_type)
+      end
+
+    end
+
+    def syntax_highlight(line)
+      padded_lineno = line[padded_lineno_with_colon_regex]
+      code          = line[padded_lineno.size..-1]
+      color_padded_lineno(padded_lineno) + color_code(code)
+    end
+
+    def color_code(code)
+      formatter = Rouge::Formatters::Terminal256.new
+      lexer     = Rouge::Lexers::Ruby.new
+      formatter.format(lexer.lex(code))
+    end
+
+    def color_padded_lineno(padded_lineno)
+      text_to_color = padded_lineno[padded_lineno_regex]
+      color         = text_to_color['=>'] ? :error_lineno : :subtle
+      color_text(padded_lineno, text_to_color, color)
+    end
+
+    def color_pattern(full_text, text_to_color, match_pattern, output_type)
+      full_text.gsub(match_pattern, color_text(match_pattern, text_to_color, output_type))
+    end
+
+    def color_text(full_text, text_to_color, output_type)
+
+      return full_text unless text_to_color && text_to_color.size > 0
+
+      colorized_text  = rainbow(text_to_color, output_type)
+      remaining_text = full_text
+      text_processed = ''
+
+      while remaining_text[text_to_color]
+        before_text                 = before_text_to_color(remaining_text, text_to_color)
+        reset_color                 = get_reset_color(before_text).to_s
+        text_processed             += before_text + colorized_text
+        index_after_text_processed  = (before_text + text_to_color).size
+        remaining_text              = reset_color + remaining_text[index_after_text_processed..-1].to_s
+      end
+
+      text_processed + remaining_text
+
+    end
+
+    def before_text_to_color(remaining_text, text_to_color)
+      index = remaining_text.index(text_to_color)
+      return '' if !index || index == 0
+      remaining_text[0..index - 1]
+    end
+
+    def get_reset_color(before_text)
+      index_of_color_to_reset_to = before_text.rindex(color_regex)
+      before_text[index_of_color_to_reset_to..-1][color_regex] if index_of_color_to_reset_to
+    end
+
+    def color_regex
+      /\e\[(\d|;)+m/
+    end
+
+    def padded_lineno_regex
+      /^\s+(=>)?\s\d+/
+    end
+
+    def padded_lineno_with_colon_regex
+      /^\s+(=>)?\s\d+:/
+    end
+
+    def rainbow(str, output_type)
+      Rainbow(str).color(colors[output_type])
+    end
+
+    def colors
+      error        = :tomato
+      error_lineno = :gold
+      method_name  = :deepskyblue
+      subtle       = :olive
+      very_subtle  = :dimgray
+
+      {
+        app_dir:               subtle,
+        backtrace_line:        very_subtle,
+        absolute_base_dir:     subtle,
+        relative_base_dir:     subtle,
+        calling_method:        :green,
+        did_you_mean_text:     :royalblue,
+        did_you_mean_word:     method_name,
+        error_lineno:          error_lineno,
+        error_lineno_padded:   error_lineno,
+        file_name:             :greenyellow,
+        horizontal_line:       :red,
+        lineno_subtle_padded:  subtle,
+        message:               error,
+        method_class:          :mediumpurple,
+        method_name:           method_name,
+        other_class_or_module: :darksalmon,
+        prominent:             :ivory,
+        ruby_error_class:      :orangered,
+        ruby_error_text:       error,
+        subtle:                subtle,
+        suggestion:            :lightgreen,
+        var_for_method:        :palevioletred
+      }
+    end
+
+  end
+
+end

data/lib/helpers/globals.rb

@@ -0,0 +1,27 @@
+module Mentor
+
+  module Globals
+
+    DIR = __dir__ + '/../..'
+
+    attr_accessor :cancel_exit_after_error, :tp
+
+    def cancel_exit_after_error?
+      @cancel_exit_after_error
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def enabled?
+      @enabled == true
+    end
+
+  end
+
+end

data/lib/helpers/output_helper.rb

@@ -0,0 +1,37 @@
+module Mentor
+
+  module OutputHelper
+
+    def home_to_tilde(path)
+      path.sub(ENV['HOME'], '~')
+    end
+
+    def indent_lines(*lines, indent: 2)
+      lines.flatten!
+
+      indent.downto(1).each do |number_of_spaces|
+        if lines.all? { |line| line.size + indent * 2 <= terminal_width }
+          return lines.map { |line| ' ' * number_of_spaces + line }
+        end
+      end
+
+      lines
+    end
+
+    def lines_from_file
+      return @lines_from_file if @lines_from_file
+      file = File.new(Mentor.tp.path)
+      @lines_from_file = file.map { |line| [file.lineno, line.chomp] }.to_h
+    end
+
+    def terminal_width
+      `tput cols`.to_i
+    end
+
+    def valid_var_name
+      /(@@|@|\$)?[a-zA-Z][a-zA-Z_0-9]*/
+    end
+
+  end
+
+end

data/lib/helpers/outputs.rb

@@ -0,0 +1,140 @@
+module Mentor
+
+  module Outputs
+
+    include OutputHelper
+
+    def absolute_base_dir
+      Dir.pwd + '/'
+    end
+
+    def app_dir
+      Mentor.tp.path.               # Full path
+        sub(absolute_base_dir, ''). # Remove path up until this file
+        split('/')[0..-2].          # Split path into parts and exclude filename
+        join('/') +                 # Join with '/'
+        '/'                         # Add one more '/' to end of it
+    end
+
+    def backtrace_lines
+
+      # Mentor.tp.raised_exception.backtrace disappears after accessing it once
+      # So we just do it once and then save the result to @@backtrace_lines
+      if self.class.class_variable_defined?(:@@backtrace_lines)
+        return @@backtrace_lines
+      end
+
+      bt_lines = Mentor.tp.raised_exception.
+                 backtrace[1..-1].                            # Remove first
+                 grep_v(/bin\/mentor/).                       # Remove mentor involvement
+                 map { |line| line.sub!(Dir.pwd + '/', '') }. # Remove path before current dir
+                 map { |line| 'from ' + line }                # Add 'from'
+
+      return bt_lines if bt_lines.empty?
+
+      # Make it appear so backtrace came from `<main>' instead of being required by mentor
+      bt_lines[-1].gsub!("`<top (required)>'", "`<main>'")
+
+      @@backtrace_lines = bt_lines
+
+    end
+
+    def calling_method
+      (Mentor.tp.method_id || '<main>').to_s
+    end
+
+    def did_you_mean_word
+      if Mentor.tp.raised_exception.respond_to? :corrections
+        Mentor.tp.raised_exception.corrections.first&.to_s
+      end
+    end
+
+    def did_you_mean_text
+      'Did you mean?'
+    end
+
+    def error_lineno_padded(width)
+      "=> #{@lineno}".rjust(width)
+    end
+
+    def error_lineno
+      Mentor.tp.lineno.to_s
+    end
+
+    def file_name
+      Mentor.tp.path.split('/').last
+    end
+
+    def horizontal_line
+      '─' * terminal_width
+    end
+
+    def instance_methods
+      Mentor.tp.raised_exception.receiver.class.instance_methods -
+      Mentor.tp.raised_exception.receiver.class.superclass.instance_methods
+    end
+
+    def lineno_subtle_padded(width)
+      @lineno.to_s.rjust(width)
+    end
+
+    def message
+      if Mentor.tp.raised_exception.respond_to? :original_message
+        Mentor.tp.raised_exception.original_message
+      else
+        Mentor.tp.raised_exception.message
+      end
+    end
+
+    def method_name
+      if Mentor.tp.raised_exception.respond_to? :spell_checker
+        if Mentor.tp.raised_exception.spell_checker.respond_to?(:method_name)
+          Mentor.tp.raised_exception.spell_checker.method_name.to_s
+        else
+          raise "cannot determine method name"
+        end
+      end
+    end
+
+    def method_class
+      if Mentor.tp.raised_exception.respond_to? :receiver
+        Mentor.tp.raised_exception.receiver.class.to_s
+      end
+    end
+
+    def method_class_plural
+      pluralize method_class
+    end
+
+    def method_class_superclass
+      Mentor.tp.raised_exception.receiver.class.superclass
+    end
+
+    def method_class_superclasses
+      to_sentence(Mentor.tp.raised_exception.receiver.class.ancestors - typical_classes)
+    end
+
+    def relative_base_dir
+      home_to_tilde(absolute_base_dir)
+    end
+
+    def ruby_error_class
+      Mentor.tp.raised_exception.class.to_s
+    end
+
+    def ruby_error_text
+      'Ruby Error:'
+    end
+
+    def var_for_method
+      culprit_line = lines_from_file[Mentor.tp.lineno]
+      var = culprit_line[/#{valid_var_name}\.#{method_name}/].to_s.chomp(".#{method_name}")
+      if var.empty?
+        culprit_line[/#{valid_var_name} method_name/].to_s.chomp(".#{method_name}")
+      end
+      var
+    end
+
+  end
+
+end

data/lib/helpers/requires.rb

@@ -0,0 +1,21 @@
+module Mentor
+  gems = [
+    'pry',
+    'rainbow',
+    'rouge',
+  ]
+
+  helpers = [
+    'output_helper',
+    'outputs',
+    'colorize'
+  ].map { |file| Globals::DIR + '/lib/helpers/' + file }
+
+  sections = Dir.glob(Globals::DIR + '/lib/sections/*.rb')
+  errors   = Dir.glob(Globals::DIR + '/lib/errors/*.rb')
+
+  (gems + helpers + sections + errors).each { |file| require file }
+
+  require_relative '../main'
+
+end

data/lib/main.rb

@@ -0,0 +1,23 @@
+module Mentor
+
+  class Main
+
+    def initialize
+
+      error_class = MentorError.find
+
+      return unless error_class
+
+      begin
+        error = error_class.new
+        raise error
+      rescue *MentorError.error_classes
+        error.output
+        exit 1 unless Mentor.cancel_exit_after_error?
+      end
+
+    end
+
+  end
+
+end

data/lib/mentor/version.rb

@@ -0,0 +1,3 @@
+module Mentor
+  VERSION = '0.1.0'
+end

data/lib/mentor.rb

@@ -0,0 +1,37 @@
+require 'mentor/version'
+
+module Mentor
+
+  class Init
+
+    def self.setup
+      require_relative 'helpers/globals'
+      Mentor.extend(Globals)
+      setup_trace_point
+      Mentor.enable
+    end
+
+    private
+
+    def self.setup_trace_point
+
+      TracePoint.trace(:raise) do |tp|
+        tp.disable
+
+          if Mentor.enabled?
+            Mentor.disable
+            require_relative 'helpers/requires'
+            Mentor.tp = tp
+            Main.new
+          end
+
+        tp.enable
+      end
+
+    end
+
+  end
+
+end
+
+Mentor::Init.setup

data/lib/sections/backtrace.rb

@@ -0,0 +1,15 @@
+module Mentor
+
+  class Backtrace
+
+    include Outputs
+
+    attr_reader :lines
+
+    def initialize
+      @lines = indent_lines(backtrace_lines, indent: 10)
+    end
+
+  end
+
+end

data/lib/sections/did_you_mean_correction.rb

@@ -0,0 +1,20 @@
+module Mentor
+
+  class DidYouMeanCorrection
+
+    include Outputs
+
+    attr_reader :line
+
+    def initialize
+      @line = "#{did_you_mean_text}  #{did_you_mean_word}"
+    end
+
+    def self.can_handle?
+      Mentor.tp.raised_exception.respond_to?(:corrections) &&
+      Mentor.tp.raised_exception.corrections.any?
+    end
+
+  end
+
+end

data/lib/sections/error_class_specific_help.rb

@@ -0,0 +1,16 @@
+module Mentor
+
+  class ErrorClassSpecificHelp
+
+    include Outputs, Colorize
+
+    attr_reader :lines
+
+    def initialize(lines)
+      @lines = indent_lines(lines)
+      colorize_section
+    end
+
+  end
+
+end

data/lib/sections/header.rb

@@ -0,0 +1,47 @@
+module Mentor
+
+  class Header
+
+    include Outputs, Colorize
+
+    attr_reader :lines
+
+    def initialize
+      @lines = [
+        horizontal_line,
+        title_indented,
+        horizontal_line,
+      ]
+
+      colorize_section
+    end
+
+    private
+
+    def title_indented
+      if title_bar_spacer_size > 4
+        " #{ruby_error_text} #{ruby_error_class}#{title_bar_spacer_with_indent}#{file_name}:#{error_lineno}"
+      elsif title_bar_spacer_size > 2
+        "#{ruby_error_text} #{ruby_error_class}#{title_bar_spacer_without_indent}#{file_name}:#{error_lineno}"
+      else
+        "#{ruby_error_text} #{ruby_error_class}\n#{file_name}:#{error_lineno}"
+      end
+    end
+
+    def title_bar_spacer_size
+      start_of_line = ruby_error_text + ' ' + ruby_error_class
+      end_of_line   = file_name + ':' + error_lineno
+      terminal_width - (start_of_line.length + end_of_line.length)
+    end
+
+    def title_bar_spacer_without_indent
+      ' ' * title_bar_spacer_size
+    end
+
+    def title_bar_spacer_with_indent
+      ' ' * (title_bar_spacer_size - 2)
+    end
+
+  end
+
+end

data/lib/sections/line_of_code.rb

@@ -0,0 +1,30 @@
+module Mentor
+
+  class LineOfCode < String
+
+    include Outputs
+
+    def initialize(lineno, line, max_length)
+      @lineno     = lineno
+      @line       = line
+      @max_length = max_length
+      super("#{padded_lineno}:  #{@line}")
+    end
+
+    private
+
+    def padded_lineno
+      if error_lineno?
+        error_lineno_padded(@max_length)
+      else
+        lineno_subtle_padded(@max_length)
+      end
+    end
+
+    def error_lineno?
+      @lineno == Mentor.tp.lineno
+    end
+
+  end
+
+end

data/lib/sections/lines_of_codes.rb

@@ -0,0 +1,70 @@
+module Mentor
+
+  class LinesOfCode
+
+    include Outputs
+
+    attr_accessor :lines
+
+    def initialize
+      @lines = indent_lines(lines_of_code_from_method_or_file, indent: 4)
+    end
+
+    private
+
+    def lines_of_code_from_method_or_file
+      if calling_method_can_be_obtained?
+        set_first_and_last_from_method
+      else
+        set_first_and_last_from_file
+      end
+
+      lineno_max_length = "=> #{@last_lineno}".length
+
+      (@first_lineno..@last_lineno).map do |lineno|
+        LineOfCode.new(lineno, lines_from_file[lineno], lineno_max_length)
+      end
+    end
+
+    def calling_method_can_be_obtained?
+      calling_method != '<main>'
+    end
+
+    def set_first_and_last_from_method
+      method_text = Pry::Method.from_str("#{Mentor.tp.defined_class}##{calling_method}").source.split("\n")
+      @first_lineno = lines_from_file.select { |lineno, line| line["def #{calling_method}"] }.sort.last.first
+      @last_lineno  = @first_lineno + method_text.size - 1
+    end
+
+    def set_first_and_last_from_file
+      @first_lineno = Mentor.tp.lineno
+      @first_lineno -= 1 until first_line_at_start_of_file? || first_line_empty? ||
+                               line_prior_to_first_line_ends?
+      @last_lineno = Mentor.tp.lineno
+      @last_lineno += 1 until last_line_at_end_of_file? || last_line_empty?
+    end
+
+    def first_line_at_start_of_file?
+      @first_lineno == 1
+    end
+
+    def first_line_empty?
+      lines_from_file[@first_lineno].empty?
+    end
+
+    def line_prior_to_first_line_ends?
+      lines_from_file[@first_lineno - 1]['end']
+    end
+
+    def last_line_at_end_of_file?
+      @last_lineno == lines_from_file.size
+    end
+
+    def last_line_empty?
+      lines_from_file[@last_lineno].empty?
+    end
+
+  end
+
+end
+

data/lib/sections/relative_path.rb

@@ -0,0 +1,15 @@
+module Mentor
+
+  class RelativePath
+
+    include Outputs
+
+    attr_accessor :lines
+
+    def initialize
+      @lines = indent_lines(relative_base_dir + app_dir + file_name + ':' + error_lineno)
+    end
+
+  end
+
+end

data/lib/sections/ruby_error_complete.rb

@@ -0,0 +1,21 @@
+module Mentor
+
+  class RubyErrorComplete
+
+    include Outputs, Colorize
+
+    attr_reader :lines
+
+    def initialize
+      @lines = []
+      @lines << RubyErrorMain.new.lines
+      @lines << DidYouMeanCorrection.new.line if DidYouMeanCorrection.can_handle?
+      @lines << Backtrace.new.lines
+      @lines = indent_lines(@lines)
+      @lines << ''
+      @lines << horizontal_line
+    end
+
+  end
+
+end

data/lib/sections/ruby_error_main.rb

@@ -0,0 +1,77 @@
+module Mentor
+
+  class RubyErrorMain
+
+    include Outputs
+
+    attr_reader :lines
+
+    def initialize
+      @lines = ruby_error_main
+    end
+
+    private
+
+    def single_line
+      parts = []
+      parts << path_and_lineno
+      parts << message
+      parts << bracketed_class
+      parts.flatten.join(' ')
+    end
+
+    def path_and_lineno
+      app_path_and_lineno = "#{app_dir}#{file_name}:#{error_lineno}:in `#{calling_method}':"
+
+      if backtrace_lines.any?
+        absolute_base_dir + app_path_and_lineno
+      else
+        app_path_and_lineno
+      end
+    end
+
+    def bracketed_class
+      "(#{ruby_error_class})"
+    end
+
+    def ruby_error_main
+      if single_line.size <= terminal_width
+        [single_line]
+      else
+        ruby_error_wrapped
+      end
+    end
+
+    def ruby_error_wrapped
+      if fit_on_one_or_two_lines?(path_and_lineno, message)
+        [path_and_lineno + ' ' + message, bracketed_class]
+
+      elsif fit_on_one_or_two_lines?(message, bracketed_class)
+        [path_and_lineno, message + ' ' + bracketed_class]
+
+      else
+        [path_and_lineno, message, bracketed_class]
+
+      end
+    end
+
+    def fit_on_one_or_two_lines?(part_a, part_b)
+      fit_on_one_line?(part_a, part_b) ||
+      does_not_fit_on_one_line?(part_a) && fit_on_two_lines?(part_a, part_b)
+    end
+
+    def fit_on_one_line?(part_a, part_b)
+      (part_a + ' ' + part_b).size <= terminal_width
+    end
+
+    def does_not_fit_on_one_line?(part)
+      part.size >= terminal_width
+    end
+
+    def fit_on_two_lines?(part_a, part_b)
+      (part_a + ' ' + part_b).size <= terminal_width * 2
+    end
+
+  end
+
+end

data/lib/sections/suggestion.rb

@@ -0,0 +1,23 @@
+module Mentor
+
+  class Suggestion
+
+    include Outputs, Colorize
+
+    attr_reader :lines
+
+    def initialize(suggestion = '')
+      @lines = suggestion
+      format_lines
+    end
+
+    private
+
+    def format_lines
+      @lines = indent_lines(@lines)
+      colorize_section
+    end
+
+  end
+
+end

data/mentor.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mentor/version'
+
+Gem::Specification.new do |spec|
+  spec.name     = 'mentor'
+  spec.version  = Mentor::VERSION
+  spec.authors  = ['Sean Lerner']
+  spec.email    = ['sean@smallcity.ca']
+  spec.summary  = 'Helpful error messages for new ruby programmers.'
+  spec.homepage = 'https://gitlab.com/seanlerner/mentor'
+  spec.license  = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.executables   << 'mentor'
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'pry',           '~> 0.10'
+  spec.add_dependency 'rainbow',       '~> 2.2'
+  spec.add_dependency 'rouge',         '~> 2.0'
+
+  spec.add_development_dependency 'bundler',        '~> 1.13'
+  spec.add_development_dependency 'guard',          '~> 2.14'
+  spec.add_development_dependency 'guard-minitest', '~> 2.4'
+  spec.add_development_dependency 'minitest',       '~> 5.0'
+  spec.add_development_dependency 'rake',           '~> 10.0'
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: mentor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sean Lerner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- sean@smallcity.ca
+executables:
+- mentor
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/mentor
+- lib/errors/mentor_error.rb
+- lib/errors/mentor_no_method_error.rb
+- lib/errors/no_method_did_you_mean_suggestion_error.rb
+- lib/helpers/colorize.rb
+- lib/helpers/globals.rb
+- lib/helpers/output_helper.rb
+- lib/helpers/outputs.rb
+- lib/helpers/requires.rb
+- lib/main.rb
+- lib/mentor.rb
+- lib/mentor/version.rb
+- lib/sections/backtrace.rb
+- lib/sections/did_you_mean_correction.rb
+- lib/sections/error_class_specific_help.rb
+- lib/sections/header.rb
+- lib/sections/line_of_code.rb
+- lib/sections/lines_of_codes.rb
+- lib/sections/relative_path.rb
+- lib/sections/ruby_error_complete.rb
+- lib/sections/ruby_error_main.rb
+- lib/sections/suggestion.rb
+- mentor.gemspec
+homepage: https://gitlab.com/seanlerner/mentor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Helpful error messages for new ruby programmers.
+test_files: []