debugger-xml 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+.rvmrc
+vendor/bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in debugger-xml.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Anton Astashov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+## Description
+
+This is a gem, which adds the XML printer to the 'debugger' gem, using the same API as
+the ruby-debug-ide gem, which allows it to be used with Ruby IDEs (for example, in my
+vim-ruby-debugger :))
+
+## Installation
+
+As usual, add it to your Gemfile, and you are all set
+
+    gem 'debugger-xml'
+
+## Usage
+
+There is the the bin/rdebug-ide file, check it out. For description of XML API,
+check http://debug-commons.rubyforge.org/protocol-spec.html, I tried to be
+compatible with it
+
+## Tests
+
+It uses debugger/test helpers. To run all tests, just do
+
+    rake test
+

data/Rakefile

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

data/bin/rdebug-ide

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+#
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'optparse'
+require 'ostruct'
+require 'debugger'
+require 'ruby-debug/ide_processor'
+
+$stdout.sync = true
+
+class RdebugIde
+
+  def initialize
+    check_argv!
+    Debugger.const_set("ARGV", ARGV.clone)
+    Debugger.const_set("RDEBUG_SCRIPT", rdebug_path)
+    install_interruption_hander
+    Debugger.tracing = options.tracing
+    Debugger.wait_for_start = options.wait_for_start
+    Debugger.wait_connection = true
+    Debugger.printer = Printers::Xml.new
+    Debugger.const_set("PROG_SCRIPT", ARGV.shift)
+  end
+
+  def run
+    Debugger.start_remote_ide(options.host, options.port)
+    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 rdebug_path
+      File.expand_path($0).tap do |path|
+        if RUBY_PLATFORM =~ /mswin/
+          rdebug_path << ".cmd" unless rdebug_path =~ /\.cmd$/i
+        end
+      end
+    end
+
+    def options
+      opts
+      @options
+    end
+
+    def opts
+      @opts ||= begin
+        @options = OpenStruct.new(host: "127.0.0.1", port: 12345, stop: false, tracing: false, wait_for_start: true)
+        opts = OptionParser.new do |opts|
+          opts.banner = %{
+            Using rdebug-ide
+            Usage: rdebug-ide is supposed to be called from RDT, NetBeans, RubyMine or
+            vim-ruby-debugger. The command line interface to 'debugger' is rdebug.
+          }.gsub(/^\s*/, '')
+          opts.separator ""
+          opts.separator "Options:"
+          opts.on("-h", "--host HOST", "Host name used for remote debugging") { |host| @options.host = host }
+          opts.on("--cport PORT", Integer, "Port used for control commands") { |cport| @options.cport = cport }
+          opts.on("-p", "--port PORT", Integer, "Port used for remote debugging") { |port| @options.port = port }
+          opts.on("--wait", String, "Wait for 'start' command") do |bool|
+            @options.wait_for_start = (bool == "false" ? false : true)
+          end
+          opts.on('--stop', 'stop when the script is loaded') { @options.stop = true }
+          opts.on("-x", "--trace", "turn on line tracing") { @options.tracing = true }
+          opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") { |path| $LOAD_PATH.unshift(path) }
+        end
+        opts.parse!
+        opts
+      end
+    end
+
+end
+
+RdebugIde.new.run

data/debugger-xml.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'debugger/xml/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "debugger-xml"
+  gem.version       = Debugger::Xml::VERSION
+  gem.authors       = ["Anton Astashov"]
+  gem.email         = ["anton.astashov@gmail.com"]
+  gem.description   = %q{XML interface for debugger}
+  gem.summary       = %q{Implements XML interface for the 'debugger' gem, compatible with ruby-debug-ide gem}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "debugger", '>= 1.5.0'
+  gem.add_dependency 'builder', '>= 2.0.0'
+  gem.add_development_dependency 'rake', '~> 0.9.2.2'
+  gem.add_development_dependency 'minitest', '~> 2.12.1'
+  gem.add_development_dependency 'mocha', '~> 0.13.0'
+end

data/lib/debugger/printers/texts/xml.yml

