byebug 5.0.0 → 6.0.0

data/lib/byebug/commands/list.rb

@@ -10,34 +10,41 @@ module Byebug
     include Helpers::FileHelper
     include Helpers::ParseHelper
 
-    def regexp
+    self.allow_in_post_mortem = true
+
+    def self.regexp
       /^\s* l(?:ist)? (?:\s*([-=])|\s+(\S+))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        l[ist][[-=]][ nn-mm]
+
+        #{short_description}
+
+        Lists lines forward from current line or from the place where code was
+        last listed. If "list-" is specified, lists backwards instead. If
+        "list=" is specified, lists from current line regardless of where code
+        was last listed. A line range can also be specified to list specific
+        sections of code.
+      EOD
+    end
+
+    def self.short_description
+      'Lists lines of source code'
+    end
+
     def execute
-      exist = File.exist?(@state.file)
-      return errmsg "No sourcefile available for #{@state.file}\n" unless exist
+      msg = "No sourcefile available for #{frame.file}"
+      return errmsg(msg) unless File.exist?(frame.file)
 
-      @match ||= match('list')
-      max_lines = n_lines(@state.file)
+      max_lines = n_lines(frame.file)
       b, e = range(@match[2], max_lines)
       return errmsg('Invalid line range') unless valid_range?(b, e, max_lines)
 
       display_lines(b, e)
 
-      @state.prev_line = b
-    end
-
-    def description
-      <<-EOD
-        l[ist][[-=]][ nn-mm]
-
-        Lists lines of code forward from current line or from the place where
-        code was last listed. If "list-" is specified, lists backwards instead.
-        If "list=" is specified, lists from current line regardless of where
-        code was last listed. A line range can also be specified to list
-        specific sections of code.
-      EOD
+      processor.prev_line = b
     end
 
     private
@@ -99,9 +106,10 @@ module Byebug
     end
 
     def lower(size, direction = '+')
-      return @state.line - size / 2 if direction == '=' || !@state.prev_line
+      prev_line = processor.prev_line
+      return frame.line - size / 2 if direction == '=' || prev_line.nil?
 
-      move(@state.prev_line, size, direction)
+      move(prev_line, size, direction)
     end
 
     def move(line, size, direction = '+')
@@ -109,16 +117,19 @@ module Byebug
     end
 
     #
-    # Show lines in @state.file from line number <min> to line number <max>.
+    # Show a range of lines in the current file.
+    #
+    # @param min [Integer] Lower bound
+    # @param max [Integer] Upper bound
     #
     def display_lines(min, max)
-      puts "\n[#{min}, #{max}] in #{@state.file}"
+      puts "\n[#{min}, #{max}] in #{frame.file}"
 
-      File.foreach(@state.file).with_index do |line, lineno|
+      File.foreach(frame.file).with_index do |line, lineno|
         break if lineno + 1 > max
         next unless (min..max).include?(lineno + 1)
 
-        mark = lineno + 1 == @state.line ? '=> ' : '   '
+        mark = lineno + 1 == frame.line ? '=> ' : '   '
         puts format("#{mark}%#{max.to_s.size}d: %s", lineno + 1, line)
       end
     end

data/lib/byebug/commands/method.rb

@@ -1,18 +1,40 @@
 require 'byebug/command'
+require 'byebug/helpers/eval'
 
 module Byebug
   #
   # Show methods of specific classes/modules/objects.
   #
   class MethodCommand < Command
-    include Columnize
+    include Helpers::EvalHelper
 
-    def regexp
+    self.allow_in_post_mortem = true
+
+    def self.regexp
       /^\s* m(?:ethod)? \s+ (i(:?nstance)?\s+)?/x
     end
 
+    def self.description
+      <<-EOD
+        m[ethod] (i[nstance][ <obj>]|<class|module>)
+
+        #{short_description}
+
+        When invoked with "instance", shows instance methods of the object
+        specified as argument or of self no object was specified.
+
+        When invoked only with a class or module, shows class methods of the
+        class or module specified as argument.
+      EOD
+    end
+
+    def self.short_description
+      'Shows methods of an object, class or module'
+    end
+
     def execute
-      obj = bb_eval(@match.post_match)
+      obj = single_thread_eval(@match.post_match)
+
       result =
         if @match[1]
           prc('method.methods', obj.methods.sort) { |item, _| { name: item } }
@@ -25,17 +47,5 @@ module Byebug
         end
       puts result
     end
