honeybadger 5.2.1 → 5.3.0

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/context.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "frame"
+require_relative "helpers/path"
+require_relative "helpers/file"
+require_relative "processors/command_processor"
+
+module Byebug
+  #
+  # Mantains context information for the debugger and it's the main
+  # communication point between the library and the C-extension through the
+  # at_breakpoint, at_catchpoint, at_tracing, at_line and at_return callbacks
+  #
+  class Context
+    include Helpers::FileHelper
+
+    class << self
+      include Helpers::PathHelper
+
+      attr_writer :ignored_files
+
+      #
+      # List of files byebug will ignore while debugging
+      #
+      def ignored_files
+        @ignored_files ||=
+          Byebug.mode == :standalone ? lib_files + [bin_file] : lib_files
+      end
+
+      attr_writer :interface
+
+      def interface
+        @interface ||= LocalInterface.new
+      end
+
+      attr_writer :processor
+
+      def processor
+        @processor ||= CommandProcessor
+      end
+    end
+
+    #
+    # Reader for the current frame
+    #
+    def frame
+      @frame ||= Frame.new(self, 0)
+    end
+
+    #
+    # Writer for the current frame
+    #
+    def frame=(pos)
+      @frame = Frame.new(self, pos)
+    end
+
+    extend Forwardable
+    def_delegators :frame, :file, :line
+
+    #
+    # Current file & line information
+    #
+    def location
+      "#{normalize(file)}:#{line}"
+    end
+
+    #
+    # Current file, line and source code information
+    #
+    def full_location
+      return location if virtual_file?(file)
+
+      "#{location} #{get_line(file, line)}"
+    end
+
+    #
+    # Context's stack size
+    #
+    def stack_size
+      return 0 unless backtrace
+
+      backtrace.drop_while { |l| ignored_file?(l.first.path) }
+               .take_while { |l| !ignored_file?(l.first.path) }
+               .size
+    end
+
+    def interrupt
+      step_into 1
+    end
+
+    #
+    # Line handler
+    #
+    def at_line
+      self.frame = 0
+      return if ignored_file?(file)
+
+      processor.at_line
+    end
+
+    #
+    # Tracing handler
+    #
+    def at_tracing
+      return if ignored_file?(file)
+
+      processor.at_tracing
+    end
+
+    #
+    # Breakpoint handler
+    #
+    def at_breakpoint(breakpoint)
+      processor.at_breakpoint(breakpoint)
+    end
+
+    #
+    # Catchpoint handler
+    #
+    def at_catchpoint(exception)
+      processor.at_catchpoint(exception)
+    end
+
+    #
+    # Return handler
+    #
+    def at_return(return_value)
+      return if ignored_file?(file)
+
+      processor.at_return(return_value)
+    end
+
+    #
+    # End of class definition handler
+    #
+    def at_end
+      return if ignored_file?(file)
+
+      processor.at_end
+    end
+
+    private
+
+    def processor
+      @processor ||= self.class.processor.new(self, self.class.interface)
+    end
+
+    #
+    # Tells whether a file is ignored by the debugger.
+    #
+    # @param path [String] filename to be checked.
+    #
+    def ignored_file?(path)
+      self.class.ignored_files.include?(path)
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/core.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "helpers/reflection"
+require "byebug/byebug"
+require_relative "context"
+require_relative "breakpoint"
+require_relative "interface"
+require_relative "processors/script_processor"
+require_relative "processors/post_mortem_processor"
+require_relative "commands"
+require_relative "remote"
+require_relative "printers/plain"
+
+#
+# Main debugger's container module. Everything is defined under this module
+#
+module Byebug
+  include Helpers::ReflectionHelper
+
+  extend self
+
+  #
+  # Configuration file used for startup commands. Default value is .byebugrc
+  #
+  attr_accessor :init_file
+  self.init_file = ".byebugrc"
+
+  #
+  # Debugger's display expressions
+  #
+  attr_accessor :displays
+  self.displays = []
+
+  #
+  # Running mode of the debugger. Can be either:
+  #
+  # * :attached => Attached to a running program through the `byebug` method.
+  # * :standalone => Started through `byebug` script.
+  # * :off => Ignoring any `byebug` method calls.
+  #
+  attr_accessor :mode
+
+  #
+  # Runs normal byebug initialization scripts.
+  #
+  # Reads and executes the commands from init file (if any) in the current
+  # working directory. This is only done if the current directory is different
+  # from your home directory. Thus, you can have more than one init file, one
+  # generic in your home directory, and another, specific to the program you
+  # are debugging, in the directory where you invoke byebug.
+  #
+  def run_init_script
+    rc_dirs.each do |dir|
+      rc_file = File.expand_path(File.join(dir, init_file))
+      next unless File.exist?(rc_file)
+
+      run_rc_file(rc_file)
+    end
+  end
+
+  def self.load_settings
+    Dir.glob(File.join(__dir__, "settings", "*.rb")).each do |file|
+      require file
+    end
+
+    constants.grep(/[a-z]Setting/).map do |name|
+      setting = const_get(name).new
+      Byebug::Setting.settings[setting.to_sym] = setting
+    end
+  end
+
+  #
+  # Saves information about the unhandled exception and gives a byebug
+  # prompt back to the user before program termination.
+  #
+  def self.handle_post_mortem
+    return unless raised_exception
+
+    context = raised_exception.__bb_context
+
+    PostMortemProcessor.new(context).at_line
+  end
+
+  at_exit { Byebug.handle_post_mortem if Byebug.post_mortem? }
+
+  private
+
+  #
+  # Runs a initialization script file
+  #
+  def run_rc_file(rc_file)
+    interface = ScriptInterface.new(rc_file)
+
+    ScriptProcessor.new(nil, interface).process_commands
+  end
+
+  #
+  # List of folders to load rc files from
+  #
+  # @note Files will be loaded in the order specified here.
+  #
+  def rc_dirs
+    [ENV["HOME"], Dir.pwd].compact.uniq
+  end
+end
+
+Byebug.load_settings
+
+#
+# Extends the extension class to be able to pass information about the
+# debugging environment from the c-extension to the user.
+#
+class Exception
+  attr_reader :__bb_context
+end

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Custom exception exception to signal "command not found" errors
+  #
+  class CommandNotFound < NoMethodError
+    def initialize(input, parent = nil)
+      @input = input
+      @parent = parent
+
+      super("Unknown command '#{name}'. Try '#{help}'")
+    end
+
+    private
+
+    def name
+      build_cmd(@parent, @input)
+    end
+
+    def help
+      build_cmd("help", @parent)
+    end
+
+    def build_cmd(*args)
+      args.compact.join(" ")
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/frame.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative "helpers/file"
+
+module Byebug
+  #
+  # Represents a frame in the stack trace
+  #
+  class Frame
+    include Helpers::FileHelper
+
+    attr_reader :pos
+
+    def initialize(context, pos)
+      @context = context
+      @pos = pos
+    end
+
+    def file
+      @context.frame_file(pos)
+    end
+
+    def line
+      @context.frame_line(pos)
+    end
+
+    def _self
+      @context.frame_self(pos)
+    end
+
+    def _binding
+      @context.frame_binding(pos)
+    end
+
+    def _class
+      @context.frame_class(pos)
+    end
+
+    def _method
+      @context.frame_method(pos)
+    end
+
+    def current?
+      @context.frame.pos == pos
+    end
+
+    #
+    # Gets local variables for the frame.
+    #
+    def locals
+      return [] unless _binding
+
+      _binding.local_variables.each_with_object({}) do |e, a|
+        a[e] = _binding.local_variable_get(e)
+        a
+      end
+    end
+
+    #
+    # Gets current method arguments for the frame.
+    #
+    def args
+      return c_args unless _binding
+
+      ruby_args
+    end
+
+    #
+    # Returns the current class in the frame or an empty string if the current
+    # +callstyle+ setting is 'short'
+    #
+    def deco_class
+      Setting[:callstyle] == "short" || _class.to_s.empty? ? "" : "#{_class}."
+    end
+
+    def deco_block
+      _method[/(?:block(?: \(\d+ levels\))?|rescue) in /] || ""
+    end
+
+    def deco_method
+      _method[/((?:block(?: \(\d+ levels\))?|rescue) in )?(.*)/]
+    end
+
+    #
+    # Builds a string containing all available args in the frame number, in a
+    # verbose or non verbose way according to the value of the +callstyle+
+    # setting
+    #
+    def deco_args
+      return "" if args.empty?
+
+      my_args = args.map do |arg|
+        prefix, default = prefix_and_default(arg[0])
+
+        kls = use_short_style?(arg) ? "" : "##{locals[arg[1]].class}"
+
+        "#{prefix}#{arg[1] || default}#{kls}"
+      end
+
+      "(#{my_args.join(', ')})"
+    end
+
+    #
+    # Builds a formatted string containing information about current method call
+    #
+    def deco_call
+      deco_block + deco_class + deco_method + deco_args
+    end
+
+    #
+    # Formatted filename in frame
+    #
+    def deco_file
+      Setting[:fullpath] ? File.expand_path(file) : shortpath(file)
+    end
+
+    #
+    # Properly formatted frame number of frame
+    #
+    def deco_pos
+      format("%-2<pos>d", pos: pos)
+    end
+
+    #
+    # Formatted mark for the frame.
+    #
+    # --> marks the current frame
+    # ͱ-- marks c-frames
+    #     marks regular frames
+    #
+    def mark
+      return "-->" if current?
+      return "    ͱ--" if c_frame?
+
+      "   "
+    end
+
+    #
+    # Checks whether the frame is a c-frame
+    #
+    def c_frame?
+      _binding.nil?
+    end
+
+    def to_hash
+      {
+        mark: mark,
+        pos: deco_pos,
+        call: deco_call,
+        file: deco_file,
+        line: line,
+        full_path: File.expand_path(deco_file)
+      }
+    end
+
+    private
+
+    def c_args
+      return [] unless _self.to_s != "main"
+
+      _class.instance_method(_method).parameters
+    end
+
+    def ruby_args
+      meth_name = _binding.eval("__method__")
+      return [] unless meth_name
+
+      meth_obj = _class.instance_method(meth_name)
+      return [] unless meth_obj
+
+      meth_obj.parameters
+    end
+
+    def use_short_style?(arg)
+      Setting[:callstyle] == "short" || arg[1].nil? || locals.empty?
+    end
+
+    def prefix_and_default(arg_type)
+      return ["&", "block"] if arg_type == :block
+      return ["*", "args"] if arg_type == :rest
+
+      ["", nil]
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/helpers/bin.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities for interaction with executables
+    #
+    module BinHelper
+      #
+      # Cross-platform way of finding an executable in the $PATH.
+      # Adapted from: https://gist.github.com/steakknife/88b6c3837a5e90a08296
+      #
+      def which(cmd)
+        return File.expand_path(cmd) if File.exist?(cmd)
+
+        [nil, *search_paths].each do |path|
+          exe = find_executable(path, cmd)
+          return exe if exe
+        end
+
+        nil
+      end
+
+      def find_executable(path, cmd)
+        executable_file_extensions.each do |ext|
+          exe = File.expand_path(cmd + ext, path)
+
+          return exe if real_executable?(exe)
+        end
+
+        nil
+      end
+
+      def search_paths
+        ENV["PATH"].split(File::PATH_SEPARATOR)
+      end
+
+      def executable_file_extensions
+        ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+      end
+
+      def real_executable?(file)
+        File.executable?(file) && !File.directory?(file)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/helpers/eval.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist evaluation of code strings
+    #
+    module EvalHelper
+      #
+      # Evaluates an +expression+ in a separate thread.
+      #
+      # @param expression [String] Expression to evaluate
+      #
+      def separate_thread_eval(expression)
+        allowing_other_threads do
+          in_new_thread { warning_eval(expression) }
+        end
+      end
+
+      #
+      # Evaluates an +expression+ that might use or defer execution to threads
+      # other than the current one.
+      #
+      # @note This is necessary because when in byebug's prompt, every thread is
+      # "frozen" so that nothing gets run. So we need to unlock threads prior
+      # to evaluation or we will run into a deadlock.
+      #
+      # @param expression [String] Expression to evaluate
+      #
+      def multiple_thread_eval(expression)
+        allowing_other_threads { warning_eval(expression) }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # returning nil in an error happens.
+      #
+      def silent_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |_e| nil }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # handling the errors at an error level.
+      #
+      def error_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |e| raise(e, msg(e)) }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # handling the errors at a warning level.
+      #
+      def warning_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |e| errmsg(msg(e)) }
+      end
+
+      private
+
+      def safe_eval(str, binding)
+        binding.eval(str.gsub(/\Aeval /, ""), "(byebug)", 1)
+      rescue StandardError, ScriptError => e
+        yield(e)
+      end
+
+      def msg(exception)
+        msg = Setting[:stack_on_error] ? error_msg(exception) : warning_msg(exception)
+
+        pr("eval.exception", text_message: msg)
+      end
+
+      def error_msg(exception)
+        at = exception.backtrace
+
+        locations = ["#{at.shift}: #{warning_msg(exception)}"]
+        locations += at.map { |path| "  from #{path}" }
+        locations.join("\n")
+      end
+
+      def warning_msg(exception)
+        "#{exception.class} Exception: #{exception.message}"
+      end
+
+      #
+      # Run block temporarily ignoring all TracePoint events.
+      #
+      # Used to evaluate stuff within Byebug's prompt. Otherwise, any code
+      # creating new threads won't be properly evaluated because new threads
+      # will get blocked by byebug's main thread.
+      #
+      def allowing_other_threads
+        Byebug.unlock
+
+        res = yield
+
+        Byebug.lock
+
+        res
+      end
+
+      #
+      # Runs the given block in a new thread, waits for it to finish and
+      # returns the new thread's result.
+      #
+      def in_new_thread
+        res = nil
+
+        Thread.new { res = yield }.join
+
+        res
+      end
+
+      def safe_inspect(var)
+        var.inspect
+      rescue StandardError
+        safe_to_s(var)
+      end
+
+      def safe_to_s(var)
+        var.to_s
+      rescue StandardError
+        "*Error in evaluation*"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/helpers/file.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities for interaction with files
+    #
+    module FileHelper
+      #
+      # Reads lines of source file +filename+ into an array
+      #
+      def get_lines(filename)
+        File.foreach(filename).reduce([]) { |acc, elem| acc << elem.chomp }
+      end
+
+      #
+      # Reads line number +lineno+ from file named +filename+
+      #
+      def get_line(filename, lineno)
+        File.open(filename) do |f|
+          f.gets until f.lineno == lineno - 1
+          f.gets
+        end
+      end
+
+      #
+      # Returns the number of lines in file +filename+ in a portable,
+      # one-line-at-a-time way.
+      #
+      def n_lines(filename)
+        File.foreach(filename).reduce(0) { |acc, _elem| acc + 1 }
+      end
+
+      #
+      # Regularize file name.
+      #
+      def normalize(filename)
+        return filename if virtual_file?(filename)
+
+        return File.basename(filename) if Setting[:basename]
+
+        File.exist?(filename) ? File.realpath(filename) : filename
+      end
+
+      #
+      # A short version of a long path
+      #
+      def shortpath(fullpath)
+        components = Pathname(fullpath).each_filename.to_a
+        return fullpath if components.size <= 2
+
+        File.join("...", components[-3..-1])
+      end
+
+      #
+      # True for special files like -e, false otherwise
+      #
+      def virtual_file?(name)
+        ["(irb)", "-e", "(byebug)", "(eval)"].include?(name)
+      end
+    end
+  end
+end