ruby-debug-ide19 0.4.10

data/lib/ruby-debug/xml_printer.rb

@@ -0,0 +1,268 @@
+require 'cgi'
+require 'yaml'
+
+module Debugger
+
+  class XmlPrinter # :nodoc:
+    attr_accessor :interface
+    
+    def initialize(interface)
+      @interface = interface
+    end
+    
+    def print_msg(*args)
+      msg, *args = args
+      xml_message = CGI.escapeHTML(msg % args)
+      print "<message>#{xml_message}</message>"
+    end
+
+    # Sends debug message to the frontend if XML debug logging flag (--xml-debug) is on.
+    def print_debug(*args)
+      Debugger.print_debug(*args)
+      if Debugger.xml_debug
+        msg, *args = args
+        xml_message = CGI.escapeHTML(msg % args)
+        @interface.print("<message debug='true'>#{xml_message}</message>")
+      end
+    end
+
+    def print_error(*args)
+      print_element("error") do
+        msg, *args = args
+        print CGI.escapeHTML(msg % args)
+      end
+    end
+    
+    def print_frames(context, current_frame_id)
+      print_element("frames") do
+        (0...context.stack_size).each do |id|
+          print_frame(context, id, current_frame_id)
+        end
+      end
+    end
+    
+    def print_current_frame(frame_pos)
+      print_debug "Selected frame no #{frame_pos}"
+    end
+    
+    def print_frame(context, frame_id, current_frame_id)
+      # idx + 1: one-based numbering as classic-debugger
+      file = context.frame_file(frame_id)
+      print "<frame no=\'%s\' file=\'%s\' line=\'%s\' #{"current='true' " if frame_id == current_frame_id}/>",
+        frame_id + 1, File.expand_path(file), context.frame_line(frame_id)
+    end
+    
+    def print_contexts(contexts)
+      print_element("threads") do
+        contexts.each do |c|
+          print_context(c) unless c.ignored?
+        end
+      end
+    end
+    
+    def print_context(context)
+      current = 'current="yes"' if context.thread == Thread.current
+      print "<thread id=\"%s\" status=\"%s\" #{current}/>", context.thnum, context.thread.status
+    end
+    
+    def print_variables(vars, kind)
+      print_element("variables") do
+        # print self at top position
+        print_variable('self', yield('self'), kind) if vars.include?('self')
+        vars.sort.each do |v|
+          print_variable(v, yield(v), kind) unless v == 'self'
+        end
+      end
+    end
+    
+    def print_array(array)
+      print_element("variables") do
+        index = 0 
+        array.each { |e|
+          print_variable('[' + index.to_s + ']', e, 'instance') 
+          index += 1 
+        }
+      end
+    end
+    
+    def print_hash(hash)
+      print_element("variables") do
+        hash.keys.each { | k |
+          if k.class.name == "String"
+            name = '\'' + k + '\''
+          else
+            name = k.to_s
+          end
+          print_variable(name, hash[k], 'instance') 
+        }
+      end
+    end
+    
+    def print_variable(name, value, kind)
+      name = name.to_s
+      unless value
+        print("<variable name=\"%s\" kind=\"%s\"/>", CGI.escapeHTML(name), kind)
+        return
+      end
+      if value.is_a?(Array) || value.is_a?(Hash)
+        has_children = !value.empty?
+        unless has_children
+          value_str = "Empty #{value.class}"
+        else
+          value_str = "#{value.class} (#{value.size} element(s))"
+        end
+      else
+        has_children = !value.instance_variables.empty? || !value.class.class_variables.empty?
+        value_str = value.to_s || 'nil' rescue "<#to_s method raised exception: #$!>"
+        unless value_str.is_a?(String)
+          value_str = "ERROR: #{value.class}.to_s method returns #{value_str.class}. Should return String." 
+        end
+        if value_str =~ /^\"(.*)"$/
+          value_str = $1
+        end
+      end
+      value_str = "[Binary Data]" if value_str.is_binary_data?
+      print("<variable name=\"%s\" kind=\"%s\" value=\"%s\" type=\"%s\" hasChildren=\"%s\" objectId=\"%#+x\"/>",
+          CGI.escapeHTML(name), kind, CGI.escapeHTML(value_str), value.class,
+          has_children, value.respond_to?(:object_id) ? value.object_id : value.id)
+    end
+    
+    def print_breakpoints(breakpoints)
+      print_element 'breakpoints' do
+        breakpoints.sort_by{|b| b.id }.each do |b|
+          print "<breakpoint n=\"%d\" file=\"%s\" line=\"%s\" />", b.id, b.source, b.pos.to_s
+        end
+      end
+    end
+    
+    def print_breakpoint_added(b)
+      print "<breakpointAdded no=\"%s\" location=\"%s:%s\"/>", b.id, b.source, b.pos
+    end
+    
+    def print_breakpoint_deleted(b)
+      print "<breakpointDeleted no=\"%s\"/>", b.id
+    end
+    
+    def print_breakpoint_enabled(b)
+      print "<breakpointEnabled bp_id=\"%s\"/>", b.id
+    end
+    
+    def print_breakpoint_disabled(b)
+      print "<breakpointDisabled bp_id=\"%s\"/>", b.id
+    end
+    
+    def print_contdition_set(bp_id)
+      print "<conditionSet bp_id=\"%d\"/>", bp_id
+    end
+
+    def print_catchpoint_set(exception_class_name)
+      print "<catchpointSet exception=\"%s\"/>", exception_class_name
+    end
+
+    def print_expressions(exps)
+      print_element "expressions" do
+        exps.each_with_index do |(exp, value), idx|
+          print_expression(exp, value, idx+1)
+        end
+      end unless exps.empty?
+    end
+    
+    def print_expression(exp, value, idx)
+      print "<dispay name=\"%s\" value=\"%s\" no=\"%d\" />", exp, value, idx
+    end
+    
+    def print_eval(exp, value)
+      print "<eval expression=\"%s\" value=\"%s\" />",  CGI.escapeHTML(exp), value
+    end
+    
+    def print_pp(value)
+      print value
+    end
+    
+    def print_list(b, e, file, line)
+      print "[%d, %d] in %s\n", b, e, file
+      if lines = Debugger.source_for(file)
+        b.upto(e) do |n|
+          if n > 0 && lines[n-1]
+            if n == line
+              print "=> %d  %s\n", n, lines[n-1].chomp
+            else
+              print "   %d  %s\n", n, lines[n-1].chomp
+            end
+          end
+        end
+      else
+        print "No sourcefile available for %s\n", file
+      end
+    end
+    
+    def print_methods(methods)
+      print_element "methods" do
+        methods.each do |method|
+          print "<method name=\"%s\" />", method
+        end
+      end
+    end
+    
+    # Events
+    
+    def print_breakpoint(n, breakpoint)
+      print("<breakpoint file=\"%s\" line=\"%s\" threadId=\"%d\"/>", 
+      breakpoint.source, breakpoint.pos, Debugger.current_context.thnum)
+    end
+    
+    def print_catchpoint(exception)
+      context = Debugger.current_context
+      print("<exception file=\"%s\" line=\"%s\" type=\"%s\" message=\"%s\" threadId=\"%d\"/>", 
+      context.frame_file(0), context.frame_line(0), exception.class, CGI.escapeHTML(exception.to_s), context.thnum)
+    end
+    
+    def print_trace(context, file, line)
+      Debugger::print_debug "trace: location=\"%s:%s\", threadId=%d", file, line, context.thnum
+      # TBD: do we want to clog fronend with the <trace> elements? There are tons of them.
+      # print "<trace file=\"%s\" line=\"%s\" threadId=\"%d\" />", file, line, context.thnum
+    end
+    
+    def print_at_line(context, file, line)
+      print "<suspended file=\'%s\' line=\'%s\' threadId=\'%d\' frames=\'%d\'/>",
+        File.expand_path(file), line, context.thnum, context.stack_size
+    end
+    
+    def print_exception(exception, binding)
+      print "<processingException type=\"%s\" message=\"%s\"/>", 
+        exception.class, CGI.escapeHTML(exception.to_s)
+    end
+    
+    def print_inspect(eval_result)
+      print_element("variables") do 
+        print_variable("eval_result", eval_result, 'local')
+      end
+    end
+    
+    def print_load_result(file, exception=nil)
+      if exception then
+        print("<loadResult file=\"%s\" exceptionType=\"%s\" exceptionMessage=\"%s\"/>", file, exception.class, CGI.escapeHTML(exception.to_s))        
+      else
+        print("<loadResult file=\"%s\" status=\"OK\"/>", file)        
+       end    
+    end
+
+    def print_element(name)
+      print("<#{name}>")
+      begin
+        yield
+      ensure
+        print("</#{name}>")
+      end
+    end
+
+    private
+    
+    def print(*params)
+      Debugger::print_debug(*params)
+      @interface.print(*params)
+    end
+    
+  end
+
+end

