debugger-xml 0.0.4 → 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## 0.1.0
+* Added rdebug-vim, used by vim-ruby-debugger. It is designed specifically for that vim plugin.
+  It creates new unix socket, and listen connections to it. After receiving commands/events, it
+  writes response to a file, and pokes Vim, so it can read it.
+
+## 0.0.4
+* First working version, copies ruby-debug-ide interface

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake/testtask'
 desc "Run tests."
 task :test do
   Rake::TestTask.new(:test) do |t|
-    t.test_files = FileList["test/*_test.rb"]
+    t.test_files = FileList["test/**/*_test.rb"]
     t.verbose = true
   end
 end

data/bin/rdebug-vim

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'optparse'
+require 'ostruct'
+require 'debugger'
+require 'debugger/xml'
+
+$stdout.sync = true
+
+class RdebugVim
+
+  def initialize
+    check_argv!
+    Debugger.const_set("RDEBUG_SCRIPT", File.expand_path($0))
+    install_interruption_hander
+    Debugger.tracing = false
+    Debugger.wait_for_start = true
+    Debugger.printer = Printers::Xml.new
+    Debugger.const_set("PROG_SCRIPT", ARGV.shift)
+  end
+
+  def run
+    Debugger.start_for_vim(options)
+    bt = Debugger.debug_load(Debugger::PROG_SCRIPT, false, false)
+    if bt
+      print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+      print "Uncaught exception: #{bt}\n"
+    end
+  end
+
+  private
+
+    def check_argv!
+      if ARGV.empty?
+        puts opts
+        puts
+        puts "Must specify a script to run"
+        exit(1)
+      end
+    end
+
+    def install_interruption_hander
+      trap('INT') { Debugger.interrupt_last }
+    end
+
+    def options
+      opts
+      @options
+    end
+
+    def opts
+      @opts ||= begin
+        @options = OpenStruct.new
+        opts = OptionParser.new do |opts|
+          opts.banner = %{
+            Using rdebug-vim
+            Usage: rdebug-vim is supposed to be called from vim-ruby-debugger.
+            The command line interface to 'debugger' is rdebug.
+          }.gsub(/^\s*/, '')
+          opts.separator ""
+          opts.separator "Options:"
+          opts.on("-f", "--file FILE", String, "File for communication with Vim") { |file| @options.file = file }
+          opts.on("-o", "--output FILE", String, "File where standard/error output is sent to") do |file|
+            @options.output_file = file
+          end
+          opts.on("-s", "--socket FILE", String, "Socket file to communicate with debugger") do |file|
+            @options.socket = file
+          end
+          opts.on("-lf", "--logger_file FILE", String, "File for logging") { |file| @options.logger_file = file }
+          opts.on("-dm", "--debug_mode MODE", Integer, "Debug mode") { |mode| @options.debug_mode = mode == 1 }
+          opts.on("-ve", "--vim_executable FILE", String, "Vim executable file (e.g., 'mvim')") do |file|
+            @options.vim_executable = file
+          end
+          opts.on("-vs", "--vim_servername NAME", String, "Vim servername (e.g., 'VIM')") do |name|
+            @options.vim_servername = name
+          end
+          opts.on("-spr", "--separator NAME", String, "Output results separator") do |name|
+            @options.separator = name
+          end
+          opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") { |path| $LOAD_PATH.unshift(path) }
+        end
+        opts.parse!
+        opts
+      end
+    end
+
+end
+
+RdebugVim.new.run

data/lib/debugger/xml/extensions/vim_server.rb

