byebug 4.0.4 → 4.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d5196fdd3dc5f4325d6a7dc03edc403c3f54adc
-  data.tar.gz: b99153ca69aa352475c74692bd4cf0092b7fafa6
+  metadata.gz: 86c24793f077ce32dceea91c8bde07dce922a274
+  data.tar.gz: f166af0f5a9b01024978ebf2ebb5d9b7103d8a7b
 SHA512:
-  metadata.gz: aab4f3f7ed3f5da8c08b024b8b616fbbb67020cf652e7d9474b83fef9b0abeacee16a19016fd47fb3c4117071a4b1e9d6b0f491c3862626ea58351973bc06912
-  data.tar.gz: 760d9cd65c9b2a7afad5c7f47d079dc84a1e3b0d0af754099998513a3d6a2ff835fcc661bdab3d0d8100cb0884d0e8d03a902d73763266e1761c7473fe733e09
+  metadata.gz: 19d9a87a1f69496bdb00574437c3913b167d2da92d1b1b35c64412a70adfc8309f2bc78bdac5233bea310bd46543af2966b762453318e450ff6d73092626b16d
+  data.tar.gz: cfe46396685e6cec68816f38b70183317cf7585e1bbec594de6e670962151a5cd1eb4e1eb2483c0aafe43e94d741589c595c8d8e5a4cecb5124200b617c04b05

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 4.0.5 - 2015-04-02
+### Fixed
+* #131
+* Thread commands help format should be consistent with the rest of the help
+system now.
+
 ## 4.0.4 - 2015-03-27
 ### Fixed
 * #127

data/CONTRIBUTING.md

@@ -17,6 +17,11 @@ API and a lot of bugs have been recently corrected. Without this fixes,
 `byebug` will fail to work properly, so make sure you have always the last
 patch level releases of Ruby installed.
 
+Also, if you are developing on linux, make sure you have the GNU indent utility
+installed for automatic check of code style in C files. If you're developing in
+MacOSX, just make sure you keep a consistent style if you edit the C-extension
+files. Travis CI will do the automatic check anyways.
+
 
 ## Getting started
 

data/GUIDE.md

@@ -223,28 +223,28 @@ the output so that it nicely fits our screen.
 (byebug) set width 80
 Maximum width of byebug's output is 80
 (byebug) ps private_methods
-Array             default_src_encoding  open                        sleep      
-Complex           define_method         p                           spawn      
-Digest            eval                  pp                          sprintf    
-Float             exec                  print                       srand      
-Hash              exit                  printf                      syscall    
-Integer           exit!                 private                     system     
-Pathname          fail                  proc                        test       
-Rational          fork                  public                      throw      
-String            format                putc                        timeout    
-URI               gem_original_require  puts                        trace_var  
-__callee__        gets                  raise                       trap       
+Array             default_src_encoding  open                        sleep
+Complex           define_method         p                           spawn
+Digest            eval                  pp                          sprintf
+Float             exec                  print                       srand
+Hash              exit                  printf                      syscall
+Integer           exit!                 private                     system
+Pathname          fail                  proc                        test
+Rational          fork                  public                      throw
+String            format                putc                        timeout
+URI               gem_original_require  puts                        trace_var
+__callee__        gets                  raise                       trap
 __dir__           global_variables      rand                        untrace_var