data/test/rd_basic_test.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'basic_test'
+require 'rd_test_base'
+
+class RDSteppingAndBreakpointsTest < RDTestBase
+
+  include BasicTest
+
+end

data/test/rd_catchpoint_test.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'rd_test_base'
+
+class RDCatchpointTest < RDTestBase
+
+  def test_catchpoint_basics
+    create_socket ['sleep 0.01', '5/0', 'sleep 0.01']
+    run_to_line(1)
+    send_next
+    assert_suspension(@test_path, 2, 1)
+    send_ruby('catch ZeroDivisionError')
+    assert_catchpoint_set('ZeroDivisionError')
+    send_next
+    assert_exception(@test_path, 2, 'ZeroDivisionError')
+    send_next
+  end
+  
+end
+

data/test/rd_condition_test.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'rd_test_base'
+require 'condition_test'
+
+class RDConditionTest < RDTestBase
+
+  include ConditionTest
+
+end
+

data/test/rd_enable_disable_test.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'rd_test_base'
+
+class RDEnableDisableTest < RDTestBase
+
+  def test_enable_disable_basics
+    create_socket ['1.upto(10) do', 'sleep 0.01', 'sleep 0.01', 'end']
+    
+    send_test_breakpoint(2)
+    assert_breakpoint_added_no(1)
+    send_test_breakpoint(3)
+    assert_breakpoint_added_no(2)
+    
+    start_debugger
+    assert_test_breakpoint(2)
+    send_cont
+    assert_test_breakpoint(3)
+    send_cont
+    assert_test_breakpoint(2)
+    send_ruby('disable 2')
+    assert_breakpoint_disabled(2)
+    send_cont
+    assert_test_breakpoint(2)
+    send_cont
+    assert_test_breakpoint(2)
+    send_ruby('enable 2')
+    assert_breakpoint_enabled(2)
+    send_cont
+    assert_test_breakpoint(3)
+    send_cont
+    assert_test_breakpoint(2)
+    send_cont
+    assert_test_breakpoint(3)
+    send_ruby('disable 1')
+    assert_breakpoint_disabled(1)
+    send_ruby('disable 2')
+    assert_breakpoint_disabled(2)
+    send_cont
+  end
+
+end
+

