introduce break pre: to specify pre-command

`break LOC do: CMD` runs CMD and continue at LOC.
`break LOC pre: CMD` runs CMD at LOC but keeps suspend.
`binding.bp()` also has `do:` and `pre:` keywords like break command.
`command:` and `nonstop:` keywords are removed from `binding.bp()`.

Author: ko1

README.md

@@ -387,10 +387,10 @@ The `<...>` notation means the argument.
    * Set breakpoint on the method `<expr>.<name>`.
 * `b[reak] ... if: <expr>`
   * break if `<expr>` is true at specified location.
+* `b[reak] ... pre: <command>`
+  * break and run `<command>` before stopping.
 * `b[reak] ... do: <command>`
   * break and run `<command>`, and continue.
-* `b[reak] ... if: <cond_expr> do: <command>`
-  * combination of `if:` and `do:`.
 * `b[reak] if: <expr>`
   * break if: `<expr>` is true at any lines.
   * Note that this feature is super slow.

lib/debug/breakpoint.rb

@@ -50,8 +50,9 @@ def deleted?
 
     def suspend
       if @command
-        provider, cmds, nonstop = @command
-        nonstop = true if nonstop.nil?
+        provider, pre_cmds, do_cmds = @command
+        nonstop = true if do_cmds
+        cmds = [*pre_cmds&.split(';;'), *do_cmds&.split(';;')]
         SESSION.add_preset_commands provider, cmds, kick: false, continue: nonstop
       end
 
@@ -60,8 +61,9 @@ def suspend
 
     def to_s
       s = ''.dup
-      s << " if: #{@cond}"       if defined?(@cond) && @cond
-      s << " do: #{@command[1].join(';; ')}" if defined?(@command) && @command
+      s << " if: #{@cond}"        if defined?(@cond) && @cond
+      s << " pre: #{@command[1]}" if defined?(@command) && @command && @command[1]
+      s << " do: #{@command[2]}"  if defined?(@command) && @command && @command[2]
       s
     end
 
@@ -83,7 +85,7 @@ def generate_label(name)
   class LineBreakpoint < Breakpoint
     attr_reader :path, :line, :iseq
 
-    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil, nonstop: nil
+    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil
       @path = path
       @line = line
       @cond = cond

lib/debug/session.rb

@@ -346,10 +346,10 @@ def process_command line
       #    * Set breakpoint on the method `<expr>.<name>`.
       # * `b[reak] ... if: <expr>`
       #   * break if `<expr>` is true at specified location.
+      # * `b[reak] ... pre: <command>`
+      #   * break and run `<command>` before stopping.
       # * `b[reak] ... do: <command>`
       #   * break and run `<command>`, and continue.
-      # * `b[reak] ... if: <cond_expr> do: <command>`
-      #   * combination of `if:` and `do:`.
       # * `b[reak] if: <expr>`
       #   * break if: `<expr>` is true at any lines.
       #   * Note that this feature is super slow.
@@ -872,42 +872,37 @@ def delete_breakpoint arg = nil
       end
     end
 
-    def repl_add_breakpoint arg
-      arg.strip!
-      make_command = -> cmd do
-        ['break do', cmd.split(';;').map{|e| e.strip}]
-      end
+    BREAK_KEYWORDS = %w(if: do: pre:).freeze
 
-      case arg
-      when /\Aif:\s*(.+)do:\s*(.+)\z/
-        cond = $1
-        cmd = make_command.call($2)
-      when /\Aif:\s*(.+)\z/
-        cond = $1
-      when /\A(.+?)\s+if:\s+(.+)\s+do:\s*(.+)e\z/
-        sig = $1
-        cond = $2
-        cmd = make_command.call $3
-      when /\A(.+?)\s+if:\s+(.+)\z/
-        sig = $1
-        cond = $2
-      when /\A(.+?)\s+do:(.+)\z/
-        sig = $1
-        cmd = make_command.call $2
-      else
-        sig = arg
-      end
+    def parse_break arg
+      mode = :sig
+      expr = Hash.new{|h, k| h[k] = []}
+      arg.split(' ').each{|w|
+        if BREAK_KEYWORDS.any?{|pat| w == pat}
+          mode = w[0..-2].to_sym
+        else
+          expr[mode] << w
+        end
+      }
+      expr.default_proc = nil
+      expr.transform_values{|v| v.join(' ')}
+    end
 
-      case sig
+    def repl_add_breakpoint arg
+      expr = parse_break arg.strip
+      cond = expr[:if]
+      cmd = ['break', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+
+      case expr[:sig]
       when /\A(\d+)\z/
-        add_line_breakpoint @tc.location.path, $1.to_i, cond: cond, command: cmd
+        add_line_breakpoint @tc.location.path, $1.to_i, cond: expr[:if], command: cmd
       when /\A(.+)[:\s+](\d+)\z/
-        add_line_breakpoint $1, $2.to_i, cond: cond, command: cmd
+        add_line_breakpoint $1, $2.to_i, cond: expr[:if], command: cmd
       when /\A(.+)([\.\#])(.+)\z/
-        @tc << [:breakpoint, :method, $1, $2, $3, cond, cmd]
+        @tc << [:breakpoint, :method, $1, $2, $3, expr[:if], cmd]
         return :noretry
       when nil
-        add_check_breakpoint cond
+        add_check_breakpoint expr[:if]
       else
         @ui.puts "Unknown breakpoint format: #{arg}"
         @ui.puts
@@ -1263,18 +1258,15 @@ class << self
       # ::DEBUGGER__.add_catch_breakpoint 'RuntimeError'
 
       Binding.module_eval do
-        def bp command: nil, nonstop: nil
+        def bp pre: nil, do: nil
           return unless SESSION.active?
-          cmds = ['binding.bp', command.split(";;")] if command && !command.strip.empty?
 
-          # nonstop
-          #  nil: auto_continue if command is given
-          nonstop = true if cmds if nonstop == nil
+          if pre || (do_expr = binding.local_variable_get(:do))
+            cmds = ['binding.bp', pre, do_expr]
+          end
 
-          # maybe it is the end of the file
-          ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1, oneshot: true, command: cmds, nonstop: nonstop
+          ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1, oneshot: true, command: cmds
           true
-          
         end
         alias debug bp
       end

test/debug/bp_test.rb

@@ -30,7 +30,7 @@ def program
       <<~RUBY
      1| class Foo
      2|   def bar
-     3|     binding.bp(command: "continue")
+     3|     binding.bp(do: "continue")
      4|     baz
      5|   end
      6|

test/debug/watch_test.rb

@@ -11,7 +11,7 @@ def program
          3|
          4|   def initialize(name)
          5|     @name = name
-         6|     binding.bp(command: "watch @name")
+         6|     binding.bp(do: "watch @name")
          7|   end
          8| end
          9|