byebug 11.0.1

data/lib/byebug/commands/step.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+require "byebug/helpers/parse"
+
+module Byebug
+  #
+  # Implements the step functionality.
+  #
+  # Allows the user the continue execution until the next instruction, possibily
+  # 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.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "byebug/subcommands"
+
+require "byebug/commands/thread/current"
+require "byebug/commands/thread/list"
+require "byebug/commands/thread/resume"
+require "byebug/commands/thread/stop"
+require "byebug/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/thread/current.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "byebug/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 "byebug/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 "byebug/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 "byebug/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 "byebug/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/tracevar.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "byebug/command"
+
+module Byebug
+  #
+  # Show (and possibily 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 "byebug/command"
+require "byebug/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 "byebug/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.not_global", var: var)
+      end
+    end
+  end
+end

data/lib/byebug/commands/up.rb

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