-
-    def description
-      <<-EOD
-        m[ethod] (i[nstance][ <obj>]|<class|module>)
-
-        When invoked with "instance", shows instance methods of the object
-        specified as argument or of self no object was specified.
-
-        When invoked only with a class or module, shows class methods of the
-        class or module specified as argument.
-      EOD
-    end
   end
 end

data/lib/byebug/commands/next.rb

@@ -11,26 +11,28 @@ module Byebug
   class NextCommand < Command
     include Helpers::ParseHelper
 
-    self.allow_in_post_mortem = false
-
-    def regexp
+    def self.regexp
       /^\s* n(?:ext)? (?:\s+(\S+))? \s*$/x
     end
 
-    def execute
-      steps, err = parse_steps(@match[1], 'Next')
-      return errmsg(err) unless steps
-
-      @state.context.step_over(steps, @state.frame)
-      @state.proceed
-    end
-
-    def description
+    def self.description
       <<-EOD
         n[ext][ nnn]
 
-        Steps over once or nnn times.
+        #{short_description}
       EOD
     end
+
+    def self.short_description
+      'Runs one or more lines of code'
+    end
+
+    def execute
+      steps, err = parse_steps(@match[1], 'Next')
+      return errmsg(err) unless steps
+
+      context.step_over(steps, context.frame.pos)
+      processor.proceed!
+    end
   end
 end

data/lib/byebug/commands/pry.rb

@@ -1,16 +1,31 @@
 require 'byebug/command'
+require 'byebug/helpers/eval'
 
 module Byebug
   #
   # Enter Pry from byebug's prompt
   #
   class PryCommand < Command
-    def regexp
+    self.allow_in_post_mortem = true
+
+    def self.regexp
       /^\s* pry \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        pry
+
+        #{short_description}
+      EOD
+    end
+
+    def self.short_description
+      'Starts a Pry session'
+    end
+
     def execute
-      unless @state.interface.is_a?(LocalInterface)
+      unless processor.interface.is_a?(LocalInterface)
         return errmsg(pr('base.errors.only_local'))
       end
 
@@ -20,15 +35,7 @@ module Byebug
         errmsg(pr('pry.errors.not_installed'))
       end
 
-      get_binding.pry
-    end
-
-    def description
-      <<-EOD
-        pry
-
-        Starts a Pry session.
-      EOD
+      context.binding.pry
     end
   end
 end

data/lib/byebug/commands/ps.rb

@@ -5,40 +5,38 @@ require 'byebug/helpers/eval'
 
 module Byebug
   #
-  # Evaluation, pretty printing, columnizing and sorting from byebug's prompt
+  # Enhanced evaluation of expressions from byebug's prompt. Besides
+  # evaluating, it sorts and pretty prints arrays.
   #
   class PsCommand < Command
     include Helpers::EvalHelper
-    include Columnize
 
-    self.allow_in_control = true
+    self.allow_in_post_mortem = true
 
-    def regexp
-      /^\s* ps \s+/x
+    def self.regexp
+      /^\s* ps (\s+ (.+)) \s*$/x
     end
 
-    def execute
-      out = StringIO.new
-      run_with_binding do |b|
-        res = eval_with_setting(b, @match.post_match, Setting[:stack_on_error])
-
-        if res.is_a?(Array)
-          puts "#{columnize(res.map(&:to_s).sort!, Setting[:width])}"
-        else
-          PP.pp(res, out)
-          puts out.string
-        end
-      end
-    rescue
-      out.puts $ERROR_INFO.message
-    end
-
-    def description
+    def self.description
       <<-EOD
         ps <expression>
 
-        Evaluates <expression>, an array, sort and columnize its value.
+        #{short_description}
       EOD
     end
+
+    def self.short_description
+      'Evaluates an expression and prettyprints & sort the result'
+    end
+
+    def execute
+      return puts(help) unless @match[1]
+
+      res = thread_safe_eval(@match[1])
+      res = res.sort if res.respond_to?(:sort)
+
+      out = PP.pp(res, StringIO.new, Setting[:width])
+      print pr('eval.result', expr: @match[1], result: out.string)
+    end
   end
 end

data/lib/byebug/commands/quit.rb

@@ -6,29 +6,35 @@ module Byebug
   #
   class QuitCommand < Command
     self.allow_in_control = true
+    self.allow_in_post_mortem = true
 
-    def regexp
+    def self.regexp
       /^\s* q(?:uit)? \s* (?:(!|\s+unconditionally))? \s*$/x
     end
 
