debugger-ide 0.0.1 → 0.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+# gem "rails"

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,108 @@
+require 'rubygems'
+
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'date'
+
+desc 'Default: run unit tests.'
+task :default => [:test]
+
+# ------- Default Package ----------
+RUBY_DEBUG_IDE_VERSION = "0.4.13"
+
+FILES = FileList[
+#  'CHANGES',
+#  'ChangeLog',
+#  'ChangeLog.archive',
+  'MIT-LICENSE',
+  'Rakefile',
+  'bin/*',
+  'lib/**/*'
+ # 'test/**/*'
+]
+
+ide_spec = Gem::Specification.new do |spec|
+  spec.name = "ruby-debug-ide19"
+
+  spec.homepage = "http://rubyforge.org/projects/ruby-debug19"
+  spec.summary = "IDE interface for ruby-debug."
+  spec.description = <<-EOF
+An interface which glues ruby-debug to IDEs like Eclipse (RDT) and NetBeans.
+EOF
+
+  spec.version = RUBY_DEBUG_IDE_VERSION
+
+  spec.author = "Markus Barchfeld, Martin Krauskopf, Mark Moseley"
+  spec.email = "mark@fast-software.com"
+  spec.platform = Gem::Platform::RUBY
+  spec.require_path = "lib"
+  spec.bindir = "bin"
+  spec.executables = ["rdebug-ide"]
+  spec.files = FILES.to_a
+  spec.add_dependency("debugger", "~> 1.2.1")
+
+  spec.required_ruby_version = '>= 1.8.2'
+  spec.date = DateTime.now
+  spec.rubyforge_project = 'debug-commons'
+
+  # rdoc
+  spec.has_rdoc = false
+end
+
+# Rake task to build the default package
+Rake::GemPackageTask.new(ide_spec) do |pkg|
+  pkg.need_tar = true
+end
+
+# 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 GNU-style ChangeLog via svn2cl"
+task :ChangeLog do
+  system("svn2cl --authors=svn2cl_usermap svn://rubyforge.org/var/svn/debug-commons/ruby-debug-ide/trunk -o ChangeLog")
+end
+
+#desc "Publish ruby-debug to RubyForge."
+#task :publish do
+#  require 'rake/contrib/sshpublisher'
+#
+#  # Get ruby-debug path
+#  ruby_debug_path = File.expand_path(File.dirname(__FILE__))
+#
+#  publisher = Rake::SshDirPublisher.new("kent@rubyforge.org",
+#        "/var/www/gforge-projects/ruby-debug", ruby_debug_path)
+#end
+#
+#desc "Clear temp files"
+#task :clean do
+#  cd "ext" do
+#    if File.exists?("Makefile")
+#      sh "make clean"
+#      rm "Makefile"
+#    end
+#  end
+#end
+#
+## ---------  RDoc Documentation ------
+#desc "Generate rdoc documentation"
+#Rake::RDocTask.new("rdoc") do |rdoc|
+#  rdoc.rdoc_dir = 'doc'
+#  rdoc.title    = "ruby-debug"
+#  # Show source inline with line numbers
+#  rdoc.options << "--inline-source" << "--line-numbers"
+#  # Make the readme file the start page for the generated html
+#  rdoc.options << '--main' << 'README'
+#  rdoc.rdoc_files.include('bin/**/*',
+#                          'lib/**/*.rb',
+#                          'ext/**/ruby_debug.c',
+#                          'README',
+#                          'LICENSE')
+#end

data/lib/ruby-debug-ide.rb

