ruby-debug-ide 0.1.2

data/bin/rdebug-ide

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'optparse'
+require "ostruct"
+require 'ruby-debug'
+
+$stdout.sync=true
+
+options = OpenStruct.new(
+  'host'        => nil,
+  'port'        => 1234,
+  'tracing'     => false,
+  'frame_bind'  => false
+)
+
+opts = OptionParser.new do |opts|
+  opts.banner = <<EOB
+Using ruby-debug-base #{Debugger::VERSION}
+Usage: rdebug-javaide is supposed to be called from RDT or NetBeans. 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") {|options.host|}
+  opts.on("-p", "--port PORT", Integer, "Port used for remote debugging") {|options.port|}
+  opts.on("-x", "--trace", "turn on line tracing") {options.tracing = true}
+  opts.on("-d", "--debug", "Debug self - prints information for debugging ruby-debug itself") do
+    Debugger.is_debug = true
+  end
+  opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
+    $LOAD_PATH.unshift(path)
+  end
+  
+  opts.on("--keep-frame-binding", "Keep frame bindings") {options.frame_bind = true}
+  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?
+  puts opts
+  puts
+  puts "Must specify a script to run"
+  exit(1)
+end    
+
+# save script name
+Debugger::PROG_SCRIPT = ARGV.shift
+  
+# install interruption handler
+trap('INT') { Debugger.interrupt_last }
+  
+# set options
+Debugger.keep_frame_binding = options.frame_bind
+
+Debugger.main(options.host, options.port)

data/lib/ruby-debug.rb

@@ -0,0 +1,128 @@
+require 'pp'
+require 'stringio'
+require "socket"
+require 'thread'
+require 'ruby_debug.so'
+require 'ruby-debug/xml_printer'
+require 'ruby-debug/processor'
+require 'ruby-debug/event_processor'
+
+module Debugger
+  
+  class Context
+    def interrupt
+      self.stop_next = 1
+    end
+    
+    private
+    
+    def processor
+      Debugger.processor
+    end
+    
+    def at_breakpoint(breakpoint)
+      processor.at_breakpoint(self, breakpoint)
+    end
+    
+    def at_catchpoint(excpt)
+      processor.at_catchpoint(self, excpt)
+    end
+    
+    def at_tracing(file, line)
+      processor.at_tracing(self, file, line)
+    end
+    
+    def at_line(file, line)
+      processor.at_line(self, file, line)
+    end
+  end
+  
+  class << self
+    attr_accessor :processor, :is_debug
+    attr_reader :control_thread
+    
+    #
+    # Interrupts the current thread
+    #
+    def interrupt
+      current_context.interrupt
+    end
+    
+    #
+    # 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 main(host, port)
+      return if started?
+      
+      start
+      
+      start_control(host, port)
+      
+      @mutex = Mutex.new
+      @proceed = ConditionVariable.new
+      
+      # wait for start command
+      @mutex.synchronize do
+        @proceed.wait(@mutex)
+      end 
+      
+      debug_load Debugger::PROG_SCRIPT
+    end
+    
+    def run_prog_script
+      @mutex.synchronize do
+        @proceed.signal
+      end
+    end
+    
+    def start_control(host, port)
+      raise "Debugger is not started" unless started?
+      return if @control_thread
+      @control_thread = DebugThread.new do
+        server = TCPServer.new(host, port)
+        while (session = server.accept)
+          begin
+            interface = RemoteInterface.new(session)
+            @processor = EventProcessor.new(interface)
+            processor = ControlCommandProcessor.new(interface)
+            processor.process_commands
+          rescue StandardError, ScriptError => ex
+            puts ex
+          end
+        end
+      end
+    end
+    
+  end
+  
+  class Exception # :nodoc:
+    attr_reader :__debug_file, :__debug_line, :__debug_binding, :__debug_context
+  end
+  
+  module Kernel
+    #
+    # Stops the current thread after a number of _steps_ made.
+    #
+    def debugger(steps = 1)
+      Debugger.current_context.stop_next = steps
+    end
+    
+    #
+    # Returns a binding of n-th call frame
+    #
+    def binding_n(n = 0)
+      Debugger.current_context.frame_binding[n+1]
+    end
+  end
+  
+end

data/lib/ruby-debug/command.rb