@@ -0,0 +1,121 @@
+general:
+  errors:
+    unsupported: "Unsupported command '{cmd}'"
+
+breakpoints:
+  set_breakpoint_to_line:
+    tag: breakpointAdded
+    attributes:
+      "no": "{id}"
+      location: "{file}:{line}"
+  set_breakpoint_to_method:
+    tag: breakpointAdded
+    attributes:
+      "no": "{id}"
+      method: "{class}::{method}"
+  stop_at_breakpoint:
+    tag: breakpoint
+    attributes:
+      file: "{file}"
+      line: "{line}"
+      threadId: "{thread_id}"
+  delete:
+    tag: breakpointDeleted
+    attributes:
+      "no": "{id}"
+
+conditions:
+  set_condition:
+    tag: conditionSet
+    attributes:
+      bp_id: "{id}"
+  unset_condition:
+    tag: conditionSet # Would ideally be conditionUnset, but we keep compatibility with old ruby-debug-ide
+    attributes:
+      bp_id: "{id}"
+
+display:
+  result:
+    tag: display
+    attributes:
+      key: "{exp}"
+      value: "{result}"
+
+eval:
+  exception:
+    tag: processingException
+    attributes:
+      type: "{class}"
+      message: "{value}"
+  result:
+    tag: eval
+    attributes:
+      expression: "{expr}"
+      value: "{result}"
+
+frame:
+  line:
+    tag: frame
+    attributes:
+      "no": "{pos}"
+      file: "{file}"
+      line: "{line}"
+      current: "{mark}"
+
+method:
+  methods:
+    tag: method
+    attributes:
+      name: "{name}"
+
+stop:
+  suspend:
+    tag: suspended
+    attributes:
+      file: "{file}"
+      line: "{line_number}"
+      threadId: "{thnum}"
+      frames: "{frames}"
+
+toggle:
+  breakpoint_enabled:
+    tag: breakpointEnabled
+    attributes:
+      bp_id: "{id}"
+  breakpoint_disabled:
+    tag: breakpointDisabled
+    attributes:
+      bp_id: "{id}"
+
+restart:
+  success:
+    tag: restart
+    attributes:
+      command: "{cmd}"
+
+set:
+  errors:
+    no_subcommand: "'set' must be followed by the name of a subcommand"
+
+show:
+  errors:
+    no_subcommand: "'show' must be followed by the name of a subcommand"
+
+thread:
+  context:
+    tag: thread
+    attributes:
+      id: "{id}"
+      status: "{status}"
+      current: "{current}"
+
+variable:
+  variable:
+    tag: variable
+    attributes:
+      name: "{name}"
+      kind: "{kind}"
+      value: "{value}"
+      type: "{type}"
+      hasChildren: "{has_children}"
+      objectId: "{id}"

data/lib/debugger/printers/xml.rb

