byebug 3.2.0 → 3.3.0

data/lib/byebug/command.rb

@@ -3,22 +3,64 @@ require 'forwardable'
 require 'byebug/helper'
 
 module Byebug
+  #
+  # Parent class of all byebug commands.
+  #
+  # Subclasses need to implement a `regexp` and an `execute` command.
+  #
   class Command
     Subcmd = Struct.new(:name, :min, :help)
 
+    def initialize(state)
+      @match, @state = nil, state
+    end
+
+    def match(input)
+      @match = regexp.match(input)
+    end
+
+    protected
+
+    extend Forwardable
+    def_delegators :@state, :errmsg, :puts
+
+    def confirm(msg)
+      @state.confirm(msg) == 'y'
+    end
+
+    def bb_eval(str, b = get_binding)
+      eval(str, b)
+    rescue StandardError, ScriptError => e
+      at = eval('Thread.current.backtrace_locations', b)
+      puts "#{at.shift}: #{e.class} Exception(#{e.message})"
+      at.each { |path| puts "\tfrom #{path}" }
+      nil
+    end
+
+    def bb_warning_eval(str, b = get_binding)
+      eval(str, b)
+    rescue StandardError, ScriptError => e
+      puts "#{e.class} Exception: #{e.message}"
+      nil
+    end
+
+    def get_binding(pos = @state.frame_pos)
+      @state.context ? @state.context.frame_binding(pos) : TOPLEVEL_BINDING
+    end
+
     class << self
-      attr_accessor :allow_in_control, :unknown
+      attr_accessor :allow_in_control
       attr_writer :allow_in_post_mortem, :always_run
 
       def allow_in_post_mortem
-        @allow_in_post_mortem ||= !defined?(@allow_in_post_mortem) ? true : false
+        !defined?(@allow_in_post_mortem) ? true : false
       end
 
       def always_run
         @always_run ||= 0
       end
 
-      def help(args)
+      def help(args = nil)
         if args && args[1]
           output = format_subcmd(args[1])
         else
@@ -28,36 +70,33 @@ module Byebug
         output
       end
 
-      def find(subcmds, param)
-        param.downcase!
-        for try_subcmd in subcmds do
-          if (param.size >= try_subcmd.min) and
-              (try_subcmd.name[0..param.size-1] == param)
-            return try_subcmd
+      def find(subcmds, str)
+        str.downcase!
+        subcmds.each do |subcmd|
+          if (str.size >= subcmd.min) && (subcmd.name[0..str.size - 1] == str)
+            return subcmd
           end
         end
-        return nil
+
+        nil
       end
 
       def format_subcmd(subcmd_name)
         subcmd = find(self::Subcommands, subcmd_name)
-        return "Invalid \"#{names.join("|")}\" " \
+        return "Invalid \"#{names.join('|')}\" " \
                "subcommand \"#{args[1]}\"." unless subcmd
 
-        return "#{subcmd.help}.\n"
+        "\n  #{subcmd.help}.\n\n"
       end
 
       def format_subcmds
-        cmd_name = names.join("|")
-        s = "\n"                                     \
-            "--\n"                                   \
-            "List of \"#{cmd_name}\" subcommands:\n" \
-            "--\n"
+        header = names.join('|')
+        s = "  List of \"#{header}\" subcommands:\n  --\n"
         w = self::Subcommands.map(&:name).max_by(&:size).size
-        for subcmd in self::Subcommands do
-          s += sprintf "%s %-#{w}s -- %s\n", cmd_name, subcmd.name, subcmd.help
+        self::Subcommands.each do |subcmd|
+          s += format("  %s %-#{w}s -- %s\n", header, subcmd.name, subcmd.help)
         end
-        return s
+        s + "\n"
       end
 
       def commands
@@ -73,58 +112,11 @@ module Byebug
           require file
         end
 
