runger_byebug 11.2.0

data/lib/byebug/commands/edit.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Byebug
+  #
+  # Edit a file from byebug's prompt.
+  #
+  class EditCommand < Command
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* ed(?:it)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        edit[ file:lineno]
+
+        #{short_description}
+
+        With no argumnt, edits file containing most re line listed. Editing
+        targets can also be specified to start editing at a specific line in a
+        specific file
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Edits source files"
+    end
+
+    def execute
+      file, line = location(@match[1])
+      return edit_error("not_exist", file) unless File.exist?(file)
+      return edit_error("not_readable", file) unless File.readable?(file)
+
+      cmd = line ? "#{editor} +#{line} #{file}" : "#{editor} #{file}"
+
+      Kernel.system(cmd)
+    end
+
+    private
+
+    def location(matched)
+      if matched.nil?
+        file = frame.file
+        return errmsg(pr("edit.errors.state")) unless file
+
+        line = frame.line
+      elsif (@pos_match = /([^:]+)[:]([0-9]+)/.match(matched))
+        file, line = @pos_match.captures
+      else
+        file = matched
+        line = nil
+      end
+
+      [File.expand_path(file), line]
+    end
+
+    def editor
+      ENV["EDITOR"] || "vim"
+    end
+
+    def edit_error(type, file)
+      errmsg(pr("edit.errors.#{type}", file: file))
+    end
+  end
+end

data/lib/byebug/commands/enable/breakpoints.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/toggle"
+
+module Byebug
+  #
+  # Reopens the +enable+ command to define the +breakpoints+ subcommand
+  #
+  class EnableCommand < Command
+    #
+    # Enables all or specific breakpoints
+    #
+    class BreakpointsCommand < Command
+      include Helpers::ToggleHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* b(?:reakpoints)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          en[able] b[reakpoints][ <ids>]
+
+          #{short_description}
+
+          Give breakpoint numbers (separated by spaces) as arguments or no
+          argument at all if you want to enable every breakpoint.
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Enable all or specific breakpoints."
+      end
+
+      def execute
+        enable_disable_breakpoints("enable", @match[1])
+      end
+    end
+  end
+end

data/lib/byebug/commands/enable/display.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/toggle"
+
+module Byebug
+  #
+  # Reopens the +enable+ command to define the +display+ subcommand
+  #
+  class EnableCommand < Command
+    #
+    # Enables all or specific displays
+    #
+    class DisplayCommand < Command
+      include Helpers::ToggleHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* d(?:isplay)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          en[able] d[isplay][ <id1> <id2> .. <idn>]
+
+          #{short_description}
+
+          Arguments are the code numbers of the expressions to enable. Do "info
+          display" to see the current list of code numbers. If no arguments are
+          specified, all displays are enabled.
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Enables expressions to be displayed when program stops."
+      end
+
+      def execute
+        enable_disable_display("enable", @match[1])
+      end
+    end
+  end
+end

