better_errors 1.0.0 → 2.9.1

data/gemfiles/rails51_haml.gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 5.1.0"
+gem 'i18n', '< 1.5.2' if RUBY_VERSION < '2.3'
+gem "haml"
+
+gem 'simplecov',      require: false
+gem 'simplecov-lcov', require: false
+
+gemspec path: "../"

data/gemfiles/rails52.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 5.2.0"
+gem 'i18n', '< 1.5.2' if RUBY_VERSION < '2.3'
+
+gem 'simplecov',      require: false
+gem 'simplecov-lcov', require: false
+
+gemspec path: "../"

data/gemfiles/rails52_boc.gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 5.2.0"
+gem 'i18n', '< 1.5.2' if RUBY_VERSION < '2.3'
+gem "binding_of_caller"
+
+gem 'simplecov',      require: false
+gem 'simplecov-lcov', require: false
+
+gemspec path: "../"

data/gemfiles/rails52_haml.gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 5.2.0"
+gem 'i18n', '< 1.5.2' if RUBY_VERSION < '2.3'
+gem "haml"
+
+gem 'simplecov',      require: false
+gem 'simplecov-lcov', require: false
+
+gemspec path: "../"

data/gemfiles/rails60.gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 6.0.0"
+
+gem 'simplecov',      require: false
+gem 'simplecov-lcov', require: false
+
+gemspec path: "../"

data/gemfiles/rails60_boc.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 6.0.0"
+gem "binding_of_caller"
+
+gem 'simplecov',      require: false
+gem 'simplecov-lcov', require: false
+
+gemspec path: "../"

data/gemfiles/rails60_haml.gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 6.0.0"
+gem "haml"
+
+gem 'simplecov',      require: false
+gem 'simplecov-lcov', require: false
+
+gemspec path: "../"

data/lib/better_errors/code_formatter/html.rb

@@ -11,7 +11,7 @@ module BetterErrors
         sprintf '<pre class="%s">%s</pre>', class_name, str
       }
     end
-    
+
     def formatted_nums
       each_line_of(highlighted_lines) { |highlight, current_line, str|
         class_name = highlight ? "highlight" : ""

data/lib/better_errors/code_formatter.rb

@@ -11,9 +11,9 @@ module BetterErrors
       ".erb"  => :erb,
       ".haml" => :haml
     }
-    
+
     attr_reader :filename, :line, :context
-    
+
     def initialize(filename, line, context = 5)
       @filename = filename
       @line     = line
@@ -29,7 +29,7 @@ module BetterErrors
     def formatted_code
       formatted_lines.join
     end
-    
+
     def coderay_scanner
       ext = File.extname(filename)
       FILE_TYPES[ext] || :text
@@ -40,20 +40,20 @@ module BetterErrors
         yield (current_line == line), current_line, str
       }
     end
-    
+
     def highlighted_lines
       CodeRay.scan(context_lines.join, coderay_scanner).div(wrap: nil).lines
     end
-    
+
     def context_lines
       range = line_range
       source_lines[(range.begin - 1)..(range.end - 1)] or raise Errno::EINVAL
     end
-    
+
     def source_lines
       @source_lines ||= File.readlines(filename)
     end
-    
+
     def line_range
       min = [line - context, 1].max
       max = [line + context, source_lines.count].min

data/lib/better_errors/editor.rb

