debugger-xml 0.0.1

data/lib/debugger/xml.rb

@@ -0,0 +1,3 @@
+require "debugger"
+require "debugger/printers/xml"
+Dir.glob(File.expand_path("../**/*.rb", __FILE__)).each { |f| require f }

data/lib/debugger/xml/extensions/commands/edit.rb

@@ -0,0 +1,13 @@
+module Debugger
+  class Edit < Command
+
+    def execute_with_xml(*args)
+      errmsg(pr("general.errors.unsupported", cmd: 'edit')) && return if Debugger.printer.type == "xml"
+      execute_without_xml(*args)
+    end
+
+    alias_method :execute_without_xml, :execute
+    alias_method :execute, :execute_with_xml
+
+  end
+end

data/lib/debugger/xml/extensions/commands/frame.rb

@@ -0,0 +1,14 @@
+module Debugger
+  module FrameFunctions
+
+    # Mark should be 'true' or 'false', as a String
+    def get_pr_arguments_with_xml(mark, *args)
+      get_pr_arguments_without_xml((!!mark).to_s, *args)
+    end
+
+    alias_method :get_pr_arguments_without_xml, :get_pr_arguments
+    alias_method :get_pr_arguments, :get_pr_arguments_with_xml
+
+  end
+end
+

data/lib/debugger/xml/extensions/commands/help.rb

@@ -0,0 +1,13 @@
+module Debugger
+  class HelpCommand < Command
+
+    def execute_with_xml(*args)
+      errmsg(pr("general.errors.unsupported", cmd: 'help')) && return if Debugger.printer.type == "xml"
+      execute_without_xml(*args)
+    end
+
+    alias_method :execute_without_xml, :execute
+    alias_method :execute, :execute_with_xml
+
+  end
+end

data/lib/debugger/xml/extensions/commands/info.rb

@@ -0,0 +1,13 @@
+module Debugger
+  class InfoCommand < Command
+
+    def execute_with_xml(*args)
+      errmsg(pr("general.errors.unsupported", cmd: 'info')) && return if Debugger.printer.type == "xml"
+      execute_without_xml(*args)
+    end
+
+    alias_method :execute_without_xml, :execute
+    alias_method :execute, :execute_with_xml
+
+  end
+end

data/lib/debugger/xml/extensions/commands/irb.rb

@@ -0,0 +1,13 @@
+module Debugger
+  class IRBCommand < Command
+
+    def execute_with_xml(*args)
+      errmsg(pr("general.errors.unsupported", cmd: 'irb')) && return if Debugger.printer.type == "xml"
+      execute_without_xml(*args)
+    end
+
+    alias_method :execute_without_xml, :execute
+    alias_method :execute, :execute_with_xml
+
+  end
+end

data/lib/debugger/xml/extensions/commands/kill.rb

@@ -0,0 +1,13 @@
+module Debugger
+  class KillCommand < Command
+
+    def execute_with_xml(*args)
+      errmsg(pr("general.errors.unsupported", cmd: 'kill')) && return if Debugger.printer.type == "xml"
+      execute_without_xml(*args)
+    end
+
+    alias_method :execute_without_xml, :execute
+    alias_method :execute, :execute_with_xml
+
+  end
+end

data/lib/debugger/xml/extensions/commands/tmate.rb

@@ -0,0 +1,13 @@
+module Debugger
+  class TextMateCommand < Command
+
+    def execute_with_xml(*args)
+      errmsg(pr("general.errors.unsupported", cmd: 'tmate')) && return if Debugger.printer.type == "xml"
+      execute_without_xml(*args)
+    end
+
+    alias_method :execute_without_xml, :execute
+    alias_method :execute, :execute_with_xml
+
+  end
+end

data/lib/debugger/xml/extensions/commands/trace.rb

@@ -0,0 +1,13 @@
+module Debugger
+  class TraceCommand < Command
+
+    def execute_with_xml(*args)
+      errmsg(pr("general.errors.unsupported", cmd: 'trace')) && return if Debugger.printer.type == "xml"
+      execute_without_xml(*args)
+    end
+
+    alias_method :execute_without_xml, :execute
+    alias_method :execute, :execute_with_xml
+
+  end
+end

