byebug 3.2.0 → 3.3.0

data/lib/byebug/commands/display.rb

@@ -1,25 +1,29 @@
 module Byebug
+  #
+  # Custom display utilities.
+  #
   module DisplayFunctions
     def display_expression(exp)
-      print "#{exp} = #{bb_warning_eval(exp).inspect}\n"
+      "#{exp} = #{bb_warning_eval(exp).inspect}"
     end
 
     def active_display_expressions?
-      @state.display.select{|d| d[0]}.size > 0
+      @state.display.select { |d| d[0] }.size > 0
     end
 
     def print_display_expressions
       n = 1
-      for d in @state.display
-        if d[0]
-          print "#{n}: "
-          display_expression(d[1])
-        end
+      @state.display.each do |d|
+        puts "#{n}: #{display_expression(d[1])}" if d[0]
         n += 1
       end
     end
   end
 
+  #
+  # Implements the functionality of adding custom expressions to be displayed
+  # every time the debugger stops.
+  #
   class AddDisplayCommand < Command
     self.allow_in_post_mortem = false
 
@@ -30,8 +34,7 @@ module Byebug
     def execute
       exp = @match[1]
       @state.display.push [true, exp]
-      print "#{@state.display.size}: "
-      display_expression(exp)
+      puts "#{@state.display.size}: #{display_expression(exp)}"
     end
 
     class << self
@@ -40,11 +43,16 @@ module Byebug
       end
 
       def description
-        %{disp[lay] <expression>\tadd expression into display expression list}
+        %(disp[lay] <expression>
+
+          Add <expression> into display expression list.)
       end
     end
   end
 
+  #
+  # Displays the value of enabled expressions.
+  #
   class DisplayCommand < Command
     self.allow_in_post_mortem = false
 
@@ -66,49 +74,7 @@ module Byebug
       end
 
       def description
-        %{disp[lay]\t\tdisplay expression list}
-      end
-    end
-  end
-
-  class DeleteDisplayCommand < Command
-    self.allow_in_post_mortem = false
-
-    def regexp
-      /^\s* undisp(?:lay)? (?:\s+(\S+))? \s*$/x
-    end
-
-    def execute
-      unless pos = @match[1]
-        if confirm('Clear all expressions? (y/n) ')
-          for d in @state.display
-            d[0] = false
-          end
-        end
-      else
-        pos = get_int(pos, 'Undisplay')
-        return unless pos
-        if @state.display[pos-1]
-          @state.display[pos-1][0] = nil
-        else
-          errmsg "Display expression %d is not defined.\n", pos
-        end
-      end
-    end
-
-    class << self
-      def names
-        %w(undisplay)
-      end
-
-      def description
-        %{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.}
+        %(disp[lay]        Display expression list.)
       end
     end
   end

data/lib/byebug/commands/edit.rb

@@ -1,4 +1,7 @@
 module Byebug
+  #
+  # Edit a file from byebug's prompt.
+  #
   class EditCommand < Command
     self.allow_in_control = true
 
@@ -7,13 +10,13 @@ module Byebug
     end
 
     def execute
-      if not @match[1]
+      if !@match[1]
         unless @state.file
           return errmsg "We are not in a state that has an associated file.\n"
         end
         file = @state.file
         line = @state.line if @state.line
-      elsif @pos_match = /([^:]+)[:]([0-9]+)/.match(@match[1])
+      elsif (@pos_match = /([^:]+)[:]([0-9]+)/.match(@match[1]))
         file, line = @pos_match.captures
       elsif File.exist?(@match[1])
         file = @match[1]
@@ -37,11 +40,11 @@ module Byebug
       end
 
       def description
-        %{edit[ file:lineno]\tEdit specified file.
+        %(edit[ file:lineno]        Edit specified files.
 
           With no argument, edits file containing most recent line listed.
           Editing targets can also be specified to start editing at a specific
-          line in a specific file.}
+          line in a specific file.)
       end
     end
   end

data/lib/byebug/commands/enable_disable.rb

