better_errors-creditkudos 2.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2a6d2b9e47dea68238e091ce6321912938bfd39
+  data.tar.gz: ba2cbaed992e4cd2f24ac099c1bfad1b3ac81926
+SHA512:
+  metadata.gz: 1e814e90c2024718b0369fa1e703d90f0d623fd0a6926388c0a5b98b220a2c67880ec3254a966b951dbdf0109bdc76f6de82ec2cdfc2af5d4fd45e8567827362
+  data.tar.gz: 2da774b33b1310bc8754072fa5cc61705eae2ab1f5cf1e9f695f99cda6355264added72b5935a8be76df9de6d35cb8cbcd4195e0b545e83b08af13a3fa971cd1

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+/tmp
+/Gemfile.lock
+/coverage
+/.yardoc
+/doc
+/.bundle
+/vendor/gems

data/.travis.yml

@@ -0,0 +1,8 @@
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.1

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --no-private

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+
+See https://github.com/charliesome/better_errors/releases

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "rake"
+gem "rack", "1.6.4"
+gem "rspec", "2.14.1"
+gem "binding_of_caller", platforms: :ruby
+gem "pry", "0.9.12"
+gem "yard"
+gem "kramdown"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012-2016 Charlie Somerville
+
+MIT License
+
+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,128 @@
+# Better Errors [![Gem Version](https://img.shields.io/gem/v/better_errors.svg)](https://rubygems.org/gems/better_errors) [![Build Status](https://travis-ci.org/charliesome/better_errors.svg)](https://travis-ci.org/charliesome/better_errors) [![Code Climate](https://img.shields.io/codeclimate/github/charliesome/better_errors.svg)](https://codeclimate.com/github/charliesome/better_errors)
+
+Better Errors replaces the standard Rails error page with a much better and more useful error page. It is also usable outside of Rails in any Rack app as Rack middleware.
+
+![image](https://i.imgur.com/6zBGAAb.png)
+
+## Features
+
+* Full stack trace
+* Source code inspection for all stack frames (with highlighting)
+* Local and instance variable inspection
+* Live REPL on every stack frame
+
+## Installation
+
+Add this to your Gemfile:
+
+```ruby
+group :development do
+  gem "better_errors"
+end
+```
+
+If you would like to use Better Errors' **advanced features** (REPL, local/instance variable inspection, pretty stack frame names), you need to add the [`binding_of_caller`](https://github.com/banister/binding_of_caller) gem by [@banisterfiend](https://twitter.com/banisterfiend) to your Gemfile:
+
+```ruby
+gem "binding_of_caller"
+```
+
+This is an optional dependency however, and Better Errors will work without it.
+
+_Note: If you discover that Better Errors isn't working - particularly after upgrading from version 0.5.0 or less - be sure to set `config.consider_all_requests_local = true` in `config/environments/development.rb`._
+
+## Security
+
+**NOTE:** It is *critical* you put better\_errors in the **development** section. **Do NOT run better_errors in production, or on Internet facing hosts.**
+
+You will notice that the only machine that gets the Better Errors page is localhost, which means you get the default error page if you are developing on a remote host (or a virtually remote host, such as a Vagrant box). Obviously, the REPL is not something you want to expose to the public, but there may also be other pieces of sensitive information available in the backtrace.
+
+To poke selective holes in this security mechanism, you can add a line like this to your startup (for example, on Rails it would be `config/environments/development.rb`)
+
+```ruby
+BetterErrors::Middleware.allow_ip! ENV['TRUSTED_IP'] if ENV['TRUSTED_IP']
+```
+
+Then run Rails like this:
+
+```shell
+TRUSTED_IP=66.68.96.220 rails s
+```
+
+Note that the `allow_ip!` is actually backed by a `Set`, so you can add more than one IP address or subnet.
+
+**Tip:** You can find your apparent IP by hitting the old error page's "Show env dump" and looking at "REMOTE_ADDR".
+
+**VirtualBox:** If you are using VirtualBox and are accessing the guest from your host's browser, you will need to use `allow_ip!` to see the error page.
+
+## Usage
+
+If you're using Rails, there's nothing else you need to do.
+
+If you're not using Rails, you need to insert `BetterErrors::Middleware` into your middleware stack, and optionally set `BetterErrors.application_root` if you'd like Better Errors to abbreviate filenames within your application.
+
+Here's an example using Sinatra:
+
+```ruby
+require "sinatra"
+require "better_errors"
+
+configure :development do
+  use BetterErrors::Middleware
+  BetterErrors.application_root = __dir__
+end
+
+get "/" do
+  raise "oops"
+end
+```
+
+### Plain text
+
+Better Errors will render a plain text error page  when the request is an
+`XMLHttpRequest` or when the `Accept` header does *not* include 'html'.
+
+### Unicorn, Puma, and other multi-worker servers
+
+Better Errors works by leaving a lot of context in server process memory. If
+you're using a web server that runs multiple "workers" it's likely that a second
+request (as happens when you click on a stack frame) will hit a different
+worker. That worker won't have the necessary context in memory, and you'll see
+a `Session Expired` message.
+
+If this is the case for you, consider turning the number of workers to one (1)
+in `development`. Another option would be to use Webrick, Mongrel, Thin,
+or another single-process server as your `rails server`, when you are trying
+to troubleshoot an issue in development.
+
+##Specify editor to open files in
+
+```ruby
+# e.g. in config/initializers/better_errors.rb
+# Other preset values are [:mvim, :macvim, :textmate, :txmt, :tm, :sublime, :subl, :st]
+BetterErrors.editor = :mvim
+```
+
+
+##Set maximum variable size for inspector.
+
+```ruby
+# e.g. in config/initializers/better_errors.rb
+# This will stop BetterErrors from trying to render larger objects, which can cause
+# slow loading times and browser performance problems.
+# default value: 100_000
+BetterErrors.maximum_variable_inspect_size = 100_000
+```
+
+
+## Get in touch!
+
+If you're using better_errors, I'd love to hear from you. Drop me a line and tell me what you think!
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+namespace :test do
+  RSpec::Core::RakeTask.new(:with_binding_of_caller)
+
+  without_task = RSpec::Core::RakeTask.new(:without_binding_of_caller)
+  without_task.ruby_opts = "-I spec -r without_binding_of_caller"
+
+  task :all => [:with_binding_of_caller, :without_binding_of_caller]
+end
+
+task :default => "test:all"

data/better_errors-creditkudos.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'better_errors/version'
+
+Gem::Specification.new do |s|
+  s.name          = "better_errors-creditkudos"
+  s.version       = BetterErrors::VERSION
+  s.authors       = ["Charlie Somerville"]
+  s.email         = ["charlie@charliesomerville.com"]
+  s.description   = %q{Temporary fork of better_errors with some performance improvements.}
+  s.summary       = %q{Temporary fork of better_errors with some performance improvements.}
+  s.homepage      = "https://github.com/creditkudos/better_errors"
+  s.license       = "MIT"
+
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = ">= 2.0.0"
+
+  s.add_dependency "erubis", ">= 2.6.6"
+  s.add_dependency "coderay", ">= 1.0.0"
+  s.add_dependency "rack", ">= 0.9.0"
+
+  # optional dependencies:
+  # s.add_dependency "binding_of_caller"
+  # s.add_dependency "pry"
+end

data/lib/better_errors.rb

@@ -0,0 +1,152 @@
+require "pp"
+require "erubis"
+require "coderay"
+require "uri"
+
+require "better_errors/code_formatter"
+require "better_errors/error_page"
+require "better_errors/middleware"
+require "better_errors/raised_exception"
+require "better_errors/repl"
+require "better_errors/stack_frame"
+require "better_errors/version"
+
+module BetterErrors
+  POSSIBLE_EDITOR_PRESETS = [
+    { symbols: [:emacs, :emacsclient],  sniff: /emacs/i, url: "emacs://open?url=file://%{file}&line=%{line}" },
+    { symbols: [:macvim, :mvim],        sniff: /vim/i,   url: proc { |file, line| "mvim://open?url=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}" },
+  ]
+
+  class << self
+    # The path to the root of the application. Better Errors uses this property
+    # to determine if a file in a backtrace should be considered an application
+    # frame. If you are using Better Errors with Rails, you do not need to set
+    # this attribute manually.
+    #
+    # @return [String]
+    attr_accessor :application_root
+
+    # The logger to use when logging exception details and backtraces. If you
+    # are using Better Errors with Rails, you do not need to set this attribute
+    # manually. If this attribute is `nil`, nothing will be logged.
+    #
+    # @return [Logger, nil]
+    attr_accessor :logger
+
+    # @private
+    attr_accessor :binding_of_caller_available
+
+    # @private
+    alias_method :binding_of_caller_available?, :binding_of_caller_available
+
+    # The ignored instance variables.
+    # @return [Array]
+    attr_accessor :ignored_instance_variables
+
+    # The maximum variable payload size. If variable.inspect exceeds this,
+    # the variable won't be returned.
+    # @return int
+    attr_accessor :maximum_variable_inspect_size
+  end
+  @ignored_instance_variables = []
+
+  # Returns a proc, which when called with a filename and line number argument,
+  # returns a URL to open the filename and line in the selected editor.
+  #
+  # Generates TextMate URLs by default.
+  #
+  #   BetterErrors.editor["/some/file", 123]
+  #     # => txmt://open?url=file:///some/file&line=123
+  #
+  # @return [Proc]
+  def self.editor
+    @editor
+  end
+
+  # Configures how Better Errors generates open-in-editor URLs.
+  #
+  # @overload BetterErrors.editor=(sym)
+  #   Uses one of the preset editor configurations. Valid symbols are:
+  #
+  #   * `:textmate`, `:txmt`, `:tm`
+  #   * `:sublime`, `:subl`, `:st`
+  #   * `:macvim`
+  #
+  #   @param [Symbol] sym
+  #
+  # @overload BetterErrors.editor=(str)
+  #   Uses `str` as the format string for generating open-in-editor URLs.
+  #
+  #   Use `%{file}` and `%{line}` as placeholders for the actual values.
+  #
+  #   @example
+  #     BetterErrors.editor = "my-editor://open?url=%{file}&line=%{line}"
+  #
+  #   @param [String] str
+  #
+  # @overload BetterErrors.editor=(proc)
+  #   Uses `proc` to generate open-in-editor URLs. The proc will be called
+  #   with `file` and `line` parameters when a URL needs to be generated.
+  #
+  #   Your proc should take care to escape `file` appropriately with
+  #   `URI.encode_www_form_component` (please note that `URI.escape` is **not**
+  #   a suitable substitute.)
+  #
+  #   @example
+  #     BetterErrors.editor = proc { |file, line|
+  #       "my-editor://open?url=#{URI.encode_www_form_component file}&line=#{line}"
+  #     }
+  #
+  #   @param [Proc] proc
+  #
+  def self.editor=(editor)
+    POSSIBLE_EDITOR_PRESETS.each do |config|
+      if config[:symbols].include?(editor)
+        return self.editor = config[:url]
+      end
+    end
+
+    if editor.is_a? String
+      self.editor = proc { |file, line| editor % { file: URI.encode_www_form_component(file), line: line } }
+    else
+      if editor.respond_to? :call
+        @editor = editor
+      else
+        raise TypeError, "Expected editor to be a valid editor key, a format string or a callable."
+      end
+    end
+  end
+
+  # Enables experimental Pry support in the inline REPL
+  #
+  # If you encounter problems while using Pry, *please* file a bug report at
+  # https://github.com/charliesome/better_errors/issues
+  def self.use_pry!
+    REPL::PROVIDERS.unshift const: :Pry, impl: "better_errors/repl/pry"
+  end
+
+  # Automatically sniffs a default editor preset based on the EDITOR
+  # environment variable.
+  #
+  # @return [Symbol]
+  def self.default_editor
+    POSSIBLE_EDITOR_PRESETS.detect(-> { {} }) { |config|
+      ENV["EDITOR"] =~ config[:sniff]
+    }[:url] || :textmate
+  end
+
+  BetterErrors.editor = default_editor
+end
+
+begin
+  require "binding_of_caller"
+  require "better_errors/exception_extension"
+  BetterErrors.binding_of_caller_available = true
+  BetterErrors.maximum_variable_inspect_size ||= 100_000
+rescue LoadError
+  BetterErrors.binding_of_caller_available = false
+end
+
+require "better_errors/rails" if defined? Rails::Railtie

data/lib/better_errors/code_formatter.rb

@@ -0,0 +1,63 @@
+module BetterErrors
+  # @private
+  class CodeFormatter
+    require "better_errors/code_formatter/html"
+    require "better_errors/code_formatter/text"
+
+    FILE_TYPES = {
+      ".rb"   => :ruby,
+      ""      => :ruby,
+      ".html" => :html,
+      ".erb"  => :erb,
+      ".haml" => :haml
+    }
+
+    attr_reader :filename, :line, :context
+
+    def initialize(filename, line, context = 5)
+      @filename = filename
+      @line     = line
+      @context  = context
+    end
+
+    def output
+      formatted_code
+    rescue Errno::ENOENT, Errno::EINVAL
+      source_unavailable
+    end
+
+    def formatted_code
+      formatted_lines.join
+    end
+
+    def coderay_scanner
+      ext = File.extname(filename)
+      FILE_TYPES[ext] || :text
+    end
+
+    def each_line_of(lines, &blk)
+      line_range.zip(lines).map { |current_line, str|
+        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
+      min..max
+    end
+  end
+end