data/lib/debugger/xml/extensions/commands/variables.rb

@@ -0,0 +1,16 @@
+module Debugger
+  class VarInstanceCommand < Command
+
+    def execute_with_xml(*args)
+      if Debugger.printer.type == "xml"
+        print Debugger.printer.print_instance_variables(get_obj(@match))
+      else
+        execute_without_xml(*args)
+      end
+    end
+
+    alias_method :execute_without_xml, :execute
+    alias_method :execute, :execute_with_xml
+
+  end
+end

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

@@ -0,0 +1,28 @@
+module Debugger
+  class << self
+    attr_accessor :wait_for_start
+
+    def start_remote_ide(host, port)
+      return if @control_thread
+      @mutex = Mutex.new
+      @proceed = ConditionVariable.new
+      start
+      @control_thread = DebugThread.new do
+        server = TCPServer.new(host, port)
+        while (session = server.accept)
+          interface = IdeInterface.new(session)
+          processor = IdeControlCommandProcessor.new(interface)
+          self.handler = IdeProcessor.new(interface)
+          processor.process_commands
+        end
+      end
+      @mutex.synchronize { @proceed.wait(@mutex) } if wait_for_start
+    end
+
+    def proceed
+      return unless @mutex
+      @mutex.synchronize { @proceed.signal }
+    end
+
+  end
+end

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

@@ -0,0 +1,9 @@
+module Debugger
+  class CommandProcessor < Processor
+
+    def self.annotate_location_and_text(output)
+      output
+    end
+
+  end
+end

data/lib/debugger/xml/ide_processor.rb

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,65 @@
+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

data/lib/debugger/xml/version.rb

@@ -0,0 +1,5 @@
+module Debugger
+  module Xml
+    VERSION = "0.0.1"
+  end
+end

data/test/breakpoints_test.rb