-    def execute
-      return unless @match[1] || confirm(pr('quit.confirmations.really'))
-
-      @state.interface.autosave
-      @state.interface.close
-      exit! # exit -> exit!: No graceful way to stop...
-    end
-
-    def description
+    def self.description
       <<-EOD
         q[uit] [!|unconditionally]
 
-        Exits from byebug.
+        #{short_description}
 
         Normally we prompt before exiting. However if the parameter
         "unconditionally" is given or command is suffixed with !, we exit
         without asking further questions.
       EOD
     end
+
+    def self.short_description
+      'Exits byebug'
+    end
+
+    def execute
+      return unless @match[1] || confirm(pr('quit.confirmations.really'))
+
+      processor.interface.autosave
+      processor.interface.close
+
+      Process.exit!
+    end
   end
 end

data/lib/byebug/commands/restart.rb

@@ -1,41 +1,45 @@
 require 'byebug/command'
+require 'byebug/helpers/path'
+require 'shellwords'
 
 module Byebug
   #
   # Restart debugged program from within byebug.
   #
   class RestartCommand < Command
-    self.allow_in_control = true
+    include Helpers::PathHelper
 
-    def regexp
-      /^\s* (?:restart|R) (?:\s+(?<args>.+))? \s*$/x
-    end
+    self.allow_in_control = true
+    self.allow_in_post_mortem = true
 
-    def execute
-      if Byebug.mode == :standalone
-        cmd = "#{Gem.bin_path('byebug', 'byebug')} #{$PROGRAM_NAME}"
-      else
-        cmd = $PROGRAM_NAME
-      end
-
-      if @match[:args]
-        cmd += " #{@match[:args]}"
-      else
-        require 'shellwords'
-        cmd += " #{$ARGV.compact.shelljoin}"
-      end
-
-      puts pr('restart.success', cmd: cmd)
-      exec(cmd)
+    def self.regexp
+      /^\s* restart (?:\s+(?<args>.+))? \s*$/x
     end
 
-    def description
+    def self.description
       <<-EOD
-        restart|R [args]
+        restart [args]
 
-        Restart the program. This is a re-exec - all byebug state
-        is lost. If command arguments are passed those are used.
+        #{short_description}
+
+        This is a re-exec - all byebug state is lost. If command arguments are
+        passed those are used.
       EOD
     end
+
+    def self.short_description
+      'Restarts the debugged program'
+    end
+
+    def execute
+      argv = [$PROGRAM_NAME]
+
+      argv.unshift(bin_file) if Byebug.mode == :standalone
+
+      argv += (@match[:args] ? @match[:args].shellsplit : $ARGV.compact)
+
+      puts pr('restart.success', cmd: argv.shelljoin)
+      exec(*argv)
+    end
   end
 end

data/lib/byebug/commands/save.rb

@@ -6,11 +6,31 @@ module Byebug
   #
   class SaveCommand < Command
     self.allow_in_control = true
+    self.allow_in_post_mortem = true
 
-    def regexp
+    def self.regexp
       /^\s* sa(?:ve)? (?:\s+(\S+))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        save[ FILE]
+
+        #{short_description}
+
+        Byebug state is saved as a script file. This includes breakpoints,
+        catchpoints, display expressions and some settings. If no filename is
+        given, byebug will fabricate one.
+
+        Use the "source" command in another debug session to restore the saved
+        file.
+      EOD
+    end
+
+    def self.short_description
+      'Saves current byebug session to a file'
+    end
+
     def execute
       file = File.open(@match[1] || Setting[:savefile], 'w')
 
@@ -23,18 +43,6 @@ module Byebug
       file.close
     end
 
-    def description
-      <<-EOD
-        save[ FILE]
-
-        Saves current byebug state to FILE as a script file. This includes
-        breakpoints, catchpoints, display expressions and some settings. If no
-        filename is given, we will fabricate one.
-
-        Use the "source" command in another debug session to restore them.
-      EOD
-    end
-
     private
 
     def save_breakpoints(file)
@@ -50,11 +58,11 @@ module Byebug
     end
 
     def save_displays(file)
-      @state.display.each { |d| file.puts "display #{d[1]}" if d[0] }
+      Byebug.displays.each { |d| file.puts "display #{d[1]}" if d[0] }
     end
 
     def save_settings(file)
-      %w(autoeval autoirb autolist basename).each do |setting|
+      %w(autoirb autolist basename).each do |setting|
         file.puts "set #{setting} #{Setting[setting.to_sym]}"
       end
     end