@@ -0,0 +1,47 @@
+require_relative 'ide_server'
+
+module Debugger
+  class << self
+
+    def start_for_vim(options)
+      return if @control_thread
+      daemonize!
+      $stdout.reopen(options.output_file, 'w')
+      $stderr.reopen(options.output_file, 'w')
+      @mutex = Mutex.new
+      @proceed = ConditionVariable.new
+      start
+      File.unlink(options.socket) if File.exist?(options.socket)
+      server = UNIXServer.new(options.socket)
+      Xml::Vim::Notification.new("establish_connection", options).send
+      @control_thread = DebugThread.new do
+        begin
+          while (session = server.accept)
+            interface = Xml::Vim::Interface.new(session, options)
+            processor = Xml::Vim::ControlCommandProcessor.new(interface)
+            self.handler = Xml::Vim::Processor.new(interface)
+            processor.process_commands
+          end
+        rescue Exception => e
+          puts "INTERNAL ERROR!!! #{$!}" rescue nil
+          puts $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+          raise e
+        ensure
+          server.close
+        end
+      end
+      @mutex.synchronize { @proceed.wait(@mutex) } if wait_for_start
+    end
+
+    private
+
+      def daemonize!
+        pid = Process.fork
+        if pid
+          print pid
+          exit
+        end
+      end
+
+  end
+end

data/lib/debugger/xml/ide/control_command_processor.rb

@@ -0,0 +1,81 @@
+module Debugger
+  module Xml
+    module Ide
+
+      class ControlCommandProcessor < Debugger::Processor
+
+        def initialize(interface)
+          @interface = interface
+        end
+
+        def process_commands
+          while input = @interface.read_command
+            process_input(input)
+          end
+        rescue IOError, Errno::EPIPE
+        rescue Exception
+          print "INTERNAL ERROR!!! #{$!}\n" rescue nil
+          print $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+        ensure
+          @interface.close
+        end
+
+        def process_command(cmd)
+          catch(:debug_error) do
+            if matched_cmd = control_commands.find { |c| c.match(cmd) }
+              matched_cmd.execute
+            else
+              process_context_commands(cmd)
+            end
+          end
+        end
+
+        private
+
+          def control_commands
+            @control_commands = begin
+              control_command_classes = Command.commands.select(&:allow_in_control)
+              state = Debugger::ControlCommandProcessor::State.new(@interface, control_command_classes)
+              control_command_classes.map { |cmd| cmd.new(state) }
+            end
+          end
+
+          def process_input(input)
+            split_commands(input).each do |cmd|
+              process_command(cmd)
+            end
+          end
+
+          def process_context_commands(input)
+            unless Debugger.handler.at_line?
+              errmsg pr("base.errors.no_suspended_thread", input: input)
+              return
+            end
+            event_command_classes = Command.commands.select(&:event)
+            state = Debugger::CommandProcessor::State.new do |s|
+              s.context = Debugger.handler.context
+              s.file    = Debugger.handler.file
+              s.line    = Debugger.handler.line
+              s.binding = Debugger.handler.context.frame_binding(0)
+              s.interface = @interface
+              s.commands = event_command_classes
+            end
+            event_commands = event_command_classes.map { |cls| cls.new(state) }
+            catch(:debug_error) do
+              if cmd = event_commands.find { |c| c.match(input) }
+                if state.context.dead? && cmd.class.need_context
+                  print pr("base.errors.command_unavailable")
+                else
+                  cmd.execute
+                end
+              else
+                print pr("base.errors.unknown_command", input: input)
+              end
+            end
+            state.context.thread.run if state.proceed?
+          end
+      end
+
+    end
+  end
+end

data/lib/debugger/xml/ide/interface.rb