-__method__        include               readline                    using      
-`                 initialize            readlines                   warn       
-abort             initialize_clone      require                     y          
-at_exit           initialize_copy       require_relative          
-autoload          initialize_dup        respond_to_missing?       
-autoload?         iterator?             rubygems_require          
-binding           lambda                select                    
-block_given?      load                  set_trace_func            
-caller            local_variables       singleton_method_added    
-caller_locations  loop                  singleton_method_removed  
+__method__        include               readline                    using
+`                 initialize            readlines                   warn
+abort             initialize_clone      require                     y
+at_exit           initialize_copy       require_relative
+autoload          initialize_dup        respond_to_missing?
+autoload?         iterator?             rubygems_require
+binding           lambda                select
+block_given?      load                  set_trace_func
+caller            local_variables       singleton_method_added
+caller_locations  loop                  singleton_method_removed
 catch             method_missing        singleton_method_undefined
 (byebug)
 ```
@@ -500,7 +500,7 @@ Run options: --seed 31679
 
 [2, 11] in test_triangle.rb
     2: require_relative 'triangle.rb'
-    3: 
+    3:
     4: class TestTriangle < Minitest::Test
     5:   def test_basic
     6:     byebug
@@ -1035,7 +1035,7 @@ run a sleeping thread.
 
 Now we can investigate the problem in the employer's side:
 
-``bash
+```bash
 (byebug) s
 [30, 39] in /path/to/company.rb
    30:
@@ -1088,7 +1088,7 @@ Now we can investigate the problem in the employer's side:
    39:         show_off(@results.pop)
    40:       end
 (byebug)
-``
+```
 
 Now we can see the problem, the `@results` variable is always empty! The
 employee forgot to leave the results in his manager's deck. We fix it by
@@ -1193,14 +1193,14 @@ get a line trace, `tracer` is most likely faster than `byebug`.
 ```bash
 $ time byebug --trace --no-stop hanoi.rb > /dev/null
 
-real	0m0.743s
-user	0m0.668s
-sys	0m0.068s
+real 0m0.743s
+user 0m0.668s
+sys  0m0.068s
 $ time ruby -rtracer hanoi.rb > /dev/null
 
-real	0m0.077s
-user	0m0.072s
-sys	0m0.004s
+real 0m0.077s
+user 0m0.072s
+sys  0m0.004s
 ```
 
 ### Byebug default options
@@ -1620,19 +1620,40 @@ will just call pretty-print.
  :pretty_inspect,
  :byebug]
 (byebug) putl Kernel.instance_methods
-nil?  <=>              tainted?    frozen?            private_methods             remove_instance_variable  public_send    define_singleton_method  byebug
-===   class            untaint     to_s               public_methods              instance_of?              respond_to?    object_id
-=~    singleton_class  untrust     inspect            instance_variables          kind_of?                  extend         to_enum
-!~    clone            untrusted?  methods            instance_variable_get       is_a?                     display        enum_for
-eql?  dup              trust       singleton_methods  instance_variable_set       tap                       method         gem
-hash  taint            freeze      protected_methods  instance_variable_defined?  send                      public_method  pretty_inspect
+nil?             trust                       is_a?
+===              freeze                      tap
+=~               frozen?                     send
+!~               to_s                        public_send
+eql?             inspect                     respond_to?
+hash             methods                     extend
+<=>              singleton_methods           display
+class            protected_methods           method
+singleton_class  private_methods             public_method
+clone            public_methods              singleton_method
+dup              instance_variables          define_singleton_method
+itself           instance_variable_get       object_id
+taint            instance_variable_set       to_enum
+tainted?         instance_variable_defined?  enum_for
+untaint          remove_instance_variable    gem
+untrust          instance_of?                pretty_inspect
+untrusted?       kind_of?
 (byebug) ps Kernel.instance_methods
-!~      clone                    extend   instance_of?                kind_of?        private_methods           respond_to?        tap      untrusted?
-<=>     define_singleton_method  freeze   instance_variable_defined?  method          protected_methods         send               to_enum
-===     display                  frozen?  instance_variable_get       methods         public_method             singleton_class    to_s   
-=~      dup                      gem      instance_variable_set       nil?            public_methods            singleton_methods  trust  
-byebug  enum_for                 hash     instance_variables          object_id       public_send               taint              untaint
-class   eql?                     inspect  is_a?                       pretty_inspect  remove_instance_variable  tainted?           untrust
+!~                       instance_of?                public_send
+<=>                      instance_variable_defined?  remove_instance_variable
+===                      instance_variable_get       respond_to?
+=~                       instance_variable_set       send
+class                    instance_variables          singleton_class
+clone                    is_a?                       singleton_method
+define_singleton_method  itself                      singleton_methods
+display                  kind_of?                    taint
+dup                      method                      tainted?
+enum_for                 methods                     tap
+eql?                     nil?                        to_enum
+extend                   object_id                   to_s
+freeze                   pretty_inspect              trust
+frozen?                  private_methods             untaint
+gem                      protected_methods           untrust
+hash                     public_method               untrusted?
 ```
 
 Finally, if you need more advanced functionality from REPL's, you can enter

