byebug 11.0.1

data/lib/byebug/command.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "byebug/helpers/string"
+
+module Byebug
+  #
+  # Parent class of all byebug commands.
+  #
+  # Subclass it and name the subclass ending with the word Command to implement
+  # your own custom command.
+  #
+  # @example Define a custom command
+  #
+  # class MyCustomCommand < Command
+  #   def self.regexp
+  #     /custom_regexp/
+  #   end
+  #
+  #   def self.description
+  #     "Custom long desc"
+  #   end
+  #
+  #   def.short_description
+  #     "Custom short desc"
+  #   end
+  #
+  #   def execute
+  #     # My command's implementation
+  #   end
+  # end
+  #
+  class Command
+    extend Forwardable
+
+    attr_reader :processor
+
+    def initialize(processor, input = self.class.to_s)
+      @processor = processor
+      @match = match(input)
+    end
+
+    def context
+      @context ||= processor.context
+    end
+
+    def frame
+      @frame ||= context.frame
+    end
+
+    def arguments
+      @match[0].split(" ").drop(1).join(" ")
+    end
+
+    def_delegators "self.class", :help, :match
+
+    def_delegator "processor.printer", :print, :pr
+    def_delegator "processor.printer", :print_collection, :prc
+    def_delegator "processor.printer", :print_variables, :prv
+
+    def_delegators "processor.interface", :errmsg, :puts, :print, :confirm
+
+    class << self
+      include Helpers::StringHelper
+
+      #
+      # Special methods to allow command filtering in processors
+      #
+      attr_accessor :allow_in_control, :allow_in_post_mortem
+
+      attr_writer :always_run
+
+      def always_run
+        @always_run ||= 0
+      end
+
+      #
+      # Name of the command, as executed by the user.
+      #
+      def to_s
+        name
+          .split("::")
+          .map { |n| n.gsub(/Command$/, "").downcase if n =~ /Command$/ }
+          .compact
+          .join(" ")
+      end
+
+      def columnize(width)
+        format(
+          "  %-<name>#{width}s -- %<description>s\n",
+          name: to_s,
+          description: short_description
+        )
+      end
+
+      #
+      # Default help text for a command.
+      #
+      def help
+        prettify(description)
+      end
+
+      #
+      # Command's regexp match against an input
+      #
+      def match(input)
+        regexp.match(input)
+      end
+    end
+  end
+end

data/lib/byebug/command_list.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "byebug/errors"
+
+module Byebug
+  #
+  # Holds an array of subcommands for a command
+  #
+  class CommandList
+    include Enumerable
+
+    def initialize(commands)
+      @commands = commands.sort_by(&:to_s)
+    end
+
+    def match(input)
+      find { |cmd| cmd.match(input) }
+    end
+
+    def each
+      @commands.each { |cmd| yield(cmd) }
+    end
+
+    def to_s
+      "\n" + map { |cmd| cmd.columnize(width) }.join + "\n"
+    end
+
+    private
+
+    def width
+      @width ||= map(&:to_s).max_by(&:size).size
+    end
+  end
+end

data/lib/byebug/commands.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "byebug/commands/break"
+require "byebug/commands/catch"
+require "byebug/commands/condition"
+require "byebug/commands/continue"
+require "byebug/commands/debug"
+require "byebug/commands/delete"
+require "byebug/commands/disable"
+require "byebug/commands/display"
+require "byebug/commands/down"
+require "byebug/commands/edit"
+require "byebug/commands/enable"
+require "byebug/commands/finish"
+require "byebug/commands/frame"
+require "byebug/commands/help"
+require "byebug/commands/history"
+require "byebug/commands/info"
+require "byebug/commands/interrupt"
+require "byebug/commands/irb"
+require "byebug/commands/kill"
+require "byebug/commands/list"
+require "byebug/commands/method"
+require "byebug/commands/next"
+require "byebug/commands/pry"
+require "byebug/commands/quit"
+require "byebug/commands/restart"
+require "byebug/commands/save"
+require "byebug/commands/set"
+require "byebug/commands/show"
+require "byebug/commands/skip"
+require "byebug/commands/source"
+require "byebug/commands/step"
+require "byebug/commands/thread"
+require "byebug/commands/tracevar"
+require "byebug/commands/undisplay"
+require "byebug/commands/untracevar"
+require "byebug/commands/up"
+require "byebug/commands/var"
+require "byebug/commands/where"

data/lib/byebug/commands/break.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/eval"
+require "byebug/helpers/file"
+require "byebug/helpers/parse"
+require "byebug/source_file_formatter"
+
+module Byebug
+  #
+  # Implements breakpoint functionality
+  #
+  class BreakCommand < Command
+    include Helpers::EvalHelper
+    include Helpers::FileHelper
+    include Helpers::ParseHelper
+
+    self.allow_in_control = true
+
+    def self.regexp
+      /^\s* b(?:reak)? (?:\s+ (.+?))? (?:\s+ if \s+(.+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        b[reak] [<file>:]<line> [if <expr>]
+        b[reak] [<module>::...]<class>(.|#)<method> [if <expr>]
+
+        They can be specified by line or method and an expression can be added
+        for conditionally enabled breakpoints.
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Sets breakpoints in the source code"
+    end
+
+    def execute
+      return puts(help) unless @match[1]
+
+      b = line_breakpoint(@match[1]) || method_breakpoint(@match[1])
+      return errmsg(pr("break.errors.location")) unless b
+
+      return puts(pr("break.created", id: b.id, file: b.source, line: b.pos)) if syntax_valid?(@match[2])
+
+      errmsg(pr("break.errors.expression", expr: @match[2]))
+      b.enabled = false
+    end
+
+    private
+
+    def line_breakpoint(location)
+      line_match = location.match(/^(\d+)$/)
+      file_line_match = location.match(/^(.+):(\d+)$/)
+      return unless line_match || file_line_match
+
+      file = line_match ? frame.file : file_line_match[1]
+      line = line_match ? line_match[1].to_i : file_line_match[2].to_i
+
+      add_line_breakpoint(file, line)
+    end
+
+    def method_breakpoint(location)
+      location.match(/([^.#]+)[.#](.+)/) do |match|
+        klass = target_object(match[1])
+        method = match[2].intern
+
+        Breakpoint.add(klass, method, @match[2])
+      end
+    end
+
+    def target_object(str)
+      k = error_eval(str)
+
+      k&.is_a?(Module) ? k.name : str
+    rescue StandardError
+      errmsg("Warning: breakpoint source is not yet defined")
+      str
+    end
+
+    def add_line_breakpoint(file, line)
+      raise(pr("break.errors.source", file: file)) unless File.exist?(file)
+
+      fullpath = File.realpath(file)
+
+      raise(pr("break.errors.far_line", lines: n_lines(file), file: fullpath)) if line > n_lines(file)
+
+      unless Breakpoint.potential_line?(fullpath, line)
+        msg = pr(
+          "break.errors.line",
+          file: fullpath,
+          line: line,
+          valid_breakpoints: valid_breakpoints_for(fullpath, line)
+        )
+
+        raise(msg)
+      end
+
+      Breakpoint.add(fullpath, line, @match[2])
+    end
+
+    def valid_breakpoints_for(path, line)
+      potential_lines = Breakpoint.potential_lines(path)
+      annotator = ->(n) { potential_lines.include?(n) ? "[B]" : "   " }
+      source_file_formatter = SourceFileFormatter.new(path, annotator)
+
+      source_file_formatter.lines_around(line).join.chomp
+    end
+  end
+end

data/lib/byebug/commands/catch.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/eval"
+
+module Byebug
+  #
+  # Implements exception catching.
+  #
+  # Enables the user to catch unhandled assertion when they happen.
+  #
+  class CatchCommand < Command
+    include Helpers::EvalHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* cat(?:ch)? (?:\s+(\S+))? (?:\s+(off))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        cat[ch][ (off|<exception>[ off])]
+
+        #{short_description}
+
+        catch                 -- lists catchpoints
+        catch off             -- deletes all catchpoints
+        catch <exception>     -- enables handling <exception>
+        catch <exception> off -- disables handling <exception>
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Handles exception catchpoints"
+    end
+
+    def execute
+      return info unless @match[1]
+
+      return @match[1] == "off" ? clear : add(@match[1]) unless @match[2]
+
+      return errmsg pr("catch.errors.off", off: cmd) unless @match[2] == "off"
+
+      remove(@match[1])
+    end
+
+    private
+
+    def remove(exception)
+      return errmsg pr("catch.errors.not_found", exception: exception) unless Byebug.catchpoints.member?(exception)
+
+      puts pr("catch.removed", exception: exception)
+      Byebug.catchpoints.delete(exception)
+    end
+
+    def add(exception)
+      errmsg pr("catch.errors.not_class", class: exception) if warning_eval(exception.is_a?(Class).to_s)
+
+      puts pr("catch.added", exception: exception)
+      Byebug.add_catchpoint(exception)
+    end
+
+    def clear
+      Byebug.catchpoints.clear if confirm(pr("catch.confirmations.delete_all"))
+    end
+
+    def info
+      if Byebug.catchpoints && !Byebug.catchpoints.empty?
+        Byebug.catchpoints.each_key do |exception|
+          puts("#{exception}: #{exception.is_a?(Class)}")
+        end
+      else
+        puts "No exceptions set to be caught."
+      end
+    end
+  end
+end

data/lib/byebug/commands/condition.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/parse"
+
+module Byebug
+  #
+  # Implements conditions on breakpoints.
+  #
+  # Adds the ability to stop on breakpoints only under certain conditions.
+  #
+  class ConditionCommand < Command
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* cond(?:ition)? (?:\s+(\d+)(?:\s+(.*))?)? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        cond[ition] <n>[ expr]
+
+        #{short_description}
+
+        Specify breakpoint number <n> to break only if <expr> is true. <n> is
+        an integer and <expr> is an expression to be evaluated whenever
+        breakpoint <n> is reached. If no expression is specified, the condition
+        is removed.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Sets conditions on breakpoints"
+    end
+
+    def execute
+      return puts(help) unless @match[1]
+
+      breakpoints = Byebug.breakpoints.sort_by(&:id)
+      return errmsg(pr("condition.errors.no_breakpoints")) if breakpoints.empty?
+
+      pos, err = get_int(@match[1], "Condition", 1)
+      return errmsg(err) if err
+
+      breakpoint = breakpoints.find { |b| b.id == pos }
+      return errmsg(pr("break.errors.no_breakpoint")) unless breakpoint
+
+      return errmsg(pr("break.errors.not_changed", expr: @match[2])) unless syntax_valid?(@match[2])
+
+      breakpoint.expr = @match[2]
+    end
+  end
+end

data/lib/byebug/commands/continue.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/parse"
+
+module Byebug
+  #
+  # Implements the continue command.
+  #
+  # Allows the user to continue execution until the next stopping point, a
+  # specific line number or until program termination.
+  #
+  class ContinueCommand < Command
+    include Helpers::ParseHelper
+
+    def self.regexp
+      /^\s* c(?:ont(?:inue)?)? (?:(!|\s+unconditionally|\s+\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        c[ont[inue]][ <line_number>]
+
+        #{short_description}
+
+        Normally the program stops at the next breakpoint. However, if the
+        parameter "unconditionally" is given or the command is suffixed with
+        "!", the program will run until the end regardless of any enabled
+        breakpoints.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Runs until program ends, hits a breakpoint or reaches a line"
+    end
+
+    def execute
+      if until_line?
+        num, err = get_int(modifier, "Continue", 0, nil)
+        return errmsg(err) unless num
+
+        filename = File.expand_path(frame.file)
+        return errmsg(pr("continue.errors.unstopped_line", line: num)) unless Breakpoint.potential_line?(filename, num)
+
+        Breakpoint.add(filename, num)
+      end
+
+      processor.proceed!
+
+      Byebug.mode = :off if unconditionally?
+      Byebug.stop if unconditionally? || Byebug.stoppable?
+    end
+
+    private
+
+    def until_line?
+      @match[1] && !["!", "unconditionally"].include?(modifier)
+    end
+
+    def unconditionally?
+      @match[1] && ["!", "unconditionally"].include?(modifier)
+    end
+
+    def modifier
+      @match[1].lstrip
+    end
+  end
+end