-        Byebug.constants.grep(/Functions$/).map {
-          |name| Byebug.const_get(name)
-        }.each { |mod| include mod }
-      end
-    end
-
-    def initialize(state)
-      @match, @state = nil, state
-    end
-
-    def match(input)
-      @match = regexp.match(input)
-    end
-
-    protected
-
-      extend Forwardable
-      def_delegators :@state, :errmsg, :print
-
-      def confirm(msg)
-        @state.confirm(msg) == 'y'
-      end
-
-      def bb_eval(str, b = get_binding)
-        begin
-          eval(str, b)
-        rescue StandardError, ScriptError => e
-          at = eval('Thread.current.backtrace_locations(1)', b)
-          print "#{at.shift}: #{e.class} Exception(#{e.message})\n"
-          for i in at
-            print "\tfrom #{i}\n"
-          end
-          nil
-        end
-      end
-
-      def bb_warning_eval(str, b = get_binding)
-        begin
-          eval(str, b)
-        rescue StandardError, ScriptError => e
-          print "#{e.class} Exception: #{e.message}\n"
-          nil
+        Byebug.constants.grep(/Functions$/).map do |name|
+          include Byebug.const_get(name)
         end
       end
-
-      def get_binding pos = @state.frame_pos
-        @state.context ? @state.context.frame_binding(pos) : TOPLEVEL_BINDING
-      end
-
-      def get_context(thnum)
-        Byebug.contexts.find {|c| c.thnum == thnum}
-      end
+    end
   end
 
   Command.load_commands

data/lib/byebug/commands/break.rb

@@ -1,14 +1,19 @@
 module Byebug
+  #
+  # Implements breakpoint functionality
+  #
   class BreakCommand < Command
     self.allow_in_post_mortem = false
     self.allow_in_control = true
 
+    POSITION_REGEXP = '(?:(\d+)|(.+?)[:.#]([^.:\s]+))'
+
     def regexp