@@ -0,0 +1,67 @@
+module Debugger
+  module Xml
+    module Ide
+      class Interface < Debugger::Interface # :nodoc:
+        attr_accessor :command_queue
+        attr_accessor :histfile
+        attr_accessor :history_save
+        attr_accessor :history_length
+        attr_accessor :restart_file
+
+        def initialize(socket)
+          @command_queue = []
+          @socket = socket
+          @history_save = false
+          @history_length = 256
+          @histfile = ''
+          @restart_file = nil
+        end
+
+        def close
+          @socket.close
+        rescue Exception
+        end
+
+        def print_debug(msg)
+          STDOUT.puts(msg)
+        end
+
+        def errmsg(*args)
+          print(*args)
+        end
+
+        def confirm(prompt)
+          true
+        end
+
+        def finalize
+          close
+        end
+
+        # Workaround for JRuby issue http://jira.codehaus.org/browse/JRUBY-2063
+        def non_blocking_gets
+          loop do
+            result, _, _ = IO.select([@socket], nil, nil, 0.2)
+            next unless result
+            return result[0].gets
+          end
+        end
+
+        def read_command(*args)
+          result = non_blocking_gets
+          raise IOError unless result
+          result.chomp
+        end
+
+        def readline_support?
+          false
+        end
+
+        def print(*args)
+          @socket.printf(*escape_input(args))
+        end
+
+      end
+    end
+  end
+end

data/lib/debugger/xml/ide/processor.rb

@@ -0,0 +1,93 @@
+require 'ruby-debug/processor'
+
+module Debugger
+  module Xml
+    module Ide
+
+      class Processor < Debugger::Processor
+        attr_reader :context, :file, :line, :display
+        def initialize(interface)
+          @mutex = Mutex.new
+          @interface = interface
+          @display = []
+        end
+
+        def at_breakpoint(context, breakpoint)
+          raise "@last_breakpoint supposed to be nil. is #{@last_breakpoint}" if @last_breakpoint
+          # at_breakpoint is immediately followed by #at_line event. So postpone breakpoint printing until #at_line.
+          @last_breakpoint = breakpoint
+        end
+        protect :at_breakpoint
+
+        # TODO: Catching exceptions doesn't work so far, need to fix
+        def at_catchpoint(context, excpt)
+        end
+
+        # We don't have tracing for IDE
+        def at_tracing(*args)
+        end
+
+        def at_line(context, file, line)
+          if context.nil? || context.stop_reason == :step
+            print_file_line(context, file, line)
+          end
+          line_event(context, file, line)
+        end
+        protect :at_line
+
+        def at_return(context, file, line)
+          print_file_line(context, file, line)
+          context.stop_frame = -1
+          line_event(context, file, line)
+        end
+
+        def at_line?
+          !!@line
+        end
+
+        private
+
+          def print_file_line(context, file, line)
+            print(
+              Debugger.printer.print(
+                "stop.suspend",
+                file: CommandProcessor.canonic_file(file), line_number: line, line: Debugger.line_at(file, line),
+                thnum: context && context.thnum, frames: context && context.stack_size
+              )
+            )
+          end
+
+          def line_event(context, file, line)
+            @line = line
+            @file = file
+            @context = context
+            if @last_breakpoint
+              # followed after #at_breakpoint in the same thread. Print breakpoint
+              # now when @line, @file and @context are correctly set to prevent race
+              # condition with `control thread'.
+              n = Debugger.breakpoints.index(@last_breakpoint) + 1
+              print pr("breakpoints.stop_at_breakpoint",
+                id: n, file: @file, line: @line, thread_id: Debugger.current_context.thnum
+              )
+            end
+            if @context && @context.thread.is_a?(Debugger::DebugThread)
+              raise pr("thread.errors.debug_trace", thread: @context.thread)
+            end
+            # will be resumed by commands like `step', `next', `continue', `finish'
+            # from `control thread'
+            stop_thread
+          ensure
+            @line = nil
+            @file = nil
+            @context = nil
+            @last_breakpoint = nil
+          end
+
+          def stop_thread
+            Thread.stop
+          end
+      end
+
+    end
+  end
+end

data/lib/debugger/xml/version.rb

@@ -1,5 +1,5 @@
 module Debugger
   module Xml
-    VERSION = "0.0.4"
+    VERSION = "0.1.0"
   end
 end

data/lib/debugger/xml/vim/control_command_processor.rb

