byebug 5.0.0 → 6.0.0

data/lib/byebug/commands/catch.rb

@@ -1,4 +1,5 @@
 require 'byebug/command'
+require 'byebug/helpers/eval'
 
 module Byebug
   #
@@ -7,50 +8,73 @@ module Byebug
   # Enables the user to catch unhandled assertion when they happen.
   #
   class CatchCommand < Command
-    def regexp
+    include Helpers::EvalHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
       /^\s* cat(?:ch)? (?:\s+(\S+))? (?:\s+(off))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        cat[ch][ (off|<exception>[ off])]
+
+        #{short_description}
+
+        catch                 -- lists catchpoints
+        catch off             -- deletes all catchpoints
+        catch <exception>     -- enables handling <exception>
+        catch <exception> off -- disables handling <exception>
+      EOD
+    end
+
+    def self.short_description
+      'Handles exception catchpoints'
+    end
+
     def execute
-      ex = @match[1]
-      return info_catch unless ex
+      return info unless @match[1]
 
-      cmd = @match[2]
-      unless cmd
-        if 'off' == ex
-          Byebug.catchpoints.clear if
-            confirm(pr('catch.confirmations.delete_all'))
+      return 'off' == @match[1] ? clear : add(@match[1]) unless @match[2]
 
-          return
-        end
+      return errmsg pr('catch.errors.off', off: cmd) unless @match[2] == 'off'
+
+      remove(@match[1])
+    end
 
-        is_class = bb_eval("#{ex.is_a?(Class)}")
-        puts pr('catch.errors.not_class', class: ex) unless is_class
+    private
 
-        Byebug.add_catchpoint(ex)
-        return puts pr('catch.catching', exception: ex)
+    def remove(exception)
+      unless Byebug.catchpoints.member?(exception)
+        return errmsg pr('catch.errors.not_found', exception: exception)
       end
 
-      if cmd == 'off'
-        exists = Byebug.catchpoints.member?(ex)
-        return errmsg pr('catch.errors.not_found', exception: ex) unless exists
+      puts pr('catch.removed', exception: exception)
+      Byebug.catchpoints.delete(exception)
+    end
 
-        Byebug.catchpoints.delete(ex)
-        return errmsg pr('catch.errors.removed', exception: ex)
+    def add(exception)
+      if single_thread_eval("#{exception.is_a?(Class)}")
+        errmsg pr('catch.errors.not_class', class: exception)
       end
 
-      errmsg pr('catch.errors.off', off: cmd)
+      puts pr('catch.added', exception: exception)
+      Byebug.add_catchpoint(exception)
     end
 
-    def description
-      <<-EOD
-        cat[ch][ (off|<exception>[ off])]
+    def clear
+      Byebug.catchpoints.clear if confirm(pr('catch.confirmations.delete_all'))
+    end
 
-        "catch" lists catchpoints.
-        "catch off" deletes all catchpoints.
-        "catch <exception>" enables handling <exception>.
-        "catch <exception> off" disables handling <exception>.
-      EOD
+    def info
+      if Byebug.catchpoints && !Byebug.catchpoints.empty?
+        Byebug.catchpoints.each do |exception, _hits|
+          puts("#{exception}: #{exception.is_a?(Class)}")
+        end
+      else
+        puts 'No exceptions set to be caught.'
+      end
     end
   end
 end

data/lib/byebug/commands/condition.rb

@@ -10,12 +10,29 @@ module Byebug
   class ConditionCommand < Command
     include Helpers::ParseHelper
 
-    self.allow_in_post_mortem = false
+    self.allow_in_post_mortem = true
 
-    def regexp
+    def self.regexp
       /^\s* cond(?:ition)? (?:\s+(\d+)(?:\s+(.*))?)? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        cond[ition] <n>[ expr]
+
+        #{short_description}
+
+        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.
+      EOD
+    end
+
+    def self.short_description
+      'Sets conditions on breakpoints'
+    end
+
     def execute
       return puts(help) unless @match[1]
 
@@ -34,16 +51,5 @@ module Byebug
 
       breakpoint.expr = @match[2]
     end
