debugger-xml 0.3.3 → 0.4.0

data/lib/debugger_xml/multiprocess/pre_child.rb

@@ -0,0 +1,79 @@
+module DebuggerXml
+  module MultiProcess
+    class << self
+      def pre_child
+        return unless ENV['IDE_PROCESS_DISPATCHER']
+
+        require 'socket'
+        require 'ostruct'
+
+        host = ENV['DEBUGGER_HOST']
+        port = find_free_port(host)
+
+        options = OpenStruct.new(
+          host: host,
+          port: port,
+          stop: false,
+          tracing: false,
+          wait_for_start: true,
+          int_handler: true,
+          debug_mode: (ENV['DEBUGGER_DEBUG_MODE'] == 'true'),
+          dispatcher_port: ENV['IDE_PROCESS_DISPATCHER']
+        )
+
+        acceptor_host, acceptor_port = ENV['IDE_PROCESS_DISPATCHER'].split(":")
+        acceptor_host, acceptor_port = '127.0.0.1', acceptor_host unless acceptor_port
+
+        connected = false
+        3.times do |i|
+          begin
+            s = TCPSocket.open(acceptor_host, acceptor_port)
+            s.print(port)
+            s.close
+            connected = true
+            start_debugger(options)
+            return
+          rescue => bt
+            $stderr.puts "#{Process.pid}: connection failed(#{i+1})"
+            $stderr.puts "Exception: #{bt}"
+            $stderr.puts bt.backtrace.map { |l| "\t#{l}" }.join("\n")
+            sleep 0.3
+          end unless connected
+        end
+      end
+
+      def start_debugger(options)
+        if Debugger.started?
+          # we're in forked child, only need to restart control thread
+          Debugger.breakpoints.clear
+          Debugger.control_thread = nil
+        end
+
+        if options.int_handler
+          # install interruption handler
+          trap('INT') { Debugger.interrupt_last }
+        end
+
+        # set options
+        Debugger.tracing = options.tracing
+        Debugger.wait_for_start = options.wait_for_start
+        Debugger.wait_connection = true
+        Debugger.printer = Printers::Xml.new
+        DebuggerXml.logger = if options.debug_mode
+          Debugger::Xml::Ide::Logger.new
+        else
+          Debugger::Xml::FakeLogger.new
+        end
+        DebuggerXml.start_remote_ide(options.host, options.port)
+      end
+
+
+      def find_free_port(host)
+        server = TCPServer.open(host, 0)
+        port   = server.addr[1]
+        server.close
+        port
+      end
+    end
+  end
+end

data/lib/{debugger/xml → debugger_xml}/multiprocess/starter.rb

@@ -5,6 +5,6 @@ if ENV['IDE_PROCESS_DISPATCHER']
     next unless path =~ /debugger-xml|\/debugger\/|linecache/
     $LOAD_PATH << path
   end
-  require 'debugger/xml'
-  Debugger::Xml::MultiProcess.pre_child
+  require 'debugger_xml'
+  DebuggerXml::MultiProcess.pre_child
 end

data/lib/debugger_xml/version.rb

@@ -0,0 +1,3 @@
+module DebuggerXml
+  VERSION = "0.4.0"
+end

data/lib/debugger_xml/vim/control_command_processor.rb

@@ -0,0 +1,23 @@
+require 'debugger_xml/ide/control_command_processor'
+
+module DebuggerXml
+  module Vim
+
+    class ControlCommandProcessor < Ide::ControlCommandProcessor
+      def initialize(*args)
+        super(*args)
+        @mutex = Mutex.new
+      end
+
+      private
+
+        def process_command(*args)
+          @mutex.synchronize do
+            super(*args)
+            @interface.send_response
+          end
+        end
+
+    end
+  end
+end

data/lib/debugger_xml/vim/interface.rb

@@ -0,0 +1,46 @@
+require 'debugger_xml/ide/interface'
+
+module DebuggerXml
+  module Vim
+    class Interface < Ide::Interface
+      def initialize(socket, options)
+        super(socket)
+        @options = options
+        @output = []
+      end
+
+      def print(*args)
+        escaped_args = escape_input(args)
+        value = escaped_args.first % escaped_args[1..-1]
+        DebuggerXml.logger.puts("Going to print: #{value}")
+        @output << sprintf(value)
+      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
+
+        def escape_input(args)
+          new_args = args.dup
+          new_args.first.gsub!("%", "%%") if args.first.is_a?(String)
+          new_args
+        end
+
+    end
+  end
+end