data/lib/byebug/commands/enable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../subcommands"
+
+require_relative "../commands/enable/breakpoints"
+require_relative "../commands/enable/display"
+
+module Byebug
+  #
+  # Enabling custom display expressions or breakpoints.
+  #
+  class EnableCommand < Command
+    include Subcommands
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* en(?:able)? (?:\s+ (.+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        en[able][[ b[reakpoints]| d[isplay])][ n1[ n2[ ...[ nn]]]]]
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Enables breakpoints or displays"
+    end
+  end
+end

data/lib/byebug/commands/finish.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Implements the finish functionality.
+  #
+  # Allows the user to continue execution until certain frames are finished.
+  #
+  class FinishCommand < Command
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = false
+
+    def self.regexp
+      /^\s* fin(?:ish)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        fin[ish][ n_frames]
+
+        #{short_description}
+
+        If no number is given, we run until the current frame returns. If a
+        number of frames `n_frames` is given, then we run until `n_frames`
+        return from the current position.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Runs the program until frame returns"
+    end
+
+    def execute
+      if @match[1]
+        n_frames, err = get_int(@match[1], "finish", 0, max_frames - 1)
+        return errmsg(err) unless n_frames
+      else
+        n_frames = 1
+      end
+
+      force = n_frames.zero? ? true : false
+      context.step_out(context.frame.pos + n_frames, force)
+      context.frame = 0
+      processor.proceed!
+    end
+
+    private
+
+    def max_frames
+      context.stack_size - context.frame.pos
+    end
+  end
+end

data/lib/byebug/commands/frame.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../command"
+require_relative "../helpers/frame"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Move to specific frames in the backtrace.
+  #
+  class FrameCommand < Command
+    include Helpers::FrameHelper
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* f(?:rame)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        f[rame][ frame-number]
+
+        #{short_description}
+
+        If a frame number has been specified, to moves to that frame. Otherwise
+        it moves to the newest frame.
+
+        A negative number indicates position from the other end, so "frame -1"
+        moves to the oldest frame, and "frame 0" moves to the newest frame.
+
+        Without an argument, the command prints the current stack frame. Since
+        the current position is redisplayed, it may trigger a resyncronization
+        if there is a front end also watching over things.
+
+        Use the "bt" command to find out where you want to go.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Moves to a frame in the call stack"
+    end
+
+    def execute
+      return print(pr("frame.line", context.frame.to_hash)) unless @match[1]
+
+      pos, err = get_int(@match[1], "Frame")
+      return errmsg(err) unless pos
+
+      switch_to_frame(pos)
+
+      ListCommand.new(processor).execute if Setting[:autolist]
+    end
+  end
+end

data/lib/byebug/commands/help.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../errors"
+
+module Byebug
+  #
+  # Ask for help from byebug's prompt.
+  #
+  class HelpCommand < Command
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* h(?:elp)? (?:\s+(\S+))? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        h[elp][ <cmd>[ <subcmd>]]
+
+        #{short_description}
+
+        help                -- prints a summary of all commands
+        help <cmd>          -- prints help on command <cmd>
+        help <cmd> <subcmd> -- prints help on <cmd>'s subcommand <subcmd>
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Helps you using byebug"
+    end
+
+    def execute
+      return help_for_all unless @match[1]
+
+      return help_for(@match[1], command) unless @match[2]
+
+      help_for(@match[2], subcommand)
+    end
+
+    private
+
+    def help_for_all
+      puts(processor.command_list.to_s)
+    end
+
+    def help_for(input, cmd)
+      raise CommandNotFound.new(input, command) unless cmd
+
+      puts(cmd.help)
+    end
+
+    def command
+      @command ||= processor.command_list.match(@match[1])
+    end
+
+    def subcommand
+      return unless command
+
+      @subcommand ||= command.subcommand_list.match(@match[2])
+    end
+  end
+end

data/lib/byebug/commands/history.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Show history of byebug commands.
+  #
+  class HistoryCommand < Command
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* hist(?:ory)? (?:\s+(?<num_cmds>.+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        hist[ory][ num_cmds]
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Shows byebug's history of commands"
+    end
+
+    def execute
+      history = processor.interface.history
+
+      size, = get_int(@match[:num_cmds], "history", 1) if @match[:num_cmds]
+
+      puts history.to_s(size)
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Reopens the +info+ command to define the +breakpoints+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about current breakpoints
+    #
+    class BreakpointsCommand < Command
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* b(?:reakpoints)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          inf[o] b[reakpoints]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Status of user settable breakpoints"
+      end
+
+      def execute
+        return puts("No breakpoints.") if Byebug.breakpoints.empty?
+
+        breakpoints = Byebug.breakpoints.sort_by(&:id)
+
+        if @match[1]
+          indices = @match[1].split(/ +/).map(&:to_i)
+          breakpoints = breakpoints.select { |b| indices.member?(b.id) }
+          return errmsg("No breakpoints found among list given") if breakpoints.empty?
+        end
+
+        puts "Num Enb What"
+        breakpoints.each { |b| info_breakpoint(b) }
+      end
+
+      private
+
+      def info_breakpoint(brkpt)
+        interp = format(
+          "%-<id>3d %-<status>3s at %<file>s:%<line>s%<expression>s",
+          id: brkpt.id,
+          status: brkpt.enabled? ? "y" : "n",
+          file: brkpt.source,
+          line: brkpt.pos,
+          expression: brkpt.expr.nil? ? "" : " if #{brkpt.expr}"
+        )
+        puts interp
+        hits = brkpt.hit_count
+        return unless hits.positive?
+
+        s = hits > 1 ? "s" : ""
+        puts "  breakpoint already hit #{hits} time#{s}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Reopens the +info+ command to define the +display+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about display expressions
+    #
+    class DisplayCommand < Command
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* d(?:isplay)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          inf[o] d[display]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "List of expressions to display when program stops"
+      end
+
+      def execute
+        return puts("There are no auto-display expressions now.") unless Byebug.displays.find { |d| d[0] }
+
+        puts "Auto-display expressions now in effect:"
+        puts "Num Enb Expression"
+
+        Byebug.displays.each_with_index do |d, i|
+          interp = format(
+            "%<number>3d: %<status>s  %<expression>s",
+            number: i + 1,
+            status: d[0] ? "y" : "n",
+            expression: d[1]
+          )
+
+          puts(interp)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/file"
+
+module Byebug
+  #
+  # Reopens the +info+ command to define the +file+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about a particular source file
+    #
+    class FileCommand < Command
+      include Helpers::FileHelper
+      include Helpers::StringHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* f(?:ile)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          inf[o] f[ile]
+
+          #{short_description}
+
+          It informs about file name, number of lines, possible breakpoints in
+          the file, last modification time and sha1 digest.
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Information about a particular source file."
+      end
+
+      def execute
+        file = @match[1] || frame.file
+        return errmsg(pr("info.errors.undefined_file", file: file)) unless File.exist?(file)
+
+        puts prettify <<-RUBY
+          File #{info_file_basic(file)}
+
+          Breakpoint line numbers: #{info_file_breakpoints(file)}
+
+          Modification time: #{info_file_mtime(file)}
+
+          Sha1 Signature: #{info_file_sha1(file)}
+        RUBY
+      end
+
+      private
+
+      def info_file_basic(file)
+        path = File.expand_path(file)
+        return unless File.exist?(path)
+
+        s = n_lines(path) == 1 ? "" : "s"
+        "#{path} (#{n_lines(path)} line#{s})"
+      end
+
+      def info_file_breakpoints(file)
+        breakpoints = Breakpoint.potential_lines(file)
+        return unless breakpoints
+
+        breakpoints.to_a.sort.join(" ")
+      end
+
+      def info_file_mtime(file)
+        File.stat(file).mtime
+      end
+
+      def info_file_sha1(file)
+        require "digest/sha1"
+        Digest::SHA1.hexdigest(file)
+      end
+    end
+  end
+end

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