-
-    def description
-      <<-EOD
-        cond[ition] <n>[ expr]
-
-        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.
-      EOD
-    end
   end
 end

data/lib/byebug/commands/continue.rb

@@ -11,16 +11,28 @@ module Byebug
   class ContinueCommand < Command
     include Helpers::ParseHelper
 
-    def regexp
+    def self.regexp
       /^\s* c(?:ont(?:inue)?)? (?:\s+(\S+))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        c[ont[inue]][ <line_number>]
+
+        #{short_description}
+      EOD
+    end
+
+    def self.short_description
+      'Runs until program ends, hits a breakpoint or reaches a line'
+    end
+
     def execute
       if @match[1]
         num, err = get_int(@match[1], 'Continue', 0, nil)
         return errmsg(err) unless num
 
-        filename = File.expand_path(@state.file)
+        filename = File.expand_path(frame.file)
         unless Breakpoint.potential_line?(filename, num)
           return errmsg(pr('continue.errors.unstopped_line', line: num))
         end
@@ -28,15 +40,7 @@ module Byebug
         Breakpoint.add(filename, num)
       end
 
-      @state.proceed
-    end
-
-    def description
-      <<-EOD
-        c[ont[inue]][ <n>]
-
-        Run until program ends, hits a breakpoint or reaches line <n>.
-      EOD
+      processor.proceed!
     end
   end
 end

data/lib/byebug/commands/delete.rb

@@ -8,20 +8,35 @@ module Byebug
   class DeleteCommand < Command
     include Helpers::ParseHelper
 
-    self.allow_in_post_mortem = false
     self.allow_in_control = true
+    self.allow_in_post_mortem = true
 
-    def regexp
+    def self.regexp
       /^\s* del(?:ete)? (?:\s+(.*))?$/x
     end
 
+    def self.description
+      <<-EOD
+        del[ete][ nnn...]
+
+        #{short_description}
+
+        Without and argument, deletes all breakpoints. With integer arguments,
+        it deletes specific breakpoints.
+      EOD
+    end
+
+    def self.short_description
+      'Deletes breakpoints'
+    end
+
     def execute
       unless @match[1]
         if confirm(pr('break.confirmations.delete_all'))
           Byebug.breakpoints.clear
         end
 
-        return nil
+        return
       end
 
       @match[1].split(/ +/).each do |number|
@@ -34,14 +49,5 @@ module Byebug
         end
       end
     end
-
-    def description
-      <<-EOD
-        del[ete][ nnn...]
-
-        Without and argument, deletes all breakpoints. With integer arguments,
-        it deletes specific breakpoints.
-      EOD
-    end
   end
 end

data/lib/byebug/commands/disable.rb

@@ -10,23 +10,22 @@ module Byebug
   class DisableCommand < Command
     include Subcommands
 
-    def regexp
+    self.allow_in_post_mortem = true
+
+    def self.regexp
       /^\s* dis(?:able)? (?:\s+ (.+))? \s*$/x
     end
 
-    def description
+    def self.description
       <<-EOD
         dis[able][[ breakpoints| display)][ n1[ n2[ ...[ nn]]]]]
 
-        Disables breakpoints or displays.
-
-        "disable" by itself shows this help
-        "disable breakpoints" disables all breakpoints.
-        "disable displays" disables all displays.
-
-        You can also specify a space separated list of breakpoint or display
-        numbers to disable only specific breakpoints or displays.
+        #{short_description}
        EOD
     end
+
+    def self.short_description
+      'Disables breakpoints or displays'
+    end
   end
 end

data/lib/byebug/commands/disable/breakpoints.rb

@@ -8,22 +8,16 @@ module Byebug
     #
     # Disables all or specific breakpoints
     #
-    class BreakpointsSubcommand < Command
+    class BreakpointsCommand < Command
       include Helpers::ToggleHelper
 
-      def regexp
-        /^\s* b(?:reakpoints)? (?:\s+ (.+))? \s*$/x
-      end
-
-      def execute
-        enable_disable_breakpoints('disable', @match[1])
-      end
+      self.allow_in_post_mortem = true
 