data/lib/debugger_xml/vim/logger.rb

@@ -0,0 +1,16 @@
+module DebuggerXml
+  module Vim
+    class Logger
+      def initialize(logger_file)
+        @logger_file = logger_file
+      end
+
+      def puts(string)
+        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

data/lib/debugger_xml/vim/notification.rb

@@ -0,0 +1,35 @@
+module DebuggerXml
+  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

data/lib/debugger_xml/vim/processor.rb

@@ -0,0 +1,20 @@
+require 'debugger_xml/ide/processor'
+
+module DebuggerXml
+  module Vim
+
+    class Processor < Ide::Processor
+      def initialize(control_command_processor, *args)
+        @control_command_processor = control_command_processor
+        super(*args)
+      end
+
+      def stop_thread
+        @control_command_processor.process_command("where")
+        @control_command_processor.process_command("var ide")
+        super
+      end
+    end
+
+  end
+end

data/test/breakpoints_test.rb

@@ -2,7 +2,6 @@ require_relative 'test_helper'
 
 describe "Breakpoints" do
   include TestDsl
-  temporary_change_method_value(Debugger, :printer, Printers::Xml.new)
 
   describe "setting breakpoint in the current file" do
     it "must return right response" do

data/test/ide/control_command_processor_test.rb

@@ -1,21 +1,26 @@
 require_relative '../test_helper'
-require 'debugger/xml/ide/control_command_processor'
+require 'debugger_xml/ide/control_command_processor'
 
-describe Debugger::Xml::Ide::ControlCommandProcessor do
+describe DebuggerXml::Ide::ControlCommandProcessor do
   include TestDsl
 
-  let(:klass) { Debugger::Xml::Ide::ControlCommandProcessor }
-  let(:interface) { Debugger.handler.interface }
+  let(:klass) { DebuggerXml::Ide::ControlCommandProcessor }
+  let(:interface) { $proxy.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))
+  subject { klass.new(interface, $proxy) }
 
   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)
+    @handler = $proxy.handler
+    $proxy.handler = DebuggerXml::Ide::Processor.new(TestInterface.new, $proxy)
+    $proxy.handler.instance_variable_set("@context", context)
+    $proxy.handler.instance_variable_set("@file", file)
+    $proxy.handler.instance_variable_set("@line", 30)
+  end
+
+  after do
+    $proxy.handler = @handler
   end
 
   it "must process a control command" do
@@ -34,22 +39,22 @@ describe Debugger::Xml::Ide::ControlCommandProcessor do
   it "must show error if there is no such command" do
     enter 'bla'
     subject.process_commands
-    check_output_includes "Unknown command: bla"
+    check_output_includes "<error>Unknown command: bla</error>"
   end
 
   it "must show error if context is dead" do
     context.expects(:dead?).returns(true)
     enter 'step'
     subject.process_commands
-    check_output_includes "Command is unavailable"
+    check_output_includes "<error>Command is unavailable</error>"
   end
 
   it "must show error if no suspended thread" do
-    Debugger.handler.stubs(:at_line?).returns(false)
+    $proxy.handler.stubs(:at_line?).returns(false)
     enter 'step'
     subject.process_commands
     check_output_includes(
-      "There is no thread suspended at the time and therefore no context to execute 'step'",
+      "<error>There is no thread suspended at the time and therefore no context to execute 'step'</error>",
     interface.error_queue)
   end
 

data/test/ide/processor_test.rb

@@ -1,17 +1,17 @@
 require_relative '../test_helper'
-require 'debugger/xml/ide/processor'
+require 'debugger_xml/ide/processor'
 
-describe Debugger::Xml::Ide::Processor do
+describe DebuggerXml::Ide::Processor do
   include TestDsl
 
   before { Thread.stubs(:stop) }
 
-  let(:klass) { Debugger::Xml::Ide::Processor }
+  let(:klass) { DebuggerXml::Ide::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) }
+  subject { klass.new(interface, $proxy) }
 
   describe "#at_breakpoint" do
     it "must assign breakpoint to instance variable" do
@@ -35,20 +35,13 @@ describe Debugger::Xml::Ide::Processor do
     describe "print current position" do
       it "must print if context is nil" do
         subject.at_line(nil, file, 30)
