ruby-debug-ide-docker 0.6.1

data/Gemfile

@@ -0,0 +1,28 @@
+source "http://rubygems.org"
+
+# @param [Array<String>] versions compatible ruby versions
+# @return [Array<String>] an array with mri platforms of given versions
+def mries(*versions)
+  versions.flat_map do |v|
+    %w(ruby mingw x64_mingw)
+        .map { |platform| "#{platform}_#{v}".to_sym unless platform == "x64_mingw" && v < "2.0" }
+        .delete_if &:nil?
+  end
+end
+
+gem "ruby-debug-base", :platforms => [:jruby, *mries('18')]
+gem "ruby-debug-base19x", ">= 0.11.32", :platforms => mries('19')
+if RUBY_VERSION && RUBY_VERSION >= "2.0"
+  gem "debase", "~> 0.2.2", :platforms => mries('20', '21', '22', '23', '24', '25')
+end
+
+gemspec
+
+group :development do
+  gem "bundler"
+end
+
+group :test do
+  gem "test-unit"
+end
+

data/MIT-LICENSE

@@ -0,0 +1,24 @@
+The file lib/classic-debug.rb is based on the debug.rb file from Ruby
+project.
+
+Copyright (c) 2007-2008, debug-commons team
+
+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/Rakefile

@@ -0,0 +1,42 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => [:test]
+
+# Unit tests
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.libs << "test-base"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = false
+end
+
+desc "Create a ChangeLog"
+# simple rake task to output a changelog between two commits, tags ...
+# output is formatted simply, commits are grouped under each author name
+desc "generate changelog with nice clean output"
+task :changelog, :since_c, :until_c do |t,args|
+  since_c = args[:since_c] || `git tag | head -1`.chomp
+  until_c = args[:until_c]
+  cmd=`git log --pretty='format:%ci::%an <%ae>::%s::%H' #{since_c}..#{until_c}`
+
+  entries = Hash.new
+  changelog_content = String.new
+
+  cmd.split("\n").each do |entry|
+    date, author, subject, hash = entry.chomp.split("::")
+    entries[author] = Array.new unless entries[author]
+    day = date.split(" ").first
+    entries[author] << "#{subject} (#{hash})" unless subject =~ /Merge/
+  end
+
+  # generate clean output
+  entries.keys.each do |author|
+    changelog_content += author + "\n"
+    entries[author].reverse.each { |entry| changelog_content += "  * #{entry}\n" }
+  end
+
+  puts changelog_content
+end

data/bin/gdb_wrapper

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'thread'
+require 'ostruct'
+
+$stdout.sync = true
+$stderr.sync = true
+
+options = OpenStruct.new(
+    'pid' => nil,
+    'sdk_path' => nil,
+    'uid' => nil,
+    'gems_to_include' => []
+)
+
+module DebugPrinter
+
+  class << self
+    attr_accessor :cli_debug
+
+    def print_debug(msg)
+      if DebugPrinter.cli_debug
+        $stderr.puts msg
+      end
+    end
+  end
+
+end
+
+DebugPrinter.cli_debug = ARGV.include? '--debug'
+
+opts = OptionParser.new do |opts|
+  # TODO need some banner
+  opts.banner = <<EOB
+Some useful banner.
+EOB
+
+  opts.on('--pid PID', 'pid of process you want to attach to for debugging') do |pid|
+    options.pid = pid
+  end
+
+  opts.on('--ruby-path RUBY_PATH', 'path to ruby interpreter') do |ruby_path|
+    options.ruby_path = ruby_path
+  end
+
+  opts.on('--uid UID', 'uid which this process should set after executing gdb attach') do |uid|
+    options.uid = uid
+  end
+
+  opts.on('--include-gem GEM_LIB_PATH', 'lib of gem to include') do |gem_lib_path|
+    options.gems_to_include << gem_lib_path
+  end
+end
+
+opts.parse! ARGV
+
+unless options.pid
+  $stderr.puts 'You should specify PID of process you want to attach to'
+  exit 1
+end
+
+unless options.ruby_path
+  $stderr.puts 'You should specify path to the ruby interpreter'
+  exit 1
+end
+
+argv = '["' + ARGV * '", "' + '"]'
+child_argv = '["' + ARGV * '", "' + "', '--ignore-port" + '"]'
+debugger_loader_path = File.expand_path(File.dirname(__FILE__)) + '/../lib/ruby-debug-ide/attach/debugger_loader'
+
+options.gems_to_include.each do |gem_path|
+  $LOAD_PATH.unshift(gem_path) unless $LOAD_PATH.include?(gem_path)
+end
+
+require 'ruby-debug-ide/greeter'
+Debugger::print_greeting_msg($stdout, nil, nil)
+
+require 'ruby-debug-ide/attach/util'
+require 'ruby-debug-ide/attach/native_debugger'
+require 'ruby-debug-ide/attach/process_thread'
+
+
+child_pids = get_child_pids(options.pid.to_s)
+attach_threads = Array.new
+attach_threads << attach_and_return_thread(options, options.pid, debugger_loader_path, argv)
+
+attach_threads << child_pids.map {|pid| attach_and_return_thread(options, pid, debugger_loader_path, child_argv)}
+
+
+attach_threads.each {|thread| thread.join}
+if options.uid
+  DebugPrinter.print_debug("changing current uid from #{Process.uid} to #{options.uid}")
+  Process::Sys.setuid(options.uid.to_i)
+end
+sleep

