debug 1.2.3 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebbeeac4c437bdefb9c0115008b705debb189b6332ee9ea056fd469c323c7149
-  data.tar.gz: 7a6abfb0490eaa49ec118efe89e50c51111be291a0b342fca930c3887a66aa72
+  metadata.gz: 7316cec0879fc91787183e28cad0bbc4a1f819eb7d3ee4530a28b2ee173877e9
+  data.tar.gz: e37f36b72d3aec5fed4559c78474358c487e3c1748a732984a42331c2a96191a
 SHA512:
-  metadata.gz: 7bfb31a8b9b5fc882c20c28992ecdc501d4a11a8088023664ef2d590385e7ba3a8f756b92b74c607b0148e7e6710c213a14659ce8f33e10b261ee4031993582d
-  data.tar.gz: ad174799dd193021f845e971e08c19cc8c31bb915ee603659c33299c4a5e21d9bdf2e7687dfb1da75e0e573442fdc116b343d8caa7e54550ae62fbeea1ed6165
+  metadata.gz: 51ba70e0a9b9c73170080a0e428edf178aa98aceb409e8d4b69ea16eb36796467852c07ba38c103cbac8f7e0861119d40d1e6272d5d002ac472ec2b92801a5b5
+  data.tar.gz: 8e02dc629e83151c4a1b744ed3dcd9262e57d1c6dad012bfa1f42410636f9f467a189aa3579abad419e443c943c39930729305311456b06c4fc0a562ef49827c

data/CONTRIBUTING.md

@@ -206,17 +206,15 @@ end
 #### gentest options
 You can get more information about `gentest` here.
 
-The default method name is `test_foo` and the class name is `FooTest`. The file name will be `[Lowercase letters with "Test" removed from the class name]_test.rb`.
-```shell
-# run without any options(test method name will be `test_foo`, class name will be `FooTest`, file name will be `foo_test.rb`)
-$ bin/gentest target.rb
-# specify the class name(test method name will be `test_foo`, class name will be `StepTest`, file name will be `step_test.rb`)
-$ bin/gentest target.rb -c StepTest
-# specify the method name(test method name will be `test_step`, class name will be `FooTest`, file name will be `foo_test.rb`)
-$ bin/gentest target.rb -m test_step
-# specify class name and method name(test method name will be `test_step`, class name will be `StepTest`, file name will be `step_test.rb`.)
-$ bin/gentest target.rb -c StepTest -m test_step
-```
+The default method name is `test_#{some integer numbers}`, the class name is `FooTest`, and the file name will be `foo_test.rb`.
+The following table shows examples of the gentest options.
+
+| Command | Description | File | Class | Method |
+| --- | --- | --- | --- | --- |
+| `$ bin/gentest target.rb` | Run without any options | `foo_test.rb` | `FooTest` | `test_#{some integer numbers}` |
+| `$ bin/gentest target.rb -c step` | Specify the class name | `step_test.rb` | `StepTest` | `test_#{some integer numbers}` |
+| `$ bin/gentest target.rb -m test_step` | Specify the method name | `foo_test.rb` | `FooTest` | `test_step` |
+| `$ bin/gentest target.rb -c step -m test_step` | Specify the class name and the method name | `step_test.rb` | `StepTest` | `test_step` |
 
 ## To Update README
 

data/README.md

@@ -11,7 +11,9 @@ New debug.rb has several advantages:
 * [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))
+  * Integration with rich debugger frontend
+    * VSCode/DAP ([VSCode rdbg Ruby Debugger - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg))
+    * Chrome DevTools
 * Extensible: application can introduce debugging support with several ways:
   * By `rdbg` command
   * By loading libraries with `-r` command line option
