debugger-xml 0.3.3 → 0.4.0

data/lib/debugger_xml/debugger_proxy.rb

@@ -0,0 +1,115 @@
+module DebuggerXml
+  class DebuggerProxy
+    def start
+      ::Debugger.start
+    end
+
+    def handler
+      ::Debugger.handler
+    end
+
+    def handler=(value)
+      ::Debugger.handler = value
+    end
+
+    def control_commands(interface)
+      control_command_classes = commands.select(&:allow_in_control)
+      state = ::Debugger::ControlCommandProcessor::State.new(interface, control_command_classes)
+      control_command_classes.map { |cmd| cmd.new(state) }
+    end
+
+    def build_command_processor_state(interface)
+      ::Debugger::CommandProcessor::State.new do |s|
+        s.context = handler.context
+        s.file    = handler.file
+        s.line    = handler.line
+        s.binding = handler.context.frame_binding(0)
+        s.interface = interface
+        s.commands = event_command_classes
+      end
+    end
+
+    def commands
+      ::Debugger::Command.commands
+    end
+
+    def event_commands(state)
+      event_command_classes.map { |cls| cls.new(state) }
+    end
+
+    def print(*args)
+      printer.print(*args)
+    end
+
+    def canonic_file(file)
+      ::Debugger::CommandProcessor.canonic_file(file)
+    end
+
+    def line_at(file, line)
+      ::Debugger.line_at(file, line)
+    end
+
+    def breakpoints
+      ::Debugger.breakpoints
+    end
+
+    def debug_thread?(context)
+      context && context.thread.is_a?(debug_thread_class)
+    end
+
+    def debug_thread_class
+      ::Debugger::DebugThread
+    end
+
+    def current_context
+      ::Debugger.current_context
+    end
+
+    def set_rdebug_script(file)
+      ::Debugger.const_set("RDEBUG_SCRIPT", file)
+    end
+
+    def set_prog_script(file)
+      ::Debugger.const_set("PROG_SCRIPT", file)
+    end
+
+    def set_argv(argv)
+      ::Debugger.const_set("ARGV", argv)
+    end
+
+    def interrupt_last
+      ::Debugger.interrupt_last
+    end
+
+    def tracing=(value)
+      ::Debugger.tracing = value
+    end
+
+    def wait_connection=(value)
+      ::Debugger.wait_connection = value
+    end
+
+    def printer=(value)
+      ::Debugger.printer = value
+    end
+
+    def debug_load
+      ::Debugger.debug_load(::Debugger::PROG_SCRIPT, false, false)
+    end
+
+    def inspect_command_class
+      ::Debugger::InspectCommand
+    end
+
+    private
+
+    def event_command_classes
+      commands.select(&:event)
+    end
+
+    def printer
+      ::Debugger.printer
+    end
+
+  end
+end

data/lib/debugger_xml/fake_logger.rb

@@ -0,0 +1,9 @@
+module DebuggerXml
+  class FakeLogger
+    def initialize(*args)
+    end
+
+    def puts(*args)
+    end
+  end
+end

data/lib/debugger_xml/ide/control_command_processor.rb

@@ -0,0 +1,69 @@
+module DebuggerXml
+  module Ide
+    class ControlCommandProcessor
+
+      def initialize(interface, proxy)
+        @interface = interface
+        @proxy = proxy
+      end
+
+      def process_commands
+        while input = @interface.read_command
+          process_input(input)
+        end
+      rescue IOError, Errno::EPIPE
+      rescue Exception
+        @interface.print("INTERNAL ERROR!!! #{$!}\n") rescue nil
+        @interface.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 = @proxy.control_commands(@interface).find { |c| c.match(cmd) }
+            matched_cmd.execute
+          else
+            process_context_commands(cmd)
+          end
+        end
+      end
+
+    private
+
+      def process_input(input)
+        split_commands(input).each do |cmd|
+          process_command(cmd)
+        end
+      end
+
+      def process_context_commands(input)
+        unless @proxy.handler.at_line?
+          @interface.errmsg(@proxy.print("base.errors.no_suspended_thread", input: input))
+          return
+        end
+        state = @proxy.build_command_processor_state(@interface)
+        event_commands = @proxy.event_commands(state)
+        catch(:debug_error) do
+          if cmd = event_commands.find { |c| c.match(input) }
+            if state.context.dead? && cmd.class.need_context
+              @interface.print(@proxy.print("base.errors.command_unavailable"))
+            else
+              cmd.execute
+            end
+          else
+            @interface.print(@proxy.print("base.errors.unknown_command", input: input))
+          end
+        end
+        state.context.thread.run if state.proceed?
+      end
+
+      # Split commands like this:
+      # split_commands("abc;def\\;ghi;jkl") => ["abc", "def;ghi", "jkl"]
+      def split_commands(input)
+        input.split(/(?<!\\);/).map { |e| e.gsub("\\;", ";") }
+      end
+
+    end
+  end
+end