@@ -0,0 +1,17 @@
+module Debugger
+  module Xml
+    module Vim
+
+      class ControlCommandProcessor < Ide::ControlCommandProcessor
+        private
+
+          def process_input(input)
+            super(input)
+            @interface.send_response
+          end
+
+      end
+    end
+  end
+end
+

data/lib/debugger/xml/vim/interface.rb

@@ -0,0 +1,39 @@
+require 'debugger/xml/ide/interface'
+
+module Debugger
+  module Xml
+    module Vim
+      class Interface < Ide::Interface
+        def initialize(socket, options)
+          super(socket)
+          @options = options
+          @output = []
+        end
+
+        def print(*args)
+          @output << sprintf(*escape_input(args))
+        end
+
+        def send_response
+          create_directory(@options.file)
+          message = @output.join(@options.separator)
+          @output.clear
+          unless message.empty?
+            File.open(@options.file, 'w') do |f|
+              f.puts(message)
+            end
+            Notification.new("receive_command", @options).send
+          end
+        end
+
+        private
+
+          def create_directory(file)
+            dir = File.dirname(file)
+            Dir.mkdir(dir) unless File.exist?(dir) && File.directory?(dir)
+          end
+
+      end
+    end
+  end
+end

data/lib/debugger/xml/vim/notification.rb

@@ -0,0 +1,37 @@
+module Debugger
+  module Xml
+    module Vim
+      class Notification
+
+        def initialize(command, options)
+          @command = command
+          @executable = options.vim_executable
+          @servername = options.vim_servername
+          @debug_mode = options.debug_mode
+          @logger_file = options.logger_file
+        end
+
+        def send
+          command = ":call RubyDebugger.#{@command}()"
+          starter = "<C-\\\\>"
+          sys_cmd = "#{@executable} --servername #{@servername} -u NONE -U NONE " +
+            "--remote-send \"#{starter}<C-N>#{command}<CR>\""
+          log("Executing command: #{sys_cmd}")
+          system(sys_cmd);
+        end
+
+        private
+
+          def log(string)
+            if @debug_mode
+              File.open(@logger_file, 'a') do |f|
+                # match vim redir style new lines, rather than trailing
+                f << "\ndebugger-xml, #{Time.now.strftime("%H:%M:%S")} : #{string.chomp}"
+              end
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/debugger/xml/vim/processor.rb

@@ -0,0 +1,21 @@
+require 'ruby-debug/processor'
+
+module Debugger
+  module Xml
+    module Vim
+
+      class Processor < Ide::Processor
+        private
+          def stop_thread
+            processor = Vim::ControlCommandProcessor.new(@interface)
+            processor.process_command("where")
+            processor.process_command("var local")
+            @interface.send_response
+            super
+          end
+      end
+
+    end
+  end
+end
+

data/test/{ide_control_command_processor_test.rb → ide/control_command_processor_test.rb}

@@ -1,15 +1,15 @@
-require_relative 'test_helper'
-require 'debugger/xml/ide_processor'
+require_relative '../test_helper'
+require 'debugger/xml/ide/control_command_processor'
 
-describe Debugger::Xml::IdeControlCommandProcessor do
+describe Debugger::Xml::Ide::ControlCommandProcessor do
   include TestDsl
 
-  let(:klass) { Debugger::Xml::IdeControlCommandProcessor }
+  let(:klass) { Debugger::Xml::Ide::ControlCommandProcessor }
   let(:interface) { Debugger.handler.interface }
   let(:file) { fullpath('jump') }
   let(:context) { stub(frame_binding: stub, stop_reason: nil, thread: stub, thnum: 1, stack_size: 2, dead?: false) }
   subject { klass.new(interface) }
-  temporary_change_method_value(Debugger, :handler, Debugger::Xml::IdeProcessor.new(TestInterface.new))
+  temporary_change_method_value(Debugger, :handler, Debugger::Xml::Ide::Processor.new(TestInterface.new))
 
   before do
     Thread.stubs(:stop)

data/test/{ide_processor_test.rb → ide/processor_test.rb}

