debug 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3e49208dc5aafac57624c1bfb06a1f1d4975bc1a3ea1739b170cd97b4805f80
-  data.tar.gz: 631bb42bb4bb78cb6bda141e062e317edfb49fc01bbf6e4ca65036efc5175c12
+  metadata.gz: 5e9851059a728e477461cc318c9b94932fa0aeb19215f936ab6c25cf62f67cd0
+  data.tar.gz: b050eee3dbf0afecfda2c1221fe38ab678808405c10f89d5832a1950e2728aa8
 SHA512:
-  metadata.gz: 03d36a4f2ba792570d77206897e112e74947cf951f36dbd62b94f6faefbc431735b92da833682b1e768368e9393051cc7efea784daf853ab6d927b57780ca780
-  data.tar.gz: 837963016cb3d8cb932796706323761ecbcdda55d9c8da0cc68d1d324ad92018e06959489273edbb7a3f0fadc817d699dd744266a3e48ce6ce1647370a77cd1d
+  metadata.gz: a15549ee06b890a32d0960dd24a99c4c925d66b5f6512a7e5ff3052f10ca3a255038d44eaa2d10046cbe2b68bca121c813db3a8e5fea68def5dcd2e1797864d7
+  data.tar.gz: '058b5ef8c6e40a8ccfa12b62b09c8808c1b524c398e37a25ffd790b8a8e0364026911478019d06100b7a6d8fde878dd7695f2f2630f3f35f37f12695b84b2ddf'

data/README.md

@@ -8,7 +8,7 @@ This debug.rb is replacement of traditional lib/debug.rb standard library which
 New debug.rb has several advantages:
 
 * Fast: No performance penalty on non-stepping mode and non-breakpoints.
