debug 1.0.0.beta6 → 1.0.0.beta7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fffc4898e989a76e77a9076407cc1ba6d31b13a531e739c8972afe71bf049285
-  data.tar.gz: 190c18099e1078e00786dde75819b0b793647cd9508b0577e88d93d6a06c045c
+  metadata.gz: d545d212530685e0eaf7163bc0b2517befd0edfdc1b083c64ecab6bfcb6958b8
+  data.tar.gz: 6662febf1dccfbc0e7e4ec785578fb5eac2a076fa488a4a3a814582f80fa940f
 SHA512:
-  metadata.gz: 647e6c227bded49c962b8d6934557a26930664f5f1ddd57fd596c6651b1c655c1c77e64d5cbba28d2125cdd8a27817e33dc94d465d01f6b43b7f0be61ee30a35
-  data.tar.gz: ceb4dbf7b9479dc54ff5af725e973985493650ca9aaebd16878c4669fa037ae2ee1ec9ddddf83eb25dd65dc2057d0419a74005ec5d74c98585d855eb918e53bb
+  metadata.gz: 3173551c5ada6fb2f7f71656a5762b6a6a6cc541d80d371532abfe1e03188f81ffb397df1a2c8d743c34983e27c5abe6e33ae8d8188502960501801af3aa9ea3
+  data.tar.gz: 59c84ef76b01d8630b764784d68edb7b1e25e2c336cab56a74e23add5f606f14c3dfe2d6cdd9fe3779e328ca8873317d5d7b56a8e5a7951ecc3a081c20c309d8

data/README.md

@@ -83,6 +83,7 @@ require 'debug/run' # start the debug console
 # ... rest of program ...
 ```
 
+
 ```
 $ ruby target.rb
 ```
@@ -90,6 +91,24 @@ $ ruby target.rb
 When you run the program with the debug console, you will see the debug console prompt `(rdbg)`.
 The debuggee program (`target.rb`) is suspended at the beginning of `target.rb`.
 
+
+Alternatively, start the debugger at a specific location in your program using `binding.break` (`binding.b` for short).
+
+```ruby
+# target.rb
+require 'debug' # start the debugger
+
+# ... program ...
+
+binding.break # setup a breakpoint at this line
+
+# ... rest of program ...
+```
+
+```
+$ ruby target.rb
+```
+
 You can type any debugger's command described bellow. "c" or "continue" resume the debuggee program.
 You can suspend the debuggee program and show the debug console with `Ctrl-C`.
 
@@ -310,20 +329,41 @@ If there are `~/.rdbgrc`, the file is loaded as initial scripts which contains d
 
 If there are `~/.rdbgrc.rb` is available, it is loaded as a ruby script at same timing.
 
-### Environment variables
+### Configurations
 
-You can control debuggee's behavior with environment variables:
+You can configure debugger's setting with environment variables and `config` command.
+You can write any configuration into `~/.rdbgrc` like:
+
+```
+config set log_level INFO
+config set no_color true
+```
 
-* `RUBY_DEBUG_NONSTOP`: 1 for nonstop at the beginning of program.
-* `RUBY_DEBUG_INIT_SCRIPT`: Initial script path loaded at the first stop.
-* `RUBY_DEBUG_COMMANDS`: Debug commands invoked at the first stop. Commands should be separated by ';;'.
-* `RUBY_DEBUG_SHOW_SRC_LINES`: Show n lines source code on breakpoint (default: 10 lines).
-* `RUBY_DEBUG_SHOW_FRAMES`: Show n frames on breakpoint (default: 2 frames).
-* Remote debugging
-  * `RUBY_DEBUG_PORT`: TCP/IP remote debugging: port to open.
-  * `RUBY_DEBUG_HOST`: TCP/IP remote debugging: host (localhost if not given) to open.
-  * `RUBY_DEBUG_SOCK_PATH`: UNIX Domain Socket remote debugging: socket path to open.
-  * `RUBY_DEBUG_SOCK_DIR`: UNIX Domain Socket remote debugging: socket directory to open.
+
+* UI
+  * `RUBY_DEBUG_LOG_LEVEL` (`log_level`): Log level same as Logger (default: WARN)
+  * `RUBY_DEBUG_SHOW_SRC_LINES` (`show_src_lines`): Show n lines source code on breakpoint (default: 10 lines)
+  * `RUBY_DEBUG_SHOW_FRAMES` (`show_frames`): Show n frames on breakpoint (default: 2 frames)
+  * `RUBY_DEBUG_SHOW_INFO_LINES` (`show_info_lines`): Show n lines on info command (default: 10 lines, 0 for unlimited)
+  * `RUBY_DEBUG_USE_SHORT_PATH` (`use_short_path`): Show shoten PATH (like $(Gem)/foo.rb)
+  * `RUBY_DEBUG_SKIP_NOSRC` (`skip_nosrc`): Skip on no source code lines (default: false)
+  * `RUBY_DEBUG_SKIP_PATH` (`skip_path`): Skip showing frames for given paths (default: [])
+  * `RUBY_DEBUG_NO_COLOR` (`no_color`): Do not use colorize (default: false)
+  * `RUBY_DEBUG_NO_SIGINT_HOOK` (`no_sigint_hook`): Do not suspend on SIGINT (default: false)
+
+* BOOT
+  * `RUBY_DEBUG_NONSTOP` (`nonstop`): Nonstop mode
+  * `RUBY_DEBUG_INIT_SCRIPT` (`init_script`): debug command script path loaded at first stop
+  * `RUBY_DEBUG_COMMANDS` (`commands`): debug commands invoked at first stop. commands should be separated by ';;'
+  * `RUBY_DEBUG_NO_RC` (`no_rc`): ignore loading ~/.rdbgrc(.rb)
+  * `RUBY_DEBUG_HISTORY` (`history`): save and load history file (default: ~/.rdbg_history)
+
+* REMOTE
+  * `RUBY_DEBUG_PORT` (`port`): TCP/IP remote debugging: port
+  * `RUBY_DEBUG_HOST` (`host`): TCP/IP remote debugging: host (localhost if not given)
+  * `RUBY_DEBUG_SOCK_PATH` (`sock_path`): UNIX Domain Socket remote debugging: socket path
+  * `RUBY_DEBUG_SOCK_DIR` (`sock_dir`): UNIX Domain Socket remote debugging: socket directory
+  * `RUBY_DEBUG_COOKIE` (`cookie`): Cookie for negotiation
 
 ## Debug command on the debug console
 
@@ -366,10 +406,14 @@ The `<...>` notation means the argument.
    * Set breakpoint on the method `<class>#<name>`.
 * `b[reak] <expr>.<name>`
    * Set breakpoint on the method `<expr>.<name>`.