@@ -0,0 +1,190 @@
+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
+      enter 'break 10'
+      id = nil
+      debug_file('breakpoint1') { id = breakpoint.id }
+      check_output_includes "<breakpointAdded no=\"#{id}\" location=\"#{fullpath('breakpoint1')}:10\"/>"
+    end
+  end
+
+  describe "setting breakpoint to unexisted line" do
+    it "must show an error" do
+      enter 'break 100'
+      debug_file("breakpoint1")
+      check_output_includes "<error>There are only 15 lines in file 'breakpoint1.rb'</error>", interface.error_queue
+    end
+  end
+
+
+  describe "shows a message when stopping at breakpoint" do
+    temporary_change_hash_value(Debugger::Command.settings, :basename, false)
+
+    it "must show a message with full filename" do
+      enter 'break 14', 'cont'
+      debug_file("breakpoint1")
+      check_output_includes "<breakpoint file=\"#{fullpath('breakpoint1')}\" line=\"14\" threadId=\"1\"/>"
+    end
+
+    it "must show a message with basename" do
+      enter 'set basename', 'break 14', 'cont'
+      debug_file("breakpoint1")
+      check_output_includes "<breakpoint file=\"breakpoint1.rb\" line=\"14\" threadId=\"1\"/>"
+    end
+
+    it "must not show <suspended>" do
+      enter 'break 14', 'cont'
+      debug_file("breakpoint1")
+      check_output_doesnt_include /<suspended[^>]+line="14"/
+    end
+  end
+
+  describe "set breakpoint in a file when setting breakpoint to unexisted file" do
+    before do
+      enter "break asf:324"
+      debug_file("breakpoint1")
+    end
+
+    it "must show an error" do
+      check_output_includes "<error>No source file named asf</error>", interface.error_queue
+    end
+
+    it "must ask about setting breakpoint anyway" do
+      check_output_includes "<confirmation>Set breakpoint anyway?</confirmation>", interface.confirm_queue
+    end
+  end
+
+  describe "set breakpoint to a method" do
+    describe "set breakpoint to an instance method" do
+      it "must output show in xml" do
+        enter 'break A#b', 'cont'
+        id = nil
+        debug_file("breakpoint1") { id = breakpoint.id }
+        check_output_includes "<breakpointAdded no=\"#{id}\" method=\"A::b\"/>"
+      end
+    end
+
+    describe "set breakpoint to unexisted class" do
+      it "must show an error" do
+        enter "break B.a"
+        debug_file("breakpoint1")
+        check_output_includes "<error>Unknown class B</error>", interface.error_queue
+      end
+    end
+  end
+
+  describe "set breakpoint to an invalid location" do
+    it "must show an error" do
+      enter "break foo"
+      debug_file("breakpoint1")
+      check_output_includes '<error>Invalid breakpoint location: foo</error>', interface.error_queue
+    end
+  end
+
+
+  describe "disabling a breakpoint" do
+    it "must show success message" do
+      enter "break 14", ->{"disable #{breakpoint.id}"}, "break 15"
+      id = nil
+      debug_file("breakpoint1") { id = breakpoint.id }
+      check_output_includes "<breakpointDisabled bp_id=\"#{id}\"/>"
+    end
+
+    describe "errors" do
+      it "must show an error if syntax is incorrect" do
+        enter "disable"
+        debug_file("breakpoint1")
+        check_output_includes(
+          "<error>'disable' must be followed 'display', 'breakpoints' or breakpoint numbers</error>",
+          interface.error_queue
+        )
+      end
+
+      it "must show an error if no breakpoints is set" do
+        enter "disable 1"
+        debug_file("breakpoint1")
+        check_output_includes '<error>No breakpoints have been set</error>', interface.error_queue
+      end
+
+      it "must show an error if not a number is provided as an argument to 'disable' command" do
+        enter "break 14", "disable foo"
+        debug_file("breakpoint1")
+        check_output_includes "<error>Disable breakpoints argument 'foo' needs to be a number</error>"
+      end
+    end
+  end
+
+  describe "enabling a breakpoint" do
+    it "must show success message" do
+      enter "break 14", ->{"enable #{breakpoint.id}"}, "break 15"
+      id = nil
+      debug_file("breakpoint1") { id = breakpoint.id }
+      check_output_includes "<breakpointEnabled bp_id=\"#{id}\"/>"
+    end
+
+    it "must show an error if syntax is incorrect" do
+      enter "enable"
+      debug_file("breakpoint1")
+      check_output_includes(
+        "<error>'enable' must be followed 'display', 'breakpoints' or breakpoint numbers</error>",
+        interface.error_queue
+      )
+    end
+  end
+
+  describe "deleting a breakpoint" do
+    it "must show a success message" do
+      breakpoint_id = nil
+      enter "break 14", ->{breakpoint_id = breakpoint.id; "delete #{breakpoint_id}"}, "break 15"
+      debug_file("breakpoint1")
+      check_output_includes "<breakpointDeleted no=\"#{breakpoint_id}\"/>"
+    end
+  end
+
+  describe "Conditional breakpoints" do
+    it "must show an error when conditional syntax is wrong" do
+      enter "break 14 ifa b == 3", "break 15", "cont"
+      debug_file("breakpoint1") { state.line.must_equal 15 }
+      check_output_includes(
+        "<error>Expecting 'if' in breakpoint condition; got: ifa b == 3</error>",
+        interface.error_queue
+      )
+    end
+
+    describe "enabling with wrong conditional syntax" do
+      it "must show an error" do
+        enter(
+          "break 14",
+          ->{"disable #{breakpoint.id}"},
+          ->{"cond #{breakpoint.id} b -=( 3"},
+          ->{"enable #{breakpoint.id}"}
+        )
+        debug_file("breakpoint1")
+        check_output_includes(
+          "<error>Expression 'b -=( 3' syntactically incorrect; breakpoint remains disabled</error>",
+          interface.error_queue
+        )
+      end
+    end
+
+    it "must show an error if no file or line is specified" do
+      enter "break ifa b == 3", "break 15", "cont"
+      debug_file("breakpoint1") { state.line.must_equal 15 }
+      check_output_includes "<error>Invalid breakpoint location: ifa b == 3</error>", interface.error_queue
+    end
+
+    it "must show an error if expression syntax is invalid" do
+      enter "break if b -=) 3", "break 15", "cont"
+      debug_file("breakpoint1") { state.line.must_equal 15 }
+      check_output_includes(
+        "<error>Expression 'b -=) 3' syntactically incorrect; breakpoint disabled</error>",
+        interface.error_queue
+      )
+    end
+  end
+end