byebug 11.0.1

data/lib/byebug/commands/info/line.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Reopens the +info+ command to define the +line+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about current location
+    #
+    class LineCommand < Command
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* l(?:ine)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          inf[o] l[ine]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Line number and file name of current position in source file."
+      end
+
+      def execute
+        puts "Line #{frame.line} of \"#{frame.file}\""
+      end
+    end
+  end
+end

data/lib/byebug/commands/info/program.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Reopens the +info+ command to define the +args+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about arguments of the current method/block
+    #
+    class ProgramCommand < Command
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* p(?:rogram)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          inf[o] p[rogram]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Information about the current status of the debugged program."
+      end
+
+      def execute
+        puts "Program stopped. "
+        format_stop_reason context.stop_reason
+      end
+
+      private
+
+      def format_stop_reason(stop_reason)
+        case stop_reason
+        when :step
+          puts "It stopped after stepping, next'ing or initial start."
+        when :breakpoint
+          puts "It stopped at a breakpoint."
+        when :catchpoint
+          puts "It stopped at a catchpoint."
+        end
+      end
+    end
+  end
+end

data/lib/byebug/commands/interrupt.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "byebug/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 "byebug/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 "byebug/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 "byebug/command"
+require "byebug/source_file_formatter"
+require "byebug/helpers/file"
+require "byebug/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 "byebug/command"
+require "byebug/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 "byebug/command"
+require "byebug/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