better_errors-creditkudos 2.1.1

data/lib/better_errors/code_formatter/html.rb

@@ -0,0 +1,26 @@
+module BetterErrors
+  # @private
+  class CodeFormatter::HTML < CodeFormatter
+    def source_unavailable
+      "<p class='unavailable'>Source is not available</p>"
+    end
+
+    def formatted_lines
+      each_line_of(highlighted_lines) { |highlight, current_line, str|
+        class_name = highlight ? "highlight" : ""
+        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" : ""
+        sprintf '<span class="%s">%5d</span>', class_name, current_line
+      }
+    end
+
+    def formatted_code
+      %{<div class="code_linenums">#{formatted_nums.join}</div><div class="code">#{super}</div>}
+    end
+  end
+end

data/lib/better_errors/code_formatter/text.rb

@@ -0,0 +1,14 @@
+module BetterErrors
+  # @private
+  class CodeFormatter::Text < CodeFormatter
+    def source_unavailable
+      "# Source is not available"
+    end
+
+    def formatted_lines
+      each_line_of(context_lines) { |highlight, current_line, str|
+        sprintf '%s %3d   %s', (highlight ? '>' : ' '), current_line, str
+      }
+    end
+  end
+end

data/lib/better_errors/error_page.rb

@@ -0,0 +1,129 @@
+require "cgi"
+require "json"
+require "securerandom"
+
+module BetterErrors
+  # @private
+  class ErrorPage
+    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)))
+    end
+
+    attr_reader :exception, :env, :repls
+
+    def initialize(exception, env)
+      @exception = RaisedException.new(exception)
+      @env = env
+      @start_time = Time.now.to_f
+      @repls = []
+    end
+
+    def id
+      @id ||= SecureRandom.hex(8)
+    end
+
+    def render(template_name = "main")
+      self.class.template(template_name).result binding
+    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
+        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) }
+    end
+
+    def backtrace_frames
+      exception.backtrace
+    end
+
+    def exception_type
+      exception.type
+    end
+
+    def exception_message
+      exception.message.lstrip
+    end
+
+    def application_frames
+      backtrace_frames.select(&:application?)
+    end
+
+    def first_frame
+      application_frames.first || backtrace_frames.first
+    end
+
+  private
+    def editor_url(frame)
+      BetterErrors.editor[frame.filename, frame.line]
+    end
+
+    def rack_session
+      env['rack.session']
+    end
+
+    def rails_params
+      env['action_dispatch.request.parameters']
+    end
+
+    def uri_prefix
+      env["SCRIPT_NAME"] || ""
+    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
+
+    def text_heading(char, str)
+      str + "\n" + char*str.size
+    end
+
+    def inspect_value(obj)
+      inspect_raw_value(obj)
+    rescue NoMethodError
+      "<span class='unsupported'>(object doesn't support inspect)</span>"
+    rescue Exception => e
+      binding.pry
+      "<span class='unsupported'>(exception #{CGI.escapeHTML(e.class.to_s)} was raised in inspect)</span>"
+    end
+
+    def inspect_raw_value(obj)
+      value = CGI.escapeHTML(obj.inspect)
+
+      if !BetterErrors.maximum_variable_inspect_size.nil? && value.length > BetterErrors.maximum_variable_inspect_size
+        value = "<span class='unsupported'>(object too large - modify #{CGI.escapeHTML(obj.class.to_s)}#inspect or raise BetterErrors.maximum_variable_inspect_size)</span>"
+      end
+
+      value
+    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/middleware.rb

@@ -0,0 +1,141 @@
+require "json"
+require "ipaddr"
+require "set"
+require "rack"
+
+module BetterErrors
+  # Better Errors' error handling middleware. Including this in your middleware
+  # stack will show a Better Errors error page for exceptions raised below this
+  # middleware.
+  #
+  # If you are using Ruby on Rails, you do not need to manually insert this
+  # middleware into your middleware stack.
+  #
+  # @example Sinatra
+  #   require "better_errors"
+  #
+  #   if development?
+  #     use BetterErrors::Middleware
+  #   end
+  #
+  # @example Rack
+  #   require "better_errors"
+  #   if ENV["RACK_ENV"] == "development"
+  #     use BetterErrors::Middleware
+  #   end
+  #
+  class Middleware
+    # The set of IP addresses that are allowed to access Better Errors.
+    #
+    # Set to `{ "127.0.0.1/8", "::1/128" }` by default.
+    ALLOWED_IPS = Set.new
+
+    # Adds an address to the set of IP addresses allowed to access Better
+    # Errors.
+    def self.allow_ip!(addr)
+      ALLOWED_IPS << IPAddr.new(addr)
+    end
+
+    allow_ip! "127.0.0.0/8"
+    allow_ip! "::1/128" rescue nil # windows ruby doesn't have ipv6 support
+
+    # A new instance of BetterErrors::Middleware
+    #
+    # @param app      The Rack app/middleware to wrap with Better Errors
+    # @param handler  The error handler to use.
+    def initialize(app, handler = ErrorPage)
+      @app      = app
+      @handler  = handler
+    end
+
+    # Calls the Better Errors middleware
+    #
+    # @param [Hash] env
+    # @return [Array]
+    def call(env)
+      if allow_ip? env
+        better_errors_call env
+      else
+        @app.call env
+      end
+    end
+
+  private
+
+    def allow_ip?(env)
+      request = Rack::Request.new(env)
+      return true unless request.ip and !request.ip.strip.empty?
+      ip = IPAddr.new request.ip.split("%").first
+      ALLOWED_IPS.any? { |subnet| subnet.include? ip }
+    end
+
+    def better_errors_call(env)
+      case env["PATH_INFO"]
+      when %r{/__better_errors/(?<id>.+?)/(?<method>\w+)\z}
+        internal_call env, $~
+      when %r{/__better_errors/?\z}
+        show_error_page env
+      else
+        protected_app_call env
+      end
+    end
+
+    def protected_app_call(env)
+      @app.call env
+    rescue Exception => ex
+      @error_page = @handler.new ex, env
+      log_exception
+      show_error_page(env, ex)
+    end
+
+    def show_error_page(env, exception=nil)
+      type, content = if @error_page
+        if text?(env)
+          [ 'plain', @error_page.render('text') ]
+        else
+          [ 'html', @error_page.render ]
+        end
+      else
+        [ 'html', no_errors_page ]
+      end
+
+      status_code = 500
+      if defined? ActionDispatch::ExceptionWrapper
+        status_code = ActionDispatch::ExceptionWrapper.new(env, exception).status_code
+      end
+
+      [status_code, { "Content-Type" => "text/#{type}; charset=utf-8" }, [content]]
+    end
+
+    def text?(env)
+      env["HTTP_X_REQUESTED_WITH"] == "XMLHttpRequest" ||
+      !env["HTTP_ACCEPT"].to_s.include?('html')
+    end
+
+    def log_exception
+      return unless BetterErrors.logger
+
+      message = "\n#{@error_page.exception_type} - #{@error_page.exception_message}:\n"
+      @error_page.backtrace_frames.each do |frame|
+        message << "  #{frame}\n"
+      end
+
+      BetterErrors.logger.fatal message
+    end
+
+    def internal_call(env, opts)
+      if opts[:id] != @error_page.id
+        return [200, { "Content-Type" => "text/plain; charset=utf-8" }, [JSON.dump(error: "Session expired")]]
+      end
+
+      env["rack.input"].rewind
+      response = @error_page.send("do_#{opts[:method]}", JSON.parse(env["rack.input"].read))
+      [200, { "Content-Type" => "text/plain; charset=utf-8" }, [JSON.dump(response)]]
+    end
+
+    def no_errors_page
+      "<h1>No errors</h1><p>No errors have been recorded yet.</p><hr>" +
+      "<code>Better Errors v#{BetterErrors::VERSION}</code>"
+    end
+  end
+end

