runger_byebug 11.2.0

data/lib/byebug/commands/set.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Change byebug settings.
+  #
+  class SetCommand < Command
+    include Helpers::ParseHelper
+
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* set (?:\s+(?<setting>\w+))? (?:\s+(?<value>\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        set <setting> <value>
+
+        #{short_description}
+
+        Boolean values take "on", "off", "true", "false", "1" or "0". If you
+        don't specify a value, the boolean setting will be enabled. Conversely,
+        you can use "set no<setting>" to disable them.
+
+        You can see these environment settings with the "show" command.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Modifies byebug settings"
+    end
+
+    def self.help
+      super + Setting.help_all
+    end
+
+    def execute
+      key = @match[:setting]
+      value = @match[:value]
+      return puts(help) if key.nil? && value.nil?
+
+      setting = Setting.find(key)
+      return errmsg(pr("set.errors.unknown_setting", key: key)) unless setting
+
+      if !setting.boolean? && value.nil?
+        err = pr("set.errors.must_specify_value", key: key)
+      elsif setting.boolean?
+        value, err = get_onoff(value, /^no/.match?(key) ? false : true)
+      elsif setting.integer?
+        value, err = get_int(value, setting.to_sym, 1)
+      end
+      return errmsg(err) if value.nil?
+
+      setting.value = value
+
+      puts setting.to_s
+    end
+
+    private
+
+    def get_onoff(arg, default)
+      return default if arg.nil?
+
+      case arg
+      when "1", "on", "true"
+        true
+      when "0", "off", "false"
+        false
+      else
+        [nil, pr("set.errors.on_off", arg: arg)]
+      end
+    end
+  end
+end

data/lib/byebug/commands/show.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Byebug
+  #
+  # Show byebug settings.
+  #
+  class ShowCommand < Command
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* show (?:\s+(?<setting>\w+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        show <setting> <value>
+
+        #{short_description}
+
+        You can change them with the "set" command.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Shows byebug settings"
+    end
+
+    def self.help
+      super + Setting.help_all
+    end
+
+    def execute
+      key = @match[:setting]
+      return puts(help) unless key
+
+      setting = Setting.find(key)
+      return errmsg(pr("show.errors.unknown_setting", key: key)) unless setting
+
+      puts Setting.settings[setting.to_sym]
+    end
+  end
+end

data/lib/byebug/commands/skip.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Allows the user to continue execution until the next breakpoint, as
+  # long as it is different from the current one
+  #
+  class SkipCommand < Command
+    include Helpers::ParseHelper
+
+    class << self
+      attr_writer :file_line, :file_path
+      attr_reader :previous_autolist
+
+      def file_line
+        @file_line ||= 0
+      end
+
+      def file_path
+        @file_path ||= ""
+      end
+
+      def setup_autolist(value)
+        @previous_autolist = ListCommand.always_run
+        ListCommand.always_run = value
+      end
+
+      def restore_autolist
+        ListCommand.always_run = @previous_autolist
+        @previous_autolist = nil
+      end
+    end
+
+    def self.regexp
+      /^\s* sk(?:ip)? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        sk[ip]
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Runs until the next breakpoint as long as it is different from the current one"
+    end
+
+    def initialize_attributes
+      self.class.always_run = 2
+      self.class.setup_autolist(0)
+      self.class.file_path = frame.file
+      self.class.file_line = frame.line
+    end
+
+    def keep_execution
+      [self.class.file_path, self.class.file_line] == [frame.file, frame.line]
+    end
+
+    def reset_attributes
+      self.class.always_run = 0
+      ListCommand.new(processor).execute if self.class.previous_autolist == 1
+      self.class.restore_autolist
+    end
+
+    def auto_run
+      return false unless self.class.always_run == 2
+
+      keep_execution ? processor.proceed! : reset_attributes
+      true
+    end
+
+    def execute
+      return if auto_run
+
+      initialize_attributes
+      processor.proceed!
+      Byebug.stop if Byebug.stoppable?
+    end
+  end
+end

data/lib/byebug/commands/source.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Byebug
+  #
+  # Execute a file containing byebug commands.
+  #
+  # It can be used to restore a previously saved debugging session.
+  #
+  class SourceCommand < Command
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* so(?:urce)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        source <file>
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Restores a previously saved byebug session"
+    end
+
+    def execute
+      return puts(help) unless @match[1]
+
+      file = File.expand_path(@match[1]).strip
+      return errmsg(pr("source.errors.not_found", file: file)) unless File.exist?(file)
+
+      processor.interface.read_file(file)
+    end
+  end
+end

data/lib/byebug/commands/step.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Implements the step functionality.
+  #
+  # Allows the user the continue execution until the next instruction, possibly
+  # in a different frame. Use step to step into method calls or blocks.
+  #
+  class StepCommand < Command
+    include Helpers::ParseHelper
+
+    def self.regexp
+      /^\s* s(?:tep)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        s[tep][ times]
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Steps into blocks or methods one or more times"
+    end
+
+    def execute
+      steps, err = parse_steps(@match[1], "Steps")
+      return errmsg(err) unless steps
+
+      context.step_into(steps, context.frame.pos)
+      processor.proceed!
+    end
+  end
+end

data/lib/byebug/commands/thread/current.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/thread"
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +current+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Information about the current thread
+    #
+    class CurrentCommand < Command
+      include Helpers::ThreadHelper
+
+      def self.regexp
+        /^\s* c(?:urrent)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          th[read] c[urrent]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Shows current thread information."
+      end
+
+      def execute
+        display_context(context)
+      end
+    end
+  end
+end

data/lib/byebug/commands/thread/list.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/thread"
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +list+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Information about threads
+    #
+    class ListCommand < Command
+      include Helpers::ThreadHelper
+
+      def self.regexp
+        /^\s* l(?:ist)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          th[read] l[ist] <thnum>
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Lists all threads."
+      end
+
+      def execute
+        contexts = Byebug.contexts.sort_by(&:thnum)
+
+        thread_list = prc("thread.context", contexts) do |context, _|
+          thread_arguments(context)
+        end
+
+        print(thread_list)
+      end
+    end
+  end
+end

data/lib/byebug/commands/thread/resume.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/thread"
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +resume+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Resumes the specified thread
+    #
+    class ResumeCommand < Command
+      include Helpers::ThreadHelper
+
+      def self.regexp
+        /^\s* r(?:esume)? (?: \s* (\d+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          th[read] r[esume] <thnum>
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Resumes execution of the specified thread."
+      end
+
+      def execute
+        return puts(help) unless @match[1]
+
+        context, err = context_from_thread(@match[1])
+        return errmsg(err) if err
+
+        return errmsg(pr("thread.errors.already_running")) unless context.suspended?
+
+        context.resume
+        display_context(context)
+      end
+    end
+  end
+end

data/lib/byebug/commands/thread/stop.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/thread"
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +stop+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Stops the specified thread
+    #
+    class StopCommand < Command
+      include Helpers::ThreadHelper
+
+      def self.regexp
+        /^\s* st(?:op)? (?: \s* (\d+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          th[read] st[op] <thnum>
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Stops the execution of the specified thread."
+      end
+
+      def execute
+        return puts(help) unless @match[1]
+
+        context, err = context_from_thread(@match[1])
+        return errmsg(err) if err
+
+        context.suspend
+        display_context(context)
+      end
+    end
+  end
+end

data/lib/byebug/commands/thread/switch.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/thread"
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +switch+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Switches to the specified thread
+    #
+    class SwitchCommand < Command
+      include Helpers::ThreadHelper
+
+      def self.regexp
+        /^\s* sw(?:itch)? (?: \s* (\d+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          th[read] sw[itch] <thnum>
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Switches execution to the specified thread"
+      end
+
+      def execute
+        return puts(help) unless @match[1]
+
+        context, err = context_from_thread(@match[1])
+        return errmsg(err) if err
+
+        display_context(context)
+
+        context.switch
+
+        processor.proceed!
+      end
+    end
+  end
+end

data/lib/byebug/commands/thread.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../subcommands"
+
+require_relative "../commands/thread/current"
+require_relative "../commands/thread/list"
+require_relative "../commands/thread/resume"
+require_relative "../commands/thread/stop"
+require_relative "../commands/thread/switch"
+
+module Byebug
+  #
+  # Manipulation of Ruby threads
+  #
+  class ThreadCommand < Command
+    include Subcommands
+
+    def self.regexp
+      /^\s* th(?:read)? (?:\s+ (.+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        th[read] <subcommand>
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Commands to manipulate threads"
+    end
+  end
+end

data/lib/byebug/commands/tracevar.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Byebug
+  #
+  # Show (and possibly stop) at every line that changes a global variable.
+  #
+  class TracevarCommand < Command
+    def self.regexp
+      /^\s* tr(?:acevar)? (?: \s+ (\S+))?  # (variable-name)?
+                          (?: \s+ (stop|nostop))?
+       \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        tr[acevar] <variable> [[no]stop]
+
+        #{short_description}
+
+        If "stop" is specified, execution will stop every time the variable
+        changes its value. If nothing or "nostop" is specified, execution won't
+        stop, changes will just be logged in byebug's output.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Enables tracing of a global variable"
+    end
+
+    def execute
+      var = @match[1]
+      return errmsg(pr("trace.errors.needs_global_variable")) unless var
+      return errmsg(pr("trace.errors.var_is_not_global", name: var)) unless global_variables.include?(:"#{var}")
+
+      stop = @match[2] && @match[2] !~ /nostop/
+
+      instance_eval do
+        trace_var(:"#{var}") { |val| on_change(var, val, stop) }
+      end
+
+      puts pr("trace.messages.success", var: var)
+    end
+
+    private
+
+    def on_change(name, value, stop)
+      puts pr("trace.messages.on_change", name: name, value: value)
+
+      context.step_out(1, false) if stop
+    end
+  end
+end

data/lib/byebug/commands/undisplay.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Remove expressions from display list.
+  #
+  class UndisplayCommand < Command
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* undisp(?:lay)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        undisp[lay][ nnn]
+
+        #{short_description}
+
+        Arguments are the code numbers of the expressions to stop displaying. No
+        argument means cancel all automatic-display expressions. Type "info
+        display" to see the current list of code numbers.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Stops displaying all or some expressions when program stops"
+    end
+
+    def execute
+      if @match[1]
+        pos, err = get_int(@match[1], "Undisplay", 1, Byebug.displays.size)
+        return errmsg(err) unless err.nil?
+
+        last_display = Byebug.displays[pos - 1]
+        return errmsg(pr("display.errors.undefined", expr: pos)) unless last_display
+
+        last_display[0] = nil
+      else
+        return unless confirm(pr("display.confirmations.clear_all"))
+
+        Byebug.displays.each { |d| d[0] = false }
+      end
+    end
+  end
+end

data/lib/byebug/commands/untracevar.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Byebug
+  #
+  # Stop tracing a global variable.
+  #
+  class UntracevarCommand < Command
+    def self.regexp
+      /^\s* untr(?:acevar)? (?:\s+ (\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        untr[acevar] <variable>
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Stops tracing a global variable."
+    end
+
+    def execute
+      var = @match[1]
+      if global_variables.include?(:"#{var}")
+        untrace_var(:"#{var}")
+        puts pr("trace.messages.undo", var: var)
+      else
+        errmsg pr("trace.errors.var_is_not_global", name: var)
+      end
+    end
+  end
+end