debug 1.2.2 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7831c2e401b4bf33ecd14f5cef5eeb1c1a0feb57037a162c00f6cc780975b4c6
-  data.tar.gz: 182d55e56b662858b04e03336dd8bb4d0e15da8418b3aea137d05dcd02aa4ac0
+  metadata.gz: 948301b2d85d9acb8758ae20e63a60d0253dc1d1e1bf5c2ddc276abb39d12993
+  data.tar.gz: 2e6b7c89ee568710d52d3fcaff1ff5eb44db71c4e296e039a6f21f4e5de9b9ee
 SHA512:
-  metadata.gz: dcf9f62fc4cf7f782238cd7b61137bde035047f6226eeac6cae639b28ada181862ee82ce146a1e33c6c08d80a8fc35ffe4a2cf24eda576e4792babbf8436ca88
-  data.tar.gz: 1f66b3c18a14f1f337d010a8e9d29d6a0e0b1c4c92c976a87e0c2db265ff6a1259d31918e4c10525d16154f6a8f9fa694bcdbebbb081278b6ee488ae122f8713
+  metadata.gz: dd5237c7fc194760f33cdd97c007fe1c879ed4140342821972d2385a612bd5fd4c8faffd2a3763adea1378931be13e65d46e2a23f5997412ac96c6e7c802e0d2
+  data.tar.gz: 396eab432e765065288f49cda52ce8a4449ee6c97465bde2ef70ec8ca39678b80831748b551d6aa6e4417c1c6512b8b0f8caf4371516a9178181582b9bf9542c

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))
+  * Integeration 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 debuger 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 fowllowing 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 tris 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;
 
@@ -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/breakpoint.rb

@@ -437,7 +437,7 @@ module DEBUGGER__
           end
         end
 
-      rescue ArgumentError => e
+      rescue ArgumentError
         raise if retried
         retried = true
 
@@ -458,7 +458,7 @@ module DEBUGGER__
         @override_method = true if @method
         retry
       end
-    rescue Exception => e
+    rescue Exception
       raise unless added
     end
 

data/lib/debug/client.rb

@@ -13,20 +13,59 @@ module DEBUGGER__
   class CommandLineOptionError < Exception; end
 
   class Client
-    def initialize argv
-      return util(argv) if String === argv
+    class << self
+      def util name
+        case name
+        when 'gen-sockpath'
+          puts DEBUGGER__.create_unix_domain_socket_name
+        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
+      end
 
+      def cleanup_unix_domain_sockets
+        Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*') do |file|
+          if /(\d+)$/ =~ file
+            begin
+              Process.kill(0, $1.to_i)
+            rescue Errno::EPERM
+            rescue Errno::ESRCH
+              File.unlink(file)
+            end
+          end
+        end
+      end
+
+      def list_connections
+        Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*')
+      end
+    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
@@ -39,43 +78,22 @@ 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 readline
-      @console.readline "(rdbg:remote) "
+    def deactivate
+      @console.deactivate if @console
     end
 
-    def util name
-      case name
-      when 'gen-sockpath'
-        puts DEBUGGER__.create_unix_domain_socket_name
-      when 'list-socks'
-        cleanup_unix_domain_sockets
-        puts list_connections
+    def readline
+      if @multi_process
+        @console.readline "(rdbg:remote\##{@pid}) "
       else
-        raise "Unknown utility: #{name}"
-      end
-    end
-
-    def cleanup_unix_domain_sockets
-      Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*') do |file|
-        if /(\d+)$/ =~ file
-          begin
-            Process.kill(0, $1.to_i)
-          rescue Errno::ESRCH
-            File.unlink(file)
-          end
-        end
+        @console.readline "(rdbg:remote) "
       end
     end
 
-    def list_connections
-      Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*')
-    end
-
     def connect_unix name = nil
       if name
         if File.exist? name
@@ -84,8 +102,9 @@ module DEBUGGER__
           @s = Socket.unix(File.join(DEBUGGER__.unix_domain_socket_dir, name))
         end
       else
-        cleanup_unix_domain_sockets
-        files = list_connections
+        Client.cleanup_unix_domain_sockets
+        files = Client.list_connections
+
         case files.size
         when 0
           $stderr.puts "No debug session is available."
@@ -117,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
@@ -137,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
@@ -156,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:'
@@ -313,7 +333,7 @@ module DEBUGGER__
 
         o.on('--util=NAME', 'Utility mode (used by tools)') do |name|
           require_relative 'client'
-          Client.new(name)
+          Client.util(name)
           exit
         end
 
@@ -351,21 +371,54 @@ module DEBUGGER__
 
   ## Unix domain socket configuration
 
-  def self.unix_domain_socket_dir
-    case
-    when path = CONFIG[:sock_dir]
-    when path = ENV['XDG_RUNTIME_DIR']
-    when home = ENV['HOME']
+  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'
+
+    if tmpdir = Dir.tmpdir
+      path = File.join(tmpdir, "ruby-debug-sock-#{Process.uid}")
+
+      unless File.exist?(path)
+        d = Dir.mktmpdir
+        File.rename(d, path)
+      end
+
+      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