runger_byebug 11.2.0

data/lib/byebug/commands/break.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/eval"
+require_relative "../helpers/file"
+require_relative "../helpers/parse"
+require_relative "../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>]
+
+        #{short_description}
+
+        They can be specified by line or method and an expression can be added
+        for conditionally enabled breakpoints.
+        for conditionally enabled breakpoints. Without arguments create a
+        a breakpoint in the current line.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Sets breakpoints in the source code"
+    end
+
+    def execute
+      b = line_breakpoint(frame.line.to_s) 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_relative "../command"
+require_relative "../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_relative "../command"
+require_relative "../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_relative "../command"
+require_relative "../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

data/lib/byebug/commands/debug.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/eval"
+
+module Byebug
+  #
+  # Spawns a subdebugger and evaluates the given expression
+  #
+  class DebugCommand < Command
+    include Helpers::EvalHelper
+
+    def self.regexp
+      /^\s* debug (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        debug <expression>
+
+        #{short_description}
+
+        Allows, for example, setting breakpoints on expressions evaluated from
+        the debugger's prompt.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Spawns a subdebugger"
+    end
+
+    def execute
+      return puts(help) unless @match[1]
+
+      puts safe_inspect(separate_thread_eval(@match[1]))
+    end
+  end
+end

data/lib/byebug/commands/delete.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Implements breakpoint deletion.
+  #
+  class DeleteCommand < Command
+    include Helpers::ParseHelper
+
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* del(?:ete)? (?:\s+(.*))?$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        del[ete][ nnn...]
+
+        #{short_description}
+
+        Without and argument, deletes all breakpoints. With integer arguments,
+        it deletes specific breakpoints.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Deletes breakpoints"
+    end
+
+    def execute
+      unless @match[1]
+        Byebug.breakpoints.clear if confirm(pr("break.confirmations.delete_all"))
+
+        return
+      end
+
+      @match[1].split(/ +/).each do |number|
+        pos, err = get_int(number, "Delete", 1)
+
+        return errmsg(err) unless pos
+
+        if Breakpoint.remove(pos)
+          puts(pr("break.messages.breakpoint_deleted", pos: pos))
+        else
+          errmsg(pr("break.errors.no_breakpoint_delete", pos: pos))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/toggle"
+
+module Byebug
+  #
+  # Reopens the +disable+ command to define the +breakpoints+ subcommand
+  #
+  class DisableCommand < Command
+    #
+    # Disables 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
+          dis[able] b[reakpoints][ <id1> <id2> .. <idn>]
+
+          #{short_description}
+
+          Give breakpoint numbers (separated by spaces) as arguments or no
+          argument at all if you want to disable every breakpoint.
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Disable all or specific breakpoints."
+      end
+
+      def execute
+        enable_disable_breakpoints("disable", @match[1])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/toggle"
+
+module Byebug
+  #
+  # Reopens the +disable+ command to define the +display+ subcommand
+  #
+  class DisableCommand < 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
+          dis[able] d[isplay][ <id1> <id2> .. <idn>]
+
+          #{short_description}
+
+          Arguments are the code numbers of the expressions to disable. Do "info
+          display" to see the current list of code numbers. If no arguments are
+          specified, all displays are disabled.
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Disables expressions to be displayed when program stops."
+      end
+
+      def execute
+        enable_disable_display("disable", @match[1])
+      end
+    end
+  end
+end

data/lib/byebug/commands/disable.rb

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

data/lib/byebug/commands/display.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/eval"
+
+module Byebug
+  #
+  # Custom expressions to be displayed every time the debugger stops.
+  #
+  class DisplayCommand < Command
+    include Helpers::EvalHelper
+
+    self.allow_in_post_mortem = false
+    self.always_run = 2
+
+    def self.regexp
+      /^\s* disp(?:lay)? (?:\s+ (.+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        disp[lay][ <expression>]
+
+        #{short_description}
+
+        If <expression> specified, adds <expression> into display expression
+        list. Otherwise, it lists all expressions.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Evaluates expressions every time the debugger stops"
+    end
+
+    def execute
+      return print_display_expressions unless @match && @match[1]
+
+      Byebug.displays.push [true, @match[1]]
+      display_expression(@match[1])
+    end
+
+    private
+
+    def display_expression(exp)
+      print pr("display.result", n: Byebug.displays.size,
+                                 exp: exp,
+                                 result: eval_expr(exp))
+    end
+
+    def print_display_expressions
+      result = prc("display.result", Byebug.displays) do |item, index|
+        active, exp = item
+
+        { n: index + 1, exp: exp, result: eval_expr(exp) } if active
+      end
+
+      print result
+    end
+
+    def eval_expr(expression)
+      error_eval(expression).inspect
+    rescue StandardError
+      "(undefined)"
+    end
+  end
+end

data/lib/byebug/commands/down.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../command"
+require_relative "../helpers/frame"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Move the current frame down in the backtrace.
+  #
+  class DownCommand < Command
+    include Helpers::FrameHelper
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* down (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        down[ count]
+
+        #{short_description}
+
+        Use the "bt" command to find out where you want to go.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Moves to a lower frame in the stack trace"
+    end
+
+    def execute
+      pos, err = parse_steps(@match[1], "Down")
+      return errmsg(err) unless pos
+
+      jump_frames(-pos)
+
+      ListCommand.new(processor).execute if Setting[:autolist]
+    end
+  end
+end