honeybadger 4.5.2 → 4.5.3

data/vendor/bundle/ruby/2.6.0/gems/notiffany-0.1.1/lib/notiffany/notifier/tmux/session.rb

@@ -0,0 +1,40 @@
+module Notiffany
+  class Notifier
+    class Tmux < Base
+      # Preserves TMux settings for all tmux sessions
+      class Session
+        def initialize
+          @options_store = {}
+
+          # NOTE: we are reading the settings of all clients
+          # - regardless of the :display_on_all_clients option
+
+          # Ideally, this should be done incrementally (e.g. if we start with
+          # "current" client and then override the :display_on_all_clients to
+          # true, only then the option store should be updated to contain
+          # settings of all clients
+          Client.new(:all).clients.each do |client|
+            @options_store[client] = {
+              "status-left-bg"  => nil,
+              "status-right-bg" => nil,
+              "status-left-fg"  => nil,
+              "status-right-fg" => nil,
+              "message-bg"      => nil,
+              "message-fg"      => nil,
+              "display-time"    => nil
+            }.merge(Client.new(client).parse_options)
+          end
+        end
+
+        def close
+          @options_store.each do |client, options|
+            options.each do |key, value|
+              Client.new(client).unset(key, value)
+            end
+          end
+          @options_store = nil
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/notiffany-0.1.1/lib/notiffany/version.rb

@@ -0,0 +1,3 @@
+module Notiffany
+  VERSION = "0.1.1"
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.12.2/lib/pry.rb

@@ -0,0 +1,132 @@
+require 'pp'
+require 'pry/forwardable'
+require 'pry/input_lock'
+require 'pry/exceptions'
+require 'pry/platform'
+require 'pry/helpers/base_helpers'
+require 'pry/hooks'
+
+class Pry
+  # The default hooks - display messages when beginning and ending Pry sessions.
+  DEFAULT_HOOKS = Pry::Hooks.new.add_hook(:before_session, :default) do |out, target, _pry_|
+    next if _pry_.quiet?
+
+    _pry_.run_command("whereami --quiet")
+  end
+
+  # The default print
+  DEFAULT_PRINT = proc do |output, value, _pry_|
+    _pry_.pager.open do |pager|
+      pager.print _pry_.config.output_prefix
+      Pry::ColorPrinter.pp(value, pager, Pry::Terminal.width! - 1)
+    end
+  end
+
+  # may be convenient when working with enormous objects and
+  # pretty_print is too slow
+  SIMPLE_PRINT = proc do |output, value|
+    begin
+      output.puts value.inspect
+    rescue RescuableException
+      output.puts "unknown"
+    end
+  end
+
+  # useful when playing with truly enormous objects
+  CLIPPED_PRINT = proc do |output, value|
+    output.puts Pry.view_clip(value, id: true)
+  end
+
+  # Will only show the first line of the backtrace
+  DEFAULT_EXCEPTION_HANDLER = proc do |output, exception, _|
+    if UserError === exception && SyntaxError === exception
+      output.puts "SyntaxError: #{exception.message.sub(/.*syntax error, */m, '')}"
+    else
+      output.puts "#{exception.class}: #{exception.message}"
+      output.puts "from #{exception.backtrace.first}"
+
+      if exception.respond_to? :cause
+        cause = exception.cause
+        while cause
+          output.puts "Caused by #{cause.class}: #{cause}\n"
+          output.puts "from #{cause.backtrace.first}"
+          cause = cause.cause
+        end
+      end
+    end
+  end
+
+  # Deal with the ^D key being pressed. Different behaviour in different cases:
+  #   1. In an expression behave like `!` command.
+  #   2. At top-level session behave like `exit` command.
+  #   3. In a nested session behave like `cd ..`.
+  DEFAULT_CONTROL_D_HANDLER = proc do |eval_string, _pry_|
+    if !eval_string.empty?
+      eval_string.replace('') # Clear input buffer.
+    elsif _pry_.binding_stack.one?
+      _pry_.binding_stack.clear
+      throw(:breakout)
+    else
+      # Otherwise, saves current binding stack as old stack and pops last
+      # binding out of binding stack (the old stack still has that binding).
+      _pry_.command_state["cd"] ||= Pry::Config.from_hash({}) # FIXME
+      _pry_.command_state['cd'].old_stack = _pry_.binding_stack.dup
+      _pry_.binding_stack.pop
+    end
+  end
+
+  DEFAULT_SYSTEM = proc do |output, cmd, _|
+    if !system(cmd)
+      output.puts "Error: there was a problem executing system command: #{cmd}"
+    end
+  end
+
+  # This is to keep from breaking under Rails 3.2 for people who are doing that
+  # IRB = Pry thing.
+  module ExtendCommandBundle; end
+end
+
+require 'method_source'
+require 'shellwords'
+require 'stringio'
+require 'strscan'
+require 'coderay'
+require 'pry/slop'
+require 'rbconfig'
+require 'tempfile'
+require 'pathname'
+
+require 'pry/version'
+require 'pry/repl'
+require 'pry/code'
+require 'pry/ring'
+require 'pry/helpers'
+require 'pry/code_object'
+require 'pry/method'
+require 'pry/wrapped_module'
+require 'pry/history'
+require 'pry/command'
+require 'pry/command_set'
+require 'pry/commands'
+require 'pry/plugins'
+require 'pry/core_extensions'
+require 'pry/basic_object'
+require 'pry/config/behavior'
+require 'pry/config/memoization'
+require 'pry/config/default'
+require 'pry/config/convenience'
+require 'pry/config'
+require 'pry/pry_class'
+require 'pry/pry_instance'
+require 'pry/cli'
+require 'pry/color_printer'
+require 'pry/pager'
+require 'pry/terminal'
+require 'pry/editor'
+require 'pry/rubygem'
+require "pry/indent"
+require "pry/last_exception"
+require "pry/prompt"
+require "pry/inspector"
+require 'pry/object_path'
+require 'pry/output'