-* `b[reak] ... if <expr>`
+* `b[reak] ... if: <expr>`
   * break if `<expr>` is true at specified location.
-* `b[reak] if <expr>`
-  * break if `<expr>` is true at any lines.
+* `b[reak] ... pre: <command>`
+  * break and run `<command>` before stopping.
+* `b[reak] ... do: <command>`
+  * break and run `<command>`, and continue.
+* `b[reak] if: <expr>`
+  * break if: `<expr>` is true at any lines.
   * Note that this feature is super slow.
 * `catch <Error>`
   * Set breakpoint on raising `<Error>`.
@@ -385,6 +429,12 @@ The `<...>` notation means the argument.
 
 * `bt` or `backtrace`
   * Show backtrace (frame) information.
+* `bt <num>` or `backtrace <num>`
+  * Only shows first `<num>` frames.
+* `bt /regexp/` or `backtrace /regexp/`
+  * Only shows frames with method name or location info that matches `/regexp/`.
+* `bt <num> /regexp/` or `backtrace <num> /regexp/`
+  * Only shows first `<num>` frames with method name or location info that matches `/regexp/`.
 * `l[ist]`
   * Show current frame's source code.
   * Next `list` command shows the successor lines.
@@ -442,6 +492,19 @@ The `<...>` notation means the argument.
 * `th[read] <thnum>`
   * Switch thread specified by `<thnum>`.
 
+### Configuration
+
+* `config`
+  * Show all configuration with description.
+* `config <name>`
+  * Show current configuration of <name>.
+* `config set <name> <val>` or `config <name> = <val>`
+  * Set <name> to <val>.
+* `config append <name> <val>` or `config <name> << <val>`
+  * Append `<val>` to `<name>` if it is an array.
+* `config unset <name>`
+  * Set <name> to default.
+
 ### Help
 
 * `h[elp]`
@@ -457,7 +520,7 @@ exe/rdbg [options] -- [debuggee options]
 
 Debug console mode:
     -n, --nonstop                    Do not stop at the beginning of the script.
-    -e COMMAND                       Execute debug command at the beginning of the script.
+    -e DEBUG_COMMAND                 Execute debug command at the beginning of the script.
     -x, --init-script=FILE           Execute debug command in the FILE.
         --no-rc                      Ignore ~/.rdbgrc
         --no-color                   Disable colorize
@@ -477,6 +540,9 @@ Debug console mode:
 
   'rdbg target.rb foo bar'                starts like 'ruby target.rb foo bar'.
   'rdbg -- -r foo -e bar'                 starts like 'ruby -r foo -e bar'.
+  'rdbg -c rake test'                     starts like 'rake test'.
+  'rdbg -c -- rake test -t'               starts like 'rake test -t'.
+  'rdbg -c bundle exec rake test'         starts like 'bundle exec rake test'.
   'rdbg -O target.rb foo bar'             starts and accepts attaching with UNIX domain socket.
   'rdbg -O --port 1234 target.rb foo bar' starts accepts attaching with TCP/IP localhost:1234.
   'rdbg -O --port 1234 -- -r foo -e bar'  starts accepts attaching with TCP/IP localhost:1234.

data/TODO.md

@@ -2,14 +2,11 @@
 
 ## Basic functionality
 
-* VScode DAP support
 * Support Ractors
 * Signal (SIGINT) support
-* Remote connection with openssl
 
 ## UI
 
-* Coloring
 * Interactive breakpoint setting
 * irb integration
 * Web browser integrated UI
@@ -28,6 +25,3 @@
 
 ## Tests
 
-* Test framework
-* Tests for commands
-* Tests for remote debugging

data/lib/debug/breakpoint.rb

@@ -49,15 +49,22 @@ module DEBUGGER__
     end
 
     def suspend
+      if @command
+        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
+
       ThreadClient.current.on_breakpoint @tp, self
     end
 
     def to_s
-      if @cond
-        " if #{@cond}"
-      else
-        ""
-      end
+      s = ''.dup
+      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
 
     def description
@@ -68,27 +75,24 @@ module DEBUGGER__
       false
     end
 
-    class << self
-      include Color
+    include Color
 
-      def generate_label(name)
-        colorize(" BP - #{name} ", [:YELLOW, :BOLD, :REVERSE])
-      end
+    def generate_label(name)
+      colorize(" BP - #{name} ", [:YELLOW, :BOLD, :REVERSE])
     end
   end
 
   class LineBreakpoint < Breakpoint
-    LABEL = generate_label("Line")
-    PENDING_LABEL = generate_label("Line (pending)")
-
     attr_reader :path, :line, :iseq
 
-    def initialize path, line, cond: nil, oneshot: false, hook_call: true
+    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil
       @path = path
       @line = line
       @cond = cond
       @oneshot = oneshot
       @hook_call = hook_call