data/lib/better_errors/rails.rb

@@ -0,0 +1,28 @@
+module BetterErrors
+  # @private
+  class Railtie < Rails::Railtie
+    initializer "better_errors.configure_rails_initialization" do
+      if use_better_errors?
+        insert_middleware
+        BetterErrors.logger = Rails.logger
+        BetterErrors.application_root = Rails.root.to_s
+      end
+    end
+
+    def insert_middleware
+      if defined? ActionDispatch::DebugExceptions
+        app.middleware.insert_after ActionDispatch::DebugExceptions, BetterErrors::Middleware
+      else
+        app.middleware.use BetterErrors::Middleware
+      end
+    end
+
+    def use_better_errors?
+      !Rails.env.production? and app.config.consider_all_requests_local
+    end
+
+    def app
+      Rails.application
+    end
+  end
+end

data/lib/better_errors/raised_exception.rb

@@ -0,0 +1,68 @@
+# @private
+module BetterErrors
+  class RaisedException
+    attr_reader :exception, :message, :backtrace
+
+    def initialize(exception)
+      if exception.respond_to?(:cause)
+        exception = exception.cause if exception.cause
+      elsif exception.respond_to?(:original_exception) && exception.original_exception
+        exception = exception.original_exception
+      end
+
+      @exception = exception
+      @message = exception.message
+
+      setup_backtrace
+      massage_syntax_error
+    end
+
+    def type
+      exception.class
+    end
+
+  private
+    def has_bindings?
+      exception.respond_to?(:__better_errors_bindings_stack) && exception.__better_errors_bindings_stack.any?
+    end
+
+    def setup_backtrace
+      if has_bindings?
+        setup_backtrace_from_bindings
+      else
+        setup_backtrace_from_backtrace
+      end
+    end
+
+    def setup_backtrace_from_bindings
+      @backtrace = exception.__better_errors_bindings_stack.map { |binding|
+        file = binding.eval "__FILE__"
+        line = binding.eval "__LINE__"
+        name = binding.frame_description
+        StackFrame.new(file, line, name, binding)
+      }
+    end
+
+    def setup_backtrace_from_backtrace
+      @backtrace = (exception.backtrace || []).map { |frame|
+        if /\A(?<file>.*?):(?<line>\d+)(:in `(?<name>.*)')?/ =~ frame
+          StackFrame.new(file, line.to_i, name)
+        end
+      }.compact
+    end
+
+    def massage_syntax_error
+      case exception.class.to_s
+      when "Haml::SyntaxError", "Sprockets::Coffeelint::Error"
+        if /\A(.+?):(\d+)/ =~ exception.backtrace.first
+          backtrace.unshift(StackFrame.new($1, $2.to_i, ""))
+        end
+      when "SyntaxError"
+        if /\A(.+?):(\d+): (.*)/m =~ exception.message
+          backtrace.unshift(StackFrame.new($1, $2.to_i, ""))
+          @message = $3
+        end
+      end
+    end
+  end
+end

data/lib/better_errors/repl.rb

@@ -0,0 +1,30 @@
+module BetterErrors
+  # @private
+  module REPL
+    PROVIDERS = [
+        { impl:   "better_errors/repl/basic",
+          const:  :Basic },
+      ]
+
+    def self.provider
+      @provider ||= const_get detect[:const]
+    end
+
+    def self.provider=(prov)
+      @provider = prov
+    end
+
+    def self.detect
+      PROVIDERS.find { |prov|
+        test_provider prov
+      }
+    end
+
+    def self.test_provider(provider)
+      require provider[:impl]
+      true
+    rescue LoadError
+      false
+    end
+  end
+end