-      /^\s* b(?:reak)? (?:\s+ #{Position_regexp})? (?:\s+(.+))? \s*$/x
+      /^\s* b(?:reak)? (?:\s+ #{POSITION_REGEXP})? (?:\s+(.+))? \s*$/x
     end
 
     def execute
-      return print BreakCommand.help(nil) if BreakCommand.names.include?(@match[0])
+      return puts(self.class.help) if self.class.names.include?(@match[0])
 
       if @match[1]
         line, _, _, expr = @match.captures
@@ -17,15 +22,15 @@ module Byebug
       end
 
       if expr && file.nil? && line.nil?
-        return errmsg "Invalid breakpoint location: #{expr}\n"
+        return errmsg("Invalid breakpoint location: #{expr}")
       elsif expr && expr !~ /^\s*if\s+(.+)/
-        return errmsg "Expecting \"if\" in breakpoint condition, got: #{expr}\n"
+        return errmsg("Expecting \"if\" in breakpoint condition, got: #{expr}")
       else
         expr = $1
       end
 
       if file.nil? && !@state.context
-        return errmsg "We are not in a state that has an associated file\n"
+        return errmsg('We are not in a state that has an associated file')
       end
 
       file = @state.file if file.nil?
@@ -33,37 +38,32 @@ module Byebug
 
       if line =~ /^\d+$/
         path = CommandProcessor.canonic_file(file)
-        return errmsg "No file named #{path}\n" unless File.exist?(file)
+        return errmsg("No file named #{path}") unless File.exist?(file)
 
-        line, n = line.to_i, File.foreach(file).count
-        return errmsg "There are only #{n} lines in file #{path}\n" if line > n
+        l, n = line.to_i, File.foreach(file).count
+        return errmsg("There are only #{n} lines in file #{path}") if l > n
 
         autoreload = Setting[:autoreload]
         possible_lines = LineCache.trace_line_numbers(file, autoreload)
-        if !possible_lines.member?(line)
-          return errmsg \
-            "Line #{line} is not a valid breakpoint in file #{path}\n"
+        unless possible_lines.member?(l)
+          return errmsg("Line #{l} is not a valid breakpoint in file #{path}")
         end
 
-        b = Byebug.add_breakpoint file, line, expr
-        print "Created breakpoint #{b.id} at #{path}:#{line}\n"
+        b = Breakpoint.add(file, l, expr)
+        puts "Created breakpoint #{b.id} at #{path}:#{l}"
 
-        if !syntax_valid?(expr)
-          errmsg "Incorrect expression \"#{expr}\"; breakpoint disabled.\n"
+        unless syntax_valid?(expr)
+          errmsg("Incorrect expression \"#{expr}\"; breakpoint disabled.")
           b.enabled = false
         end
 
       else
-        klass = bb_warning_eval(file)
-        if klass && klass.kind_of?(Module)
-          class_name = klass.name
-        else
-          return errmsg "Unknown class #{file}\n"
-        end
+        kl = bb_warning_eval(file)
+        return errmsg("Unknown class #{file}") unless kl && kl.is_a?(Module)
 
-        method = line.intern
-        b = Byebug.add_breakpoint class_name, method, expr
-        print "Created breakpoint #{b.id} at #{class_name}::#{method}\n"
+        class_name, method = kl.name, line.intern
+        b = Breakpoint.add(class_name, method, expr)
+        puts "Created breakpoint #{b.id} at #{class_name}::#{method}"
       end
     end
 

data/lib/byebug/commands/catchpoint.rb

@@ -1,4 +1,9 @@
 module Byebug
+  #
+  # Implements exception catching.
+  #
+  # Enables the user to catch unhandled assertion when they happen.
+  #
   class CatchCommand < Command
     self.allow_in_control = true
 
@@ -10,23 +15,23 @@ module Byebug
       excn = @match[1]
       return info_catch unless excn
 
-      if not @match[2]
+      if !@match[2]
         if 'off' == @match[1]
           Byebug.catchpoints.clear if
-            confirm("Delete all catchpoints? (y or n) ")
+            confirm('Delete all catchpoints? (y or n) ')
         else
-          print "Warning #{@match[1]} is not known to be a Class\n" unless
+          puts "Warning #{@match[1]} is not known to be a Class" unless
             bb_eval "#{@match[1]}.is_a?(Class)", get_binding
           Byebug.add_catchpoint @match[1]
-          print "Catching exception #{@match[1]}.\n"
+          puts "Catching exception #{@match[1]}."
         end
       elsif @match[2] != 'off'
-        errmsg "Off expected. Got #{@match[2]}\n"
+        errmsg "Off expected. Got #{@match[2]}"
       elsif Byebug.catchpoints.member?(@match[1])
         Byebug.catchpoints.delete @match[1]
-        print "Catch for exception #{match[1]} removed.\n"
+        errmsg "Catch for exception #{match[1]} removed"
       else
-        return errmsg "Catch for exception #{@match[1]} not found\n"
+        errmsg "Catch for exception #{@match[1]} not found"
       end
     end
 
@@ -36,9 +41,12 @@ module Byebug
       end
 
       def description
-        %{cat[ch]\t\t\t\tLists catchpoints
-          cat[ch] off\t\t\tDeletes all catchpoints
-          cat[ch] <exception> [off]\tEnable/disable handling <exception>.}
+        %(cat[ch][ (off|<exception>[ off])]
+
+          "catch" lists catchpoints.
+          "catch off" deletes all catchpoints.
+          "catch <exception>" enables handling <exception>.
+          "catch <exception> off" disables handling <exception>.)
       end
     end
   end

data/lib/byebug/commands/condition.rb

@@ -1,4 +1,9 @@
 module Byebug
+  #
+  # Implements conditions on breakpoints.
+  #
+  # Adds the ability to stop on breakpoints only under certain conditions.
+  #
   class ConditionCommand < Command
     self.allow_in_post_mortem = false
 
@@ -7,24 +12,20 @@ module Byebug
     end
 
     def execute
-      return print ConditionCommand.help(nil) unless @match[1]
+      return puts(ConditionCommand.help) unless @match[1]
 
       breakpoints = Byebug.breakpoints.sort_by { |b| b.id }
-      largest = breakpoints.inject(0) do |tally, b|
-        tally = b.id if b.id > tally
-      end
+      return errmsg('No breakpoints have been set') unless breakpoints.any?
 
-      return errmsg "No breakpoints have been set\n" if 0 == largest
-      return unless pos = get_int(@match[1], "Condition", 1, largest)
+      pos, err = get_int(@match[1], 'Condition', 1, breakpoints.last.id)
+      return errmsg(err) unless pos
 
       breakpoint = breakpoints.select { |b| b.id == pos }.first
 
-      if syntax_valid?(@match[2])
-        breakpoint.expr = @match[2]
-      else
-        return errmsg "Incorrect expression \"#{@match[2]}\", " \
-                      "breakpoint not changed\n"
-      end
+      return errmsg("Incorrect expression \"#{@match[2]}\", " \
+                    'breakpoint not changed') unless syntax_valid?(@match[2])
+
+      breakpoint.expr = @match[2]
     end
 
     class << self
@@ -33,12 +34,12 @@ module Byebug
       end
 
       def description
-        %{cond[ition] nnn[ expr]
+        %(cond[ition] <n>[ expr]
 
-          Specify breakpoint number nnn to break only if expr is true. nnn is an
-          integer and expr is an expression to be evaluated whenever breakpoint
-          nnn is reached. If no expression is specified, the condition is
-          removed.}
+          Specify breakpoint number <n> to break only if <expr> is true. <n> is
+          an integer and <expr> is an expression to be evaluated whenever
+          breakpoint <n> is reached. If no expression is specified, the
+          condition is removed.)
       end
     end
   end

data/lib/byebug/commands/continue.rb

@@ -1,20 +1,28 @@
 module Byebug
+  #
+  # Implements the continue command.
+  #
+  # Allows the user to continue execution until the next stopping point, a
+  # specific line number or until program termination.
+  #
   class ContinueCommand < Command
-    self.allow_in_post_mortem = true
-
     def regexp
       /^\s* c(?:ont(?:inue)?)? (?:\s+(\S+))? \s*$/x
     end
 
     def execute
-      if @match[1] && !@state.context.dead?
+      if @match[1]
+        num, err = get_int(@match[1], 'Continue', 0, nil)
+        return errmsg(err) unless num
+
         filename = File.expand_path(@state.file)
-        return unless line_number = get_int(@match[1], "Continue", 0, nil, 0)
-        unless LineCache.trace_line_numbers(filename).member?(line_number)
-          return errmsg "Line #{line_number} is not a valid stopping point in file\n"
+        unless LineCache.trace_line_numbers(filename).member?(num)
+          return errmsg("Line #{num} is not a valid stopping point in file")
         end
-        Byebug.add_breakpoint filename, line_number
+
+        Breakpoint.add(filename, num)
       end
+
       @state.proceed
     end
 
@@ -24,9 +32,9 @@ module Byebug
       end
 
       def description
-        %{c[ont[inue]][ nnn]
+        %(c[ont[inue]][ <n>]
 
-          Run until program ends, hits a breakpoint or reaches line nnn}
+          Run until program ends, hits a breakpoint or reaches line <n>.)
       end
     end
   end

data/lib/byebug/commands/delete.rb

@@ -1,4 +1,7 @@
 module Byebug
+  #
+  # Implements breakpoint deletion.
+  #
   class DeleteCommand < Command
     self.allow_in_post_mortem = false
     self.allow_in_control = true
@@ -8,16 +11,19 @@ module Byebug
     end
 
     def execute
-      return errmsg "We are not in a state we can delete breakpoints.\n" unless
-        @state.context
-
-      if not @match[1]
-        Byebug.breakpoints.clear if confirm("Delete all breakpoints? (y or n) ")
-      else
-        @match[1].split(/[ \t]+/).each do |pos|
-          return unless pos = get_int(pos, "Delete", 1)
-          errmsg "No breakpoint number %d\n", pos unless
-            Byebug.remove_breakpoint(pos)
+      unless @match[1]
+        Byebug.breakpoints.clear if confirm('Delete all breakpoints? (y/n) ')
+
+        return nil
+      end
+
+      @match[1].split(/[ \t]+/).each do |number|
+        pos, err = get_int(number, 'Delete', 1)
+
+        return errmsg(err) unless pos
+
+        unless Breakpoint.remove(pos)
+          return errmsg("No breakpoint number #{pos}")
         end
       end
     end
@@ -28,10 +34,10 @@ module Byebug
       end
 
       def description
-        %{del[ete][ nnn...]
+        %(del[ete][ nnn...]
 
-          Without and argument, deletes all breakpoints. With integer arguments,
-          it deletes specific breakpoints.}
+          Without and argument, deletes all breakpoints. With integer
+          arguments, it deletes specific breakpoints.)
       end
     end
   end