runger_byebug 11.2.0

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_relative "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,70 @@
+# frozen_string_literal: true
+
+require_relative "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|
+          code = name.to_s
+
+          if code == "$SAFE" && Gem.ruby_version >= Gem::Version.new("2.7.0.preview3")
+            code = <<~RUBY
+              original_stderr = $stderr
+
+              begin
+                $stderr = StringIO.new
+
+                #{code}
+              ensure
+                $stderr = original_stderr
+              end
+            RUBY
+          end
+
+          [name, safe_inspect(silent_eval(code, 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

data/lib/byebug/history.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+begin
+  require "readline"
+rescue LoadError
+  warn <<-MESSAGE
+    Sorry, you can't use byebug without Readline. To solve this, you need to
+    rebuild Ruby with Readline support. If using Ubuntu, try `sudo apt-get
+    install libreadline-dev` and then reinstall your Ruby.
+  MESSAGE
+
+  raise
+end
+
+module Byebug
+  #
+  # Handles byebug's history of commands.
+  #
+  class History
+    attr_reader :size
+
+    def initialize
+      @size = 0
+    end
+
+    #
+    # Array holding the list of commands in history
+    #
+    def buffer
+      Readline::HISTORY.to_a
+    end
+
+    #
+    # Restores history from disk.
+    #
+    def restore
+      return unless File.exist?(Setting[:histfile])
+
+      File.readlines(Setting[:histfile]).reverse_each { |l| push(l.chomp) }
+    end
+
+    #
+    # Saves history to disk.
+    #
+    def save
+      n_cmds = Setting[:histsize] > size ? size : Setting[:histsize]
+
+      File.open(Setting[:histfile], "w") do |file|
+        n_cmds.times { file.puts(pop) }
+      end
+
+      clear
+    end
+
+    #
+    # Discards history.
+    #
+    def clear
+      size.times { pop }
+    end
+
+    #
+    # Adds a new command to Readline's history.
+    #
+    def push(cmd)
+      return if ignore?(cmd)
+
+      @size += 1
+      Readline::HISTORY.push(cmd)
+    end
+
+    #
+    # Removes a command from Readline's history.
+    #
+    def pop
+      @size -= 1
+      Readline::HISTORY.pop
+    end
+
+    #
+    # Prints the requested numbers of history entries.
+    #
+    def to_s(n_cmds)
+      show_size = n_cmds ? specific_max_size(n_cmds) : default_max_size
+
+      commands = buffer.last(show_size)
+
+      last_ids(show_size).zip(commands).map do |l|
+        format("%<position>5d  %<command>s", position: l[0], command: l[1])
+      end.join("\n") + "\n"
+    end
+
+    #
+    # Array of ids of the last +number+ commands.
+    #
+    def last_ids(number)
+      (1 + size - number..size).to_a
+    end
+
+    #
+    # Max number of commands to be displayed when no size has been specified.
+    #
+    # Never more than Setting[:histsize].
+    #
+    def default_max_size
+      [Setting[:histsize], size].min
+    end
+
+    #
+    # Max number of commands to be displayed when a size has been specified.
+    #
+    # The only bound here is not showing more items than available.
+    #
+    def specific_max_size(number)
+      [size, number].min
+    end
+
+    #
+    # Whether a specific command should not be stored in history.
+    #
+    # For now, empty lines and consecutive duplicates.
+    #
+    def ignore?(buf)
+      return true if /^\s*$/.match?(buf)
+      return false if Readline::HISTORY.empty?
+
+      buffer[Readline::HISTORY.length - 1] == buf
+    end
+  end
+end

data/lib/byebug/interface.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative "setting"
+require_relative "history"
+require_relative "helpers/file"
+
+#
+# Namespace for all of byebug's code
+#
+module Byebug
+  #
+  # Main Interface class
+  #
+  # Contains common functionality to all implemented interfaces.
+  #
+  class Interface
+    include Helpers::FileHelper
+
+    attr_accessor :command_queue, :history
+    attr_reader :input, :output, :error
+
+    def initialize
+      @command_queue = []
+      @history = History.new
+      @last_line = ""
+    end
+
+    def last_if_empty(input)
+      @last_line = input.empty? ? @last_line : input
+    end
+
+    #
+    # Pops a command from the input stream.
+    #
+    def read_command(prompt)
+      return command_queue.shift unless command_queue.empty?
+
+      read_input(prompt)
+    end
+
+    #
+    # Pushes lines in +filename+ to the command queue.
+    #
+    def read_file(filename)
+      command_queue.concat(get_lines(filename))
+    end
+
+    #
+    # Reads a new line from the interface's input stream, parses it into
+    # commands and saves it to history.
+    #
+    # @return [String] Representing something to be run by the debugger.
+    #
+    def read_input(prompt, save_hist = true)
+      line = prepare_input(prompt)
+      return unless line
+
+      history.push(line) if save_hist
+
+      command_queue.concat(split_commands(line))
+      command_queue.shift
+    end
+
+    #
+    # Reads a new line from the interface's input stream.
+    #
+    # @return [String] New string read or the previous string if the string
+    # read now was empty.
+    #
+    def prepare_input(prompt)
+      line = readline(prompt)
+      return unless line
+
+      last_if_empty(line)
+    end
+
+    #
+    # Prints an error message to the error stream.
+    #
+    def errmsg(message)
+      error.print("*** #{message}\n")
+    end
+
+    #
+    # Prints an output message to the output stream.
+    #
+    def puts(message)
+      output.puts(message)
+    end
+
+    #
+    # Prints an output message to the output stream without a final "\n".
+    #
+    def print(message)
+      output.print(message)
+    end
+
+    #
+    # Confirms user introduced an affirmative response to the input stream.
+    #
+    def confirm(prompt)
+      readline(prompt) == "y"
+    end
+
+    def close
+    end
+
+    #
+    # Saves or clears history according to +autosave+ setting.
+    #
+    def autosave
+      Setting[:autosave] ? history.save : history.clear
+    end
+
+    #
+    # Restores history according to +autosave+ setting.
+    #
+    def autorestore
+      history.restore if Setting[:autosave]
+    end
+
+    private
+
+    #
+    # Splits a command line of the form "cmd1 ; cmd2 ; ... ; cmdN" into an
+    # array of commands: [cmd1, cmd2, ..., cmdN]
+    #
+    def split_commands(cmd_line)
+      return [""] if cmd_line.empty?
+
+      cmd_line.split(/;/).each_with_object([]) do |v, m|
+        if m.empty? || m.last[-1] != "\\"
+          m << v.strip
+          next
+        end
+
+        m.last[-1, 1] = ""
+        m.last << ";" << v
+      end
+    end
+  end
+end
+
+require_relative "interfaces/local_interface"
+require_relative "interfaces/script_interface"
+require_relative "interfaces/remote_interface"

data/lib/byebug/interfaces/local_interface.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Interface class for standard byebug use.
+  #
+  class LocalInterface < Interface
+    EOF_ALIAS = "continue"
+
+    def initialize
+      super()
+      @input = $stdin
+      @output = $stdout
+      @error = $stderr
+    end
+
+    #
+    # Reads a single line of input using Readline. If Ctrl-D is pressed, it
+    # returns "continue", meaning that program's execution will go on.
+    #
+    # @param prompt Prompt to be displayed.
+    #
+    def readline(prompt)
+      with_repl_like_sigint { without_readline_completion { Readline.readline(prompt) || EOF_ALIAS } }
+    end
+
+    #
+    # Yields the block handling Ctrl-C the following way: if pressed while
+    # waiting for input, the line is reset to only the prompt and we ask for
+    # input again.
+    #
+    # @note Any external 'INT' traps are overriden during this method.
+    #
+    def with_repl_like_sigint
+      orig_handler = trap("INT") { raise Interrupt }
+      yield
+    rescue Interrupt
+      puts("^C")
+      retry
+    ensure
+      trap("INT", orig_handler)
+    end
+
+    #
+    # Disable any Readline completion procs.
+    #
+    # Other gems, for example, IRB could've installed completion procs that are
+    # dependent on them being loaded. Disable those while byebug is the REPL
+    # making use of Readline.
+    #
+    def without_readline_completion
+      orig_completion = Readline.completion_proc
+      return yield unless orig_completion
+
+      begin
+        Readline.completion_proc = ->(_) { nil }
+        yield
+      ensure
+        Readline.completion_proc = orig_completion
+      end
+    end
+  end
+end

data/lib/byebug/interfaces/remote_interface.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../history"
+
+module Byebug
+  #
+  # Interface class for remote use of byebug.
+  #
+  class RemoteInterface < Interface
+    def initialize(socket)
+      super()
+      @input = socket
+      @output = socket
+      @error = socket
+    end
+
+    def read_command(prompt)
+      super("PROMPT #{prompt}")
+    rescue Errno::EPIPE, Errno::ECONNABORTED
+      "continue"
+    end
+
+    def confirm(prompt)
+      super("CONFIRM #{prompt}")
+    rescue Errno::EPIPE, Errno::ECONNABORTED
+      false
+    end
+
+    def print(message)
+      super(message)
+    rescue Errno::EPIPE, Errno::ECONNABORTED
+      nil
+    end
+
+    def puts(message)
+      super(message)
+    rescue Errno::EPIPE, Errno::ECONNABORTED
+      nil
+    end
+
+    def close
+      output.close
+    end
+
+    def readline(prompt)
+      puts(prompt)
+      (input.gets || "continue").chomp
+    end
+  end
+end

data/lib/byebug/interfaces/script_interface.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Interface class for command execution from script files.
+  #
+  class ScriptInterface < Interface
+    def initialize(file, verbose = false)
+      super()
+      @verbose = verbose
+      @input = File.open(file)
+      @output = verbose ? $stdout : StringIO.new
+      @error = $stderr
+    end
+
+    def read_command(prompt)
+      readline(prompt, false)
+    end
+
+    def close
+      input.close
+    end
+
+    def readline(*)
+      while (result = input.gets)
+        output.puts "+ #{result}" if @verbose
+        next if /^\s*#/.match?(result)
+
+        return result.chomp
+      end
+    end
+  end
+end

data/lib/byebug/interfaces/test_interface.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Custom interface for easier assertions
+  #
+  class TestInterface < Interface
+    attr_accessor :test_block
+
+    def initialize
+      super()
+
+      clear
+    end
+
+    def errmsg(message)
+      error.concat(prepare(message))
+    end
+
+    def print(message)
+      output.concat(prepare(message))
+    end
+
+    def puts(message)
+      output.concat(prepare(message))
+    end
+
+    def read_command(prompt)
+      cmd = super(prompt)
+
+      return cmd unless cmd.nil? && test_block
+
+      test_block.call
+      self.test_block = nil
+    end
+
+    def clear
+      @input = []
+      @output = []
+      @error = []
+      history.clear
+    end
+
+    def inspect
+      [
+        "Input:", input.join("\n"),
+        "Output:", output.join("\n"),
+        "Error:", error.join("\n")
+      ].join("\n")
+    end
+
+    def readline(prompt)
+      puts(prompt)
+
+      cmd = input.shift
+      cmd.is_a?(Proc) ? cmd.call : cmd
+    end
+
+    private
+
+    def prepare(message)
+      return message.map(&:to_s) if message.respond_to?(:map)
+
+      message.to_s.split("\n")
+    end
+  end
+end