+      @command = command
+      @pending = false
 
       @iseq = nil
       @type = nil
@@ -96,23 +100,21 @@ module DEBUGGER__
       @key = [@path, @line].freeze
 
       super()
+
       try_activate
+      @pending = !@iseq
     end
 
     def setup
       return unless @type
 
-      if !@cond
-        @tp = TracePoint.new(@type) do |tp|
-          delete if @oneshot
-          suspend
-        end
-      else
-        @tp = TracePoint.new(@type) do |tp|
+      @tp = TracePoint.new(@type) do |tp|
+        if @cond
           next unless safe_eval tp.binding, @cond
-          delete if @oneshot
-          suspend
         end
+        delete if @oneshot
+
+        suspend
       end
     end
 
@@ -138,9 +140,12 @@ module DEBUGGER__
 
       @key = [@path, @line].freeze
       SESSION.rehash_bps
-
       setup
       enable
+
+      if @pending && !@oneshot
+        DEBUGGER__.warn "#{self} is activated."
+      end
     end
 
     def activate_exact iseq, events, line
@@ -162,7 +167,6 @@ module DEBUGGER__
     end
 
     def duplicable?
-      # only binding.bp or DEBUGGER__.console are duplicable
       @oneshot
     end
 
@@ -214,9 +218,9 @@ module DEBUGGER__
       oneshot = @oneshot ? " (oneshot)" : ""
 
       if @iseq
-        "#{LABEL} #{@path}:#{@line} (#{@type})#{oneshot}" + super
+        "#{generate_label("Line")} #{@path}:#{@line} (#{@type})#{oneshot}" + super
       else
-        "#{PENDING_LABEL} #{@path}:#{@line}#{oneshot}" + super
+        "#{generate_label("Line (pending)")} #{@path}:#{@line}#{oneshot}" + super
       end
     end
 
@@ -226,7 +230,6 @@ module DEBUGGER__
   end
 
   class CatchBreakpoint < Breakpoint
-    LABEL = generate_label("Catch")
     attr_reader :last_exc
 
     def initialize pat