@@ -336,6 +338,97 @@ By default, UNIX domain socket is used for the debugging port. To use TCP/IP, yo
 $ RUBY_DEBUG_PORT=12345 ruby target.rb
 ```
 
+### Integration with external debugger frontend
+
+You can attach with external debugger frontend with VSCode and Chrome.
+
+```
+$ rdbg --open=[frontend] target.rb
+```
+
+will open a debug port and `[frontned]` can attache to the port.
+
+Also `open` command allows opening the debug port.
+
+#### VSCode integration
+
+If you don't run a debuggee Ruby process on VSCode, you can attach with VSCode later with the following steps.
+
+`rdbg --open=vscode` opens the debug port and tries to invoke the VSCode (`code` command).
+
+```
+$ rdbg --open=vscode target.rb
+DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-27706)
+DEBUGGER: wait for debugger connection...
+Launching: code /tmp/ruby-debug-vscode-20211014-27706-gd7e85/ /tmp/ruby-debug-vscode-20211014-27706-gd7e85/README.rb
+DEBUGGER: Connected.
+```
+
+And it tries to invoke the new VSCode window and VSCode starts attaching to the debuggee Ruby program automatically.
+
+You can also use `open vscode` command in REPL.
+
+```
+$ rdbg target.rb
+[1, 8] in target.rb
+     1|
+=>   2| p a = 1
+     3| p b = 2
+     4| p c = 3
+     5| p d = 4
+     6| p e = 5
+     7|
+     8| __END__
+=>#0    <main> at target.rb:2
+(rdbg) open vscode    # command
+DEBUGGER: wait for debugger connection...
+DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-28337)
+Launching: code /tmp/ruby-debug-vscode-20211014-28337-kg9dm/ /tmp/ruby-debug-vscode-20211014-28337-kg9dm/README.rb
+DEBUGGER: Connected.
+```
+
+If the machine which runs the Ruby process doesn't have a `code` command, the following message will be shown:
+
+```
+(rdbg) open vscode
+DEBUGGER: wait for debugger connection...
+DEBUGGER: Debugger can attach via UNIX domain socket (/tmp/ruby-debug-sock-1000/ruby-debug-ko1-455)
+Launching: code /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
+DEBUGGER: Can not invoke the command.
+Use the command-line on your terminal (with modification if you need).
+
+  code /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
+
+If your application is running on a SSH remote host, please try:
+
+  code --remote ssh-remote+[SSH hostname] /tmp/ruby-debug-vscode-20211014-455-gtjpwi/ /tmp/ruby-debug-vscode-20211014-455-gtjpwi/README.rb
+
+```
+
+and try to use proposed commands.
+
+Note that you can attach with `rdbg --attach` and continue REPL debugging.
+
+#### Chrome DevTool integration
+
+With `rdbg --open=chrome` command will shows the following message.
+
+```
+$ rdbg target.rb --open=chrome
+DEBUGGER: Debugger can attach via TCP/IP (127.0.0.1:43633)
+DEBUGGER: With Chrome browser, type the following URL in the address-bar:
+
+   devtools://devtools/bundled/inspector.html?ws=127.0.0.1:43633
+
+DEBUGGER: wait for debugger connection...
+```
+
+Type `devtools://devtools/bundled/inspector.html?ws=127.0.0.1:43633` in the address-bar on Chrome browser, and you can continue the debugging with chrome browser.
+
+Also `open chrome` command works like `open vscode`.
+
+For more information about how to use Chrome debugging, you might want to read [here](https://developer.chrome.com/docs/devtools/)
+
 ## Configuration
 
 You can configure the debugger's behavior with debug commands and environment variables.
@@ -367,7 +460,7 @@ config set no_color true
   * `RUBY_DEBUG_SKIP_NOSRC` (`skip_nosrc`): Skip on no source code lines (default: false)
   * `RUBY_DEBUG_KEEP_ALLOC_SITE` (`keep_alloc_site`): Keep allocation site and p, pp shows it (default: false)
   * `RUBY_DEBUG_POSTMORTEM` (`postmortem`): Enable postmortem debug (default: false)
-  * `RUBY_DEBUG_PARENT_ON_FORK` (`parent_on_fork`): Keep debugging parent process on fork (default: false)
+  * `RUBY_DEBUG_FORK_MODE` (`fork_mode`): Control which process activates a debugger after fork (both/parent/child) (default: both)
   * `RUBY_DEBUG_SIGDUMP_SIG` (`sigdump_sig`): Sigdump signal (default: disabled)
 
 * BOOT
@@ -376,6 +469,8 @@ config set no_color true
   * `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_FILE` (`history_file`): history file (default: ~/.rdbg_history)
+  * `RUBY_DEBUG_SAVE_HISTORY` (`save_history`): maximum save history lines (default: 10,000)
 
 * REMOTE
   * `RUBY_DEBUG_PORT` (`port`): TCP/IP remote debugging: port
@@ -383,6 +478,10 @@ config set no_color true
   * `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
+  * `RUBY_DEBUG_OPEN_FRONTEND` (`open_frontend`): frontend used by open command (vscode, chrome, default: rdbg).
+
+* OBSOLETE
+  * `RUBY_DEBUG_PARENT_ON_FORK` (`parent_on_fork`): Keep debugging parent process on fork (default: false)
 
 ### Initial scripts
 
@@ -596,6 +695,15 @@ The `<...>` notation means the argument.
   * Set <name> to default.
 * `source <file>`
   * Evaluate lines in `<file>` as debug commands.
+* `open`
+  * open debuggee port on UNIX domain socket and wait for attaching.
+  * Note that `open` command is EXPERIMENTAL.
+* `open [<host>:]<port>`
+  * open debuggee port on TCP/IP with given `[<host>:]<port>` and wait for attaching.
+* `open vscode`
+  * open debuggee port for VSCode and launch VSCode if available.
+* `open chrome`
+  * open debuggee port for Chrome and wait for attaching.
 
 ### Help
 
@@ -698,9 +806,10 @@ Debug console mode:
                                      The first argument should be a command name in $PATH.
                                      Example: 'rdbg -c bundle exec rake test'
 
-    -O, --open                       Start remote debugging with opening the network port.
-                                     If TCP/IP options are not given,
-                                     a UNIX domain socket will be used.
+    -O, --open=[FRONTEND]            Start remote debugging with opening the network port.
+                                     If TCP/IP options are not given, a UNIX domain socket will be used.
+                                     If FRONTEND is given, prepare for the FRONTEND.
+                                     Now rdbg, vscode and chrome is supported.
         --sock-path=SOCK_PATH        UNIX Domain socket path
         --port=PORT                  Listening TCP/IP port
         --host=HOST                  Listening TCP/IP host
@@ -716,6 +825,7 @@ Debug console mode:
   '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.
+  'rdbg target.rb -O chrome --port 1234'  starts and accepts connecting from Chrome Devtools with localhost:1234.
 
 Attach mode:
     -A, --attach                     Attach to debuggee process.
@@ -750,3 +860,4 @@ Please also check the [contributing guideline](/CONTRIBUTING.md).
 # Acknowledgement
 
 * Some tests are based on [deivid-rodriguez/byebug: Debugging in Ruby 2](https://github.com/deivid-rodriguez/byebug)
+* Several codes in `server_cdp.rb` are based on [geoffreylitt/ladybug: Visual Debugger](https://github.com/geoffreylitt/ladybug)

data/ext/debug/debug.c

@@ -2,7 +2,7 @@
 #include "ruby/ruby.h"
 #include "ruby/debug.h"
 #include "ruby/encoding.h"
-
+#include "debug_version.h"
 //
 static VALUE rb_mDebugger;
 
@@ -64,7 +64,7 @@ di_body(const rb_debug_inspector_t *dc, void *ptr)
 
         if (!NIL_P(iseq)) {
             VALUE path = iseq_realpath(iseq);
-            if (!NIL_P(path) && str_start_with(path, skip_path_prefix)) continue;
+            if (!NIL_P(path) && !NIL_P(skip_path_prefix) && str_start_with(path, skip_path_prefix)) continue;
         }
 
         loc = RARRAY_AREF(locs, i);
@@ -130,5 +130,6 @@ Init_debug(void)
     rb_define_singleton_method(rb_mDebugger, "capture_frames", capture_frames, 1);
     rb_define_singleton_method(rb_mDebugger, "frame_depth", frame_depth, 0);
     rb_define_singleton_method(rb_mDebugger, "create_method_added_tracker", create_method_added_tracker, 0);
+    rb_define_const(rb_mDebugger, "SO_VERSION", rb_str_new2(RUBY_DEBUG_VERSION));
     Init_iseq_collector();
 }

data/ext/debug/extconf.rb

@@ -1,2 +1,4 @@
 require 'mkmf'
+require_relative '../../lib/debug/version'
+File.write("debug_version.h", "#define RUBY_DEBUG_VERSION \"#{DEBUGGER__::VERSION}\"\n")
 create_makefile 'debug/debug'

data/lib/debug/client.rb

@@ -21,6 +21,18 @@ module DEBUGGER__
         when 'list-socks'
           cleanup_unix_domain_sockets
           puts list_connections
+        when 'init'
+          if ARGV.shift == '-'
+            puts <<~EOS
+            export RUBYOPT="-r #{__dir__}/prelude $(RUBYOPT)"
+            EOS
+          else
+            puts <<~EOS
+            # add the following lines in your .bash_profile
+
+            eval "$(rdbg init -)"
+            EOS
+          end
         else
           raise "Unknown utility: #{name}"
         end
@@ -31,6 +43,7 @@ module DEBUGGER__
           if /(\d+)$/ =~ file
             begin
               Process.kill(0, $1.to_i)
+            rescue Errno::EPERM
             rescue Errno::ESRCH
               File.unlink(file)
             end
@@ -44,17 +57,15 @@ module DEBUGGER__
     end
 
     def initialize argv
+      @multi_process = false
+      @pid = nil
       @console = Console.new
 
       case argv.size
       when 0
         connect_unix
       when 1
-        case arg = argv.shift
-        when /-h/, /--help/
-          help
-          exit
-        when /\A\d+\z/
+        if /\A\d+\z/ =~ (arg = argv.shift.strip)
           connect_tcp nil, arg.to_i
         else
           connect_unix arg
@@ -67,13 +78,20 @@ module DEBUGGER__
 
       @width = IO.console_size[1]
       @width = 80 if @width == 0
-      @width_changed = false
 
       send "version: #{VERSION} width: #{@width} cookie: #{CONFIG[:cookie]}"
     end
 
+    def deactivate
+      @console.deactivate if @console
+    end
+
     def readline
-      @console.readline "(rdbg:remote) "
+      if @multi_process
+        @console.readline "(rdbg:remote\##{@pid}) "
+      else
+        @console.readline "(rdbg:remote) "
+      end
     end
 
     def connect_unix name = nil
@@ -118,15 +136,19 @@ module DEBUGGER__
       }
       trap(:SIGWINCH){
         @width = IO.console_size[1]
-        @width_changed = true
       }
 
       while line = @s.gets
         p recv: line if $VERBOSE
         case line
+
         when /^out (.*)/
           puts "#{$1}"
-        when /^input/
+
+        when /^input (.+)/
+          pid = $1
+          @multi_process = true if @pid && @pid != pid
+          @pid = pid
           prev_trap = trap(:SIGINT, 'DEFAULT')
 
           begin
@@ -138,18 +160,16 @@ module DEBUGGER__
           end
 
           line = (line || 'quit').strip
+          send "command #{pid} #{@width} #{line}"
 
-          if @width_changed
-            @width_changed = false
-            send "width #{@width}"
-          end
+        when /^ask (\d+) (.*)/
+          pid = $1
+          print $2
+          send "answer #{pid} #{gets || ''}"
 
-          send "command #{line}"
-        when /^ask (.*)/
-          print $1
-          send "answer #{gets || ''}"
         when /^quit/
           raise 'quit'
+
         else
           puts "(unknown) #{line.inspect}"
         end
@@ -157,6 +177,8 @@ module DEBUGGER__
     rescue
       STDERR.puts "disconnected (#{$!})"
       exit
+    ensure
+      deactivate
     end
   end
 end

data/lib/debug/config.rb

@@ -24,7 +24,7 @@ module DEBUGGER__
     skip_nosrc:     ['RUBY_DEBUG_SKIP_NOSRC',     "CONTROL: Skip on no source code lines (default: false)",              :bool],
     keep_alloc_site:['RUBY_DEBUG_KEEP_ALLOC_SITE',"CONTROL: Keep allocation site and p, pp shows it (default: false)",   :bool],
     postmortem:     ['RUBY_DEBUG_POSTMORTEM',     "CONTROL: Enable postmortem debug (default: false)",                   :bool],
-    parent_on_fork: ['RUBY_DEBUG_PARENT_ON_FORK', "CONTROL: Keep debugging parent process on fork (default: false)",     :bool],
+    fork_mode:      ['RUBY_DEBUG_FORK_MODE',      "CONTROL: Control which process activates a debugger after fork (both/parent/child) (default: both)", :forkmode],
     sigdump_sig:    ['RUBY_DEBUG_SIGDUMP_SIG',    "CONTROL: Sigdump signal (default: disabled)"],
 
     # boot setting
@@ -33,13 +33,19 @@ module DEBUGGER__
     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_file:   ['RUBY_DEBUG_HISTORY_FILE',"BOOT: history file (default: ~/.rdbg_history)"],
+    save_history:   ['RUBY_DEBUG_SAVE_HISTORY',"BOOT: maximum save history lines (default: 10,000)"],
 
     # remote setting
-    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"],
+    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"],
+    open_frontend:  ['RUBY_DEBUG_OPEN_FRONTEND',"REMOTE: frontend used by open command (vscode, chrome, default: rdbg)."],
+
+    # obsolete
+    parent_on_fork: ['RUBY_DEBUG_PARENT_ON_FORK', "OBSOLETE: Keep debugging parent process on fork (default: false)",     :bool],
   }.freeze
 
   CONFIG_MAP = CONFIG_SET.map{|k, (ev, desc)| [k, ev]}.to_h.freeze
@@ -57,6 +63,10 @@ module DEBUGGER__
       update self.class.parse_argv(argv)
     end
 
+    def inspect
+      config.inspect
+    end
+
     def [](key)
       config[key]
     end
@@ -79,7 +89,7 @@ module DEBUGGER__
     end
 
     def append_config key, val
-      conf = self.config.dup
+      conf = config.dup
 
       if CONFIG_SET[key]
         if CONFIG_SET[key][2] == :path
@@ -187,6 +197,13 @@ module DEBUGGER__
         else
           raise "Unknown loglevel: #{valstr}"
         end
+      when :forkmode
+        case sym = valstr.to_sym
+        when :parent, :child, :both, nil
+          sym
+        else
+          raise "unknown fork mode: #{sym}"
+        end
       when :path # array of String
         valstr.split(/:/).map{|e|
           if /\A\/(.+)\/\z/ =~ e
@@ -255,10 +272,12 @@ module DEBUGGER__
 
         o.separator ''
 
-        o.on('-O', '--open', 'Start remote debugging with opening the network port.',
-                             'If TCP/IP options are not given,',
-                             'a UNIX domain socket will be used.') do
+        o.on('-O', '--open=[FRONTEND]', 'Start remote debugging with opening the network port.',
+                                        'If TCP/IP options are not given, a UNIX domain socket will be used.',
+                                        'If FRONTEND is given, prepare for the FRONTEND.',
+                                        'Now rdbg, vscode and chrome is supported.') do |f|
           config[:remote] = true
+          config[:open_frontend] = f.downcase if f
         end
         o.on('--sock-path=SOCK_PATH', 'UNIX Domain socket path') do |path|
           config[:sock_path] = path
@@ -286,6 +305,7 @@ module DEBUGGER__
         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."
+        o.separator "  '#{rdbg} target.rb -O chrome --port 1234'  starts and accepts connecting from Chrome Devtools with localhost:1234."
 
         o.separator ''
         o.separator 'Attach mode:'
@@ -351,38 +371,54 @@ module DEBUGGER__
 
   ## Unix domain socket configuration
 
-  def self.unix_domain_socket_dir
+  def self.check_dir_authority path
+    fs = File.stat(path)
+
+    unless (dir_uid = fs.uid) == (uid = Process.uid)
+      raise "#{path} uid is #{dir_uid}, but Process.uid is #{uid}"
+    end
+    unless (dir_mode = fs.mode) == 040700 # 4: dir, 7:rwx
+      raise "#{path}'s mode is #{dir_mode.to_s(8)} (should be 040700)"
+    end
+
+    path
+  end
+
+  def self.unix_domain_socket_tmpdir
     require 'tmpdir'
 
-    case
-    when path = CONFIG[:sock_dir]
-    when path = ENV['XDG_RUNTIME_DIR']
-    when tmpdir = Dir.tmpdir
+    if tmpdir = Dir.tmpdir
       path = File.join(tmpdir, "ruby-debug-sock-#{Process.uid}")
 
-      if File.exist?(path)
-        fs = File.stat(path)
-        unless (dir_uid = fs.uid) == (uid = Process.uid)
-          raise "#{path} uid is #{dir_uid}, but Process.uid is #{uid}"
-        end
-        unless (dir_mode = fs.mode) == 040700 # 4: dir, 7:rwx
-          raise "#{path}'s mode is #{dir_mode.to_s(8)} (should be 040700)"
-        end
-      else
+      unless File.exist?(path)
         d = Dir.mktmpdir
         File.rename(d, path)
       end
-    when home = ENV['HOME']
+
+      check_dir_authority(path)
+    end
+  end
+
+  def self.unix_domain_socket_homedir
+    if home = ENV['HOME']
       path = File.join(home, '.ruby-debug-sock')
 
-      case
-      when !File.exist?(path)
+      unless File.exist?(path)
         Dir.mkdir(path, 0700)
-      when !File.directory?(path)
-        raise "#{path} is not a directory."
       end
+
+      check_dir_authority(path)
+    end
+  end
+
+  def self.unix_domain_socket_dir
+    case
+    when path = CONFIG[:sock_dir]
+    when path = ENV['XDG_RUNTIME_DIR']
+    when path = unix_domain_socket_tmpdir
+    when path = unix_domain_socket_homedir
     else
-      raise 'specify RUBY_DEBUG_SOCK_DIR environment variable for UNIX domain socket directory.'
+      raise 'specify RUBY_DEBUG_SOCK_DIR environment variable.'
     end
 
     path