@@ -1,12 +1,12 @@
-require_relative 'test_helper'
-require 'debugger/xml/ide_processor'
+require_relative '../test_helper'
+require 'debugger/xml/ide/processor'
 
-describe Debugger::Xml::IdeProcessor do
+describe Debugger::Xml::Ide::Processor do
   include TestDsl
 
   before { Thread.stubs(:stop) }
 
-  let(:klass) { Debugger::Xml::IdeProcessor }
+  let(:klass) { Debugger::Xml::Ide::Processor }
   let(:interface) { TestInterface.new }
   let(:breakpoint) { stub }
   let(:context) { stub(thread: nil, stop_reason: nil, thnum: 1, stack_size: 2) }

data/test/printers/xml_test.rb

@@ -41,9 +41,16 @@ describe "Printers::Xml" do
     }
   end
 
+  def yaml_file_path(filename)
+    File.expand_path(
+      File.join("..", "..", "..", "lib", "debugger", "printers", "texts", "#{filename}.yml"),
+      __FILE__
+    )
+  end
+
   before do
     YAML.stubs(:load_file).with(yaml_file_path('xml')).returns(yaml_xml)
-    YAML.stubs(:load_file).with(yaml_file_path('base')).returns({})
+    YAML.stubs(:load_file).with(regexp_matches(/base/)).returns({})
   end
 
   describe "#print" do

data/test/vim/control_command_processor_test.rb

@@ -0,0 +1,28 @@
+require_relative '../test_helper'
+require 'debugger/xml/vim/control_command_processor'
+
+describe Debugger::Xml::Vim::ControlCommandProcessor do
+  include TestDsl
+
+  let(:klass) { Debugger::Xml::Vim::ControlCommandProcessor }
+  let(:interface) { Debugger.handler.interface }
+  let(:file) { fullpath('jump') }
+  let(:context) { stub(frame_binding: stub, stop_reason: nil, thread: stub, thnum: 1, stack_size: 2, dead?: false) }
+  subject { klass.new(interface) }
+  temporary_change_method_value(Debugger, :handler, Debugger::Xml::Ide::Processor.new(TestInterface.new))
+
+  before do
+    Thread.stubs(:stop)
+    Debugger.handler.instance_variable_set("@context", context)
+    Debugger.handler.instance_variable_set("@file", file)
+    Debugger.handler.instance_variable_set("@line", 30)
+  end
+
+  it "must send response after executing commands" do
+    Debugger::AddBreakpoint.any_instance.stubs(:execute).with()
+    Debugger::DeleteBreakpointCommand.any_instance.stubs(:execute).with()
+    interface.expects(:send_response)
+    enter 'break 5; delete 1'
+    subject.process_commands
+  end
+end

data/test/vim/interface_test.rb

@@ -0,0 +1,47 @@
+require_relative '../test_helper'
+require 'debugger/xml/vim/interface'
+
+describe Debugger::Xml::Vim::Interface do
+  include TestDsl
+
+  let(:klass) { Debugger::Xml::Vim::Interface }
+  let(:options) do
+    stub(debug_mode: false, file: filename, separator: "--sep--")
+  end
+  let(:socket) { stub }
+  let(:subject) { klass.new(socket, options) }
+  let(:filename) { File.expand_path("../tmp", __FILE__) }
+  let(:notification) { stub(send: nil) }
+
+  before do
+    File.open(filename, 'w') { |f| }
+  end
+
+  after do
+    File.unlink(filename)
+  end
+
+  it "must send command to Vim" do
+    Debugger::Xml::Vim::Notification.expects(:new).with("receive_command", options).returns(notification)
+    subject.print("foo")
+    subject.print("bar")
+    subject.send_response
+    File.read(filename).strip.must_equal "foo--sep--bar"
+  end
+
+  it "must clear the queue after sending response" do
+    Debugger::Xml::Vim::Notification.stubs(:new).with("receive_command", options).returns(notification)
+    subject.print("foo")
+    subject.print("bar")
+    subject.send_response
+    subject.print("bla")
+    subject.send_response
+    File.read(filename).strip.must_equal "bla"
+  end
+
+  it "must not send any command if there is nothing to send" do
+    Debugger::Xml::Vim::Notification.expects(:new).never
+    subject.send_response
+    File.read(filename).strip.must_equal ""
+  end
+end