data/vendor/bundle/ruby/2.6.0/gems/pry-0.12.2/lib/pry/basic_object.rb

@@ -0,0 +1,6 @@
+class Pry::BasicObject < BasicObject
+  [:Kernel, :Pry].each do |constant|
+    const_set constant, ::Object.const_get(constant)
+  end
+  include Kernel
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.12.2/lib/pry/cli.rb

@@ -0,0 +1,218 @@
+class Pry
+  # Manage the processing of command line options
+  class CLI
+    NoOptionsError = Class.new(StandardError)
+
+    class << self
+      # @return [Proc] The Proc defining the valid command line options.
+      attr_accessor :options
+
+      # @return [Array] The Procs that process the parsed options. Plugins can
+      #   utilize this facility in order to add and process their own Pry
+      #   options.
+      attr_accessor :option_processors
+
+      # @return [Array<String>] The input array of strings to process
+      #   as CLI options.
+      attr_accessor :input_args
+
+      # Add another set of CLI options (a Pry::Slop block)
+      def add_options(&block)
+        if options
+          old_options = options
+          self.options = proc do
+            instance_exec(&old_options)
+            instance_exec(&block)
+          end
+        else
+          self.options = block
+        end
+
+        self
+      end
+
+      # Bring in options defined in plugins
+      def add_plugin_options
+        Pry.plugins.values.each do |plugin|
+          plugin.load_cli_options
+        end
+
+        self
+      end
+
+      # Add a block responsible for processing parsed options.
+      def add_option_processor(&block)
+        self.option_processors ||= []
+        option_processors << block
+
+        self
+      end
+
+      # Clear `options` and `option_processors`
+      def reset
+        self.options           = nil
+        self.option_processors = nil
+      end
+
+      def parse_options(args = ARGV)
+        unless options
+          raise NoOptionsError, "No command line options defined! Use Pry::CLI.add_options to add command line options."
+        end
+
+        self.input_args = args
+
+        begin
+          opts = Pry::Slop.parse!(
+            args,
+            help: true,
+            multiple_switches: false,
+            strict: true,
+            &options
+          )
+        rescue Pry::Slop::InvalidOptionError
+          # Display help message on unknown switches and exit.
+          puts Pry::Slop.new(&options)
+          exit
+        end
+
+        Pry.initial_session_setup
+        Pry.final_session_setup
+
+        # Option processors are optional.
+        if option_processors
+          option_processors.each { |processor| processor.call(opts) }
+        end
+
+        opts
+      end
+
+      def start(opts)
+        exit if opts.help?
+
+        # invoked via cli
+        Pry.cli = true
+
+        # create the actual context
+        if opts[:context]
+          Pry.initial_session_setup
+          context = Pry.binding_for(eval(opts[:context]))
+          Pry.final_session_setup
+        else
+          context = Pry.toplevel_binding
+        end
+
+        if Pry::CLI.input_args.any? && Pry::CLI.input_args != ["pry"]
+          full_name = File.expand_path(Pry::CLI.input_args.first)
+          Pry.load_file_through_repl(full_name)
+          exit
+        end
+
+        # Start the session (running any code passed with -e, if there is any)
+        Pry.start(context, input: StringIO.new(Pry.config.exec_string))
+      end
+    end
+
+    reset
+  end
+end
+
+# Bring in options defined by plugins
+Pry::Slop.new do
+  on "no-plugins" do
+    Pry.config.should_load_plugins = false
+  end
+end.parse(ARGV.dup)
+
+if Pry.config.should_load_plugins
+  Pry::CLI.add_plugin_options
+end
+
+# The default Pry command line options (before plugin options are included)
+Pry::CLI.add_options do
+  banner(
+    "Usage: pry [OPTIONS]\n" \
+    "Start a Pry session.\n" \
+    "See http://pryrepl.org/ for more information.\n"
+  )
+
+  on :e, :exec=, "A line of code to execute in context before the session starts" do |input|
+    Pry.config.exec_string += "\n" if Pry.config.exec_string.length > 0
+    Pry.config.exec_string += input
+  end
+
+  on "no-pager", "Disable pager for long output" do
+    Pry.config.pager = false
+  end
+
+  on "no-history", "Disable history loading" do
+    Pry.config.history.should_load = false
+  end
+
+  on "no-color", "Disable syntax highlighting for session" do
+    Pry.config.color = false
+  end
+
+  on :f, "Suppress loading of pryrc" do
+    Pry.config.should_load_rc = false
+    Pry.config.should_load_local_rc = false
+  end
+
+  on :s, "select-plugin=", "Only load specified plugin (and no others)." do |plugin_name|
+    Pry.config.should_load_plugins = false
+    Pry.plugins[plugin_name].activate!
+  end
+
+  on :d, "disable-plugin=", "Disable a specific plugin." do |plugin_name|
+    Pry.plugins[plugin_name].disable!
+  end
+
+  on "no-plugins", "Suppress loading of plugins." do
+    Pry.config.should_load_plugins = false
+  end
+
+  on "plugins", "List installed plugins." do
+    puts "Installed Plugins:"
+    puts "--"
+    Pry.locate_plugins.each do |plugin|
+      puts "#{plugin.name}".ljust(18) << plugin.spec.summary
+    end
+    exit
+  end
+
+  on "simple-prompt", "Enable simple prompt mode" do
+    Pry.config.prompt = Pry::Prompt[:simple][:value]
+  end
+
+  on "noprompt", "No prompt mode" do
+    Pry.config.prompt = Pry::Prompt[:none][:value]
+  end
+
+  on :r, :require=, "`require` a Ruby script at startup" do |file|
+    Pry.config.requires << file
+  end
+
+  on :I=, "Add a path to the $LOAD_PATH", as: Array, delimiter: ":" do |load_path|
+    load_path.map! do |path|
+      /\A\.\// =~ path ? path : File.expand_path(path)
+    end
+
+    $LOAD_PATH.unshift(*load_path)
+  end
+
+  on "gem", "Shorthand for -I./lib -rgemname" do |load_path|
+    $LOAD_PATH.unshift("./lib")
+    Dir["./lib/*.rb"].each do |file|
+      Pry.config.requires << file
+    end
+  end
+
+  on :v, :version, "Display the Pry version" do
+    puts "Pry version #{Pry::VERSION} on Ruby #{RUBY_VERSION}"
+    exit
+  end
+
+  on(:c, :context=,
+     "Start the session in the specified context. Equivalent to `context.pry` in a session.",
+     default: "Pry.toplevel_binding"
+     )
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.12.2/lib/pry/code.rb