data/bin/rdebug-ide

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'optparse'
+require "ostruct"
+if RUBY_VERSION < "1.9"
+  require 'ruby-debug-ide'
+else
+  require_relative '../lib/ruby-debug-ide'
+end
+
+$stdout.sync=true
+
+options = OpenStruct.new(
+    'frame_bind'  => false,
+    'host'        => nil,
+    'load_mode'   => false,
+    'port'        => 1234,
+    'stop'        => false,
+    'tracing'     => false,
+    'int_handler' => true,
+    'dispatcher_port' => -1,
+    'evaluation_timeout' => 10,
+    'trace_to_s' => false,
+    'debugger_memory_limit' => 10,
+    'inspect_time_limit' => 100,
+    'rm_protocol_extensions' => false,
+    'catchpoint_deleted_event' => false,
+    'value_as_nested_element' => false,
+    'attach_mode' => false,
+    'cli_debug' => false
+)
+
+opts = OptionParser.new do |opts|
+  opts.banner = <<EOB
+Using ruby-debug-base #{Debugger::VERSION}
+Usage: rdebug-ide is supposed to be called from RDT, NetBeans, RubyMine, or
+       the IntelliJ IDEA Ruby plugin.  The command line interface to
+       ruby-debug is rdebug.
+EOB
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("-h", "--host HOST", "Host name used for remote debugging") {|host| options.host = host}
+  opts.on("-p", "--port PORT", Integer, "Port used for remote debugging") {|port| options.port = port}
+  opts.on("--dispatcher-port PORT", Integer, "Port used for multi-process debugging dispatcher") do |dp|
+    options.dispatcher_port = dp
+  end
+  opts.on('--evaluation-timeout TIMEOUT', Integer,'evaluation timeout in seconds (default: 10)') do |timeout|
+    options.evaluation_timeout = timeout
+  end
+  opts.on("--evaluation-control", "trace to_s evaluation") {options.trace_to_s = true}
+
+  opts.on("-m", "--memory-limit LIMIT", Integer, "evaluation memory limit in mb (default: 10)") do |limit|
+    if defined?(JRUBY_VERSION) || RUBY_VERSION < '2.0'
+      $stderr.puts "Evaluation memory limit is ineffective in JRuby and MRI < 2.0"
+      limit = 0
+    end
+    options.debugger_memory_limit = limit
+    options.trace_to_s ||= limit > 0
+  end
+
+  opts.on("-t", "--time-limit LIMIT", Integer, "evaluation time limit in milliseconds (default: 100)") do |limit|
+    options.inspect_time_limit = limit
+    options.trace_to_s ||= limit > 0
+  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("-l", "--load-mode", "load mode (experimental)") {options.load_mode = true}
+  opts.on("-d", "--debug", "Debug self - prints information for debugging ruby-debug itself") do
+    Debugger.cli_debug = true
+    options.cli_debug = true
+  end
+  opts.on("--xml-debug", "Debug self - sends information <message>s for debugging ruby-debug itself") do
+    Debugger.xml_debug = true
+  end
+  opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
+    $LOAD_PATH.unshift(path)
+  end
+  opts.on("--attach-mode", "Tells that rdebug-ide is working in attach mode") do
+    options.attach_mode = true
+  end
+  opts.on("--ignore-port", "Generate another port") do
+    options.ignore_port = true
+  end
+  opts.on("--keep-frame-binding", "Keep frame bindings") {options.frame_bind = true}
+  opts.on("--disable-int-handler", "Disables interrupt signal handler") {options.int_handler = false}
+  opts.on("--rubymine-protocol-extensions", "Enable all RubyMine-specific incompatible protocol extensions") do
+    options.rm_protocol_extensions = true
+  end
+  opts.on("--catchpoint-deleted-event", "Enable chatchpointDeleted event") do
+    options.catchpoint_deleted_event = true
+  end
+  opts.on("--value-as-nested-element", "Allow to pass variable's value as nested element instead of attribute") do
+    options.value_as_nested_element = true
+  end
+  opts.separator ""
+  opts.separator "Common options:"
+  opts.on_tail("-v", "--version", "Show version") do
+    puts "Using ruby-debug-base #{Debugger::VERSION}"
+    exit
+  end
+end
+
+begin
+  Debugger::ARGV = ARGV.clone
+  rdebug_path = File.expand_path($0)
+  if RUBY_PLATFORM =~ /mswin/
+    rdebug_path += ".cmd" unless rdebug_path =~ /\.cmd$/i
+  end
+  Debugger::RDEBUG_SCRIPT = rdebug_path
+  opts.parse! ARGV
+rescue StandardError => e
+  puts opts
+  puts
+  puts e.message
+  exit(1)
+end
+
+if ARGV.empty? && !options.attach_mode
+  puts opts
+  puts
+  puts "Must specify a script to run"
+  exit(1)
+end
+
+# save script name
+if !options.attach_mode
+  Debugger::PROG_SCRIPT = ARGV.shift
+else
+  Debugger::PROG_SCRIPT = $0
+end
+
+if options.dispatcher_port != -1
+  ENV['IDE_PROCESS_DISPATCHER'] = options.dispatcher_port.to_s
+  if RUBY_VERSION < "1.9"
+    lib_path = File.expand_path(File.dirname(__FILE__) + "/../lib/")
+    $: << lib_path unless $:.include? lib_path
+    require 'ruby-debug-ide/multiprocess'
+  else
+    require_relative '../lib/ruby-debug-ide/multiprocess'
+  end
+  Debugger::MultiProcess.do_monkey
+
+  ENV['DEBUGGER_STORED_RUBYLIB'] = ENV['RUBYLIB']
+  old_opts = ENV['RUBYOPT'] || ''
+  starter = "-r#{File.expand_path(File.dirname(__FILE__))}/../lib/ruby-debug-ide/multiprocess/starter"
+  unless old_opts.include? starter
+    ENV['RUBYOPT'] = starter
+    ENV['RUBYOPT'] += " #{old_opts}" if old_opts != ''
+  end
+  ENV['DEBUGGER_CLI_DEBUG'] = Debugger.cli_debug.to_s
+end
+
+if options.int_handler
+  # install interruption handler
+  trap('INT') { Debugger.interrupt_last }
+end
+
+# set options
+Debugger.keep_frame_binding = options.frame_bind
+Debugger.tracing = options.tracing
+Debugger.evaluation_timeout = options.evaluation_timeout
+Debugger.trace_to_s = options.trace_to_s && (options.debugger_memory_limit > 0 || options.inspect_time_limit > 0)
+Debugger.debugger_memory_limit = options.debugger_memory_limit
+Debugger.inspect_time_limit = options.inspect_time_limit
+Debugger.catchpoint_deleted_event = options.catchpoint_deleted_event || options.rm_protocol_extensions
+Debugger.value_as_nested_element = options.value_as_nested_element || options.rm_protocol_extensions
+
+if options.attach_mode
+  if Debugger::FRONT_END == "debase"
+    Debugger.init_variables
+  end
+
+  Debugger::MultiProcess::pre_child(options)
+
+  if Debugger::FRONT_END == "debase"
+    Debugger.setup_tracepoints
+    Debugger.prepare_context
+  end
+else
+  Debugger.debug_program(options)
+end

