byebug 11.0.1

data/lib/byebug/commands/pry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/eval"
+
+module Byebug
+  #
+  # Enter Pry from byebug's prompt
+  #
+  class PryCommand < Command
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* pry \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        pry
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Starts a Pry session"
+    end
+
+    def execute
+      return errmsg(pr("base.errors.only_local")) unless processor.interface.instance_of?(LocalInterface)
+
+      begin
+        require "pry"
+      rescue LoadError
+        return errmsg(pr("pry.errors.not_installed"))
+      end
+
+      Pry.start(context.frame._binding)
+    end
+  end
+end

data/lib/byebug/commands/quit.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+
+module Byebug
+  #
+  # Exit from byebug.
+  #
+  class QuitCommand < Command
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* q(?:uit)? \s* (?:(!|\s+unconditionally))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        q[uit][!| unconditionally]
+
+        #{short_description}
+
+        Normally we prompt before exiting. However, if the parameter
+        "unconditionally" is given or command is suffixed with "!", we exit
+        without asking further questions.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Exits byebug"
+    end
+
+    def execute
+      return unless @match[1] || confirm(pr("quit.confirmations.really"))
+
+      processor.interface.autosave
+      processor.interface.close
+
+      Process.exit!
+    end
+  end
+end

data/lib/byebug/commands/restart.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/bin"
+require "byebug/helpers/path"
+require "shellwords"
+require "English"
+require "rbconfig"
+
+module Byebug
+  #
+  # Restart debugged program from within byebug.
+  #
+  class RestartCommand < Command
+    include Helpers::BinHelper
+    include Helpers::PathHelper
+
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* restart (?:\s+(?<args>.+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        restart [args]
+
+        #{short_description}
+
+        This is a re-exec - all byebug state is lost. If command arguments are
+        passed those are used.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Restarts the debugged program"
+    end
+
+    def execute
+      cmd = [$PROGRAM_NAME]
+
+      cmd = prepend_byebug_bin(cmd)
+      cmd = prepend_ruby_bin(cmd)
+
+      cmd += (@match[:args] ? @match[:args].shellsplit : $ARGV)
+
+      puts pr("restart.success", cmd: cmd.shelljoin)
+      Kernel.exec(*cmd)
+    end
+
+    private
+
+    def prepend_byebug_bin(cmd)
+      cmd.unshift(bin_file) if Byebug.mode == :standalone
+      cmd
+    end
+
+    def prepend_ruby_bin(cmd)
+      cmd.unshift(RbConfig.ruby) if which("ruby") != which(cmd.first)
+      cmd
+    end
+  end
+end

data/lib/byebug/commands/save.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+
+module Byebug
+  #
+  # Save current settings to use them in another debug session.
+  #
+  class SaveCommand < Command
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* sa(?:ve)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        save[ FILE]
+
+        #{short_description}
+
+        Byebug state is saved as a script file. This includes breakpoints,
+        catchpoints, display expressions and some settings. If no filename is
+        given, byebug will fabricate one.
+
+        Use the "source" command in another debug session to restore the saved
+        file.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Saves current byebug session to a file"
+    end
+
+    def execute
+      file = File.open(@match[1] || Setting[:savefile], "w")
+
+      save_breakpoints(file)
+      save_catchpoints(file)
+      save_displays(file)
+      save_settings(file)
+
+      print pr("save.messages.done", path: file.path)
+      file.close
+    end
+
+    private
+
+    def save_breakpoints(file)
+      Byebug.breakpoints.each do |b|
+        file.puts "break #{b.source}:#{b.pos}#{" if #{b.expr}" if b.expr}"
+      end
+    end
+
+    def save_catchpoints(file)
+      Byebug.catchpoints.each_key do |c|
+        file.puts "catch #{c}"
+      end
+    end
+
+    def save_displays(file)
+      Byebug.displays.each { |d| file.puts "display #{d[1]}" if d[0] }
+    end
+
+    def save_settings(file)
+      %w[autoirb autolist basename].each do |setting|
+        file.puts "set #{setting} #{Setting[setting.to_sym]}"
+      end
+    end
+  end
+end

data/lib/byebug/commands/set.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/parse"
+
+module Byebug
+  #
+  # Change byebug settings.
+  #
+  class SetCommand < Command
+    include Helpers::ParseHelper
+
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* set (?:\s+(?<setting>\w+))? (?:\s+(?<value>\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        set <setting> <value>
+
+        #{short_description}
+
+        Boolean values take "on", "off", "true", "false", "1" or "0". If you
+        don't specify a value, the boolean setting will be enabled. Conversely,
+        you can use "set no<setting>" to disable them.
+
+        You can see these environment settings with the "show" command.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Modifies byebug settings"
+    end
+
+    def self.help
+      super + Setting.help_all
+    end
+
+    def execute
+      key = @match[:setting]
+      value = @match[:value]
+      return puts(help) if key.nil? && value.nil?
+
+      setting = Setting.find(key)
+      return errmsg(pr("set.errors.unknown_setting", key: key)) unless setting
+
+      if !setting.boolean? && value.nil?
+        err = pr("set.errors.must_specify_value", key: key)
+      elsif setting.boolean?
+        value, err = get_onoff(value, key =~ /^no/ ? false : true)
+      elsif setting.integer?
+        value, err = get_int(value, setting.to_sym, 1)
+      end
+      return errmsg(err) if value.nil?
+
+      setting.value = value
+
+      puts setting.to_s
+    end
+
+    private
+
+    def get_onoff(arg, default)
+      return default if arg.nil?
+
+      case arg
+      when "1", "on", "true"
+        true
+      when "0", "off", "false"
+        false
+      else
+        [nil, pr("set.errors.on_off", arg: arg)]
+      end
+    end
+  end
+end

data/lib/byebug/commands/show.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+
+module Byebug
+  #
+  # Show byebug settings.
+  #
+  class ShowCommand < Command
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* show (?:\s+(?<setting>\w+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        show <setting> <value>
+
+        #{short_description}
+
+        You can change them with the "set" command.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Shows byebug settings"
+    end
+
+    def self.help
+      super + Setting.help_all
+    end
+
+    def execute
+      key = @match[:setting]
+      return puts(help) unless key
+
+      setting = Setting.find(key)
+      return errmsg(pr("show.errors.unknown_setting", key: key)) unless setting
+
+      puts Setting.settings[setting.to_sym]
+    end
+  end
+end

data/lib/byebug/commands/skip.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/parse"
+
+module Byebug
+  #
+  # Allows the user to continue execution until the next breakpoint, as
+  # long as it is different from the current one
+  #
+  class SkipCommand < Command
+    include Helpers::ParseHelper
+
+    class << self
+      attr_writer :file_line, :file_path
+      attr_reader :previous_autolist
+
+      def file_line
+        @file_line ||= 0
+      end
+
+      def file_path
+        @file_path ||= ""
+      end
+
+      def setup_autolist(value)
+        @previous_autolist = ListCommand.always_run
+        ListCommand.always_run = value
+      end
+
+      def restore_autolist
+        ListCommand.always_run = @previous_autolist
+        @previous_autolist = nil
+      end
+    end
+
+    def self.regexp
+      /^\s* sk(?:ip)? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        sk[ip]
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Runs until the next breakpoint as long as it is different from the current one"
+    end
+
+    def initialize_attributes
+      self.class.always_run = 2
+      self.class.setup_autolist(0)
+      self.class.file_path = frame.file
+      self.class.file_line = frame.line
+    end
+
+    def keep_execution
+      [self.class.file_path, self.class.file_line] == [frame.file, frame.line]
+    end
+
+    def reset_attributes
+      self.class.always_run = 0
+      ListCommand.new(processor).execute if self.class.previous_autolist == 1
+      self.class.restore_autolist
+    end
+
+    def auto_run
+      return false unless self.class.always_run == 2
+
+      keep_execution ? processor.proceed! : reset_attributes
+      true
+    end
+
+    def execute
+      return if auto_run
+
+      initialize_attributes
+      processor.proceed!
+      Byebug.stop if Byebug.stoppable?
+    end
+  end
+end

data/lib/byebug/commands/source.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+
+module Byebug
+  #
+  # Execute a file containing byebug commands.
+  #
+  # It can be used to restore a previously saved debugging session.
+  #
+  class SourceCommand < Command
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* so(?:urce)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        source <file>
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Restores a previously saved byebug session"
+    end
+
+    def execute
+      return puts(help) unless @match[1]
+
+      file = File.expand_path(@match[1]).strip
+      return errmsg(pr("source.errors.not_found", file: file)) unless File.exist?(file)
+
+      processor.interface.read_file(file)
+    end
+  end
+end