-* Remote debugging: Support remote debugging natively.
+* [Remote debugging](#remote-debugging): Support remote debugging natively.
   * UNIX domain socket
   * TCP/IP
   * VSCode/DAP integration ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
@@ -44,22 +44,24 @@ To use a debugger, roughly you will do the following steps:
 2. Run a program with the debugger.
 3. At the breakpoint, enter the debugger console.
 4. Use debug commands.
-    * Query the program status (e.g. `p lvar` to see the local variable `lvar`).
-    * Control program flow (e.g. move to the another line with `step`, to the next line with `next`).
-    * Set another breakpoint (e.g. `catch Exception` to set a breakpoint when `Exception` is raised).
-    * Change the configuration (e.g. `config set no_color true` to disable coloring).
+    * [Evaluate Ruby expressions](#evaluate) (e.g. `p lvar` to see the local variable `lvar`).
+    * [Query the program status](#information) (e.g. `info` to see information about the current frame).
+    * [Control program flow](#control-flow) (e.g. move to the another line with `step`, to the next line with `next`).
+    * [Set another breakpoint](#breakpoint) (e.g. `catch Exception` to set a breakpoint that'll be triggered when `Exception` is raised).
+    * [Activate tracing in your program](#trace) (e.g. `trace call` to trace method calls).
+    * [Change the configuration](#configuration-1) (e.g. `config set no_color true` to disable coloring).
     * Continue the program (`c` or `continue`) and goto 3.
 
 ## Invoke with the debugger
 
 There are several options for (1) and (2). Please choose your favorite way.
 
-### Modify source code as `binding.pry` and `binding.irb`
+### Modify source code with [`binding.break`](#bindingbreak-method) (similar to `binding.pry` or `binding.irb`)
 
-If you can modify the source code, you can use the debugger by adding `require 'debug'` line at the top of your program and putting `binding.break` method (`binding.b` for short) into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
+If you can modify the source code, you can use the debugger by adding `require 'debug'` line at the top of your program and putting [`binding.break`](#bindingbreak-method) method (`binding.b` for short) into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
 After that, you run the program as usual and you will enter the debug console at breakpoints you inserted.
 
-The following example shows the demonstration of `binding.break`.
+The following example shows the demonstration of [`binding.break`](#bindingbreak-method).
 
 ```shell
 $ cat target.rb                        # Sample program
@@ -355,7 +357,7 @@ config set no_color true
   * `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_USE_SHORT_PATH` (`use_short_path`): Show shoten PATH (like $(Gem)/foo.rb)
+  * `RUBY_DEBUG_USE_SHORT_PATH` (`use_short_path`): Show shorten PATH (like $(Gem)/foo.rb)
   * `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)
   * `RUBY_DEBUG_NO_RELINE` (`no_reline`): Do not use Reline library (default: false)
@@ -494,7 +496,7 @@ The `<...>` notation means the argument.
   * Show information about the current frame (local variables)
   * It includes `self` as `%self` and a return value as `%return`.
 * `i[nfo] i[var[s]]` or `i[nfo] instance`
-  * Show information about insttance variables about `self`.
+  * Show information about instance variables about `self`.
 * `i[nfo] c[onst[s]]` or `i[nfo] constant[s]`
   * Show information about accessible constants except toplevel constants.
 * `i[nfo] g[lobal[s]]`

data/Rakefile

@@ -15,7 +15,7 @@ Rake::ExtensionTask.new("debug") do |ext|
   ext.lib_dir = "lib/debug"
 end
 
-task :default => [:clobber, :compile, :test, 'README.md']
+task :default => [:clobber, :compile, 'README.md', :test]
 
 file 'README.md' => ['lib/debug/session.rb', 'lib/debug/config.rb',
                      'exe/rdbg', 'misc/README.md.erb'] do

data/TODO.md

@@ -3,7 +3,7 @@
 ## Basic functionality
 
 * Support Ractors
-* Signal (SIGINT) trap handling
+* Signal (SIGINT) trap handling 
 
 ## UI
 
@@ -12,6 +12,7 @@
 * Interactive record & play debugging
 * irb integration
 * Web browser integrated UI
+* History file
 
 ## Debug command
 

data/lib/debug/config.rb

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 
 module DEBUGGER__
+  LOG_LEVELS = {
+    UNKNOWN: 0,
+    FATAL:   1,
+    ERROR:   2,
+    WARN:    3,
+    INFO:    4,
+  }.freeze
+
   CONFIG_SET = {
     # UI setting
     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],
-    use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shoten PATH (like $(Gem)/foo.rb)",                      :bool],
+    use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shorten PATH (like $(Gem)/foo.rb)",                      :bool],
     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],
     no_reline:      ['RUBY_DEBUG_NO_RELINE',      "UI: Do not use Reline library (default: false)",                 :bool],
@@ -372,7 +380,7 @@ module DEBUGGER__
     desc = cat = nil
     cmds = Hash.new
 
-    File.read(File.join(__dir__, 'session.rb')).each_line do |line|
+    File.read(File.join(__dir__, 'session.rb'), encoding: Encoding::UTF_8).each_line do |line|
       case line
       when /\A\s*### (.+)/
         cat = $1

data/lib/debug/server_dap.rb

@@ -153,8 +153,8 @@ module DEBUGGER__
         when 'setFunctionBreakpoints'
           send_response req
         when 'setExceptionBreakpoints'
-          filters = args.dig('filterOptions').map{|bp_info|
-            case bp_info.dig('filterId')
+          process_filter = ->(filter_id) {
+            case filter_id
             when 'any'
               bp = SESSION.add_catch_breakpoint 'Exception'
             when 'RuntimeError'
@@ -163,10 +163,19 @@ module DEBUGGER__
               bp = nil
             end
             {
-              verifiled: bp ? true : false,
+              verified: bp ? true : false,
               message: bp.inspect,
             }
           }
+
+          filters = args.fetch('filters').map {|filter_id|
+            process_filter.call(filter_id)
+          }
+
+          filters += args.fetch('filterOptions', {}).map{|bp_info|
+            process_filter.call(bp_info.dig('filterId'))
+          }
+
           send_response req, breakpoints: filters
         when 'configurationDone'
           send_response req
@@ -354,7 +363,7 @@ module DEBUGGER__
               fail_response req
             end
           else
-            raise "Uknown type: #{ref.inspect}"
+            raise "Unknown type: #{ref.inspect}"
           end
         else
           fail_response req
@@ -471,7 +480,7 @@ module DEBUGGER__
         fid = args.shift
         frame = @target_frames[fid]
 
-        lnum = 
+        lnum =
           if frame.binding
             frame.binding.local_variables.size
           elsif vars = frame.local_variables
@@ -580,7 +589,7 @@ module DEBUGGER__
         end
         event! :dap_result, :evaluate, req, tid: self.id, **evaluate_result(result)
       else
-        raise "Unkown req: #{args.inspect}"
+        raise "Unknown req: #{args.inspect}"
       end
     end
 

data/lib/debug/session.rb

@@ -1,7 +1,21 @@
 # frozen_string_literal: true
 
 # skip to load debugger for bundle exec
-return if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
+
+if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
+  trace_var(:$0) do |file|
+    trace_var(:$0, nil)
+    if /-r (#{__dir__}\S+)/ =~ ENV['RUBYOPT']
+      lib = $1
+      $LOADED_FEATURES.delete_if{|path| path.start_with?(__dir__)}
+      ENV['RUBY_DEBUG_INITIAL_SUSPEND_PATH'] = file
+      require lib
+      ENV['RUBY_DEBUG_INITIAL_SUSPEND_PATH'] = nil
+    end
+  end
+
+  return
+end
 
 require_relative 'config'
 require_relative 'thread_client'
@@ -9,6 +23,10 @@ require_relative 'source_repository'
 require_relative 'breakpoint'
 require_relative 'tracer'
 
+# To prevent loading old lib/debug.rb in Ruby 2.6 to 3.0
+$LOADED_FEATURES << 'debug.rb'
+require 'debug' # invalidate the $LOADED_FEATURE cache
+
 require 'json' if ENV['RUBY_DEBUG_TEST_MODE']
 
 class RubyVM::InstructionSequence
@@ -159,7 +177,7 @@ module DEBUGGER__
 
     def session_server_main
       while evt = pop_event
-        # varible `@internal_info` is only used for test
+        # variable `@internal_info` is only used for test
         tc, output, ev, @internal_info, *ev_args = evt
         output.each{|str| @ui.puts str}
 
@@ -598,7 +616,7 @@ module DEBUGGER__
       #   * Show information about the current frame (local variables)
       #   * It includes `self` as `%self` and a return value as `%return`.
       # * `i[nfo] i[var[s]]` or `i[nfo] instance`
-      #   * Show information about insttance variables about `self`.
+      #   * Show information about instance variables about `self`.
       # * `i[nfo] c[onst[s]]` or `i[nfo] constant[s]`
       #   * Show information about accessible constants except toplevel constants.
       # * `i[nfo] g[lobal[s]]`
@@ -1507,7 +1525,10 @@ module DEBUGGER__
 
   def self.setup_initial_suspend
     if !CONFIG[:nonstop]
-      if loc = ::DEBUGGER__.require_location
+      case
+      when path = ENV['RUBY_DEBUG_INITIAL_SUSPEND_PATH']
+        add_line_breakpoint path, 0, oneshot: true, hook_call: false
+      when loc = ::DEBUGGER__.require_location
         # require 'debug/start' or 'debug'
         add_line_breakpoint loc.absolute_path, loc.lineno + 1, oneshot: true, hook_call: false
       else
@@ -1519,29 +1540,8 @@ module DEBUGGER__
 
   class << self
     define_method :initialize_session do |ui|
-      DEBUGGER__.warn "Session start (pid: #{Process.pid})"
-
+      DEBUGGER__.info "Session start (pid: #{Process.pid})"
       ::DEBUGGER__.const_set(:SESSION, Session.new(ui))
-
-      # default breakpoints
-
-      # ::DEBUGGER__.add_catch_breakpoint 'RuntimeError'
-
-      Binding.module_eval do
-        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, command: cmds
-          true
-        end
-        alias b break
-        # alias bp break
-      end
-
       load_rc
     end
   end
@@ -1599,14 +1599,6 @@ module DEBUGGER__
     end
   end
 
-  LOG_LEVELS = {
-    UNKNOWN: 0,
-    FATAL:   1,
-    ERROR:   2,
-    WARN:    3,
-    INFO:    4,
-  }.freeze
-
   def self.warn msg
     log :WARN, msg
   end
@@ -1694,3 +1686,31 @@ module DEBUGGER__
   end
 end
 
+class Binding
+  def break pre: nil, do: nil
+    return if !defined?(::DEBUGGER__::SESSION) || !::DEBUGGER__::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, command: cmds
+    self
+  end
+  alias b break
+end
+
+module Kernel
+  if RUBY_VERSION >= '2.7.0'
+    eval <<~RUBY, binding, __FILE__, __LINE__
+      def debugger(...)
+        binding.break(...)
+      end
+    RUBY
+  else
+    def debugger pre: nil, do: nil
+      b = binding
+      b.break pre: pre, do: b.local_variable_get(:do)
+    end
+  end
+end

data/lib/debug/tracer.rb

@@ -216,7 +216,7 @@ module DEBUGGER__
                 out tp, " #{colorized_obj_inspect} is used as a parameter #{colorized_name} of #{method_info}"
               end
             when :rest
-              next name == :"*"
+              next if name == :"*"
 
               ary = b.local_variable_get(name)
               ary.each{|e|

data/lib/debug/version.rb

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

data/misc/README.md.erb

@@ -8,7 +8,7 @@ This debug.rb is replacement of traditional lib/debug.rb standard library which
 New debug.rb has several advantages:
 
 * Fast: No performance penalty on non-stepping mode and non-breakpoints.
-* Remote debugging: Support remote debugging natively.
+* [Remote debugging](#remote-debugging): Support remote debugging natively.
   * UNIX domain socket
   * TCP/IP
   * VSCode/DAP integration ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
@@ -44,22 +44,24 @@ To use a debugger, roughly you will do the following steps:
 2. Run a program with the debugger.
 3. At the breakpoint, enter the debugger console.
 4. Use debug commands.
-    * Query the program status (e.g. `p lvar` to see the local variable `lvar`).
-    * Control program flow (e.g. move to the another line with `step`, to the next line with `next`).
-    * Set another breakpoint (e.g. `catch Exception` to set a breakpoint when `Exception` is raised).
-    * Change the configuration (e.g. `config set no_color true` to disable coloring).
+    * [Evaluate Ruby expressions](#evaluate) (e.g. `p lvar` to see the local variable `lvar`).
+    * [Query the program status](#information) (e.g. `info` to see information about the current frame).
+    * [Control program flow](#control-flow) (e.g. move to the another line with `step`, to the next line with `next`).
+    * [Set another breakpoint](#breakpoint) (e.g. `catch Exception` to set a breakpoint that'll be triggered when `Exception` is raised).
+    * [Activate tracing in your program](#trace) (e.g. `trace call` to trace method calls).
+    * [Change the configuration](#configuration-1) (e.g. `config set no_color true` to disable coloring).
     * Continue the program (`c` or `continue`) and goto 3.
 
 ## Invoke with the debugger
 
 There are several options for (1) and (2). Please choose your favorite way.
 
-### Modify source code as `binding.pry` and `binding.irb`
+### Modify source code with [`binding.break`](#bindingbreak-method) (similar to `binding.pry` or `binding.irb`)
 
-If you can modify the source code, you can use the debugger by adding `require 'debug'` line at the top of your program and putting `binding.break` method (`binding.b` for short) into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
+If you can modify the source code, you can use the debugger by adding `require 'debug'` line at the top of your program and putting [`binding.break`](#bindingbreak-method) method (`binding.b` for short) into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
 After that, you run the program as usual and you will enter the debug console at breakpoints you inserted.
 
-The following example shows the demonstration of `binding.break`.
+The following example shows the demonstration of [`binding.break`](#bindingbreak-method).
 
 ```shell
 $ cat target.rb                        # Sample program

metadata

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