@@ -240,7 +243,9 @@ module DEBUGGER__
     def setup
       @tp = TracePoint.new(:raise){|tp|
         exc = tp.raised_exception
+        next if SystemExit === exc
         should_suspend = false
+
         exc.class.ancestors.each{|cls|
           if @pat === cls.name
             should_suspend = true
@@ -253,7 +258,7 @@ module DEBUGGER__
     end
 
     def to_s
-      "#{LABEL} #{@pat.inspect}"
+      "#{generate_label("Catch")} #{@pat.inspect}"
     end
 
     def description
@@ -262,8 +267,6 @@ module DEBUGGER__
   end
 
   class CheckBreakpoint < Breakpoint
-    LABEL = generate_label("Check")
-
     def initialize expr
       @expr = expr.freeze
       @key = [:check, @expr].freeze
@@ -285,13 +288,11 @@ module DEBUGGER__
     end
 
     def to_s
-      "#{LABEL} #{@expr}"
+      "#{generate_label("Check")} #{@expr}"
     end
   end
 
   class WatchIVarBreakpoint < Breakpoint
-    LABEL = generate_label("Watch")
-
     def initialize ivar, object, current
       @ivar = ivar.to_sym
       @object = object
@@ -332,17 +333,14 @@ module DEBUGGER__
         else
           "#{@current}"
         end
-      "#{LABEL} #{@object} #{@ivar} = #{value_str}"
+      "#{generate_label("Watch")} #{@object} #{@ivar} = #{value_str}"
     end
   end
 
   class MethodBreakpoint < Breakpoint
-    LABEL = generate_label("Method")
-    PENDING_LABEL = generate_label("Method (pending)")
-
     attr_reader :sig_method_name, :method
 
-    def initialize b, klass_name, op, method_name, cond
+    def initialize b, klass_name, op, method_name, cond, command: nil
       @sig_klass_name = klass_name
       @sig_op = op
       @sig_method_name = method_name
@@ -351,6 +349,7 @@ module DEBUGGER__
       @klass = nil
       @method = nil
       @cond = cond
+      @command = command
       @key = "#{klass_name}#{op}#{method_name}".freeze
 
       super(false)
@@ -391,13 +390,14 @@ module DEBUGGER__
       try_enable
     end
 
-    def try_enable quiet: false
+    def try_enable added: false
       eval_class_name
       search_method
 
       begin
         retried = false
         @tp.enable(target: @method)
+        DEBUGGER__.warn "#{self} is activated." if added
 
       rescue ArgumentError
         raise if retried
@@ -418,7 +418,7 @@ module DEBUGGER__
         retry
       end
     rescue Exception
-      raise unless quiet
+      raise unless added
     end
 
     def sig
@@ -427,9 +427,9 @@ module DEBUGGER__
 
     def to_s
       if @method
-        "#{LABEL} #{sig}"
+        "#{generate_label("Method")} #{sig} at #{@method.source_location.join(':')}"
       else
-        "#{PENDING_LABEL} #{sig}"
+        "#{generate_label("Method (pending)")} #{sig}"
       end + super
     end
   end

data/lib/debug/client.rb

@@ -47,6 +47,7 @@ module DEBUGGER__
       end
 
       @width = IO.console_size[1]
+      @width = 80 if @width == 0
       @width_changed = false
 
       send "version: #{VERSION} width: #{@width} cookie: #{CONFIG[:cookie]}"

data/lib/debug/color.rb

@@ -24,8 +24,12 @@ module DEBUGGER__
     end
 
     if defined? IRB::ColorPrinter.pp
-      def color_pp obj
-        IRB::ColorPrinter.pp(obj, "".dup)
+      def color_pp obj, width = SESSION.width
+        if !CONFIG[:no_color]
+          IRB::ColorPrinter.pp(obj, "".dup, width)
+        else
+          obj.pretty_inspect
+        end
       end
     else
       def color_pp obj
@@ -33,8 +37,8 @@ module DEBUGGER__
       end
     end
 
-    def colored_inspect obj
-      if !CONFIG[:no_color]
+    def colored_inspect obj, no_color: false
+      if !no_color
         color_pp obj
       else
         obj.pretty_inspect

data/lib/debug/config.rb

@@ -30,52 +30,80 @@ module DEBUGGER__
     create_unix_domain_socket_name_prefix(base_dir) + "-#{Process.pid}"
   end
 
-  CONFIG_MAP = {
-    # boot setting
-    nonstop:     'RUBY_DEBUG_NONSTOP',     # Nonstop mode ('1' is nonstop)
-    init_script: 'RUBY_DEBUG_INIT_SCRIPT', # debug command script path loaded at first stop
-    commands:    'RUBY_DEBUG_COMMANDS',    # debug commands invoked at first stop. commands should be separated by ';;'
-    no_rc:       'RUBY_DEBUG_NO_RC',       # ignore loading ~/.rdbgrc(.rb)
-
+  CONFIG_SET = {
     # UI setting
-    show_src_lines: 'RUBY_DEBUG_SHOW_SRC_LINES', # Show n lines source code on breakpoint (default: 10 lines).
-    show_frames:    'RUBY_DEBUG_SHOW_FRAMES',    # Show n frames on breakpoint (default: 2 frames).
-    use_short_path: 'RUBY_DEBUG_USE_SHORT_PATH', # Show shoten PATH (like $(Gem)/foo.rb).
-    skip_nosrc:     'RUBY_DEBUG_SKIP_NOSRC',     # Skip on no source code lines (default: false).
-    no_color:       'RUBY_DEBUG_NO_COLOR',       # Do not use colorize
-    no_sigint_hook: 'RUBY_DEBUG_NO_SIGINT_HOOK', # Do not suspend on SIGINT
-    quiet:          'RUBY_DEBUG_QUIET',          # Do not show messages
+    log_level:      ['RUBY_DEBUG_LOG_LEVEL',      "UI: Log level same as Logger (default: WARN)",                   :loglevel],
+    show_src_lines: ['RUBY_DEBUG_SHOW_SRC_LINES', "UI: Show n lines source code on breakpoint (default: 10 lines)", :int],
+    show_frames:    ['RUBY_DEBUG_SHOW_FRAMES',    "UI: Show n frames on breakpoint (default: 2 frames)",            :int],
+    show_info_lines:['RUBY_DEBUG_SHOW_INFO_LINES',"UI: Show n lines on info command (default: 10 lines, 0 for unlimited)",   :int],
+    use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shoten PATH (like $(Gem)/foo.rb)",                      :bool],
+    skip_nosrc:     ['RUBY_DEBUG_SKIP_NOSRC',     "UI: Skip on no source code lines (default: false)",              :bool],
+    skip_path:      ['RUBY_DEBUG_SKIP_PATH',      "UI: Skip showing frames for given paths (default: [])",          :path],
+    no_color:       ['RUBY_DEBUG_NO_COLOR',       "UI: Do not use colorize (default: false)",                       :bool],
+    no_sigint_hook: ['RUBY_DEBUG_NO_SIGINT_HOOK', "UI: Do not suspend on SIGINT (default: false)",                  :bool],
+
+    # boot setting
+    nonstop:        ['RUBY_DEBUG_NONSTOP',     "BOOT: Nonstop mode",                                                :bool],
+    init_script:    ['RUBY_DEBUG_INIT_SCRIPT', "BOOT: debug command script path loaded at first stop"],
+    commands:       ['RUBY_DEBUG_COMMANDS',    "BOOT: debug commands invoked at first stop. commands should be separated by ';;'"],
+    no_rc:          ['RUBY_DEBUG_NO_RC',       "BOOT: ignore loading ~/.rdbgrc(.rb)",                               :bool],
+    history:        ['RUBY_DEBUG_HISTORY',     "BOOT: save and load history file (default: ~/.rdbg_history)"],
 
     # remote setting
-    port:        'RUBY_DEBUG_PORT',        # TCP/IP remote debugging: port
-    host:        'RUBY_DEBUG_HOST',        # TCP/IP remote debugging: host (localhost if not given)
-    sock_path:   'RUBY_DEBUG_SOCK_PATH',   # UNIX Domain Socket remote debugging: socket path
-    sock_dir:    'RUBY_DEBUG_SOCK_DIR',    # UNIX Domain Socket remote debugging: socket directory
-    cookie:      'RUBY_DEBUG_COOKIE',      # Cookie for negotiation
+    port:           ['RUBY_DEBUG_PORT',      "REMOTE: TCP/IP remote debugging: port"],
+    host:           ['RUBY_DEBUG_HOST',      "REMOTE: TCP/IP remote debugging: host (localhost if not given)"],
+    sock_path:      ['RUBY_DEBUG_SOCK_PATH', "REMOTE: UNIX Domain Socket remote debugging: socket path"],
+    sock_dir:       ['RUBY_DEBUG_SOCK_DIR',  "REMOTE: UNIX Domain Socket remote debugging: socket directory"],
+    cookie:         ['RUBY_DEBUG_COOKIE',    "REMOTE: Cookie for negotiation"],
   }.freeze
 
+  CONFIG_MAP = CONFIG_SET.map{|k, (ev, desc)| [k, ev]}.to_h.freeze
+
   def self.config_to_env_hash config
     CONFIG_MAP.each_with_object({}){|(key, evname), env|
       env[evname] = config[key].to_s if config[key]
     }
   end
 
+  def self.parse_config_value name, valstr
+    return valstr unless valstr.kind_of? String
+
+    case CONFIG_SET[name][2]
+    when :bool
+      case valstr
+      when '1', 'true', 'TRUE', 'T'
+        true
+      else
+        false
+      end
+    when :int
+      valstr.to_i
+    when :loglevel
+      if DEBUGGER__::LOG_LEVELS[s = valstr.to_sym]
+        s
+      else
+        raise "Unknown loglevel: #{valstr}"
+      end
+    when :path # array of String
+      valstr.split(/:/).map{|e|
+        if /\A\/(.+)\/\z/ =~ e
+          Regexp.compile $1
+        else
+          e
+        end
+      }
+    else
+      valstr
+    end
+  end
+
   def self.parse_argv argv
     config = {
       mode: :start,
     }
     CONFIG_MAP.each{|key, evname|
       if val = ENV[evname]
-        if /_USE_/ =~ evname || /NONSTOP/ =~ evname
-          case val
-          when '1', 'true', 'TRUE', 'T'
-            config[key] = true
-          else
-            config[key] = false
-          end
-        else
-          config[key] = val
-        end
+        config[key] = parse_config_value(key, val)
       end
     }
     return config if !argv || argv.empty?
@@ -93,7 +121,7 @@ module DEBUGGER__
         config[:nonstop] = '1'
       end
 
-      o.on('-e COMMAND', 'Execute debug command at the beginning of the script.') do |cmd|
+      o.on('-e DEBUG_COMMAND', 'Execute debug command at the beginning of the script.') do |cmd|
         config[:commands] ||= ''
         config[:commands] += cmd + ';;'
       end
@@ -141,6 +169,9 @@ module DEBUGGER__
       o.separator ''
       o.separator "  '#{rdbg} target.rb foo bar'                starts like 'ruby target.rb foo bar'."
       o.separator "  '#{rdbg} -- -r foo -e bar'                 starts like 'ruby -r foo -e bar'."
+      o.separator "  '#{rdbg} -c rake test'                     starts like 'rake test'."
+      o.separator "  '#{rdbg} -c -- rake test -t'               starts like 'rake test -t'."
+      o.separator "  '#{rdbg} -c bundle exec rake test'         starts like 'bundle exec rake test'."
       o.separator "  '#{rdbg} -O target.rb foo bar'             starts and accepts attaching with UNIX domain socket."
       o.separator "  '#{rdbg} -O --port 1234 target.rb foo bar' starts accepts attaching with TCP/IP localhost:1234."
       o.separator "  '#{rdbg} -O --port 1234 -- -r foo -e bar'  starts accepts attaching with TCP/IP localhost:1234."
@@ -191,10 +222,22 @@ module DEBUGGER__
   def self.set_config kw
     kw.each{|k, v|
       if CONFIG_MAP[k]
-        CONFIG[k] = v # TODO: ractor support
+        CONFIG[k] = parse_config_value(k, v) # TODO: ractor support
       else
-        raise "unknown option: #{k}"
+        raise "Unknown configuration: #{k}"
       end
     }
   end
+
+  def self.append_config key, val
+    if CONFIG_SET[key]
+      if CONFIG_SET[key][2] == :path
+        CONFIG[key] = [*CONFIG[key], *parse_config_value(key, val)];
+      else
+        raise "not an Array type: #{key}"
+      end
+    else
+      raise "Unknown configuration: #{key}"
+    end
+  end
 end

data/lib/debug/console.rb

@@ -26,7 +26,11 @@ module DEBUGGER__
     end
 
     def width
-      IO.console_size[1]
+      if (w = IO.console_size[1]) == 0 # for tests PTY
+        80
+      else
+        w
+      end
     end
 
     def quit n
@@ -36,7 +40,7 @@ module DEBUGGER__
     def ask prompt
       setup_interrupt do
         print prompt
-        (gets || '').strip
+        ($stdin.gets || '').strip
       end
     end
 

data/lib/debug/session.rb

@@ -101,6 +101,10 @@ module DEBUGGER__
       @tp_thread_begin.enable
     end
 
+    def active?
+      @ui ? true : false
+    end
+
     def reset_ui ui
       @ui.close
       @ui = ui
@@ -172,8 +176,11 @@ module DEBUGGER__
         end
       end
     ensure
+      @tp_load_script.disable
+      @tp_thread_begin.disable
       @bps.each{|k, bp| bp.disable}
       @th_clients.each{|th, thc| thc.close}
+      @ui = nil
     end
 
     def add_preset_commands name, cmds, kick: true, continue: true
@@ -337,10 +344,14 @@ module DEBUGGER__
       #    * Set breakpoint on the method `<class>#<name>`.
       # * `b[reak] <expr>.<name>`
       #    * Set breakpoint on the method `<expr>.<name>`.
-      # * `b[reak] ... if <expr>`
+      # * `b[reak] ... if: <expr>`
       #   * break if `<expr>` is true at specified location.
-      # * `b[reak] if <expr>`
-      #   * break if `<expr>` is true at any lines.
+      # * `b[reak] ... pre: <command>`
+      #   * break and run `<command>` before stopping.
+      # * `b[reak] ... do: <command>`
+      #   * break and run `<command>`, and continue.
+      # * `b[reak] if: <expr>`
+      #   * break if: `<expr>` is true at any lines.
       #   * Note that this feature is super slow.
       when 'b', 'break'
         if arg == nil
@@ -428,8 +439,25 @@ module DEBUGGER__
 
       # * `bt` or `backtrace`
       #   * Show backtrace (frame) information.
+      # * `bt <num>` or `backtrace <num>`
+      #   * Only shows first `<num>` frames.
+      # * `bt /regexp/` or `backtrace /regexp/`
+      #   * Only shows frames with method name or location info that matches `/regexp/`.
+      # * `bt <num> /regexp/` or `backtrace <num> /regexp/`
+      #   * Only shows first `<num>` frames with method name or location info that matches `/regexp/`.
       when 'bt', 'backtrace'
-        @tc << [:show, :backtrace]
+        case arg
+        when /\A(\d+)\z/
+          @tc << [:show, :backtrace, arg.to_i, nil]
+        when /\A\/(.*)\/\z/
+          pattern = $1
+          @tc << [:show, :backtrace, nil, Regexp.compile(pattern)]
+        when /\A(\d+)\s+\/(.*)\/\z/
+          max, pattern = $1, $2
+          @tc << [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
+        else
+          @tc << [:show, :backtrace, nil, nil]
+        end
 
       # * `l[ist]`
       #   * Show current frame's source code.
@@ -609,6 +637,21 @@ module DEBUGGER__
         end
         return :retry
 
+      ### Configuration
+      # * `config`
+      #   * Show all configuration with description.
+      # * `config <name>`
+      #   * Show current configuration of <name>.
+      # * `config set <name> <val>` or `config <name> = <val>`
+      #   * Set <name> to <val>.
+      # * `config append <name> <val>` or `config <name> << <val>`
+      #   * Append `<val>` to `<name>` if it is an array.
+      # * `config unset <name>`
+      #   * Set <name> to default.
+      when 'config'
+        config_command arg
+        return :retry
+
       ### Help
 
       # * `h[elp]`
@@ -640,6 +683,73 @@ module DEBUGGER__
       return :retry
     end
 
+    def config_show key
+      key = key.to_sym
+      if CONFIG_SET[key]
+        v = CONFIG[key]
+        kv = "#{key} = #{v.nil? ? '(default)' : v.inspect}"
+        desc = CONFIG_SET[key][1]
+        line = "%-30s \# %s" % [kv, desc]
+        if line.size > SESSION.width
+          @ui.puts "\# #{desc}\n#{kv}"
+        else
+          @ui.puts line
+        end
+      else
+        @ui.puts "Unknown configuration: #{key}. 'config' shows all configurations."
+      end
+    end
+
+    def config_set key, val, append: false
+      if CONFIG_SET[key = key.to_sym]
+        begin
+          if append
+            DEBUGGER__.append_config(key, val)
+          else
+            DEBUGGER__.set_config({key => val})
+          end
+        rescue => e
+          @ui.puts e.message
+        end
+      end
+
+      config_show key
+    end
+
+    def config_command arg
+      case arg
+      when nil
+        CONFIG_SET.each do |k, _|
+          config_show k
+        end
+
+      when /\Aunset\s+(.+)\z/
+        if CONFIG_SET[key = $1.to_sym]
+          DEBUGGER__.set_config({key => nil})
+        end
+        config_show key
+
+      when /\A(\w+)\s*=\s*(.+)\z/
+        config_set $1, $2
+
+      when /\A\s*set\s+(\w+)\s+(.+)\z/
+        config_set $1, $2
+
+      when /\A(\w+)\s*<<\s*(.+)\z/
+        config_set $1, $2, append: true
+
+      when /\A\s*append\s+(\w+)\s+(.+)\z/
+        config_set $1, $2
+
+      when /\A(\w+)\z/
+        config_show $1
+
+      else
+        @ui.puts "Can not parse parameters: #{arg}"
+      end
+    end
+
+
     def cancel_auto_continue
       if @preset_command&.auto_continue
         @preset_command.auto_continue = false
@@ -762,29 +872,37 @@ module DEBUGGER__
       end
     end
 
-    def repl_add_breakpoint arg
-      arg.strip!
+    BREAK_KEYWORDS = %w(if: do: pre:).freeze
 
-      case arg
-      when /\Aif\s+(.+)\z/
-        cond = $1
-      when /(.+?)\s+if\s+(.+)\z/
-        sig = $1
-        cond = $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
+
+    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 sig
+      case expr[:sig]
       when /\A(\d+)\z/
-        add_line_breakpoint @tc.location.path, $1.to_i, cond: cond
+        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
+        add_line_breakpoint $1, $2.to_i, cond: expr[:if], command: cmd
       when /\A(.+)([\.\#])(.+)\z/
-        @tc << [:breakpoint, :method, $1, $2, $3, cond]
+        @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
@@ -908,6 +1026,7 @@ module DEBUGGER__
     ## event
 
     def on_load iseq, src
+      DEBUGGER__.info "Load #{iseq.absolute_path || iseq.path}"
       @sr.add iseq, src
 
       pending_line_breakpoints do |bp|
@@ -920,6 +1039,9 @@ module DEBUGGER__
     # breakpoint management
 
     def add_breakpoint bp
+      # don't repeat commands that add breakpoints
+      @repl_prev_line = nil
+
       if @bps.has_key? bp.key
         unless bp.duplicable?
           @ui.puts "duplicated breakpoint: #{bp}"
@@ -928,9 +1050,6 @@ module DEBUGGER__
       else
         @bps[bp.key] = bp
       end
-
-      # don't repeat commands that add breakpoints
-      @repl_prev_line = nil
     end
 
     def rehash_bps
@@ -1001,7 +1120,7 @@ module DEBUGGER__
           when MethodBreakpoint
             if bp.method.nil?
               if bp.sig_method_name == mid.to_s
-                bp.try_enable(quiet: true)
+                bp.try_enable(added: true)
               end
             end
 
@@ -1139,20 +1258,18 @@ module DEBUGGER__
       # ::DEBUGGER__.add_catch_breakpoint 'RuntimeError'
 
       Binding.module_eval do
-        def bp command: nil, nonstop: nil
-          if command
-            cmds = command.split(";;")
-            # nonstop
-            #  nil, true -> auto_continue
-            #  false     -> stop
-            SESSION.add_preset_commands 'binding.bp(command:)', cmds,
-                                        kick: false,
-                                        continue: nonstop == false ? false : true
+        def break pre: nil, do: nil
+          return unless SESSION.active?
+
+          if pre || (do_expr = binding.local_variable_get(:do))
+            cmds = ['binding.break', pre, do_expr]
           end
 
-          ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1, oneshot: true
+          ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1, oneshot: true, command: cmds
           true
         end
+        alias b break
+        # alias bp break
       end
 
       load_rc
@@ -1262,12 +1379,33 @@ module DEBUGGER__
     end
   end
 
-  def self.warn msg, level = :warn
-    case level
-    when :warn
-      STDERR.puts "DEBUGGER: #{msg}" unless CONFIG[:quiet]
-    when :error
-      STDERR.puts "DEBUGGER: #{msg}"
+  LOG_LEVELS = {
+    UNKNOWN: 0,
+    FATAL:   1,
+    ERROR:   2,
+    WARN:    3,
+    INFO:    4,
+  }.freeze
+
+  def self.warn msg
+    log :WARN, msg
+  end
+
+  def self.info msg
+    log :INFO, msg
+  end
+
+  def self.log level, msg
+    lv = LOG_LEVELS[level]
+    config_lv = LOG_LEVELS[CONFIG[:log_level] || :WARN]
+
+    if lv <= config_lv
+      if level == :WARN
+        # :WARN on debugger is general information
+        STDERR.puts "DEBUGGER: #{msg}"
+      else
+        STDERR.puts "DEBUGGER (#{level}): #{msg}"
+      end
     end
   end
 end

data/lib/debug/thread_client.rb

@@ -69,11 +69,11 @@ module DEBUGGER__
       @q_cmd = q_cmd
       @step_tp = nil
       @output = []
-      @src_lines_on_stop = (::DEBUGGER__::CONFIG[:show_src_lines]   || 10).to_i
-      @show_frames_on_stop = (::DEBUGGER__::CONFIG[:show_frames] || 2).to_i
       @frame_formatter = method(:default_frame_formatter)
       @var_map = {} # { thread_local_var_id => obj } for DAP
       set_mode nil
+
+      ::DEBUGGER__.info("Thread \##{@id} is created.")
     end
 
     def name
@@ -167,8 +167,8 @@ module DEBUGGER__
       end
 
       if event != :pause
-        show_src max_lines: @src_lines_on_stop
-        show_frames @show_frames_on_stop
+        show_src max_lines: (::DEBUGGER__::CONFIG[:show_src_lines] || 10)
+        show_frames ::DEBUGGER__::CONFIG[:show_frames] || 2
 
         if bp
           event! :suspend, :breakpoint, bp.key
@@ -304,20 +304,39 @@ module DEBUGGER__
       end
     end
 
+    def puts_variable_info label, obj
+      info = "#{colorize_cyan(label)} => #{colored_inspect(obj)}".lines
+      w = SESSION.width
+      max_inspect_lines = CONFIG[:show_inspect_lines] || 10
+
+      if (max_inspect_lines > 0 && (info.size > max_inspect_lines)) || info.any?{|l| l.size > w}
+        info = "#{colorize_cyan(label)} => #{colored_inspect(obj, no_color: true)}".lines
+        if max_inspect_lines > 0 && info.size > max_inspect_lines
+          info = info.first(max_inspect_lines - 2) +
+                 ["...(#{info.size - (max_inspect_lines - 1)} lines)\n" + info.last]
+        end
+        info.map!{|l|
+          l.length > w ? l[0..(w-4)] + '...' : l
+        }
+      end
+
+      puts info
+    end
+
     def show_locals
       if s = current_frame&.self
-        puts " #{colorize_cyan("%self")} => #{colored_inspect(s)}"
+        puts_variable_info '%self', s
       end
       if current_frame&.has_return_value
-        puts " #{colorize_cyan("%return")} => #{colored_inspect(current_frame.return_value)}"
+        puts_variable_info '%return', current_frame.return_value
       end
       if current_frame&.has_raised_exception
-        puts " #{colorize_cyan("%raised")} => #{colored_inspect(current_frame.raised_exception)}"
+        puts_variable_info "%raised", current_frame.raised_exception
       end
       if b = current_frame&.binding
         b.local_variables.each{|loc|
           value = b.local_variable_get(loc)
-          puts " #{colorize_cyan(loc)} => #{colored_inspect(value)}"
+          puts_variable_info loc, value
         }
       end
     end
@@ -326,11 +345,15 @@ module DEBUGGER__
       if s = current_frame&.self
         s.instance_variables.each{|iv|
           value = s.instance_variable_get(iv)
-          puts " #{colorize_cyan(iv)} => #{colored_inspect(value)}"
+          puts_variable_info iv, value
         }
       end
     end
 
+    def instance_eval_for_cmethod frame_self, src
+      frame_self.instance_eval(src)
+    end
+
     def frame_eval src, re_raise: false
       begin
         @success_last_eval = false
@@ -341,7 +364,7 @@ module DEBUGGER__
                    b.eval(src, "(rdbg)/#{f}")
                  else
                    frame_self = current_frame.self
-                   frame_self.instance_eval(src)
+                   instance_eval_for_cmethod(frame_self, src)
                  end
         @success_last_eval = true
         result
@@ -359,21 +382,35 @@ module DEBUGGER__
       end
     end
 
-    def frame_str(i)
+    def frame_str(i, frame: @target_frames[i])
       cur_str = (@current_frame_index == i ? '=>' : '  ')
       prefix = "#{cur_str}##{i}"
-      frame = @target_frames[i]
       frame_string = @frame_formatter.call(frame)
       "#{prefix}\t#{frame_string}"
     end
 
-    def show_frames max = (@target_frames || []).size
-      if max > 0 && @target_frames
-        size = @target_frames.size
-        max += 1 if size == max + 1
+    def show_frames max = nil, pattern = nil
+      if @target_frames && (max ||= @target_frames.size) > 0
+        frames = []
+        @target_frames.each_with_index{|f, i|
+          next if pattern && !(f.name.match?(pattern) || f.location_str.match?(pattern))
+          next if CONFIG[:skip_path] && CONFIG[:skip_path].any?{|pat|
+            case pat
+            when String
+              f.location_str.start_with?(pat)
+            when Regexp
+              f.location_str.match?(pat)
+            end
+          }
+
+          frames << [i, f]
+        }
+
+        size = frames.size
         max.times{|i|
-          break if i >= size
-          puts frame_str(i)
+          break unless frames[i]
+          index, frame = frames[i]
+          puts frame_str(index, frame: frame)
         }
         puts "  # and #{size - max} frames (use `bt' command for all frames)" if max < size
       end
@@ -404,8 +441,8 @@ module DEBUGGER__
     def make_breakpoint args
       case args.first
       when :method
-        klass_name, op, method_name, cond = args[1..]
-        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond)
+        klass_name, op, method_name, cond, cmd = args[1..]
+        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond, command: cmd)
         begin
           bp.enable
         rescue Exception => e
@@ -493,8 +530,7 @@ module DEBUGGER__
           when :pp
             result = frame_eval(eval_src)
             puts "=> "
-            PP.pp(result, out = ''.dup, SESSION.width)
-            puts out
+            puts color_pp(result, SESSION.width)
           when :call
             result = frame_eval(eval_src)
           when :display, :try_display
@@ -549,7 +585,8 @@ module DEBUGGER__
 
           case type
           when :backtrace
-            show_frames
+            max_lines, pattern = *args
+            show_frames max_lines, pattern
 
           when :list
             show_src(update_line: true, **(args.first || {}))
@@ -603,7 +640,7 @@ module DEBUGGER__
     rescue SystemExit
       raise
     rescue Exception => e
-      pp [__FILE__, __LINE__, e, e.backtrace]
+      pp ["DEBUGGER Exception: #{__FILE__}:#{__LINE__}", e, e.backtrace]
       raise
     ensure
       set_mode nil

data/lib/debug/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DEBUGGER__
-  VERSION = "1.0.0.beta6"
+  VERSION = "1.0.0.beta7"
 end

data/misc/README.md.erb

@@ -83,6 +83,7 @@ require 'debug/run' # start the debug console
 # ... rest of program ...
 ```
 
+
 ```
 $ ruby target.rb
 ```
@@ -90,6 +91,24 @@ $ ruby target.rb
 When you run the program with the debug console, you will see the debug console prompt `(rdbg)`.
 The debuggee program (`target.rb`) is suspended at the beginning of `target.rb`.
 
+
+Alternatively, start the debugger at a specific location in your program using `binding.break` (`binding.b` for short).
+
+```ruby
+# target.rb
+require 'debug' # start the debugger
+
+# ... program ...
+
+binding.break # setup a breakpoint at this line
+
+# ... rest of program ...
+```
+
+```
+$ ruby target.rb
+```
+
 You can type any debugger's command described bellow. "c" or "continue" resume the debuggee program.
 You can suspend the debuggee program and show the debug console with `Ctrl-C`.
 
@@ -310,20 +329,19 @@ If there are `~/.rdbgrc`, the file is loaded as initial scripts which contains d
 
 If there are `~/.rdbgrc.rb` is available, it is loaded as a ruby script at same timing.
 
-### Environment variables
+### Configurations
 
-You can control debuggee's behavior with environment variables:
+You can configure debugger's setting with environment variables and `config` command.
+You can write any configuration into `~/.rdbgrc` like:
 
-* `RUBY_DEBUG_NONSTOP`: 1 for nonstop at the beginning of program.
-* `RUBY_DEBUG_INIT_SCRIPT`: Initial script path loaded at the first stop.
-* `RUBY_DEBUG_COMMANDS`: Debug commands invoked at the first stop. Commands should be separated by ';;'.
-* `RUBY_DEBUG_SHOW_SRC_LINES`: Show n lines source code on breakpoint (default: 10 lines).
-* `RUBY_DEBUG_SHOW_FRAMES`: Show n frames on breakpoint (default: 2 frames).
-* Remote debugging
-  * `RUBY_DEBUG_PORT`: TCP/IP remote debugging: port to open.
-  * `RUBY_DEBUG_HOST`: TCP/IP remote debugging: host (localhost if not given) to open.
-  * `RUBY_DEBUG_SOCK_PATH`: UNIX Domain Socket remote debugging: socket path to open.
-  * `RUBY_DEBUG_SOCK_DIR`: UNIX Domain Socket remote debugging: socket directory to open.
+```
+config set log_level INFO
+config set no_color true
+```
+<% cat = nil; DEBUGGER__::CONFIG_SET.each do |key, (env, desc)| %>
+<% /\A(\w+): (.+)/ =~ desc; if cat != $1; cat = 1 %>
+* <%= $1 %>
+<% cat = $1; end %>  * `<%= env %>` (`<%= key %>`): <%= $2 %><% end %>
 
 ## Debug command on the debug console
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: debug
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta6
+  version: 1.0.0.beta7
 platform: ruby
 authors:
 - Koichi Sasada
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-07 00:00:00.000000000 Z
+date: 2021-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb