debug 0.2.0 → 1.0.0.alpha0

data/lib/debug/bp.vim

@@ -0,0 +1,68 @@
+let g:rdb_bps = {}
+
+function SET_BP()
+  let signed = sign_getplaced(bufname(), {'lnum': line('.')})
+  if empty(signed[0]['signs'])
+    call sign_place(0, '', 'signBP', bufname(), {'lnum': line('.')})
+  else
+    "echo signed[0]['signs']
+    call sign_unplace('', {'buffer': bufname(), 'id': signed[0]['signs'][0]['id']})
+  endif
+endfunction
+
+function UPDATE_BPS()
+  let signs = sign_getplaced(bufname())
+  let key = expand('%:p')
+
+  if empty(signs[0]['signs'])
+    let removed = remove(g:rdb_bps, key)
+  else
+    let g:rdb_bps[key] = signs[0]['signs']
+  endif
+endfunction
+
+function APPLY_BPS()
+  let key = expand('%:p')
+  if has_key(g:rdb_bps, key)
+    for b in g:rdb_bps[key]
+      call sign_place(0, '', 'signBP', bufname(), {'lnum': b['lnum']})
+    endfor
+  endif
+endfunction
+
+function WRITE_BPS()
+  call writefile([json_encode(g:rdb_bps)], '.rdb_breakpoints.json')
+endfunction
+
+" load
+try
+  let json = readfile('.rdb_breakpoints.json')
+  let g:rdb_bps = json_decode(json[0])
+  " {"/full/path/to/file1": [{"lnum": 10}, ...], ...}
+catch /Can't open/
+  let g:rdb_bps = {}
+catch /Invalid arguments for function json_decode/
+  let g:rdb_bps = {}
+endtry
+
+sign define signBP text=BR
+
+call APPLY_BPS()
+
+autocmd BufReadPost * call APPLY_BPS()
+autocmd BufUnload   * call UPDATE_BPS()
+autocmd VimLeave    * call WRITE_BPS()
+
+function! s:ruby_bp_settings() abort
+  echomsg "Type <Space> to toggle break points and <q> to quit"
+
+  if &readonly
+    nnoremap <silent> <buffer> <Space> :call SET_BP()<CR>
+    nnoremap <silent> <buffer> q :<C-u>quit<CR>
+  endif
+endfunction
+
+" autocmd FileType ruby call s:ruby_bp_settings()
+autocmd BufEnter *.rb call s:ruby_bp_settings()
+
+call s:ruby_bp_settings()

data/lib/debug/breakpoint.rb

@@ -0,0 +1,97 @@
+module DEBUGGER__
+  class LineBreakpoint
+    attr_reader :path, :line, :key
+
+    def initialize type, iseq, line, cond = nil, oneshot: false
+      @iseq = iseq
+      @path = iseq.path
+      @line = line
+      @type = type
+      @cond = cond
+      @oneshot = oneshot
+      @key = [@path, @line].freeze
+      setup
+      enable
+    end
+
+    def safe_eval b, expr
+      b.eval(expr)
+    rescue Exception => e
+      puts "[EVAL ERROR]"
+      puts "  expr: #{expr}"
+      puts "  err: #{e} (#{e.class})"
+      nil
+    end
+
+    def setup
+      if !@cond
+        @tp = TracePoint.new(@type) do |tp|
+          tp.disable if @oneshot
+          ThreadClient.current.on_breakpoint tp
+        end
+      else
+        @tp = TracePoint.new(@type) do |tp|
+          next unless safe_eval tp.binding, @cond
+          tp.disable if @oneshot
+          ThreadClient.current.on_breakpoint tp
+        end
+      end
+    end
+
+    def enable
+      if @type == :line
+        @tp.enable(target: @iseq, target_line: @line)
+      else
+        @tp.enable(target: @iseq)
+      end
+    rescue ArgumentError
+      puts @iseq.disasm # for debug
+      raise
+    end
+
+    def disable
+      @tp.disable
+    end
+
+    def to_s
+      "line bp #{@iseq.absolute_path}:#{@line} (#{@type})" +
+        if @cond
+          "if #{@cond}"
+        else
+          ""
+        end
+    end
+
+    def inspect
+      "<#{self.class.name} #{self.to_s}>"
+    end
+  end
+
+  class CatchBreakpoint
+    attr_reader :key
+
+    def initialize pat
+      @pat = pat
+      @tp = TracePoint.new(:raise){|tp|
+        exc = tp.raised_exception
+        exc.class.ancestors.each{|cls|
+          if pat === cls.name
+            puts "catch #{exc.class.inspect} by #{@pat.inspect}"
+            ThreadClient.current.on_suspend :catch
+          end
+        }
+      }
+      @tp.enable
+
+      @key = pat.freeze
+    end
+
+    def disable
+      @tp.disable
+    end
+
+    def to_s
+      "catch bp #{@pat.inspect}"
+    end
+  end
+end

