byebug 11.0.1

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_accessor :size
+
+    def initialize
+      self.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)
+
+      self.size += 1
+      Readline::HISTORY.push(cmd)
+    end
+
+    #
+    # Removes a command from Readline's history.
+    #
+    def pop
+      self.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], self.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)
+      [self.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*$/ =~ 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 "byebug/setting"
+require "byebug/history"
+require "byebug/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 "byebug/interfaces/local_interface"
+require "byebug/interfaces/script_interface"
+require "byebug/interfaces/remote_interface"

data/lib/byebug/interfaces/local_interface.rb

@@ -0,0 +1,44 @@
+# 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 { 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
+  end
+end

data/lib/byebug/interfaces/remote_interface.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "byebug/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 result =~ /^\s*#/
+
+        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