data/lib/byebug/attacher.rb

@@ -7,12 +7,12 @@ module Byebug
   # events occur. Before entering byebug the init script is read.
   #
   def self.attach
-    return errmsg('Byebug already started. Ignoring `byebug` call.') if started?
+    unless started?
+      self.mode = :attached
 
-    setup_cmd_line_args
-
-    start
-    run_init_script
+      start
+      run_init_script
+    end
 
     current_context.step_out(2, true)
   end

data/lib/byebug/commands/break.rb

@@ -15,15 +15,14 @@ module Byebug
     def execute
       return puts(self.class.help) unless @match[1]
 
-      brkpt = line_breakpoint(@match[1]) || method_breakpoint(@match[1])
+      b = line_breakpoint(@match[1]) || method_breakpoint(@match[1])
+
       if syntax_valid?(@match[2])
-        return puts(
-          pr('break.created', id: brkpt.id, file: brkpt.source, line: brkpt.pos)
-        )
+        return puts(pr('break.created', id: b.id, file: b.source, line: b.pos))
       end
 
       errmsg(pr('break.errors.expression', expr: @match[2]))
-      brkpt.enabled = false
+      b.enabled = false
     rescue => e
       errmsg(e.message)
     end

data/lib/byebug/commands/catch.rb

@@ -7,8 +7,6 @@ module Byebug
   # Enables the user to catch unhandled assertion when they happen.
   #
   class CatchCommand < Command
-    self.allow_in_control = false
-
     def regexp
       /^\s* cat(?:ch)? (?:\s+(\S+))? (?:\s+(off))? \s*$/x
     end

data/lib/byebug/commands/delete.rb

@@ -21,7 +21,7 @@ module Byebug
         return nil
       end
 
-      @match[1].split(/[ \t]+/).each do |number|
+      @match[1].split(/ +/).each do |number|
         pos, err = get_int(number, 'Delete', 1)
 
         return errmsg(err) unless pos

data/lib/byebug/commands/enable_disable.rb

@@ -76,7 +76,7 @@ module Byebug
 
       return errmsg(pr('toggle.errors.syntax', toggle: cmd)) unless @match[2]
 
-      args = @match[2].split(/[ \t]+/)
+      args = @match[2].split(/ +/)
       param = args.shift
       subcmd = Command.find(Subcommands, param)
       if subcmd

data/lib/byebug/commands/info.rb

@@ -176,7 +176,7 @@ module Byebug
     def execute
       return puts(self.class.help) unless @match[1]
 
-      args = @match[1].split(/[ \t]+/)
+      args = @match[1].split(/ +/)
       param = args.shift
       subcmd = Command.find(Subcommands, param)
       return errmsg "Unknown info command #{param}\n" unless subcmd

data/lib/byebug/commands/thread.rb

@@ -0,0 +1,145 @@
+require 'byebug/command'
+
+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
+
+    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)
+
+      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
+    end
+  end
+end

data/lib/byebug/commands/untracevar.rb

@@ -14,7 +14,7 @@ module Byebug
     def execute
       var = @match[1]
       if global_variables.include?(:"#{var}")
-        eval("untrace_var(:\"#{var}\")")
+        untrace_var(:"#{var}")
         puts pr('trace.messages.undo', var: var)
       else
         errmsg pr('trace.errors.not_global', var: var)

data/lib/byebug/context.rb

@@ -29,6 +29,9 @@ module Byebug
       self.class.ignored_files.include?(path)
     end
 
+    #
+    # Context's stack size
+    #
     def stack_size
       return 0 unless backtrace
 

data/lib/byebug/core.rb

@@ -10,12 +10,6 @@ require 'byebug/printers/plain'
 module Byebug
   extend self
 
-  class NoScript < StandardError
-  end
-
-  class NonExistentScript < StandardError
-  end
-
   #
   # Configuration file used for startup commands. Default value is .byebugrc
   #
@@ -27,15 +21,15 @@ module Byebug
   attr_accessor :handler
   self.handler = CommandProcessor.new
 
+  extend Forwardable
+  def_delegators :handler, :errmsg, :puts
+
   #
   # Main debugger's printer
   #
   attr_accessor :printer
   self.printer = Printers::Plain.new
 
-  extend Forwardable
-  def_delegators :handler, :errmsg, :puts
-
   #
   # Running mode of the debugger. Can be either:
   #
@@ -61,26 +55,6 @@ module Byebug
     run_script(cwd_rc) if File.exist?(cwd_rc) && cwd_rc != home_rc
   end
 
-  #
-  # Extracts debugged program from command line args
-  #
-  def setup_cmd_line_args
-    unless $PROGRAM_NAME.include?('bin/byebug')
-      self.mode = :attached
-      return
-    end
-
-    self.mode = :standalone
-
-    fail(NoScript, 'You must specify a program to debug...') if $ARGV.empty?
-
-    program = which($ARGV.shift)
-    program = which($ARGV.shift) if program == which('ruby')
-    fail(NonExistentScript, "The script doesn't exist") unless program
-
-    $PROGRAM_NAME = program
-  end
-
   private
 
   #
@@ -91,24 +65,6 @@ module Byebug
     processor = ControlCommandProcessor.new(interface)
     processor.process_commands
   end
-
-  #
-  # Cross-platform way of finding an executable in the $PATH.
-  # Borrowed from: http://stackoverflow.com/questions/2108727
-  #
-  def which(cmd)
-    return File.expand_path(cmd) if File.exist?(cmd)
-
-    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-      exts.each do |ext|
-        exe = File.join(path, "#{cmd}#{ext}")
-        return exe if File.executable?(exe) && !File.directory?(exe)
-      end
-    end
-
-    nil
-  end
 end
 
 #

data/lib/byebug/helper.rb

@@ -88,12 +88,31 @@ module Byebug
     end
 
     #
-    # Returns true if code is syntactically correct for Ruby.
+    # Returns true if code is syntactically correct for Ruby
     #
     def syntax_valid?(code)
-      eval("BEGIN {return true}\n#{code}", nil, '', 0)
-    rescue SyntaxError
-      false
+      return true unless code
+
+      without_stderr do
+        begin
+          RubyVM::InstructionSequence.compile(code)
+          true
+        rescue SyntaxError
+          false
+        end
+      end
+    end
+
+    #
+    # Temporarily disable output to $stderr
+    #
+    def without_stderr
+      stderr = $stderr
+      $stderr.reopen(IO::NULL)
+
+      yield
+    ensure
+      $stderr.reopen(stderr)
     end
 
     #

data/lib/byebug/runner.rb

@@ -1,12 +1,28 @@
 require 'optparse'
 require 'English'
 require 'byebug/core'
+require 'byebug/helper'
 
 module Byebug
   #
   # Responsible for starting the debugger when started from the command line.
   #
   class Runner
+    #
+    # Error class signaling absence of a script to debug
+    #
+    class NoScript < StandardError; end
+
+    #
+    # Error class signaling a non existent script to debug
+    #
+    class NonExistentScript < StandardError; end
+
+    #
+    # Error class signaling a script with invalid Ruby syntax
+    #
+    class InvalidScript < StandardError; end
+
     #
     # Special working modes that don't actually start the debugger.
     #
@@ -36,27 +52,6 @@ module Byebug
       EOB
     end
 
-    #
-    # Debugs a script only if syntax checks okay.
-    #
-    def debug_program
-      check_syntax($PROGRAM_NAME)
-
-      status = Byebug.debug_load($PROGRAM_NAME, @stop)
-      Byebug.puts "#{status}\n#{status.backtrace}" if status
-    end
-
-    #
-    # Exits and outputs error message if syntax of the given program is invalid.
-    #
-    def check_syntax(program_name)
-      output = `ruby -c "#{program_name}" 2>&1`
-      return unless $CHILD_STATUS.exitstatus != 0
-
-      Byebug.errmsg(output)
-      exit($CHILD_STATUS.exitstatus)
-    end
-
     #
     # Starts byebug to debug a program
     #
@@ -78,7 +73,7 @@ module Byebug
         return
       end
 
-      Byebug.setup_cmd_line_args
+      setup_cmd_line_args
 
       loop do
         debug_program
@@ -90,6 +85,11 @@ module Byebug
       end
     end
 
+    private
+
+    #
+    # Processes options passed from the command line
+    #
     def prepare_options
       OptionParser.new(banner, 25) do |opts|
         opts.banner = banner
@@ -139,5 +139,50 @@ module Byebug
         end
       end
     end
+
+    #
+    # Extracts debugged program from command line args
+    #
+    def setup_cmd_line_args
+      Byebug.mode = :standalone
+
+      fail(NoScript, 'You must specify a program to debug...') if $ARGV.empty?
+
+      program = which($ARGV.shift)
+      program = which($ARGV.shift) if program == which('ruby')
+      fail(NonExistentScript, "The script doesn't exist") unless program
+
+      $PROGRAM_NAME = program
+    end
+
+    include ParseFunctions
+    #
+    # Debugs a script only if syntax checks okay.
+    #
+    def debug_program
+      ok = syntax_valid?(File.read($PROGRAM_NAME))
+      fail(InvalidScript, 'The script has incorrect syntax') unless ok
+
+      error = Byebug.debug_load($PROGRAM_NAME, @stop)
+      Byebug.puts "#{status}\n#{status.backtrace}" if error
+    end
+
+    #
+    # Cross-platform way of finding an executable in the $PATH.
+    # Borrowed from: http://stackoverflow.com/questions/2108727
+    #
+    def which(cmd)
+      return File.expand_path(cmd) if File.exist?(cmd)
+
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+
+      nil
+    end
   end
 end

data/lib/byebug/version.rb

@@ -1,3 +1,3 @@
 module Byebug
-  VERSION = '4.0.4'
+  VERSION = '4.0.5'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: byebug
 version: !ruby/object:Gem::Version
-  version: 4.0.4
+  version: 4.0.5
 platform: ruby
 authors:
 - David Rodriguez
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-27 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: columnize
@@ -102,7 +102,7 @@ files:
 - lib/byebug/commands/show.rb
 - lib/byebug/commands/source.rb
 - lib/byebug/commands/stepping.rb
-- lib/byebug/commands/threads.rb
+- lib/byebug/commands/thread.rb
 - lib/byebug/commands/tracevar.rb
 - lib/byebug/commands/undisplay.rb
 - lib/byebug/commands/untracevar.rb
@@ -165,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby 2.0 fast debugger - base + CLI

data/lib/byebug/commands/threads.rb