-      def short_description
-        'Disable all or specific breakpoints.'
+      def self.regexp
+        /^\s* b(?:reakpoints)? (?:\s+ (.+))? \s*$/x
       end
 
-      def description
+      def self.description
         <<-EOD
           dis[able] b[reakpoints][ <id1> <id2> .. <idn>]
 
@@ -33,6 +27,14 @@ module Byebug
           argument at all if you want to disable every breakpoint.
         EOD
       end
+
+      def self.short_description
+        'Disable all or specific breakpoints.'
+      end
+
+      def execute
+        enable_disable_breakpoints('disable', @match[1])
+      end
     end
   end
 end

data/lib/byebug/commands/disable/display.rb

@@ -8,22 +8,16 @@ module Byebug
     #
     # Enables all or specific displays
     #
-    class DisplaySubcommand < Command
+    class DisplayCommand < Command
       include Helpers::ToggleHelper
 
-      def regexp
-        /^\s* d(?:isplay)? (?:\s+ (.+))? \s*$/x
-      end
-
-      def execute
-        enable_disable_display('disable', @match[1])
-      end
+      self.allow_in_post_mortem = true
 
-      def short_description
-        'Disables expressions to be displayed when program stops.'
+      def self.regexp
+        /^\s* d(?:isplay)? (?:\s+ (.+))? \s*$/x
       end
 
-      def description
+      def self.description
         <<-EOD
           dis[able] d[isplay][ <id1> <id2> .. <idn>]
 
@@ -34,6 +28,14 @@ module Byebug
           specified, all displays are disabled.
         EOD
       end
+
+      def self.short_description
+        'Disables expressions to be displayed when program stops.'
+      end
+
+      def execute
+        enable_disable_display('disable', @match[1])
+      end
     end
   end
 end

data/lib/byebug/commands/display.rb

@@ -1,56 +1,64 @@
 require 'byebug/command'
+require 'byebug/helpers/eval'
 
 module Byebug
   #
   # Custom expressions to be displayed every time the debugger stops.
   #
   class DisplayCommand < Command
-    self.allow_in_post_mortem = false
+    include Helpers::EvalHelper
 
-    def self.always_run
-      2
-    end
+    self.allow_in_post_mortem = false
+    self.always_run = 2
 
-    def regexp
+    def self.regexp
       /^\s* disp(?:lay)? (?:\s+ (.+))? \s*$/x
     end
 
-    def execute
-      return print_display_expressions unless @match && @match[1]
-
-      @state.display.push [true, @match[1]]
-      display_expression(@match[1])
-    end
-
-    def description
+    def self.description
       <<-EOD
         disp[lay][ <expression>]
 
+        #{short_descripton}
+
         If <expression> specified, adds <expression> into display expression
         list. Otherwise, it lists all expressions.
       EOD
     end
 
+    def self.short_description
+      'Evaluates expressions every time the debugger stops'
+    end
+
+    def execute
+      return print_display_expressions unless @match && @match[1]
+
+      Byebug.displays.push [true, @match[1]]
+      display_expression(@match[1])
+    end
+
     private
 
     def display_expression(exp)
-      print pr('display.result',
-               n: @state.display.size,
-               exp: exp,
-               result: bb_warning_eval(exp).inspect)
+      print pr('display.result', n: Byebug.displays.size,
+                                 exp: exp,
+                                 result: eval_expr(exp))
     end
 
     def print_display_expressions
-      result = prc('display.result', @state.display) do |item, index|
-        is_active, expression = item
-        if is_active
-          { n: index + 1,
-            exp: expression,
-            result: bb_warning_eval(expression).inspect }
-        end
+      result = prc('display.result', Byebug.displays) do |item, index|
+        active, exp = item
+
+        { n: index + 1, exp: exp, result: eval_expr(exp) } if active
       end
 
       print result
     end
+
+    def eval_expr(expression)
+      thread_safe_eval(expression).inspect
+    rescue
+      '(undefined)'
+    end
   end
 end