data/ext/mkrf_conf.rb

@@ -0,0 +1,48 @@
+jruby = defined?(JRUBY_VERSION) || (defined?(RUBY_ENGINE) && 'jruby' == RUBY_ENGINE)
+rbx = defined?(RUBY_ENGINE) && 'rbx' == RUBY_ENGINE
+
+def already_installed(dep)
+  !Gem::DependencyInstaller.new(:domain => :local).find_gems_with_sources(dep).empty? ||
+  !Gem::DependencyInstaller.new(:domain => :local,:prerelease => true).find_gems_with_sources(dep).empty?    
+end
+
+unless jruby || rbx
+  require 'rubygems'
+  require 'rubygems/command.rb'
+  require 'rubygems/dependency.rb'
+  require 'rubygems/dependency_installer.rb'
+
+  begin
+    Gem::Command.build_args = ARGV
+    rescue NoMethodError
+  end
+
+  if RUBY_VERSION < "1.9"
+    dep = Gem::Dependency.new("ruby-debug-base", '>=0.10.4')
+  elsif RUBY_VERSION < '2.0'
+    dep = Gem::Dependency.new("ruby-debug-base19x", '>=0.11.30.pre15')
+  else    
+    dep = Gem::Dependency.new("debase", '> 0')
+  end
+
+  begin
+    puts "Installing base gem"
+    inst = Gem::DependencyInstaller.new :prerelease => dep.prerelease?
+    inst.install dep
+  rescue
+    begin
+      inst = Gem::DependencyInstaller.new(:prerelease => true)
+      inst.install dep
+    rescue Exception => e
+      puts e
+      puts e.backtrace.join "\n  "
+      exit(1)
+    end
+  end unless dep.nil? || already_installed(dep)
+end
+
+# create dummy rakefile to indicate success
+f = File.open(File.join(File.dirname(__FILE__), "Rakefile"), "w")
+f.write("task :default\n")
+f.close
+