@@ -0,0 +1,195 @@
+require 'ruby-debug/printers/base'
+require 'builder'
+
+module Printers
+  class Xml < Base
+
+    def print(path, args = {})
+      case parts(path)[1]
+      when "errors"
+        print_error(path, args)
+      when "confirmations"
+        print_confirmation(path, args)
+      when "debug"
+        print_debug(path, args)
+      when "messages"
+        print_message(path, args)
+      else
+        print_general(path, args)
+      end
+    end
+
+    def print_collection(path, collection, &block)
+      settings = locate(path)
+      xml = ::Builder::XmlMarkup.new
+      tag = translate(settings["tag"])
+      xml.tag!("#{tag}s") do |xml|
+        array_of_args(collection, &block).each do |args|
+          xml.tag!(tag, translated_attributes(settings["attributes"], args))
+        end
+      end
+    end
+
+    def print_variables(variables, global_kind)
+      print_collection("variable.variable", variables) do |(key, value, kind), index|
+        Variable.new(key, value, kind || global_kind).to_hash
+      end
+    end
+
+    def print_instance_variables(object)
+      variables = if object.is_a?(Array)
+        object.each.with_index.map { |item, index| ["[#{index}]", item, 'instance'] }
+      elsif object.is_a?(Hash)
+        object.map { |key, value| [key.is_a?(String) ? "'#{key}'" : key.to_s, value, 'instance'] }
+      else
+        AllVariables.new(object).variables
+      end
+      print_variables(variables, nil)
+    end
+
+    private
+
+      def print_general(path, args)
+        settings = locate(path)
+        xml = ::Builder::XmlMarkup.new
+        tag = translate(settings["tag"], args)
+        attributes = translated_attributes(settings["attributes"], args)
+        xml.tag!(tag, attributes)
+      end
+
+      def print_debug(path, args)
+        translate(locate(path), args)
+      end
+
+      def print_error(path, args)
+        xml = ::Builder::XmlMarkup.new
+        xml.error { print_content(xml, path, args) }
+      end
+
+      def print_confirmation(path, args)
+        xml = ::Builder::XmlMarkup.new
+        xml.confirmation { print_content(xml, path, args) }
+      end
+
+      def print_message(path, args)
+        xml = ::Builder::XmlMarkup.new
+        xml.message { print_content(xml, path, args) }
+      end
+
+      def print_content(xml, path, args)
+        xml.text!(translate(locate(path), args))
+      end
+
+      def translated_attributes(attributes, args)
+        attributes.inject({}) do |hash, (key, value)|
+          hash[key] = translate(value, args)
+          hash
+        end
+      end
+
+      def contents_files
+        [File.expand_path(File.join("..", "texts", "xml.yml"), __FILE__)] + super
+      end
+
+    class Variable
+      attr_reader :name, :kind
+      def initialize(name, value, kind = nil)
+        @name = name.to_s
+        @value = value
+        @kind = kind
+      end
+
+      def has_children?
+        if @value.is_a?(Array) || @value.is_a?(Hash)
+          !@value.empty?
+        else
+          !@value.instance_variables.empty? || !@value.class.class_variables.empty?
+        end
+      rescue
+        false
+      end
+
+      def value
+        if @value.is_a?(Array) || @value.is_a?(Hash)
+          if has_children?
+            "#{@value.class} (#{@value.size} element(s))"
+          else
+            "Empty #{@value.class}"
+          end
+        else
+          value_str = @value.nil? ? 'nil' : @value.to_s
+          if !value_str.is_a?(String)
+            "ERROR: #{@value.class}.to_s method returns #{value_str.class}. Should return String."
+          elsif binary_data?(value_str)
+            "[Binary Data]"
+          else
+            value_str.gsub(/^(")(.*)(")$/, '\2')
+          end
+        end
+      rescue => e
+        "<raised exception: #{e}>"
+      end
+
+      def id
+        @value.respond_to?(:object_id) ? "%#+x" % @value.object_id : nil
+      rescue
+        nil
+      end
+
+      def type
+        @value.class
+      rescue
+        "Undefined"
+      end
+
+      def to_hash
+        {name: @name, kind: @kind, value: value, type: type, has_children: has_children?, id: id}
+      end
+
+      private
+
+        def binary_data?(string)
+          string.count("\x00-\x7F", "^ -~\t\r\n").fdiv(string.size) > 0.3 || string.index("\x00") unless string.empty?
+        end
+    end
+
+    class AllVariables
+      def initialize(object)
+        @object = object
+        @instance_binding = object.instance_eval{binding()}
+        @class_binding = object.class.class_eval('binding()')
+
+        @instance_variable_names = object.instance_variables
+        @self_variable_name = @instance_variable_names.delete('self')
+        @class_variable_names = object.class.class_variables
+      end
+
+      def variables
+        self_variables + instance_variables + class_variables
+      end
+
+      private
+
+        def instance_variables
+          @instance_variable_names.map do |var|
+            [var.to_s, (eval(var.to_s, @instance_binding) rescue "<raised exception>"), 'instance']
+          end
+        end
+
+        def self_variables
+          if @self_variable_name
+            [@self_variable_name, (eval(@self_variable_name, @instance_binding)), 'instance']
+          else
+            []
+          end
+        end
+
+        def class_variables
+          @class_variable_names.map do |var|
+            [var.to_s, (eval(var.to_s, @class_binding) rescue "<raised exception>"), 'class']
+          end
+        end
+    end
+
+  end
+end