runger_byebug 11.2.0

data/lib/byebug/commands/info.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../subcommands"
+
+require_relative "../commands/info/breakpoints"
+require_relative "../commands/info/display"
+require_relative "../commands/info/file"
+require_relative "../commands/info/line"
+require_relative "../commands/info/program"
+
+module Byebug
+  #
+  # Shows info about different aspects of the debugger.
+  #
+  class InfoCommand < Command
+    include Subcommands
+
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* i(?:nfo)? (?:\s+ (.+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        info[ subcommand]
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Shows short description and information about the program being debugged"
+    end
+  end
+end

data/lib/byebug/commands/interrupt.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Byebug
+  #
+  # Interrupting execution of current thread.
+  #
+  class InterruptCommand < Command
+    self.allow_in_control = true
+
+    def self.regexp
+      /^\s*int(?:errupt)?\s*$/
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        int[errupt]
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Interrupts the program"
+    end
+
+    def execute
+      Byebug.start
+
+      Byebug.thread_context(Thread.main).interrupt
+    end
+  end
+end

data/lib/byebug/commands/irb.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require "irb"
+require "English"
+
+module Byebug
+  #
+  # Enter IRB from byebug's prompt
+  #
+  class IrbCommand < Command
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* irb \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        irb
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Starts an IRB session"
+    end
+
+    def execute
+      return errmsg(pr("base.errors.only_local")) unless processor.interface.instance_of?(LocalInterface)
+
+      # @todo IRB tries to parse $ARGV so we must clear it (see #197). Add a
+      #   test case for it so we can remove this comment.
+      with_clean_argv { IRB.start }
+    end
+
+    private
+
+    def with_clean_argv
+      saved_argv = $ARGV.dup
+      $ARGV.clear
+      begin
+        yield
+      ensure
+        $ARGV.concat(saved_argv)
+      end
+    end
+  end
+end

data/lib/byebug/commands/kill.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Byebug
+  #
+  # Send custom signals to the debugged program.
+  #
+  class KillCommand < Command
+    self.allow_in_control = true
+
+    def self.regexp
+      /^\s* kill \s* (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        kill[ signal]
+
+        #{short_description}
+
+        Equivalent of Process.kill(Process.pid)
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Sends a signal to the current process"
+    end
+
+    def execute
+      if @match[1]
+        signame = @match[1]
+
+        return errmsg("signal name #{signame} is not a signal I know about\n") unless Signal.list.member?(signame)
+      else
+        return unless confirm("Really kill? (y/n) ")
+
+        signame = "KILL"
+      end
+
+      processor.interface.close if signame == "KILL"
+      Process.kill(signame, Process.pid)
+    end
+  end
+end

data/lib/byebug/commands/list.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../source_file_formatter"
+require_relative "../helpers/file"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # List parts of the source code.
+  #
+  class ListCommand < Command
+    include Helpers::FileHelper
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* l(?:ist)? (?:\s*([-=])|\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        l[ist][[-=]][ nn-mm]
+
+        #{short_description}
+
+        Lists lines forward from current line or from the place where code was
+        last listed. If "list-" is specified, lists backwards instead. If
+        "list=" is specified, lists from current line regardless of where code
+        was last listed. A line range can also be specified to list specific
+        sections of code.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Lists lines of source code"
+    end
+
+    def execute
+      msg = "No sourcefile available for #{frame.file}"
+      raise(msg) unless File.exist?(frame.file)
+
+      b, e = range(@match[2])
+
+      display_lines(b, e)
+
+      processor.prev_line = b
+    end
+
+    private
+
+    #
+    # Line range to be printed by `list`.
+    #
+    # If <input> is set, range is parsed from it.
+    #
+    # Otherwise it's automatically chosen.
+    #
+    def range(input)
+      return auto_range(@match[1] || "+") unless input
+
+      b, e = parse_range(input)
+      raise("Invalid line range") unless valid_range?(b, e)
+
+      [b, e]
+    end
+
+    def valid_range?(first, last)
+      first <= last && (1..max_line).cover?(first) && (1..max_line).cover?(last)
+    end
+
+    #
+    # Set line range to be printed by list
+    #
+    # @return first line number to list
+    # @return last line number to list
+    #
+    def auto_range(direction)
+      prev_line = processor.prev_line
+
+      if direction == "=" || prev_line.nil?
+        source_file_formatter.range_around(frame.line)
+      else
+        source_file_formatter.range_from(move(prev_line, size, direction))
+      end
+    end
+
+    def parse_range(input)
+      first, err = get_int(lower_bound(input), "List", 1, max_line)
+      raise(err) unless first
+
+      if upper_bound(input)
+        last, err = get_int(upper_bound(input), "List", 1, max_line)
+        raise(err) unless last
+
+        last = amend_final(last)
+      else
+        first -= (size / 2)
+      end
+
+      [first, last || move(first, size - 1)]
+    end
+
+    def move(line, size, direction = "+")
+      line.send(direction, size)
+    end
+
+    #
+    # Show a range of lines in the current file.
+    #
+    # @param min [Integer] Lower bound
+    # @param max [Integer] Upper bound
+    #
+    def display_lines(min, max)
+      puts "\n[#{min}, #{max}] in #{frame.file}"
+
+      puts source_file_formatter.lines(min, max).join
+    end
+
+    #
+    # @param range [String] A string with an integer range format
+    #
+    # @return [String] The lower bound of the given range
+    #
+    def lower_bound(range)
+      split_range(range)[0]
+    end
+
+    #
+    # @param range [String] A string with an integer range format
+    #
+    # @return [String] The upper bound of the given range
+    #
+    def upper_bound(range)
+      split_range(range)[1]
+    end
+
+    #
+    # @param str [String] A string with an integer range format
+    #
+    # @return [Array] The upper & lower bounds of the given range
+    #
+    def split_range(str)
+      str.split(/[-,]/)
+    end
+
+    extend Forwardable
+
+    def_delegators :source_file_formatter, :amend_final, :size, :max_line
+
+    def source_file_formatter
+      @source_file_formatter ||= SourceFileFormatter.new(
+        frame.file,
+        ->(n) { n == frame.line ? "=>" : "  " }
+      )
+    end
+  end
+end

data/lib/byebug/commands/method.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/eval"
+
+module Byebug
+  #
+  # Show methods of specific classes/modules/objects.
+  #
+  class MethodCommand < Command
+    include Helpers::EvalHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* m(?:ethod)? \s+ (i(:?nstance)?\s+)?/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        m[ethod] (i[nstance][ <obj>]|<class|module>)
+
+        #{short_description}
+
+        When invoked with "instance", shows instance methods of the object
+        specified as argument or of self no object was specified.
+
+        When invoked only with a class or module, shows class methods of the
+        class or module specified as argument.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Shows methods of an object, class or module"
+    end
+
+    def execute
+      obj = warning_eval(@match.post_match)
+
+      result =
+        if @match[1]
+          prc("method.methods", obj.methods.sort) { |item, _| { name: item } }
+        elsif !obj.is_a?(Module)
+          pr("variable.errors.not_module", object: @match.post_match)
+        else
+          prc("method.methods", obj.instance_methods(false).sort) do |item, _|
+            { name: item }
+          end
+        end
+      puts result
+    end
+  end
+end

data/lib/byebug/commands/next.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Implements the next functionality.
+  #
+  # Allows the user the continue execution until the next instruction in the
+  # current frame.
+  #
+  class NextCommand < Command
+    include Helpers::ParseHelper
+
+    def self.regexp
+      /^\s* n(?:ext)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        n[ext][ nnn]
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Runs one or more lines of code"
+    end
+
+    def execute
+      steps, err = parse_steps(@match[1], "Next")
+      return errmsg(err) unless steps
+
+      context.step_over(steps, context.frame.pos)
+      processor.proceed!
+    end
+  end
+end

data/lib/byebug/commands/pry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../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_relative "../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_relative "../command"
+require_relative "../helpers/bin"
+require_relative "../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_relative "../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