data/lib/ruby-debug-ide.rb

@@ -0,0 +1,173 @@
+require 'pp'
+require 'stringio'
+require "socket"
+require 'thread'
+if RUBY_VERSION < '2.0' || defined?(JRUBY_VERSION)
+  require 'ruby-debug-base'
+  Debugger::FRONT_END = "ruby-debug-base"
+else
+  require 'debase'
+  Debugger::FRONT_END = "debase"
+end
+
+require 'ruby-debug-ide/greeter'
+require 'ruby-debug-ide/xml_printer'
+require 'ruby-debug-ide/ide_processor'
+require 'ruby-debug-ide/event_processor'
+
+module Debugger
+
+  class << self
+    # Prints to the stderr using printf(*args) if debug logging flag (-d) is on.
+    def print_debug(*args)
+      if Debugger.cli_debug
+        $stderr.printf("#{Process.pid}: ")
+        $stderr.printf(*args)
+        $stderr.printf("\n")
+        $stderr.flush
+      end
+    end
+
+    def cleanup_backtrace(backtrace)
+      cleared = []
+      return cleared unless backtrace
+      backtrace.each do |line|
+        if line.index(File.expand_path(File.dirname(__FILE__) + "/..")) == 0
+          next
+        end
+        if line.index("-e:1") == 0
+          break
+        end
+        cleared << line
+      end
+      cleared
+    end
+
+    attr_accessor :attached
+    attr_accessor :cli_debug, :xml_debug, :evaluation_timeout
+    attr_accessor :trace_to_s, :debugger_memory_limit, :inspect_time_limit
+    attr_accessor :control_thread
+    attr_reader :interface
+    # protocol extensions
+    attr_accessor :catchpoint_deleted_event, :value_as_nested_element
+
+
+    #
+    # Interrupts the last debugged thread
+    #
+    def interrupt_last
+      skip do
+        if context = last_context
+          return nil unless context.thread.alive?
+          context.interrupt
+        end
+        context
+      end
+    end
+
+    def start_server(host = nil, port = 1234, notify_dispatcher = false)
+      return if started?
+      start
+      start_control(host, port, notify_dispatcher)
+    end
+
+    def prepare_debugger(options)
+      @mutex = Mutex.new
+      @proceed = ConditionVariable.new
+
+      start_server(options.host, options.port, options.notify_dispatcher)
+
+      raise "Control thread did not start (#{@control_thread}}" unless @control_thread && @control_thread.alive?
+
+      # wait for 'start' command
+      @mutex.synchronize do
+        @proceed.wait(@mutex)
+      end
+    end
+
+    def debug_program(options)
+      prepare_debugger(options)
+
+      abs_prog_script = File.expand_path(Debugger::PROG_SCRIPT)
+      bt = debug_load(abs_prog_script, options.stop, options.load_mode)
+      if bt && !bt.is_a?(SystemExit)
+        $stderr.print "Uncaught exception: #{bt}\n"
+        $stderr.print Debugger.cleanup_backtrace(bt.backtrace).map{|l| "\t#{l}"}.join("\n"), "\n"
+      end
+    end
+
+    def run_prog_script
+      return unless @mutex
+      @mutex.synchronize do
+        @proceed.signal
+      end
+    end
+
+    def start_control(host, port, notify_dispatcher)
+      raise "Debugger is not started" unless started?
+      return if @control_thread
+      @control_thread = DebugThread.new do
+        begin
+          # 127.0.0.1 seemingly works with all systems and with IPv6 as well.
+          # "localhost" and nil have problems on some systems.
+          host ||= '127.0.0.1'
+          server = TCPServer.new(host, port)
+          print_greeting_msg($stderr, host, port) if defined? IDE_VERSION
+          notify_dispatcher(port) if notify_dispatcher
+          while (session = server.accept)
+            $stderr.puts "Connected from #{session.peeraddr[2]}" if Debugger.cli_debug
+            dispatcher = ENV['IDE_PROCESS_DISPATCHER']
+            if dispatcher
+              ENV['IDE_PROCESS_DISPATCHER'] = "#{session.peeraddr[2]}:#{dispatcher}" unless dispatcher.include?(":")
+              ENV['DEBUGGER_HOST'] = host
+            end
+            begin
+              @interface = RemoteInterface.new(session)
+              self.handler = EventProcessor.new(interface)
+              IdeControlCommandProcessor.new(interface).process_commands
+            rescue StandardError, ScriptError => ex
+              bt = ex.backtrace
+              $stderr.printf "#{Process.pid}: Exception in DebugThread loop: #{ex.message}(#{ex.class})\nBacktrace:\n#{bt ? bt.join("\n  from: ") : "<none>"}\n"
+              exit 1
+            end
+          end
+        rescue
+          bt = $!.backtrace
+          $stderr.printf "Fatal exception in DebugThread loop: #{$!.message}\nBacktrace:\n#{bt ? bt.join("\n  from: ") : "<none>"}\n"
+          exit 2
+        end
+      end
+    end
+
+    private
+
+
+    def notify_dispatcher(port)
+      return unless 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
+          print_debug "Ide process dispatcher notified about sub-debugger which listens on #{port}\n"
+          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
+
+  end
+
+  class Exception # :nodoc:
+    attr_reader :__debug_file, :__debug_line, :__debug_binding, :__debug_context
+  end
+end