@@ -1,237 +0,0 @@
-require 'byebug/command'
-
-#
-# TODO: Implement thread commands as a single command with subcommands, just
-# like `info`, `var`, `enable` and `disable`. This allows consistent help
-# format and we can go back to showing help for a single command in the `help`
-# command.
-#
-module Byebug
-  #
-  # Utilities to assist commands related to threads.
-  #
-  module ThreadFunctions
-    def display_context(context, should_show_top_frame = true)
-      puts pr('thread.context',
-              thread_arguments(context, should_show_top_frame))
-    end
-
-    def thread_arguments(context, should_show_top_frame = true)
-      status_flag = if context.suspended?
-                      '$'
-                    else
-                      context.thread == Thread.current ? '+' : ' '
-                    end
-      debug_flag = context.ignored? ? '!' : ' '
-
-      if should_show_top_frame
-        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
-      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)
-
-      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
-    end
-  end
-
-  #
-  # List current threads.
-  #
-  class ThreadListCommand < Command
-    include ThreadFunctions
-
-    self.allow_in_control = true
-
-    def regexp
-      /^\s* th(?:read)? \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
-
-    class << self
-      def names
-        %w(thread)
-      end
-
-      def description
-        prettify <<-EOD
-          th[read] l[ist]  Lists all threads.
-        EOD
-      end
-    end
-  end
-
-  #
-  # Show current thread.
-  #
-  class ThreadCurrentCommand < Command
-    include ThreadFunctions
-
-    def regexp
-      /^\s* th(?:read)? \s+ (?:cur(?:rent)?)? \s*$/x
-    end
-
-    def execute
-      display_context(@state.context)
-    end
-
-    class << self
-      def names
-        %w(thread)
-      end
-
-      def description
-        prettify <<-EOD
-          th[read] cur[rent]  Shows current thread.
-        EOD
-      end
-    end
-  end
-
-  #
-  # Stop execution of a thread.
-  #
-  class ThreadStopCommand < Command
-    include ThreadFunctions
-
-    self.allow_in_control = true
-    self.allow_in_post_mortem = false
-
-    def regexp
-      /^\s* th(?:read)? \s+ stop \s* (\S*) \s*$/x
-    end
-
-    def execute
-      c, err = parse_thread_num_for_cmd('thread stop', @match[1])
-      return errmsg(err) if err
-
-      c.suspend
-      display_context(c)
-    end
-
-    class << self
-      def names
-        %w(thread)
-      end
-
-      def description
-        prettify <<-EOD
-          th[read] stop <n>  Stops thread <n>.
-        EOD
-      end
-    end
-  end
-
-  #
-  # Resume execution of a thread.
-  #
-  class ThreadResumeCommand < Command
-    include ThreadFunctions
-
-    self.allow_in_control = true
-    self.allow_in_post_mortem = false
-
-    def regexp
-      /^\s* th(?:read)? \s+ resume \s* (\S*) \s*$/x
-    end
-
-    def execute
-      c, err = parse_thread_num_for_cmd('thread resume', @match[1])
-      return errmsg(err) if err
-      return errmsg pr('thread.errors.already_running') unless c.suspended?
-
-      c.resume
-      display_context(c)
-    end
-
-    class << self
-      def names
-        %w(thread)
-      end
-
-      def description
-        prettify <<-EOD
-          th[read] resume <n>   Resumes thread <n>.
-        EOD
-      end
-    end
-  end
-
-  #
-  # Switch execution to a different thread.
-  #
-  class ThreadSwitchCommand < Command
-    include ThreadFunctions
-
-    self.allow_in_control = true
-    self.allow_in_post_mortem = false
-
-    def regexp
-      /^\s* th(?:read)? \s+ sw(?:itch)? (?:\s+(\S+))? \s*$/x
-    end
-
-    def execute
-      c, err = parse_thread_num_for_cmd('thread switch', @match[1])
-      return errmsg(err) if err
-
-      display_context(c)
-
-      c.switch
-      @state.proceed
-    end
-
-    class << self
-      def names
-        %w(thread)
-      end
-
-      def description
-        prettify <<-EOD
-          th[read] sw[itch] <n>  Switches thread context to <n>.
-        EOD
-      end
-    end
-  end
-end