data/lib/debug/client.rb

@@ -0,0 +1,135 @@
+require 'socket'
+require_relative 'config'
+
+module DEBUGGER__
+  class Client
+    begin
+      require 'readline'
+      def readline
+        Readline.readline("\n(rdb) ", true)
+      end
+    rescue LoadError
+      def readline
+        print "\n(rdb) "
+        gets
+      end
+    end
+
+    def help
+      puts "-run -e attach       # connect via UNIX Domain socket"
+      puts "-run -e attach name  # connect via UNIX Domain socket with specified name"
+      puts "-run -e attach port_num  # connect via TCP/IP socket with specified port"
+      puts "-run -e attach host port_num"
+      puts "               # connect via TCP/IP socket with specified host and port"
+    end
+
+    def initialize argv
+      case argv.size
+      when 0
+        connect_unix
+      when 1
+        case arg = argv.shift
+        when /-h/, /--help/
+          help
+          exit
+        when /\A\d+\z/
+          connect_tcp nil, arg.to_i
+        else
+          connect_unix arg
+        end
+      when 2
+        connect_tcp argv[0], argv[1]
+      else
+        help
+        exit!
+      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
+      end
+    end
+
+    def connect_unix name = nil
+      if name
+        if File.exist? name
+          @s = Socket.unix(name)
+        else
+          @s = Socket.unix(File.join(DEBUGGER__.unix_domain_socket_basedir, name))
+        end
+      else
+        cleanup_unix_domain_sockets
+        files = Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*')
+        case files.size
+        when 0
+          $stderr.puts "There is no debug sessions."
+          exit
+        when 1
+          @s = Socket.unix(files.first)
+        else
+          $stderr.puts "Please select a debug session:"
+          files.each{|f|
+            $stderr.puts "  #{File.basename(f)}"
+          }
+          exit
+        end
+      end
+    end
+
+    def connect_tcp host, port
+      @s = Socket.tcp(host, port)
+    end
+
+    def connect
+      trap(:SIGINT){
+        @s.puts "pause"
+      }
+
+      while line = @s.gets
+        # p line: line
+        case line
+        when /^out (.*)/
+          puts "#{$1}"
+        when /^input/
+          prev_trap = trap(:SIGINT, 'DEFAULT')
+
+          begin
+            line = readline
+          rescue Interrupt
+            retry
+          ensure
+            trap(:SIGINT, prev_trap)
+          end
+
+          line = (line || 'quit').strip
+          @s.puts "command #{line}"
+        when /^ask (.*)/
+          print $1
+          @s.puts "answer #{gets || ''}"
+        when /^quit/
+          raise 'quit'
+        else
+          puts "(unknown) #{line.inspect}"
+        end
+      end
+    rescue
+      STDERR.puts "disconnected (#{$!})"
+      exit
+    end
+  end
+end
+
+def connect argv = ARGV
+  DEBUGGER__::Client.new(argv).connect
+end
+
+if __FILE__ == $0
+  connect
+end

data/lib/debug/config.rb

@@ -0,0 +1,26 @@
+module DEBUGGER__
+  def self.unix_domain_socket_basedir
+    case
+    when path = ENV['RUBY_DEBUG_SOCK_DIR']
+    when path = ENV['XDG_RUNTIME_DIR']
+    when home = ENV['HOME']
+      path = File.join(home, '.ruby-debug-sock')
+      unless File.exist?(path)
+        Dir.mkdir(path, 0700)
+      end
+    else
+      raise 'specify RUBY_DEBUG_SOCK_DIR environment variable for UNIX domain socket directory.'
+    end
+
+    path
+  end
+
+  def self.create_unix_domain_socket_name_prefix
+    user = ENV['USER'] || 'ruby-debug'
+    File.join(unix_domain_socket_basedir, "ruby-debug-#{user}")
+  end
+
+  def self.create_unix_domain_socket_name
+    create_unix_domain_socket_name_prefix + "-#{Process.pid}"
+  end
+end