@@ -0,0 +1,99 @@
+require "uri"
+
+module BetterErrors
+  class Editor
+    KNOWN_EDITORS = [
+      { symbols: [:atom], sniff: /atom/i, url: "atom://core/open/file?filename=%{file}&line=%{line}" },
+      { symbols: [:emacs, :emacsclient], sniff: /emacs/i, url: "emacs://open?url=file://%{file}&line=%{line}" },
+      { symbols: [:idea], sniff: /idea/i, url: "idea://open?file=%{file}&line=%{line}" },
+      { symbols: [:macvim, :mvim], sniff: /vim/i, url: "mvim://open?url=file://%{file_unencoded}&line=%{line}" },
+      { symbols: [:rubymine], sniff: /mine/i, url: "x-mine://open?file=%{file}&line=%{line}" },
+      { symbols: [:sublime, :subl, :st], sniff: /subl/i, url: "subl://open?url=file://%{file}&line=%{line}" },
+      { symbols: [:textmate, :txmt, :tm], sniff: /mate/i, url: "txmt://open?url=file://%{file}&line=%{line}" },
+      { symbols: [:vscode, :code], sniff: /code/i, url: "vscode://file/%{file}:%{line}" },
+      { symbols: [:vscodium, :codium], sniff: /codium/i, url: "vscodium://file/%{file}:%{line}" },
+    ]
+
+    def self.for_formatting_string(formatting_string)
+      new proc { |file, line|
+        formatting_string % { file: URI.encode_www_form_component(file), file_unencoded: file, line: line }
+      }
+    end
+
+    def self.for_proc(url_proc)
+      new url_proc
+    end
+
+    # Automatically sniffs a default editor preset based on
+    # environment variables.
+    #
+    # @return [Symbol]
+    def self.default_editor
+      editor_from_environment_formatting_string ||
+        editor_from_environment_editor ||
+        editor_from_symbol(:textmate)
+    end
+
+    def self.editor_from_environment_editor
+      if ENV["BETTER_ERRORS_EDITOR"]
+        editor = editor_from_command(ENV["BETTER_ERRORS_EDITOR"])
+        return editor if editor
+        puts "BETTER_ERRORS_EDITOR environment variable is not recognized as a supported Better Errors editor."
+      end
+      if ENV["EDITOR"]
+        editor = editor_from_command(ENV["EDITOR"])
+        return editor if editor
+        puts "EDITOR environment variable is not recognized as a supported Better Errors editor. Using TextMate by default."
+      else
+        puts "Since there is no EDITOR or BETTER_ERRORS_EDITOR environment variable, using Textmate by default."
+      end
+    end
+
+    def self.editor_from_command(editor_command)
+      env_preset = KNOWN_EDITORS.find { |preset| editor_command =~ preset[:sniff] }
+      for_formatting_string(env_preset[:url]) if env_preset
+    end
+
+    def self.editor_from_environment_formatting_string
+      return unless ENV['BETTER_ERRORS_EDITOR_URL']
+
+      for_formatting_string(ENV['BETTER_ERRORS_EDITOR_URL'])
+    end
+
+    def self.editor_from_symbol(symbol)
+      KNOWN_EDITORS.each do |preset|
+        return for_formatting_string(preset[:url]) if preset[:symbols].include?(symbol)
+      end
+    end
+
+    def initialize(url_proc)
+      @url_proc = url_proc
+    end
+
+    def url(raw_path, line)
+      if virtual_path && raw_path.start_with?(virtual_path)
+        if host_path
+          file = raw_path.sub(%r{\A#{virtual_path}}, host_path)
+        else
+          file = raw_path.sub(%r{\A#{virtual_path}/}, '')
+        end
+      else
+        file = raw_path
+      end
+        
+      url_proc.call(file, line)
+    end
+
+    private
+
+    attr_reader :url_proc
+
+    def virtual_path
+      @virtual_path ||= ENV['BETTER_ERRORS_VIRTUAL_PATH']
+    end
+
+    def host_path
+      @host_path ||= ENV['BETTER_ERRORS_HOST_PATH']
+    end
+  end
+end

data/lib/better_errors/error_page.rb

@@ -1,5 +1,6 @@
 require "cgi"
 require "json"
+require "securerandom"
 
 module BetterErrors
   # @private
@@ -7,65 +8,95 @@ module BetterErrors
     def self.template_path(template_name)
       File.expand_path("../templates/#{template_name}.erb", __FILE__)
     end
-    
+
     def self.template(template_name)
-      Erubis::EscapedEruby.new(File.read(template_path(template_name)))
+      Erubi::Engine.new(File.read(template_path(template_name)), escape: true)
     end
-    
+
     attr_reader :exception, :env, :repls
-    
+
     def initialize(exception, env)
-      @exception = real_exception(exception)
+      @exception = RaisedException.new(exception)
       @env = env
       @start_time = Time.now.to_f
       @repls = []
     end
-    
-    def render(template_name = "main")
-      self.class.template(template_name).result binding
+
+    def id
+      @id ||= SecureRandom.hex(8)
+    end
+
+    def render(template_name = "main", csrf_token = nil)
+      binding.eval(self.class.template(template_name).src)
+    rescue => e
+      # Fix the backtrace, which doesn't identify the template that failed (within Better Errors).
+      # We don't know the line number, so just injecting the template path has to be enough.
+      e.backtrace.unshift "#{self.class.template_path(template_name)}:0"
+      raise
     end
-    
+
     def do_variables(opts)
       index = opts["index"].to_i
       @frame = backtrace_frames[index]
       @var_start_time = Time.now.to_f
       { html: render("variable_info") }
     end
-    
+
     def do_eval(opts)
       index = opts["index"].to_i
       code = opts["source"]
-      
-      unless binding = backtrace_frames[index].frame_binding
+
+      unless (binding = backtrace_frames[index].frame_binding)
         return { error: "REPL unavailable in this stack frame" }
       end
-      
-      result, prompt, prefilled_input =
-        (@repls[index] ||= REPL.provider.new(binding)).send_input(code)
-      
-      { result: result,
-        prompt: prompt,
-        prefilled_input: prefilled_input,
-        highlighted_input: CodeRay.scan(code, :ruby).div(wrap: nil) }
+
+      @repls[index] ||= REPL.provider.new(binding, exception)
+
+      eval_and_respond(index, code)
     end
 
     def backtrace_frames
-      @backtrace_frames ||= StackFrame.from_exception(exception)
+      exception.backtrace
+    end
+
+    def exception_type
+      exception.type
+    end
+
+    def exception_message
+      exception.message.strip.gsub(/(\r?\n\s*\r?\n)+/, "\n")
+    end
+
+    def exception_hint
+      exception.hint
+    end
+
+    def active_support_actions
+      return [] unless defined?(ActiveSupport::ActionableError)
+
+      ActiveSupport::ActionableError.actions(exception.type)
+    end
+
+    def action_dispatch_action_endpoint
+      return unless defined?(ActionDispatch::ActionableExceptions)
+
+      ActionDispatch::ActionableExceptions.endpoint
     end
 
     def application_frames
-      backtrace_frames.select { |frame| frame.context == :application }
+      backtrace_frames.select(&:application?)
     end
 
     def first_frame
-      backtrace_frames.detect { |frame| frame.context == :application } || backtrace_frames.first
+      application_frames.first || backtrace_frames.first
     end
-    
-  private
+
+    private
+
     def editor_url(frame)
-      BetterErrors.editor[frame.filename, frame.line]
+      BetterErrors.editor.url(frame.filename, frame.line)
     end
-    
+
     def rack_session
       env['rack.session']
     end
@@ -77,31 +108,15 @@ module BetterErrors
     def uri_prefix
       env["SCRIPT_NAME"] || ""
     end
-  
-    def exception_message
-      if exception.is_a?(SyntaxError) && exception.message =~ /\A.*:\d*: (.*)$/
-        $1
-      else
-        exception.message
-      end
-    end
 
-    def real_exception(exception)
-      if exception.respond_to? :original_exception
-        exception.original_exception
-      else
-        exception
-      end
-    end
-  
     def request_path
       env["PATH_INFO"]
     end
-    
+
     def html_formatted_code_block(frame)
       CodeFormatter::HTML.new(frame.filename, frame.line).output
     end
-    
+
     def text_formatted_code_block(frame)
       CodeFormatter::Text.new(frame.filename, frame.line).output
     end
@@ -111,11 +126,30 @@ module BetterErrors
     end
 
     def inspect_value(obj)
-      CGI.escapeHTML(obj.inspect)
-    rescue NoMethodError
-      "<span class='unsupported'>(object doesn't support inspect)</span>"
+      if BetterErrors.ignored_classes.include? obj.class.name
+        "<span class='unsupported'>(Instance of ignored class. "\
+        "#{obj.class.name ? "Remove #{CGI.escapeHTML(obj.class.name)} from" : "Modify"}"\
+        " BetterErrors.ignored_classes if you need to see it.)</span>"
+      else
+        InspectableValue.new(obj).to_html
+      end
+    rescue BetterErrors::ValueLargerThanConfiguredMaximum
+      "<span class='unsupported'>(Object too large. "\
+        "#{obj.class.name ? "Modify #{CGI.escapeHTML(obj.class.name)}#inspect or a" : "A"}"\
+        "djust BetterErrors.maximum_variable_inspect_size if you need to see it.)</span>"
     rescue Exception => e
-      "<span class='unsupported'>(exception was raised in inspect)</span>"
+      "<span class='unsupported'>(exception #{CGI.escapeHTML(e.class.to_s)} was raised in inspect)</span>"
+    end
+
+    def eval_and_respond(index, code)
+      result, prompt, prefilled_input = @repls[index].send_input(code)
+
+      {
+        highlighted_input: CodeRay.scan(code, :ruby).div(wrap: nil),
+        prefilled_input:   prefilled_input,
+        prompt:            prompt,
+        result:            result
+      }
     end
   end
 end

data/lib/better_errors/exception_extension.rb

@@ -0,0 +1,17 @@
+module BetterErrors
+  module ExceptionExtension
+    prepend_features Exception
+
+    def set_backtrace(*)
+      if caller_locations.none? { |loc| loc.path == __FILE__ }
+        @__better_errors_bindings_stack = ::Kernel.binding.callers.drop(1)
+      end
+
+      super
+    end
+
+    def __better_errors_bindings_stack
+      @__better_errors_bindings_stack || []
+    end
+  end
+end

data/lib/better_errors/exception_hint.rb

@@ -0,0 +1,29 @@
+module BetterErrors
+  class ExceptionHint
+    def initialize(exception)
+      @exception = exception
+    end
+
+    def hint
+      case exception
+      when NoMethodError
+        /\Aundefined method `(?<method>[^']+)' for (?<val>[^:]+):(?<klass>\w+)/.match(exception.message) do |match|
+          if match[:val] == "nil"
+            return "Something is `nil` when it probably shouldn't be."
+          elsif !match[:klass].start_with? '0x'
+            return "`#{match[:method]}` is being called on a `#{match[:klass]}` object, "\
+              "which might not be the type of object you were expecting."
+          end
+        end
+      when NameError
+        /\Aundefined local variable or method `(?<method>[^']+)' for/.match(exception.message) do |match|
+          return "`#{match[:method]}` is probably misspelled."
+        end
+      end
+    end
+
+    private
+
+    attr_reader :exception
+  end
+end

data/lib/better_errors/inspectable_value.rb

@@ -0,0 +1,45 @@
+require "cgi"
+require "objspace" rescue nil
+
+module BetterErrors
+  class ValueLargerThanConfiguredMaximum < StandardError; end
+
+  class InspectableValue
+    def initialize(value)
+      @original_value = value
+    end
+
+    def to_html
+      raise ValueLargerThanConfiguredMaximum unless value_small_enough_to_inspect?
+      value_as_html
+    end
+
+    private
+
+    attr_reader :original_value
+
+    def value_as_html
+      @value_as_html ||= CGI.escapeHTML(value)
+    end
+
+    def value
+      @value ||= begin
+        if original_value.respond_to? :inspect
+          original_value.inspect
+        else
+          original_value
+        end
+      end
+    end
+
+    def value_small_enough_to_inspect?
+      return true if BetterErrors.maximum_variable_inspect_size.nil?
+
+      if defined?(ObjectSpace) && defined?(ObjectSpace.memsize_of) && ObjectSpace.memsize_of(value)
+        ObjectSpace.memsize_of(value) <= BetterErrors.maximum_variable_inspect_size
+      else
+        value_as_html.length <= BetterErrors.maximum_variable_inspect_size
+      end
+    end
+  end
+end