byebug 4.0.5 → 5.0.0

data/lib/byebug/commands/step.rb

@@ -0,0 +1,36 @@
+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
+
+    self.allow_in_post_mortem = false
+
+    def regexp
+      /^\s* s(?:tep)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def execute
+      steps, err = parse_steps(@match[1], 'Steps')
+      return errmsg(err) unless steps
+
+      @state.context.step_into(steps, @state.frame)
+      @state.proceed
+    end
+
+    def description
+      <<-EOD
+        s[tep][ nnn]
+
+        Steps (into methods) once or nnn times.
+      EOD
+    end
+  end
+end

data/lib/byebug/commands/thread.rb

@@ -1,145 +1,28 @@
-require 'byebug/command'
+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
-    Subcommands = [
-      ['current', 1, 'Shows current thread'],
-      ['list', 1, 'Lists all threads'],
-      ['resume', 1, 'Resumes execution of specified thread number'],
-      ['stop', 2, 'Stops execution of specified thread number'],
-      ['switch', 2, 'Switches execution to specified thread']
-    ].map do |name, min, help|
-      Subcmd.new(name, min, help)
-    end
+    include Subcommands
 
     def regexp
       /^\s* th(?:read)? (?:\s+ (.+))? \s*$/x
     end
 
-    def execute
-      return puts(self.class.help) unless @match[1]
-
-      name, thnum = @match[1].split(/ +/)[0..1]
-      subcmd = Command.find(Subcommands, name)
-      return errmsg("Unknown thread command '#{name}'\n") unless subcmd
-
-      send("thread_#{subcmd.name}", thnum)
-    end
-
-    class << self
-      def names
-        %w(thread)
-      end
-
-      def description
-        prettify <<-EOD
-          Commands to manipulate threads.
-        EOD
-      end
-    end
-
-    private
-
-    def thread_list(thnum)
-      return errmsg("thread list doesn't need params") unless thnum.nil?
-
-      contexts = Byebug.contexts.sort_by(&:thnum)
-
-      thread_list = prc('thread.context', contexts) do |context, _|
-        thread_arguments(context)
-      end
-
-      print(thread_list)
-    end
-
-    def thread_current(thnum)
-      return errmsg("thread current doesn't need params") unless thnum.nil?
-
-      display_context(@state.context)
-    end
-
-    def thread_stop(thnum)
-      ctx, err = parse_thread_num_for_cmd('thread stop', thnum)
-      return errmsg(err) if err
-
-      ctx.suspend
-      display_context(ctx)
-    end
-
-    def thread_resume(thnum)
-      ctx, err = parse_thread_num_for_cmd('thread resume', thnum)
-      return errmsg(err) if err
-      return errmsg(pr('thread.errors.already_running')) unless ctx.suspended?
-
-      ctx.resume
-      display_context(ctx)
-    end
-
-    def thread_switch(thnum)
-      ctx, err = parse_thread_num_for_cmd('thread switch', thnum)
-      return errmsg(err) if err
-
-      display_context(ctx)
-
-      ctx.switch
-      @state.proceed
-    end
-
-    def display_context(context)
-      puts pr('thread.context', thread_arguments(context))
-    end
-
-    def thread_arguments(context)
-      status_flag = if context.suspended?
-                      '$'
-                    else
-                      context.thread == Thread.current ? '+' : ' '
-                    end
-      debug_flag = context.ignored? ? '!' : ' '
-
-      if context == Byebug.current_context
-        file_line = "#{@state.file}:#{@state.line}"
-      else
-        backtrace = context.thread.backtrace_locations
-        if backtrace && backtrace[0]
-          file_line = "#{backtrace[0].path}:#{backtrace[0].lineno}"
-        end
-      end
-
-      {
-        status_flag: status_flag,
-        debug_flag: debug_flag,
-        id: context.thnum,
-        thread: context.thread.inspect,
-        file_line: file_line || ''
-      }
-    end
-
-    def parse_thread_num(subcmd, arg)
-      thnum, err = get_int(arg, subcmd, 1)
-      return [nil, err] unless thnum
-
-      Byebug.contexts.find { |c| c.thnum == thnum }
-    end
-
-    def parse_thread_num_for_cmd(subcmd, arg)
-      c, err = parse_thread_num(subcmd, arg)
+    def description
+      <<-EOD
+        th]read <subcommand>
 