@@ -0,0 +1,353 @@
+require 'pry/code/loc'
+require 'pry/code/code_range'
+require 'pry/code/code_file'
+
+class Pry
+  class << self
+    # Convert the given object into an instance of `Pry::Code`, if it isn't
+    # already one.
+    #
+    # @param [Code, Method, UnboundMethod, Proc, Pry::Method, String, Array,
+    #   IO] obj
+    def Code(obj)
+      case obj
+      when Code
+        obj
+      when ::Method, UnboundMethod, Proc, Pry::Method
+        Code.from_method(obj)
+      else
+        Code.new(obj)
+      end
+    end
+  end
+
+  # `Pry::Code` is a class that encapsulates lines of source code and their
+  # line numbers and formats them for terminal output. It can read from a file
+  # or method definition or be instantiated with a `String` or an `Array`.
+  #
+  # In general, the formatting methods in `Code` return a new `Code` object
+  # which will format the text as specified when `#to_s` is called. This allows
+  # arbitrary chaining of formatting methods without mutating the original
+  # object.
+  class Code
+    class << self
+      include MethodSource::CodeHelpers
+
+      # Instantiate a `Code` object containing code loaded from a file or
+      # Pry's line buffer.
+      #
+      # @param [String] filename The name of a file, or "(pry)".
+      # @param [Symbol] code_type The type of code the file contains.
+      # @return [Code]
+      def from_file(filename, code_type = nil)
+        code_file = CodeFile.new(filename, code_type)
+        new(code_file.code, 1, code_file.code_type)
+      end
+
+      # Instantiate a `Code` object containing code extracted from a
+      # `::Method`, `UnboundMethod`, `Proc`, or `Pry::Method` object.
+      #
+      # @param [::Method, UnboundMethod, Proc, Pry::Method] meth The method
+      #   object.
+      # @param [Integer, nil] start_line The line number to start on, or nil to
+      #   use the method's original line numbers.
+      # @return [Code]
+      def from_method(meth, start_line = nil)
+        meth = Pry::Method(meth)
+        start_line ||= meth.source_line || 1
+        new(meth.source, start_line, meth.source_type)
+      end
+
+      # Attempt to extract the source code for module (or class) `mod`.
+      #
+      # @param [Module, Class] mod The module (or class) of interest.
+      # @param [Integer] candidate_rank The module candidate (by rank)
+      #   to use (see `Pry::WrappedModule::Candidate` for more information).
+      # @param [Integer, nil] start_line The line number to start on, or nil to
+      #   use the method's original line numbers.
+      # @return [Code]
+      def from_module(mod, candidate_rank = 0, start_line = nil)
+        candidate = Pry::WrappedModule(mod).candidate(candidate_rank)
+        start_line ||= candidate.line
+        new(candidate.source, start_line, :ruby)
+      end
+    end
+
+    # @return [Symbol] The type of code stored in this wrapper.
+    attr_accessor :code_type
+
+    # Instantiate a `Code` object containing code from the given `Array`,
+    # `String`, or `IO`. The first line will be line 1 unless specified
+    # otherwise. If you need non-contiguous line numbers, you can create an
+    # empty `Code` object and then use `#push` to insert the lines.
+    #
+    # @param [Array<String>, String, IO] lines
+    # @param [Integer?] start_line
+    # @param [Symbol?] code_type
+    def initialize(lines = [], start_line = 1, code_type = :ruby)
+      if lines.is_a? String
+        lines = lines.lines
+      end
+      @lines = lines.each_with_index.map { |line, lineno|
+        LOC.new(line, lineno + start_line.to_i) }
+      @code_type = code_type
+
+      @with_marker = @with_indentation = @with_line_numbers = nil
+    end
+
+    # Append the given line. +lineno+ is one more than the last existing
+    # line, unless specified otherwise.
+    #
+    # @param [String] line
+    # @param [Integer?] lineno
+    # @return [String] The inserted line.
+    def push(line, lineno = nil)
+      if lineno.nil?
+        lineno = @lines.last.lineno + 1
+      end
+      @lines.push(LOC.new(line, lineno))
+      line
+    end
+    alias << push
+
+    # Filter the lines using the given block.
+    #
+    # @yield [LOC]
+    # @return [Code]
+    def select(&block)
+      alter do
+        @lines = @lines.select(&block)
+      end
+    end
+
+    # Remove all lines that aren't in the given range, expressed either as a
+    # `Range` object or a first and last line number (inclusive). Negative
+    # indices count from the end of the array of lines.
+    #
+    # @param [Range, Integer] start_line
+    # @param [Integer?] end_line
+    # @return [Code]
+    def between(start_line, end_line = nil)
+      return self unless start_line
+
+      code_range = CodeRange.new(start_line, end_line)
+
+      alter do
+        @lines = @lines[code_range.indices_range(@lines)] || []
+      end
+    end
+
+    # Take `num_lines` from `start_line`, forward or backwards.
+    #
+    # @param [Integer] start_line
+    # @param [Integer] num_lines
+    # @return [Code]
+    def take_lines(start_line, num_lines)
+      start_idx =
+        if start_line >= 0
+          @lines.index { |loc| loc.lineno >= start_line } || @lines.length
+        else
+          [@lines.length + start_line, 0].max
+        end
+
+      alter do
+        @lines = @lines.slice(start_idx, num_lines)
+      end
+    end
+
+    # Remove all lines except for the +lines+ up to and excluding +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def before(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno >= lineno - lines && loc.lineno < lineno
+      end
+    end
+
+    # Remove all lines except for the +lines+ on either side of and including
+    # +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def around(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno >= lineno - lines && loc.lineno <= lineno + lines
+      end
+    end
+
+    # Remove all lines except for the +lines+ after and excluding +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def after(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno > lineno && loc.lineno <= lineno + lines
+      end
+    end
+
+    # Remove all lines that don't match the given `pattern`.
+    #
+    # @param [Regexp] pattern
+    # @return [Code]
+    def grep(pattern)
+      return self unless pattern
+
+      pattern = Regexp.new(pattern)
+
+      select do |loc|
+        loc.line =~ pattern
+      end
+    end
+
+    # Format output with line numbers next to it, unless `y_n` is falsy.
+    #
+    # @param [Boolean?] y_n
+    # @return [Code]
+    def with_line_numbers(y_n = true)
+      alter do
+        @with_line_numbers = y_n
+      end
+    end
+
+    # Format output with a marker next to the given +lineno+, unless +lineno+ is
+    # falsy.
+    #
+    # @param [Integer?] lineno
+    # @return [Code]
+    def with_marker(lineno = 1)
+      alter do
+        @with_marker   = !!lineno
+        @marker_lineno = lineno
+      end
+    end
+
+    # Format output with the specified number of spaces in front of every line,
+    # unless `spaces` is falsy.
+    #
+    # @param [Integer?] spaces
+    # @return [Code]
+    def with_indentation(spaces = 0)
+      alter do
+        @with_indentation = !!spaces
+        @indentation_num  = spaces
+      end
+    end
+
+    # @return [String]
+    def inspect
+      Object.instance_method(:to_s).bind(self).call
+    end
+
+    # @return [Integer] the number of digits in the last line.
+    def max_lineno_width
+      @lines.length > 0 ? @lines.last.lineno.to_s.length : 0
+    end
+
+    # @return [String] a formatted representation (based on the configuration of
+    #   the object).
+    def to_s
+      print_to_output("", false)
+    end
+
+    # @return [String] a (possibly highlighted) copy of the source code.
+    def highlighted
+      print_to_output("", true)
+    end
+
+    # Writes a formatted representation (based on the configuration of the
+    # object) to the given output, which must respond to `#<<`.
+    def print_to_output(output, color = false)
+      @lines.each do |loc|
+        loc = loc.dup
+        loc.colorize(@code_type)              if color
+        loc.add_line_number(max_lineno_width, color) if @with_line_numbers
+        loc.add_marker(@marker_lineno)        if @with_marker
+        loc.indent(@indentation_num)          if @with_indentation
+        output << loc.line
+        output << "\n"
+      end
+      output
+    end
+
+    # Get the comment that describes the expression on the given line number.
+    #
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def comment_describing(line_number)
+      self.class.comment_describing(raw, line_number)
+    end
+
+    # Get the multiline expression that starts on the given line number.
+    #
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def expression_at(line_number, consume = 0)
+      self.class.expression_at(raw, line_number, consume: consume)
+    end
+
+    # Get the (approximate) Module.nesting at the give line number.
+    #
+    # @param [Integer] line_number line number starting from 1
+    # @return [Array<Module>] a list of open modules.
+    def nesting_at(line_number)
+      Pry::Indent.nesting_at(raw, line_number)
+    end
+
+    # Return an unformatted String of the code.
+    #
+    # @return [String]
+    def raw
+      @lines.map(&:line).join("\n") << "\n"
+    end
+
+    # Return the number of lines stored.
+    #
+    # @return [Integer]
+    def length
+      @lines ? @lines.length : 0
+    end
+
+    # Two `Code` objects are equal if they contain the same lines with the same
+    # numbers. Otherwise, call `to_s` and `chomp` and compare as Strings.
+    #
+    # @param [Code, Object] other
+    # @return [Boolean]
+    def ==(other)
+      if other.is_a?(Code)
+        other_lines = other.instance_variable_get(:@lines)
+        @lines.each_with_index.all? { |loc, i| loc == other_lines[i] }
+      else
+        to_s.chomp == other.to_s.chomp
+      end
+    end
+
+    # Forward any missing methods to the output of `#to_s`.
+    def method_missing(name, *args, &block)
+      to_s.send(name, *args, &block)
+    end
+    undef =~
+
+    # Check whether String responds to missing methods.
+    def respond_to_missing?(name, include_all = false)
+      ''.respond_to?(name, include_all)
+    end
+
+    protected
+
+    # An abstraction of the `dup.instance_eval` pattern used throughout this
+    # class.
+    def alter(&block)
+      dup.tap { |o| o.instance_eval(&block) }
+    end
+  end
+end