@@ -0,0 +1,114 @@
+module Debugger
+  class Command # :nodoc:
+    class << self
+      def commands
+        @commands ||= []
+      end
+      
+      DEF_OPTIONS = {
+        :event => true, 
+        :control => false, 
+        :unknown => false,
+        :need_context => false,
+      }
+      
+      def inherited(klass)
+        DEF_OPTIONS.each do |o, v|
+          klass.options[o] = v if klass.options[o].nil?
+        end
+        commands << klass
+      end
+
+      def load_commands
+        dir = File.dirname(__FILE__)
+        Dir[File.join(dir, 'commands', '*')].each do |file|
+          require file if file =~ /\.rb$/
+        end
+      end
+      
+      def method_missing(meth, *args, &block)
+        if meth.to_s =~ /^(.+?)=$/
+          @options[$1.intern] = args.first
+        else
+          if @options.has_key?(meth)
+            @options[meth]
+          else
+            super
+          end
+        end
+      end
+      
+      def options
+        @options ||= {}
+      end
+    end
+
+    def initialize(state, printer)
+      @state, @printer = state, printer
+    end
+
+    def match(input)
+      @match = regexp.match(input)
+    end
+
+    protected
+    
+    def method_missing(meth, *args, &block)
+      if @printer.respond_to? meth
+        @printer.send meth, *args, &block
+      else
+        super
+      end
+    end
+
+    def print(*args)
+      @state.print(*args)
+    end
+
+    def confirm(msg)
+      @state.confirm(msg) == 'y'
+    end
+
+    def debug_eval(str, b = get_binding)
+      begin
+        val = eval(str, b)
+      rescue StandardError, ScriptError => e
+        @printer.print_exception(e, @state.binding) 
+        throw :debug_error
+      end
+    end
+
+    def debug_silent_eval(str)
+      begin
+        eval(str, get_binding)
+      rescue StandardError, ScriptError
+        nil
+      end
+    end
+
+    def hbinding(hash)
+      code = hash.keys.map{|k| "#{k} = hash['#{k}']"}.join(';') + ';binding'
+      if obj = @state.context.frame_self(@state.frame_pos)
+        obj.instance_eval code
+      else
+        eval code
+      end
+    end
+    private :hbinding
+ 
+    def get_binding
+      binding = @state.context.frame_binding(@state.frame_pos)
+      binding || hbinding(@state.context.frame_locals(@state.frame_pos))
+    end
+
+    def line_at(file, line)
+      Debugger.line_at(file, line)
+    end
+
+    def get_context(thnum)
+      Debugger.contexts.find{|c| c.thnum == thnum}
+    end
+  end
+  
+  Command.load_commands
+end

data/lib/ruby-debug/commands/breakpoints.rb

@@ -0,0 +1,126 @@
+module Debugger
+  class AddBreakpoint < Command # :nodoc:
+    self.control = true
+    
+    def regexp
+      / ^\s*
+        b(?:reak)?
+        \s+
+        (?:
+          (\d+) |
+          (.+?)[:.#]([^.:\s]+)
+        )
+        (?:\s+
+          if\s+(.+)
+        )?
+        $
+      /x
+    end
+
+    def execute
+      if @match[1]
+        pos, _, _, expr = @match.captures
+      else
+        _, file, pos, expr = @match.captures
+      end
+      
+      if file.nil?
+        file = File.basename(@state.file)
+      else
+        if pos !~ /^\d+$/
+          klass = debug_silent_eval(file)
+          if klass && !klass.kind_of?(Module)
+            print_error "Unknown class #{file}"
+            throw :debug_error
+          end
+          file = klass.name if klass
+        else
+          file = File.expand_path(file) if file.index(File::SEPARATOR) || \
+            File::ALT_SEPARATOR && file.index(File::ALT_SEPARATOR)
+        end
+      end
+      
+      if pos =~ /^\d+$/
+        pos = pos.to_i
+      else
+        pos = pos.intern.id2name
+      end
+      
+      b = Debugger.add_breakpoint file, pos, expr
+      print_breakpoint_added b
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak] [file|class(:|.|#)]<line|method> [if expr] -
+          \tset breakpoint to some position, (optionally) if expr == true
+        }
+      end
+    end
+  end
+
+  class BreakpointsCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*b(?:reak)?$/
+    end
+
+    def execute
+      print_breakpoints Debugger.breakpoints
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak]\tlist breakpoints
+        }
+      end
+    end
+  end
+
+  class DeleteBreakpointCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*del(?:ete)?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      pos = @match[1]
+      unless pos
+        if confirm("Clear all breakpoints? (y/n) ")
+          Debugger.breakpoints.clear
+        end
+      else
+        pos = pos.to_i
+        if b = Debugger.remove_breakpoint(pos)
+          print_breakpoint_deleted b
+        else
+          print_error "Breakpoint %d is not defined", pos
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'delete'
+      end
+
+      def help(cmd)
+        %{
+          del[ete][ nnn]\tdelete some or all breakpoints
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/catchpoint.rb

@@ -0,0 +1,40 @@
+module Debugger
+  class CatchCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*cat(?:ch)?(?:\s+(.+))?$/
+    end
+
+    def execute
+      if excn = @match[1]
+        if excn == 'off'
+          Debugger.catchpoint = nil
+          print_msg "Clear catchpoint."
+        else
+          Debugger.catchpoint = excn
+          print_msg "Set catchpoint %s.", excn
+        end
+      else
+        if Debugger.catchpoint
+          print_msg "Catchpoint %s.", Debugger.catchpoint
+        else
+          print_msg "No catchpoint."
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'catch'
+      end
+
+      def help(cmd)
+        %{
+          cat[ch]\t\t\tshow catchpoint
+          cat[ch] <an Exception>\tset catchpoint to an exception
+        }
+      end
+    end
+  end
+end