ruby-debug-ide22 0.7.4

data/Rakefile

@@ -0,0 +1,93 @@
+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
+
+desc "Generates travis.yaml"
+task :gen_travis do
+  versions = []
+
+  def versions.add(major:, minor:, include_macos: true)
+    self << { major: major, minor: [minor], include_macos: include_macos }
+  end
+
+  versions.add major: '3.0', minor: 1
+  versions.add major: '2.7', minor: 3
+  versions.add major: '2.6', minor: 7
+  versions.add major: '2.5', minor: 9
+  versions.add major: '2.4', minor: 10
+  versions.add major: '2.3', minor: 8, include_macos: false
+  versions.add major: '2.2', minor: 10, include_macos: false
+  versions.add major: '2.1', minor: 10, include_macos: false
+  versions.add major: '2.0', minor: 0, include_macos: false
+  versions.add major: '1.9', minor: 3, include_macos: false
+  versions.add major: '1.8', minor: 7, include_macos: false
+
+  puts <<EOM
+language: ruby
+dist: trusty
+matrix:
+  fast_finish: true
+  include:
+EOM
+
+  loop do
+    found_some = false
+
+    versions.each do |version|
+      minor = version[:minor].pop
+      if minor
+        found_some = true
+        full_version = "#{version[:major]}.#{minor}"
+        puts <<EOM
+    - os: linux
+      rvm: #{full_version}
+EOM
+        puts <<EOM if version[:include_macos]
+    - os: osx
+      rvm: #{full_version}
+EOM
+      end
+    end
+
+    break unless found_some
+  end
+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,200 @@
+#!/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,
+    'skip_wait_for_start' => false,
+    'keep_process_alive' => 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,
+    'key_value_mode' => false,
+    'socket_path' => nil
+)
+
+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("--skip_wait_for_start", "skip wait for 'start' command") {options.skip_wait_for_start = true}
+  opts.on("--keep-process-alive", "don't exit the process when debugger is exited") {options.keep_process_alive = 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("--key-value", "Key/Value presentation of hash items") do
+    options.key_value_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.on("--socket-path PATH", "Listen for debugger on the given UNIX domain socket path") do |path|
+    options.socket_path = path
+  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
+
+if options.keep_process_alive
+  ENV['DEBUGGER_KEEP_PROCESS_ALIVE'] = "true"
+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
+Debugger.key_value_mode = options.key_value_mode
+
+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,44 @@
+install_dir = File.expand_path("../../../..", __FILE__)
+jruby = defined?(JRUBY_VERSION) || (defined?(RUBY_ENGINE) && 'jruby' == RUBY_ENGINE)
+rbx = defined?(RUBY_ENGINE) && 'rbx' == RUBY_ENGINE
+
+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?, :install_dir => install_dir)
+    inst.install dep
+  rescue
+    begin
+      inst = Gem::DependencyInstaller.new(:prerelease => true, :install_dir => install_dir)
+      inst.install dep
+    rescue Exception => e
+      puts e
+      puts e.backtrace.join "\n  "
+      exit(1)
+    end
+  end unless dep.nil? || dep.matching_specs.any?
+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/attach/debugger_loader.rb

@@ -0,0 +1,20 @@
+def load_debugger(gems_to_include, new_argv)
+  path_to_rdebug = File.expand_path(File.dirname(__FILE__)) + '/../../../bin/rdebug-ide'
+
+  old_argv = ARGV.clone
+  ARGV.clear
+  new_argv.each do |x|
+    ARGV << x
+  end
+
+  gems_to_include.each do |gem_path|
+    $LOAD_PATH.unshift(gem_path) unless $LOAD_PATH.include?(gem_path)
+  end
+
+  load path_to_rdebug
+  
+  ARGV.clear
+  old_argv.each do |x|
+    ARGV << x
+  end
+end

data/lib/ruby-debug-ide/attach/gdb.rb