data/test/rd_inspect_test.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'rd_test_base'
+require 'inspect_test'
+
+class RDInspectTest < RDTestBase
+
+  include InspectTest
+
+end
+

data/test/rd_stepping_breakpoints_test.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'rd_test_base'
+require 'stepping_breakpoints_test'
+
+class RDSteppingAndBreakpointsTest < RDTestBase
+
+  include SteppingAndBreakpointsTest
+
+  def test_hit_breakpoint_while_stepping_over
+    create_test2 ["class Test2", "def print", "puts 'XX'", "puts 'XX'", "end", "end"]
+    create_socket ["require 'test2.rb'", "Test2.new.print", "puts 'a'"]
+    send_ruby("b #{@test2_name}:4")
+    assert_breakpoint_added_no(1)
+    run_to_line(2)
+    send_next
+    assert_breakpoint(@test2_name, 4)
+    send_cont
+  end
+
+  def test_breakpoint_and_continue_from_other_file
+    create_test2 ["class Test2", "def print12", "puts 'one'","puts 'two'", "end", "end"]
+    create_socket ["require 'test2.rb'", "Test2.new.print12", "puts 'three'"]
+    send_test_breakpoint(2)
+    assert_breakpoint_added_no(1)
+    send_ruby("b #{@test2_name}:4")
+    assert_breakpoint_added_no(2)
+    start_debugger
+    assert_test_breakpoint(2)
+    send_next # test:1 -> test2:4
+    assert_breakpoint(@test2_name, 4)
+    send_cont # test2:4 -> test:3
+  end
+
+end
+

data/test/rd_test_base.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "test-base")
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test_base'
+
+class RDTestBase < TestBase
+
+  def setup
+    super
+    @rdebug_ide = config_load('rdebug_ide', true) || find_rdebug_ide
+    unless @rdebug_ide and File.exist?(@rdebug_ide)
+      @fast_fail = true
+      assert_not_nil(@rdebug_ide, "Cannot find rdebug-ide executable. " +
+          "Neither set in the config(.private).yaml nor found on the PATH")
+      assert(false, "#{@rdebug_ide} exist")
+    end
+  end
+
+  def debug_command(script, port)
+    cmd = "#{interpreter}"
+    cmd << " --debug" if jruby?
+    cmd << " -J-Xdebug -J-Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=y" if jruby? and debug_jruby?
+    cmd << " -I '#{File.dirname(script)}' #{@rdebug_ide} _0.4.9_" +
+      (@verbose_server ? " -d" : "") +
+      " -p #{port} -- '#{script}'"
+  end
+
+  def start_debugger
+    send_ruby("start")
+  end
+
+  private
+
+  def find_rdebug_ide
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
+      rdebug_ide = File.join(dir, 'rdebug-ide')
+      return rdebug_ide if File.exists?(rdebug_ide)
+    end
+    nil
+  end
+
+end