-        check_output_includes "#{file}:30"
-      end
-
-      it "must print in xml" do
-        temporary_change_method_value(Debugger, :printer, Printers::Xml.new) do
-          subject.at_line(nil, file, 30)
-          check_output_includes %{<suspended file="#{file}" line="30" threadId="" frames=""/>}
-        end
+        check_output_includes %{<suspended file="#{file}" line="30" threadId="" frames=""/>}
       end
 
       it "must print if stop reason is :step" do
         context.stubs(:stop_reason).returns(:step)
         subject.at_line(context, file, 30)
-        check_output_includes "#{file}:30"
+        check_output_includes %{<suspended file="#{file}" line="30" threadId="1" frames="2"/>}
       end
 
       it "must clear instance variables after resuming thread" do
@@ -59,26 +52,19 @@ describe Debugger::Xml::Ide::Processor do
 
       describe "print breakpoint after at_breakpoint" do
         before do
-          Debugger.stubs(:breakpoints).returns([breakpoint])
-          Debugger.stubs(:current_context).returns(stub(thnum: 1))
+          $proxy.stubs(:breakpoints).returns([breakpoint])
+          $proxy.stubs(:current_context).returns(stub(thnum: 1))
           subject.instance_variable_set("@last_breakpoint", breakpoint)
         end
 
         it "must print in plain text" do
           subject.at_line(context, file, 30)
-          check_output_includes "Breakpoint 1 at #{file}:30"
-        end
-
-        it "must print in xml" do
-          temporary_change_method_value(Debugger, :printer, Printers::Xml.new) do
-            subject.at_line(context, file, 30)
-            check_output_includes %{<breakpoint file="#{file}" line="30" threadId="1"/>}
-          end
+          check_output_includes %{<breakpoint file="#{file}" line="30" threadId="1"/>}
         end
       end
 
       it "must show error if current thread is DebugThread" do
-        context.stubs(:thread).returns(Debugger::DebugThread.new {})
+        context.stubs(:thread).returns($proxy.debug_thread_class.new {})
         subject.at_line(context, file, 30)
         check_output_includes /DebuggerThread are not supposed to be traced/
       end
@@ -106,7 +92,7 @@ describe Debugger::Xml::Ide::Processor do
 
     it "prints current file and line" do
       subject.at_return(context, file, 30)
-      check_output_includes "#{file}:30"
+      check_output_includes %{<suspended file="#{file}" line="30" threadId="1" frames="2"/>}
     end
 
     it "stops the thread" do

data/test/printers/xml_test.rb

@@ -1,4 +1,5 @@
 require_relative '../test_helper'
+require 'ostruct'
 
 describe "Printers::Xml" do
   include PrinterHelpers

data/test/test_helper.rb

@@ -1,7 +1,16 @@
 require 'minitest/autorun'
 
-require 'debugger/xml'
-require 'debugger/test'
+DEBUGGER_TYPE = :debugger
+require 'debugger'
+require 'debugger_xml'
 
 $debugger_test_dir = File.expand_path("..", __FILE__)
-Debugger::Xml.logger = Debugger::Xml::FakeLogger.new
+$proxy = DebuggerXml::DebuggerProxy.new
+
+MiniTest::Unit::TestCase.add_setup_hook do
+  $proxy.printer = Printers::Xml.new
+end
+
+require 'debugger/test'
+
+DebuggerXml.logger = DebuggerXml::FakeLogger.new

data/test/variables_test.rb

@@ -2,7 +2,6 @@ require_relative 'test_helper'
 
 describe "Variables Command" do
   include TestDsl
-  temporary_change_method_value(Debugger, :printer, Printers::Xml.new)
 
   describe "constants" do
     it "must show constants" do

data/test/vim/control_command_processor_test.rb

@@ -1,15 +1,14 @@
 require_relative '../test_helper'
-require 'debugger/xml/vim/control_command_processor'
+require 'debugger_xml/vim/control_command_processor'
 
-describe Debugger::Xml::Vim::ControlCommandProcessor do
+describe DebuggerXml::Vim::ControlCommandProcessor do
   include TestDsl
 
-  let(:klass) { Debugger::Xml::Vim::ControlCommandProcessor }
+  let(:klass) { DebuggerXml::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))
+  subject { klass.new(interface, $proxy) }
 
   before do
     Thread.stubs(:stop)