@@ -0,0 +1,73 @@
+require 'ruby-debug-ide/attach/native_debugger'
+
+class GDB < NativeDebugger
+
+  def initialize(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+    super(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+  end
+
+  def set_flags
+    execute 'set scheduler-locking off' # we will deadlock with it
+    execute 'set unwindonsignal on'     # in case of some signal we will exit gdb
+  end
+
+  def update_threads
+    @process_threads = []
+    info_threads = (execute 'info threads').split("\n")
+    info_threads.each do |thread_info|
+      next unless thread_info =~ /[\s*]*\d+\s+Thread.*/
+      $stdout.puts "thread_info: #{thread_info}"
+      is_main = thread_info[0] == '*'
+      thread_num = thread_info.sub(/[\s*]*/, '').sub(/\s.*$/, '').to_i
+      thread = ProcessThread.new(thread_num, is_main, thread_info, self)
+      if thread.is_main
+        @main_thread = thread
+      end
+      @process_threads << thread
+    end
+    @process_threads
+  end
+
+  def check_already_under_debug
+    threads = execute 'info threads'
+    threads =~ /ruby-debug-ide/
+  end
+
+  def switch_to_thread(thread_num)
+    execute "thread #{thread_num}"
+  end
+
+  def set_break(str)
+    execute "tbreak #{str}"
+  end
+
+  def call_start_attach
+    super()
+    execute "call dlopen(\"#{@path_to_attach}\", 2)"
+    execute 'call debase_start_attach()'
+    set_break(@tbreak)
+  end
+
+  def print_delimiter
+    @pipe.puts "print \"#{@delimiter}\""
+  end
+
+  def check_delimiter(line)
+    line =~ /\$\d+\s=\s"#{@delimiter}"/
+  end
+
+  def load_debugger
+    execute "call #{@eval_string}"
+  end
+
+  def to_s
+    GDB.to_s
+  end
+
+  class << self
+    def to_s
+      'gdb'
+    end
+  end
+
+end

data/lib/ruby-debug-ide/attach/lldb.rb

@@ -0,0 +1,71 @@
+require 'ruby-debug-ide/attach/native_debugger'
+
+class LLDB < NativeDebugger
+
+  def initialize(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+    super(executable, pid, flags, gems_to_include, debugger_loader_path, argv)
+  end
+
+  def set_flags
+
+  end
+
+  def update_threads
+    @process_threads = []
+    info_threads = (execute 'thread list').split("\n")
+    info_threads.each do |thread_info|
+      next unless thread_info =~ /[\s*]*thread\s#\d+.*/
+      is_main = thread_info[0] == '*'
+      thread_num = thread_info.sub(/[\s*]*thread\s#/, '').sub(/:\s.*$/, '').to_i
+      thread = ProcessThread.new(thread_num, is_main, thread_info, self)
+      if thread.is_main
+        @main_thread = thread
+      end
+      @process_threads << thread
+    end
+    @process_threads
+  end
+
+  def check_already_under_debug
+    threads = execute 'thread list'
+    threads =~ /ruby-debug-ide/
+  end
+
+  def switch_to_thread(thread_num)
+    execute "thread select #{thread_num}"
+  end
+
+  def set_break(str)
+    execute "breakpoint set --shlib #{@path_to_attach} --name #{str}"
+  end
+
+  def call_start_attach
+    super()
+    execute "expr (void *) dlopen(\"#{@path_to_attach}\", 2)"
+    execute 'expr (int) debase_start_attach()'
+    set_break(@tbreak)
+  end
+
+  def print_delimiter
+    @pipe.puts "script print \"#{@delimiter}\""
+  end
+
+  def check_delimiter(line)
+    line =~ /#{@delimiter}$/
+  end
+
+  def load_debugger
+    execute "expr (void) #{@eval_string}"
+  end
+
+  def to_s
+    LLDB.to_s
+  end
+
+  class << self
+    def to_s
+      'lldb'
+    end
+  end
+
+end