-      case
-      when err
-        [c, err]
-      when c.nil?
-        [nil, pr('thread.errors.no_thread')]
-      when @state.context == c
-        [c, pr('thread.errors.current_thread')]
-      when c.ignored?
-        [c, pr('thread.errors.wrong_action', subcmd: subcmd, arg: arg)]
-      else
-        [c, nil]
-      end
+        Commands to manipulate threads.
+      EOD
     end
   end
 end

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

@@ -0,0 +1,35 @@
+require 'byebug/helpers/thread'
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +current+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Information about the current thread
+    #
+    class CurrentSubcommand < Command
+      include Helpers::ThreadHelper
+
+      def regexp
+        /^\s* c(?:urrent)? \s*$/x
+      end
+
+      def execute
+        display_context(@state.context)
+      end
+
+      def short_description
+        'Shows current thread information'
+      end
+
+      def description
+        <<-EOD
+          th[read] c[urrent]
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'byebug/helpers/thread'
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +list+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Information about threads
+    #
+    class ListSubcommand < Command
+      include Helpers::ThreadHelper
+
+      def regexp
+        /^\s* l(?:ist)? \s*$/x
+      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
+
+      def short_description
+        'Lists all threads'
+      end
+
+      def description
+        <<-EOD
+          th[read] l[ist] <thnum>
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,41 @@
+require 'byebug/helpers/thread'
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +stop+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Stops the specified thread
+    #
+    class StopSubcommand < Command
+      include Helpers::ThreadHelper
+
+      def regexp
+        /^\s* st(?:op)? (?: \s* (\d+))? \s*$/x
+      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
+
+      def short_description
+        'Stops the execution of the specified thread'
+      end
+
+      def description
+        <<-EOD
+          th[read] st[op] <thnum>
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'byebug/helpers/thread'
+
+module Byebug
+  #
+  # Reopens the +thread+ command to define the +switch+ subcommand
+  #
+  class ThreadCommand < Command
+    #
+    # Switches to the specified thread
+    #
+    class SwitchSubcommand < Command
+      include Helpers::ThreadHelper
+
+      def regexp
+        /^\s* sw(?:itch)? (?: \s* (\d+))? \s*$/x
+      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
+        @state.proceed
+      end
+
+      def short_description
+        'Switches execution to the specified thread'
+      end
+
+      def description
+        <<-EOD
+          th[read] sw[itch] <thnum>
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

data/lib/byebug/commands/tracevar.rb

@@ -36,22 +36,16 @@ module Byebug
       @state.context.step_out(1, false) if stop
     end
 
-    class << self
-      def names
-        %w(tracevar)
-      end
-
-      def description
-        prettify <<-EOD
-          tr[acevar] <variable> [[no]stop]
+    def description
+      <<-EOD
+        tr[acevar] <variable> [[no]stop]
 
-          Start tracing variable <variable>.
+        Start tracing variable <variable>.
 
-          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.
-        EOD
-      end
+        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.
+      EOD
     end
   end
 end

data/lib/byebug/commands/undisplay.rb

@@ -1,10 +1,13 @@
 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 = false
 
     def regexp
@@ -28,22 +31,16 @@ module Byebug
       end
     end
 
-    class << self
-      def names
-        %w(undisplay)
-      end
-
-      def description
-        prettify <<-EOD
-          undisp[lay][ nnn]
+    def description
+      <<-EOD
+        undisp[lay][ nnn]
 
-          Cancel some expressions to be displayed when program stops. Arguments
-          are the code numbers of the expressions to stop displaying. No
-          argument means cancel all automatic-display expressions. "delete
-          display" has the same effect as this command. Do "info display" to see
-          the current list of code numbers.
-        EOD
-      end
+        Cancel some expressions to be displayed when program stops. Arguments
+        are the code numbers of the expressions to stop displaying. No argument
+        means cancel all automatic-display expressions. "delete display" has the
+        same effect as this command. Do "info display" to see the current list
+        of code numbers.
+      EOD
     end
   end
 end