data/lib/debug/repl.rb

@@ -0,0 +1,67 @@
+require_relative 'session'
+
+module DEBUGGER__
+  class UI_Repl
+    def initialize
+    end
+
+    def quit n
+      exit n
+    end
+
+    def ask prompt
+      print prompt
+      (gets || '').strip
+    end
+
+    def puts str
+      case str
+      when Array
+        str.each{|line|
+          $stdout.puts line.chomp
+        }
+      when String
+        str.each_line{|line|
+          $stdout.puts line.chomp
+        }
+      when nil
+        $stdout.puts
+      end
+    end
+
+    begin
+      require 'readline'
+      def readline
+        setup_interrupt do
+          str = Readline.readline("\n(rdb) ", true)
+          (str || 'quit').strip
+        end
+      end
+    rescue LoadError
+      def readline
+        setup_interrupt do
+          print "\n(rdb) "
+          (gets || 'quit').strip
+        end
+      end
+    end
+
+    def setup_interrupt
+      current_thread = Thread.current # should be session_server thread
+
+      prev_handler = trap(:INT){
+        current_thread.raise Interrupt
+      }
+
+      yield
+    ensure
+      trap(:INT, prev_handler)
+    end
+  end
+
+  SESSION = Session.new(UI_Repl.new)
+
+  PREV_HANDLER = trap(:SIGINT){
+    ThreadClient.current.on_trap
+  }
+end

data/lib/debug/server.rb

@@ -0,0 +1,119 @@
+require 'socket'
+require_relative 'session'
+
+module DEBUGGER__
+  class UI_Server
+    def initialize
+      @sock = nil
+      @client_addr = nil
+      @q_msg = Queue.new
+      @q_ans = Queue.new
+
+      @reader_thread = Thread.new do
+        accept do |server|
+          @sock = server
+          @q_msg = Queue.new
+          @q_ans = Queue.new
+
+          setup_interrupt do
+            pause
+
+            begin
+              while line = @sock.gets
+                case line
+                when /\Apause/
+                  pause
+                when /\Acommand ?(.+)/
+                  @q_msg << $1
+                when /\Aanswer (.*)/
+                  @q_ans << $1
+                else
+                  STDERR.puts "unsupported: #{line}"
+                  exit!
+                end
+              end
+            end
+          end
+        ensure
+          @sock = nil
+          @q_msg.close
+          @q_ans.close
+        end
+      end
+    end
+
+
+    def setup_interrupt
+      prev_handler = trap(:SIGINT) do
+        # $stderr.puts "trapped SIGINT"
+        ThreadClient.current.on_trap
+
+        case prev_handler
+        when Proc
+          prev_handler.call
+        else
+          # ignore
+        end
+      end
+
+      yield
+    ensure
+      trap(:SIGINT, prev_handler)
+    end
+
+    def accept
+      raise "NOT IMPLEMENTED ERROR"
+    end
+
+    attr_reader :reader_thread
+
+    class NoRemoteError < Exception; end
+
+    def sock
+      yield @sock if @sock
+    rescue Errno::EPIPE
+      # ignore
+    end
+
+    def ask prompt
+      sock do |s|
+        s.puts "ask #{prompt}"
+        @q_ans.pop
+      end
+    end
+
+    def puts str
+      case str
+      when Array
+        enum = str.each
+      when String
+        enum = str.each_line
+      end
+
+      sock do |s|
+        enum.each do |line|
+          s.puts "out #{line.chomp}"
+        end
+      end
+    end
+
+    def readline
+      (sock do |s|
+        s.puts "input"
+        @q_msg.pop
+      end || 'continue').strip
+    end
+
+    def pause
+      $stderr.puts "DEBUG: pause request"
+      Process.kill(:SIGINT, Process.pid)
+    end
+
+    def quit n
+      # ignore n
+      sock do |s|
+        s.puts "quit"
+      end
+    end
+  end
+end