data/test/vim/notification_test.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+require 'debugger/xml/vim/notification'
+
+describe Debugger::Xml::Vim::Notification do
+  include TestDsl
+
+  let(:klass) { Debugger::Xml::Vim::Notification }
+  let(:options) do
+    stub(vim_executable: "vim", vim_servername: "VIM", debug_mode: true, logger_file: filename)
+  end
+  let(:subject) { klass.new("foo", options) }
+  let(:filename) { File.expand_path("../tmp", __FILE__) }
+  let(:command) { %{vim --servername VIM -u NONE -U NONE --remote-send \"<C-\\\\><C-N>:call RubyDebugger.foo()<CR>\"} }
+
+  before do
+    File.open(filename, 'w') { |f| }
+  end
+
+  after do
+    File.unlink(filename)
+  end
+
+  it "must send command to Vim" do
+    subject.stubs(:log)
+    subject.expects(:system).with(command)
+    subject.send
+  end
+
+  it "must log to file" do
+    subject.stubs(:system).with(command)
+    subject.send
+    File.read(filename).must_match /Executing command: vim --servername/
+  end
+end

data/test/vim/processor_test.rb

@@ -0,0 +1,36 @@
+require_relative '../test_helper'
+require 'debugger/xml/vim/processor'
+
+describe Debugger::Xml::Vim::Processor do
+  include TestDsl
+
+  before { Thread.stubs(:stop) }
+
+  let(:klass) { Debugger::Xml::Vim::Processor }
+  let(:interface) { TestInterface.new }
+  let(:breakpoint) { stub }
+  let(:context) { stub(thread: nil, stop_reason: nil, thnum: 1, stack_size: 2) }
+  let(:file) { fullpath('jump') }
+  subject { klass.new(interface) }
+
+  describe "#at_line" do
+    it "must send response" do
+      processor = stub
+      processor.stubs(:process_command).with("where")
+      processor.stubs(:process_command).with("var local")
+      Debugger::Xml::Vim::ControlCommandProcessor.stubs(:new).with(interface).returns(processor)
+      interface.expects(:send_response)
+      subject.at_line(context, file, 30)
+    end
+
+    it "must process additional commands" do
+      processor = stub
+      processor.expects(:process_command).with("where")
+      processor.expects(:process_command).with("var local")
+      Debugger::Xml::Vim::ControlCommandProcessor.expects(:new).with(interface).returns(processor)
+      interface.stubs(:send_response)
+      subject.at_line(context, file, 30)
+    end
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: debugger-xml
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-14 00:00:00.000000000 Z
+date: 2013-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debugger
@@ -96,15 +96,18 @@ email:
 - anton.astashov@gmail.com
 executables:
 - rdebug-ide
+- rdebug-vim
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/rdebug-ide
+- bin/rdebug-vim
 - debugger-xml.gemspec
 - lib/debugger/printers/texts/xml.yml
 - lib/debugger/printers/xml.rb
@@ -118,11 +121,17 @@ files:
 - lib/debugger/xml/extensions/commands/tmate.rb
 - lib/debugger/xml/extensions/commands/trace.rb
 - lib/debugger/xml/extensions/commands/variables.rb
-- lib/debugger/xml/extensions/debugger.rb
+- lib/debugger/xml/extensions/ide_server.rb
 - lib/debugger/xml/extensions/processor.rb
-- lib/debugger/xml/ide_processor.rb
-- lib/debugger/xml/interface.rb
+- lib/debugger/xml/extensions/vim_server.rb
+- lib/debugger/xml/ide/control_command_processor.rb
+- lib/debugger/xml/ide/interface.rb
+- lib/debugger/xml/ide/processor.rb
 - lib/debugger/xml/version.rb
+- lib/debugger/xml/vim/control_command_processor.rb
+- lib/debugger/xml/vim/interface.rb
+- lib/debugger/xml/vim/notification.rb
+- lib/debugger/xml/vim/processor.rb
 - test/breakpoints_test.rb
 - test/conditions_test.rb
 - test/continue_test.rb
@@ -154,8 +163,8 @@ files:
 - test/examples/variables_xml.rb
 - test/frame_test.rb
 - test/help_test.rb
-- test/ide_control_command_processor_test.rb
-- test/ide_processor_test.rb
+- test/ide/control_command_processor_test.rb
+- test/ide/processor_test.rb
 - test/info_test.rb
 - test/irb_test.rb
 - test/jump_test.rb
@@ -171,6 +180,10 @@ files:
 - test/tmate_test.rb
 - test/trace_test.rb
 - test/variables_test.rb
+- test/vim/control_command_processor_test.rb
+- test/vim/interface_test.rb
+- test/vim/notification_test.rb
+- test/vim/processor_test.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -228,8 +241,8 @@ test_files:
 - test/examples/variables_xml.rb
 - test/frame_test.rb
 - test/help_test.rb
-- test/ide_control_command_processor_test.rb
-- test/ide_processor_test.rb
+- test/ide/control_command_processor_test.rb
+- test/ide/processor_test.rb
 - test/info_test.rb
 - test/irb_test.rb
 - test/jump_test.rb
@@ -245,3 +258,7 @@ test_files:
 - test/tmate_test.rb
 - test/trace_test.rb
 - test/variables_test.rb
+- test/vim/control_command_processor_test.rb
+- test/vim/interface_test.rb
+- test/vim/notification_test.rb
+- test/vim/processor_test.rb

data/lib/debugger/xml/ide_processor.rb

@@ -1,149 +0,0 @@
-require 'ruby-debug/processor'
-
-module Debugger
-  module Xml
-
-    class IdeProcessor < Processor
-      attr_reader :context, :file, :line, :display
-      def initialize(interface)
-        @mutex = Mutex.new
-        @interface = interface
-        @display = []
-      end
-
-      def at_breakpoint(context, breakpoint)
-        raise "@last_breakpoint supposed to be nil. is #{@last_breakpoint}" if @last_breakpoint
-        # at_breakpoint is immediately followed by #at_line event. So postpone breakpoint printing until #at_line.
-        @last_breakpoint = breakpoint
-      end
-      protect :at_breakpoint
-
-      # TODO: Catching exceptions doesn't work so far, need to fix
-      def at_catchpoint(context, excpt)
-      end
-
-      # We don't have tracing for IDE
-      def at_tracing(*args)
-      end
-
-      def at_line(context, file, line)
-        if context.nil? || context.stop_reason == :step
-          print_file_line(context, file, line)
-        end
-        line_event(context, file, line)
-      end
-      protect :at_line
-
-      def at_return(context, file, line)
-        print_file_line(context, file, line)
-        context.stop_frame = -1
-        line_event(context, file, line)
-      end
-
-      def at_line?
-        !!@line
-      end
-
-      private
-
-        def print_file_line(context, file, line)
-          print(
-            Debugger.printer.print(
-              "stop.suspend",
-              file: CommandProcessor.canonic_file(file), line_number: line, line: Debugger.line_at(file, line),
-              thnum: context && context.thnum, frames: context && context.stack_size
-            )
-          )
-        end
-
-        def line_event(context, file, line)
-          @line = line
-          @file = file
-          @context = context
-          if @last_breakpoint
-            # followed after #at_breakpoint in the same thread. Print breakpoint
-            # now when @line, @file and @context are correctly set to prevent race
-            # condition with `control thread'.
-            n = Debugger.breakpoints.index(@last_breakpoint) + 1
-            print pr("breakpoints.stop_at_breakpoint",
-              id: n, file: @file, line: @line, thread_id: Debugger.current_context.thnum
-            )
-          end
-          if @context && @context.thread.is_a?(Debugger::DebugThread)
-            raise pr("thread.errors.debug_trace", thread: @context.thread)
-          end
-          # will be resumed by commands like `step', `next', `continue', `finish'
-          # from `control thread'
-          Thread.stop
-        ensure
-          @line = nil
-          @file = nil
-          @context = nil
-          @last_breakpoint = nil
-        end
-    end
-
-    class IdeControlCommandProcessor < Processor
-
-      def initialize(interface)
-        @interface = interface
-      end
-
-      def process_commands
-        control_command_classes = Command.commands.select(&:allow_in_control)
-        state = ControlCommandProcessor::State.new(@interface, control_command_classes)
-        control_commands = control_command_classes.map { |cmd| cmd.new(state) }
-
-        while input = @interface.read_command
-          split_commands(input).each do |cmd|
-            catch(:debug_error) do
-              if matched_cmd = control_commands.find { |c| c.match(cmd) }
-                matched_cmd.execute
-              else
-                process_context_commands(cmd)
-              end
-            end
-          end
-        end
-      rescue IOError, Errno::EPIPE
-      rescue Exception
-        print "INTERNAL ERROR!!! #{$!}\n" rescue nil
-        print $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
-      ensure
-        @interface.close
-      end
-
-      private
-
-        def process_context_commands(input)
-          unless Debugger.handler.at_line?
-            errmsg pr("base.errors.no_suspended_thread", input: input)
-            return
-          end
-          event_command_classes = Command.commands.select(&:event)
-          state = CommandProcessor::State.new do |s|
-            s.context = Debugger.handler.context
-            s.file    = Debugger.handler.file
-            s.line    = Debugger.handler.line
-            s.binding = Debugger.handler.context.frame_binding(0)
-            s.interface = @interface
-            s.commands = event_command_classes
-          end
-          event_commands = event_command_classes.map { |cls| cls.new(state) }
-          catch(:debug_error) do
-            if cmd = event_commands.find { |c| c.match(input) }
-              if state.context.dead? && cmd.class.need_context
-                print pr("base.errors.command_unavailable")
-              else
-                cmd.execute
-              end
-            else
-              print pr("base.errors.unknown_command", input: input)
-            end
-          end
-          state.context.thread.run if state.proceed?
-        end
-    end
-
-  end
-end

data/lib/debugger/xml/interface.rb

@@ -1,65 +0,0 @@
-module Debugger
-  module Xml
-    class IdeInterface < Interface # :nodoc:
-      attr_accessor :command_queue
-      attr_accessor :histfile
-      attr_accessor :history_save
-      attr_accessor :history_length
-      attr_accessor :restart_file
-
-      def initialize(socket)
-        @command_queue = []
-        @socket = socket
-        @history_save = false
-        @history_length = 256
-        @histfile = ''
-        @restart_file = nil
-      end
-
-      def close
-        @socket.close
-      rescue Exception
-      end
-
-      def print_debug(msg)
-        STDOUT.puts(msg)
-      end
-
-      def errmsg(*args)
-        print(*args)
-      end
-
-      def confirm(prompt)
-        true
-      end
-
-      def finalize
-        close
-      end
-
-      # Workaround for JRuby issue http://jira.codehaus.org/browse/JRUBY-2063
-      def non_blocking_gets
-        loop do
-          result, _, _ = IO.select([@socket], nil, nil, 0.2)
-          next unless result
-          return result[0].gets
-        end
-      end
-
-      def read_command(*args)
-        result = non_blocking_gets
-        raise IOError unless result
-        result.chomp
-      end
-
-      def readline_support?
-        false
-      end
-
-      def print(*args)
-        @socket.printf(*escape_input(args))
-      end
-
-    end
-  end
-end