data/lib/debugger_xml/ide/interface.rb

@@ -0,0 +1,74 @@
+module DebuggerXml
+  module Ide
+    class Interface
+      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.tap do |r|
+          DebuggerXml.logger.puts("Read command: #{r}")
+        end
+      end
+
+      def readline_support?
+        false
+      end
+
+      def print(*args)
+        escaped_args = escape_input(args)
+        value = escaped_args.first % escaped_args[1..-1]
+        DebuggerXml.logger.puts("Going to print: #{value}")
+        @socket.print(value)
+      end
+
+      def puts(*args)
+        print(*args)
+      end
+
+    end
+  end
+end

data/lib/debugger_xml/ide/logger.rb

@@ -0,0 +1,9 @@
+module DebuggerXml
+  module Ide
+    class Logger
+      def puts(string)
+        $stderr.puts(string)
+      end
+    end
+  end
+end

data/lib/debugger_xml/ide/processor.rb

@@ -0,0 +1,118 @@
+module DebuggerXml
+  module Ide
+    class Processor
+      class << self
+        private
+
+        # Copied from debugger gem.
+        def protect(mname)
+          alias_method "__#{mname}", mname
+          module_eval %{
+            def #{mname}(*args)
+              @mutex.synchronize do
+                return unless @interface
+                __#{mname}(*args)
+              end
+            rescue IOError, Errno::EPIPE
+              self.interface = nil
+            rescue SignalException
+              raise
+            rescue Exception
+              @interface.print "INTERNAL ERROR!!! #\{$!\}\n" rescue nil
+              @interface.print $!.backtrace.map{|l| "\t#\{l\}"}.join("\n") rescue nil
+            end
+          }
+        end
+      end
+
+      attr_reader :context, :file, :line, :display
+      attr_accessor :interface
+
+      def initialize(interface, proxy)
+        @mutex = Mutex.new
+        @interface = interface
+        @proxy = proxy
+        @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)
+          @interface.print(
+            @proxy.print(
+              "stop.suspend",
+              file: @proxy.canonic_file(file),
+              line_number: line,
+              line: @proxy.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 = @proxy.breakpoints.index(@last_breakpoint) + 1
+            @interface.print(@proxy.print("breakpoints.stop_at_breakpoint",
+              id: n, file: @file, line: @line, thread_id: @proxy.current_context.thnum
+            ))
+          end
+          if @proxy.debug_thread?(@context)
+            raise @proxy.print("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
+          @proxy.inspect_command_class.clear_references
+        end
+
+        def stop_thread
+          Thread.stop
+        end
+    end
+  end
+end

data/lib/debugger_xml/multiprocess/monkey.rb

@@ -0,0 +1,47 @@
+module DebuggerXml
+  module MultiProcess
+    def self.create_mp_fork(private=false)
+      %Q{
+        alias pre_debugger_fork fork
+
+        #{private ? "private" : ""}
+        def fork(*args)
+          if block_given?
+            return pre_debugger_fork{DebuggerXml::MultiProcess::pre_child; yield}
+          end
+          result = pre_debugger_fork
+          DebuggerXml::MultiProcess::pre_child unless result
+          result
+        end
+      }
+    end
+
+    def self.create_mp_exec(private=false)
+      %Q{
+        alias pre_debugger_exec exec
+
+        #{private ? "private" : ""}
+        def exec(*args)
+          Debugger.handler.interface.close
+          pre_debugger_exec(*args)
+        end
+      }
+    end
+  end
+end
+
+module Kernel
+  class << self
+    module_eval DebuggerXml::MultiProcess.create_mp_fork
+    module_eval DebuggerXml::MultiProcess.create_mp_exec
+  end
+  module_eval DebuggerXml::MultiProcess.create_mp_fork(true)
+  module_eval DebuggerXml::MultiProcess.create_mp_exec(true)
+end
+
+module Process
+  class << self
+    module_eval DebuggerXml::MultiProcess.create_mp_fork
+    module_eval DebuggerXml::MultiProcess.create_mp_exec
+  end
+end