@@ -0,0 +1,130 @@
+module Byebug
+  #
+  # Mixin to assist command parsing
+  #
+  module EnableDisableFunctions
+    def enable_disable_breakpoints(is_enable, args)
+      return errmsg('No breakpoints have been set') if Breakpoint.none?
+
+      all_breakpoints = Byebug.breakpoints.sort_by { |b| b.id }
+      if args.empty?
+        selected_breakpoints = all_breakpoints
+      else
+        selected_ids = []
+        args.each do |pos|
+          last_id = all_breakpoints.last.id
+          pos, err = get_int(pos, "#{is_enable} breakpoints", 1, last_id)
+          return errmsg(err) unless pos
+
+          selected_ids << pos
+        end
+        selected_breakpoints = all_breakpoints.select do
+          |b| selected_ids.include?(b.id)
+        end
+      end
+
+      selected_breakpoints.each do |b|
+        enabled = ('enable' == is_enable)
+        if enabled && !syntax_valid?(b.expr)
+          return errmsg("Expression \"#{b.expr}\" syntactically incorrect; " \
+                        'breakpoint remains disabled.')
+        end
+
+        b.enabled = enabled
+      end
+    end
+
+    def enable_disable_display(is_enable, args)
+      if 0 == @state.display.size
+        return errmsg('No display expressions have been set')
+      end
+
+      args.each do |pos|
+        pos, err = get_int(pos, "#{is_enable} display", 1, @state.display.size)
+        return errmsg(err) unless pos
+
+        @state.display[pos - 1][0] = ('enable' == is_enable)
+      end
+    end
+  end
+
+  #
+  # Enabling or disabling custom display expressions or breakpoints.
+  #
+  class EnableDisableCommand < Command
+    Subcommands = [
+      ['breakpoints', 2, 'Enable/disable breakpoints. Give breakpoint '      \
+                         'numbers (separated by spaces) as arguments or no ' \
+                         'argument at all if you want to enable/disable '    \
+                         'every breakpoint'],
+      ['display', 2, 'Enable/disable some expressions to be displayed when ' \
+                     ' when program stops. Arguments are the code numbers '  \
+                     'of the expressions to resume/stop displaying. Do '     \
+                     '"info display" to see the current list of code '       \
+                     'numbers']
+    ].map do |name, min, help|
+      Subcmd.new(name, min, help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* (dis|en)(?:able)? (?:\s+(.+))? \s*$/x
+    end
+
+    def execute
+      cmd = @match[1] == 'dis' ? 'disable' : 'enable'
+
+      return errmsg("\"#{cmd}\" must be followed by \"display\", " \
+                    "\"breakpoints\" or breakpoint ids") unless @match[2]
+
+      args = @match[2].split(/[ \t]+/)
+      param = args.shift
+      subcmd = Command.find(Subcommands, param)
+      if subcmd
+        send("#{cmd}_#{subcmd.name}", args)
+      else
+        send("#{cmd}_breakpoints", args.unshift(param))
+      end
+    end
+
+    def enable_breakpoints(args)
+      enable_disable_breakpoints('enable', args)
+    end
+
+    def enable_display(args)
+      enable_disable_display('enable', args)
+    end
+
+    def disable_breakpoints(args)
+      enable_disable_breakpoints('disable', args)
+    end
+
+    def disable_display(args)
+      enable_disable_display('disable', args)
+    end
+
+    class << self
+      def names
+        %w((en|dis)able)
+      end
+
+      def description
+        %{(en|dis)[able][[ (breakpoints|display)][ n1[ n2[ ...[ nn]]]]]
+
+         Enables or disables breakpoints or displays.
+
+         "enable" by itself enables all breakpoints, just like
+         "enable breakpoints". On the other side, "disable" or
+         "disable breakpoints" disable all breakpoints.
+
+         You can also specify a space separated list of breakpoint numbers to
+         enable or disable specific breakpoints. You can use either
+         "enable <id1> ... <idn>" or "enable breakpoints <id1> ... <idn>" and
+         the same with "disable".
+
+         If instead of "breakpoints" you specify "display", the command will
+         work exactly the same way, but displays will get enabled/disabled
+         instead of breakpoints.}
+      end
+    end
+  end
+end

data/lib/byebug/commands/eval.rb

@@ -1,6 +1,10 @@
+require 'English'
 require 'pp'
 
 module Byebug
+  #
+  # Utilities used by the eval command
+  #
   module EvalFunctions
     def run_with_binding
       binding = get_binding
@@ -8,6 +12,9 @@ module Byebug
     end
   end
 
+  #
+  # Evaluation of expressions from byebug's prompt.
+  #
   class EvalCommand < Command
     self.allow_in_control = true
 
@@ -24,13 +31,13 @@ module Byebug
       expr = @match ? @match.post_match : @input
       run_with_binding do |b|
         if Setting[:stack_on_error]
-          print "#{bb_eval(expr, b).inspect}\n"
+          puts "#{bb_eval(expr, b).inspect}"
         else
-          print "#{bb_warning_eval(expr, b).inspect}\n"
+          puts "#{bb_warning_eval(expr, b).inspect}"
         end
       end
     rescue
-      print "#{$!.class} Exception: #{$!.message}\n"
+      puts "#{$ERROR_INFO.class} Exception: #{$ERROR_INFO.message}"
     end
 
     class << self
@@ -39,15 +46,19 @@ module Byebug
       end
 
       def description
-        %{(p|e[val]) expression
+        %{(p|e[val]) <expression>
+
+          Evaluates <expression> and prints its value.
 
-          Evaluate expression and print its value
           * NOTE - unknown input is automatically evaluated, to turn this off
-          use 'set noautoeval'}
+          use 'set noautoeval'.}
       end
     end
   end
 
+  #
+  # Evaluation and pretty printing from byebug's prompt.
+  #
   class PPCommand < Command
     self.allow_in_control = true
 
@@ -64,9 +75,9 @@ module Byebug
           PP.pp(bb_warning_eval(@match.post_match, b), out)
         end
       end
-      print out.string
+      puts out.string
     rescue
-      out.puts $!.message
+      out.puts $ERROR_INFO.message
     end
 
     class << self
@@ -75,11 +86,16 @@ module Byebug
       end
 
       def description
-        %{pp expression\tevaluate expression and pretty-print its value}
+        %(pp <expression>
+
+          Evaluates <expression> and pretty-prints its value.)
       end
     end
   end
 
+  #
+  # Evaluation, pretty printing and columnizing from byebug's prompt.
+  #
   class PutLCommand < Command
     include Columnize
     self.allow_in_control = true
@@ -97,15 +113,15 @@ module Byebug
           vals = bb_warning_eval(@match.post_match, b)
         end
         if vals.is_a?(Array)
-          vals = vals.map{|item| item.to_s}
-          print "#{columnize(vals, Setting[:width])}\n"
+          vals = vals.map { |item| item.to_s }
+          puts "#{columnize(vals, Setting[:width])}"
         else
           PP.pp(vals, out)
-          print out.string
+          puts out.string
         end
       end
     rescue
-      out.puts $!.message
+      out.puts $ERROR_INFO.message
     end
 
     class << self
@@ -114,13 +130,16 @@ module Byebug
       end
 
       def description
-        %{putl expression
+        %(putl <expression>
 
-          Evaluate expression, an array, and columnize its value}
+          Evaluates <expression>, an array, and columnize its value.)
       end
     end
   end
 
+  #
+  # Evaluation, pretty printing, columnizing and sorting from byebug's prompt
+  #
   class PSCommand < Command
     include Columnize
     self.allow_in_control = true
@@ -138,15 +157,15 @@ module Byebug
           vals = bb_warning_eval(@match.post_match, b)
         end
         if vals.is_a?(Array)
-          vals = vals.map{|item| item.to_s}
-          print "#{columnize(vals.sort!, Setting[:width])}\n"
+          vals = vals.map { |item| item.to_s }
+          puts "#{columnize(vals.sort!, Setting[:width])}"
         else
           PP.pp(vals, out)
-          print out.string
+          puts out.string
         end
       end
     rescue
-      out.puts $!.message
+      out.puts $ERROR_INFO.message
     end
 
     class << self
@@ -155,11 +174,10 @@ module Byebug
       end
 
       def description
-        %{ps expression
+        %(ps <expression>
 
-          Evaluate expression, an array, sort and columnize its value}
+          Evaluates <expression>, an array, sort and columnize its value.)
       end
     end
   end
-
 end

data/lib/byebug/commands/finish.rb

@@ -1,4 +1,9 @@
 module Byebug
+  #
+  # Implements the finish functionality.
+  #
+  # Allows the user to continue execution until certain frames are finished.
+  #
   class FinishCommand < Command
     self.allow_in_post_mortem = false
 
@@ -8,8 +13,12 @@ module Byebug
 
     def execute
       max_frames = Context.stack_size - @state.frame_pos
-      n_frames = get_int(@match[1], 'finish', 0, max_frames - 1, 1)
-      return nil unless n_frames
+      if @match[1]
+        n_frames, err = get_int(@match[1], 'finish', 0, max_frames - 1)
+        return errmsg(err) unless n_frames
+      else
+        n_frames = 1
+      end
 
       force = n_frames == 0 ? true : false
       @state.context.step_out(@state.frame_pos + n_frames, force)
@@ -23,11 +32,11 @@ module Byebug
       end
 
       def description
-        %{fin[ish][ n_frames]\tExecute until frame returns.
+        %(fin[ish][ n_frames]        Execute until frame returns.
 
           If no number is given, we run until the current frame returns. If a
           number of frames `n_frames` is given, then we run until `n_frames`
-          return from the current position.}
+          return from the current position.)
       end
     end
   end