@@ -0,0 +1,184 @@
+require 'pp'
+require 'stringio'
+require "socket"
+require 'thread'
+require 'debugger'
+if RUBY_VERSION < "1.9"
+  require 'ruby-debug/xml_printer'
+  require 'ruby-debug/processor'
+  require 'ruby-debug/event_processor'
+else
+  require_relative 'ruby-debug/xml_printer'
+  require_relative 'ruby-debug/processor'
+  require_relative 'ruby-debug/event_processor'
+end
+
+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(*args)
+        $stderr.printf("\n")
+        $stderr.flush
+      end
+    end
+    
+    def without_stderr
+      begin
+        if RUBY_PLATFORM =~ /(win32|mingw32)/
+          $stderr = File.open('NUL', 'w')
+        else
+          $stderr = File.open('/dev/null', 'w')
+        end
+        yield
+      ensure
+        $stderr = STDERR
+      end
+    end
+    
+  end
+
+  class Context
+    def interrupt
+      self.stop_next = 1
+    end
+    
+    private
+    
+    def event_processor
+      Debugger.event_processor
+    end
+    
+    def at_breakpoint(breakpoint)
+      event_processor.at_breakpoint(self, breakpoint)
+    end
+    
+    def at_catchpoint(excpt)
+      event_processor.at_catchpoint(self, excpt)
+    end
+    
+    def at_tracing(file, line)
+      if event_processor
+        event_processor.at_tracing(self, file, line)
+      else
+        Debugger::print_debug "trace: location=\"%s:%s\", threadId=%d", file, line, self.thnum
+      end
+    end
+    
+    def at_line(file, line)
+      event_processor.at_line(self, file, line)
+    end
+ 
+    def at_return(file, line)
+      event_processor.at_return(self, file, line)
+    end
+  end
+  
+  class << self
+    
+    attr_accessor :event_processor, :cli_debug, :xml_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 start_server(host = nil, port = 1234)
+      start
+      start_control(host, port)
+    end
+
+    def debug_program(options)
+      start_server(options.host, options.port)
+
+      raise "Control thread did not start (#{@control_thread}}" unless @control_thread && @control_thread.alive?
+      
+      @mutex = Mutex.new
+      @proceed = ConditionVariable.new
+      
+      # wait for 'start' command
+      @mutex.synchronize do
+        @proceed.wait(@mutex)
+      end
+      
+      bt = debug_load(Debugger::PROG_SCRIPT, options.stop, options.load_mode)
+      if bt
+        $stderr.print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+        $stderr.print "Uncaught exception: #{bt}\n"
+      end
+    end
+    
+    def run_prog_script
+      return unless @mutex
+      @mutex.synchronize do
+        @proceed.signal
+      end
+    end
+    
+    def start_control(host, port)
+      return if @control_thread
+      @control_thread = DebugThread.new do
+        begin
+          $stderr.printf "Fast Debugger (ruby-debug-ide 0.4.9) listens on #{host}:#{port}\n"
+          # 127.0.0.1 seemingly works with all systems and with IPv6 as well.
+          # "localhost" and nil on have problems on some systems.
+          host ||= '127.0.0.1'
+          server = TCPServer.new(host, port)
+          while (session = server.accept)
+            begin
+              interface = RemoteInterface.new(session)
+              @event_processor = EventProcessor.new(interface)
+              ControlCommandProcessor.new(interface).process_commands
+            rescue StandardError, ScriptError => ex
+              $stderr.printf "Exception in DebugThread loop: #{ex}\n"
+              exit 1
+            end
+          end
+        rescue
+          $stderr.printf "Exception in DebugThread: #$!\n"
+          exit 2
+        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,173 @@
+if RUBY_VERSION < "1.9"
+  require 'ruby-debug/helper'
+else
+  require_relative 'helper'
+end
+
+
+module Debugger
+
+  class Command # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
+      defined?(SubcmdStruct)
+
+    # Find param in subcmds. param id downcased and can be abbreviated
+    # to the minimum length listed in the subcommands
+    def find(subcmds, param)
+      param.downcase!
+      for try_subcmd in subcmds do
+        if (param.size >= try_subcmd.min) and
+            (try_subcmd.name[0..param.size-1] == param)
+          return try_subcmd
+        end
+      end
+      return nil
+    end
+
+    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
+        Debugger.constants.grep(/Functions$/).map { |name| Debugger.const_get(name) }.each do |mod|
+          include mod
+        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
+    
+    # FIXME: use delegate? 
+    def errmsg(*args)
+      @printer.print_error(*args)
+    end
+
+    def print(*args)
+      @state.print(*args)
+    end
+
+    # see Timeout::timeout, the difference is that we must use a DebugThread
+    # because every other thread would be halted when the event hook is reached
+    # in ruby-debug.c
+    def timeout(sec)
+      return yield if sec == nil or sec.zero?
+      if Thread.respond_to?(:critical) and Thread.critical
+        raise ThreadError, "timeout within critical session"
+      end
+      begin
+        x = Thread.current
+        y = DebugThread.start {
+          sleep sec
+          x.raise StandardError, "Timeout: evaluation took longer than #{sec} seconds." if x.alive?
+        }
+        yield sec
+      ensure
+        y.kill if y and y.alive?
+      end
+    end
+    
+    def debug_eval(str, b = get_binding)
+      begin
+        str = str.to_s
+        max_time = 10
+        to_inspect = str.gsub(/\\n/, "\n")
+        @printer.print_debug("Evaluating with timeout after %i sec", max_time)
+        timeout(max_time) do
+          if RUBY_VERSION < "1.9"
+            eval(to_inspect, b)
+          else
+            Debugger::without_stderr { eval(to_inspect, b) }
+          end
+        end
+      rescue StandardError, ScriptError => e
+        @printer.print_exception(e, @state.binding) 
+        throw :debug_error
+      end
+    end
+
+    def debug_silent_eval(str)
+      begin
+        str = str.to_s
+        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