byebug 11.0.1

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,75 @@
+# 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) if str !~ /\A-?[0-9]+\z/
+
+        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
+
+        without_stderr do
+          begin
+            RubyVM::InstructionSequence.compile(code)
+            true
+          rescue SyntaxError
+            false
+          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 utilitie
+    #
+    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

data/lib/byebug/helpers/thread.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities for thread subcommands
+    #
+    module ThreadHelper
+      def display_context(ctx)
+        puts pr("thread.context", thread_arguments(ctx))
+      end
+
+      def thread_arguments(ctx)
+        {
+          status_flag: status_flag(ctx),
+          debug_flag: debug_flag(ctx),
+          id: ctx.thnum,
+          thread: ctx.thread.inspect,
+          file_line: location(ctx),
+          pid: Process.pid,
+          status: ctx.thread.status,
+          current: current_thread?(ctx)
+        }
+      end
+
+      def current_thread?(ctx)
+        ctx.thread == Thread.current
+      end
+
+      def context_from_thread(thnum)
+        ctx = Byebug.contexts.find { |c| c.thnum.to_s == thnum }
+
+        err = if ctx.nil?
+                pr("thread.errors.no_thread")
+              elsif ctx == context
+                pr("thread.errors.current_thread")
+              elsif ctx.ignored?
+                pr("thread.errors.ignored", arg: thnum)
+              end
+
+        [ctx, err]
+      end
+
+      private
+
+      # @todo Check whether it is Byebug.current_context or context
+      def location(ctx)
+        return context.location if ctx == Byebug.current_context
+
+        backtrace = ctx.thread.backtrace_locations
+        return "" unless backtrace && backtrace[0]
+
+        "#{backtrace[0].path}:#{backtrace[0].lineno}"
+      end
+
+      def status_flag(ctx)
+        return "$" if ctx.suspended?
+
+        current_thread?(ctx) ? "+" : " "
+      end
+
+      def debug_flag(ctx)
+        ctx.ignored? ? "!" : " "
+      end
+    end
+  end
+end

data/lib/byebug/helpers/toggle.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "byebug/helpers/parse"
+
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist breakpoint/display enabling/disabling.
+    #
+    module ToggleHelper
+      include ParseHelper
+
+      def enable_disable_breakpoints(is_enable, args)
+        raise pr("toggle.errors.no_breakpoints") if Breakpoint.none?
+
+        select_breakpoints(is_enable, args).each do |b|
+          enabled = (is_enable == "enable")
+          raise pr("toggle.errors.expression", expr: b.expr) if enabled && !syntax_valid?(b.expr)
+
+          puts pr("toggle.messages.toggled", bpnum: b.id,
+                                             endis: enabled ? "en" : "dis")
+          b.enabled = enabled
+        end
+      end
+
+      def enable_disable_display(is_enable, args)
+        raise pr("toggle.errors.no_display") if n_displays.zero?
+
+        selected_displays = args ? args.split(/ +/) : [1..n_displays + 1]
+
+        selected_displays.each do |pos|
+          pos, err = get_int(pos, "#{is_enable} display", 1, n_displays)
+          raise err unless err.nil?
+
+          Byebug.displays[pos - 1][0] = (is_enable == "enable")
+        end
+      end
+
+      private
+
+      def select_breakpoints(is_enable, args)
+        all_breakpoints = Byebug.breakpoints.sort_by(&:id)
+        return all_breakpoints if args.nil?
+
+        selected_ids = []
+        args.split(/ +/).each do |pos|
+          last_id = all_breakpoints.last.id
+          pos, err = get_int(pos, "#{is_enable} breakpoints", 1, last_id)
+          raise(ArgumentError, err) unless pos
+
+          selected_ids << pos
+        end
+
+        all_breakpoints.select { |b| selected_ids.include?(b.id) }
+      end
+
+      def n_displays
+        Byebug.displays.size
+      end
+    end
+  end
+end

data/lib/byebug/helpers/var.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "byebug/helpers/eval"
+
+module Byebug
+  module Helpers
+    #
+    # Utilities for variable subcommands
+    #
+    module VarHelper
+      include EvalHelper
+
+      def var_list(ary, binding = context.frame._binding)
+        vars = ary.sort.map do |name|
+          [name, safe_inspect(silent_eval(name.to_s, binding))]
+        end
+
+        puts prv(vars, "instance")
+      end
+
+      def var_global
+        globals = global_variables.reject do |v|
+          %i[$IGNORECASE $= $KCODE $-K $binding].include?(v)
+        end
+
+        var_list(globals)
+      end
+
+      def var_instance(str)
+        obj = warning_eval(str || "self")
+
+        var_list(obj.instance_variables, obj.instance_eval { binding })
+      end
+
+      def var_local
+        locals = context.frame.locals
+        cur_self = context.frame._self
+        locals[:self] = cur_self unless cur_self.to_s == "main"
+        puts prv(locals.keys.sort.map { |k| [k, locals[k]] }, "instance")
+      end
+
+      def var_args
+        args = context.frame.args
+        return if args == [[:rest]]
+
+        all_locals = context.frame.locals
+        arg_values = args.map { |arg| arg[1] }
+
+        locals = all_locals.select { |k, _| arg_values.include?(k) }
+        puts prv(locals.keys.sort.map { |k| [k, locals[k]] }, "instance")
+      end
+    end
+  end
+end