runger_byebug 11.2.0

data/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/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/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/lib/byebug/helpers/eval.rb

@@ -0,0 +1,134 @@
+# 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 if 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(&block)
+        Byebug.unlock
+
+        tracepoint_allow_reentry(&block)
+      ensure
+        Byebug.lock
+      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
+
+      if TracePoint.respond_to?(:allow_reentry)
+        def tracepoint_allow_reentry(&block)
+          TracePoint.allow_reentry(&block)
+        end
+      else
+        def tracepoint_allow_reentry
+          yield
+        end
+      end
+    end
+  end
+end

data/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

data/lib/byebug/helpers/frame.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist frame navigation
+    #
+    module FrameHelper
+      def switch_to_frame(frame)
+        new_frame = index_from_start(frame)
+        return frame_err("c_frame") if Frame.new(context, new_frame).c_frame?
+
+        adjust_frame(new_frame)
+      end
+
+      def jump_frames(steps)
+        adjust_frame(navigate_to_frame(steps))
+      end
+
+      private
+
+      def adjust_frame(new_frame)
+        return frame_err("too_low") if new_frame >= context.stack_size
+        return frame_err("too_high") if new_frame.negative?
+
+        context.frame = new_frame
+        processor.prev_line = nil
+      end
+
+      def navigate_to_frame(jump_no)
+        current_jumps = 0
+        current_pos = context.frame.pos
+
+        loop do
+          current_pos += direction(jump_no)
+          break if out_of_bounds?(current_pos)
+
+          next if Frame.new(context, current_pos).c_frame?
+
+          current_jumps += 1
+          break if current_jumps == jump_no.abs
+        end
+
+        current_pos
+      end
+
+      def out_of_bounds?(pos)
+        !(0...context.stack_size).cover?(pos)
+      end
+
+      def frame_err(msg)
+        errmsg(pr("frame.errors.#{msg}"))
+      end
+
+      #
+      # @param step [Integer] A positive or negative integer
+      #
+      # @return [Integer] +1 if step is positive / -1 if negative
+      #
+      def direction(step)
+        step / step.abs
+      end
+
+      #
+      # Convert a possibly negative index to a positive index from the start
+      # of the callstack. -1 is the last position in the stack and so on.
+      #
+      # @param i [Integer] Integer to be converted in a proper positive index.
+      #
+      def index_from_start(index)
+        index >= 0 ? index : context.stack_size + index
+      end
+    end
+  end
+end

data/lib/byebug/helpers/parse.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist command parsing
+    #
+    module ParseHelper
+      #
+      # Parses +str+ of command +cmd+ as an integer between +min+ and +max+.
+      #
+      # If either +min+ or +max+ is nil, that value has no bound.
+      #
+      # @todo Remove the `cmd` parameter. It has nothing to do with the method's
+      # purpose.
+      #
+      def get_int(str, cmd, min = nil, max = nil)
+        return nil, pr("parse.errors.int.not_number", cmd: cmd, str: str) unless /\A-?[0-9]+\z/.match?(str)
+
+        int = str.to_i
+        if min && int < min
+          err = pr("parse.errors.int.too_low", cmd: cmd, str: str, min: min)
+          return nil, err
+        elsif max && int > max
+          err = pr("parse.errors.int.too_high", cmd: cmd, str: str, max: max)
+          return nil, err
+        end
+
+        int
+      end
+
+      #
+      # @return true if code is syntactically correct for Ruby, false otherwise
+      #
+      def syntax_valid?(code)
+        return true unless code
+
+        if defined?(RubyVM::InstructionSequence.compile)
+          without_stderr do
+            RubyVM::InstructionSequence.compile(code)
+            true
+          rescue SyntaxError
+            false
+          end
+        else
+          require "ripper" unless defined?(Ripper)
+          without_stderr do
+            !Ripper.sexp(code).nil?
+          end
+        end
+      end
+
+      #
+      # @return +str+ as an integer or 1 if +str+ is empty.
+      #
+      def parse_steps(str, cmd)
+        return 1 unless str
+
+        steps, err = get_int(str, cmd, 1)
+        return nil, err unless steps
+
+        steps
+      end
+
+      private
+
+      #
+      # Temporarily disable output to $stderr
+      #
+      def without_stderr
+        old_stderr = $stderr
+        $stderr = StringIO.new
+
+        yield
+      ensure
+        $stderr = old_stderr
+      end
+    end
+  end
+end

data/lib/byebug/helpers/path.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities for managing gem paths
+    #
+    module PathHelper
+      def bin_file
+        @bin_file ||= File.join(root_path, "exe", "byebug")
+      end
+
+      def root_path
+        @root_path ||= File.expand_path(File.join("..", "..", ".."), __dir__)
+      end
+
+      def lib_files
+        @lib_files ||= glob_for("lib")
+      end
+
+      def test_files
+        @test_files ||= glob_for("test")
+      end
+
+      def gem_files
+        @gem_files ||= [bin_file] + lib_files
+      end
+
+      def all_files
+        @all_files ||= gem_files + test_files
+      end
+
+      private
+
+      def glob_for(dir)
+        Dir.glob(File.join(root_path, dir, "**", "*.rb"))
+      end
+    end
+  end
+end

data/lib/byebug/helpers/reflection.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Reflection utility
+    #
+    module ReflectionHelper
+      #
+      # List of "command" classes in the including module
+      #
+      def commands
+        constants(false)
+          .map { |const| const_get(const, false) }
+          .select { |c| c.is_a?(Class) && c.name =~ /[a-z]Command$/ }
+      end
+    end
+  end
+end

data/lib/byebug/helpers/string.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities for interaction with strings
+    #
+    module StringHelper
+      #
+      # Converts +str+ from an_underscored-or-dasherized_string to
+      # ACamelizedString.
+      #
+      def camelize(str)
+        str.dup.split(/[_-]/).map(&:capitalize).join("")
+      end
+
+      #
+      # Improves indentation and spacing in +str+ for readability in Byebug's
+      # command prompt.
+      #
+      def prettify(str)
+        "\n" + deindent(str) + "\n"
+      end
+
+      #
+      # Removes a number of leading whitespace for each input line.
+      #
+      def deindent(str, leading_spaces: 6)
+        str.gsub(/^ {#{leading_spaces}}/, "")
+      end
+    end
+  end
+end