debugger 1.0.0.rc1

data/lib/debugger.rb

@@ -0,0 +1,7 @@
+module Debugger
+end
+# TODO: merge cli/ into lib/
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../cli')
+
+require 'ruby-debug'
+require 'debugger/version'

data/lib/debugger/version.rb

@@ -0,0 +1,3 @@
+module Debugger
+  VERSION = '1.0.0.rc1'
+end

data/lib/ruby-debug-base.rb

@@ -0,0 +1,304 @@
+require 'ruby_debug.so'
+require 'rubygems'
+require 'linecache19'
+
+module Debugger
+  
+  # Default options to Debugger.start
+  DEFAULT_START_SETTINGS = { 
+    :init        => true,  # Set $0 and save ARGV? 
+    :post_mortem => false, # post-mortem debugging on uncaught exception?
+    :tracing     => nil    # Debugger.tracing value. true/false resets,
+                           # nil keeps the prior value
+  } unless defined?(DEFAULT_START_SETTINGS)
+
+  class Context
+    def interrupt
+      self.stop_next = 1
+    end
+    
+    alias __c_frame_binding frame_binding
+    def frame_binding(frame)
+      __c_frame_binding(frame) || hbinding(frame)
+    end
+
+    private
+
+    def hbinding(frame)
+      hash = frame_locals(frame)
+      code = hash.keys.map{|k| "#{k} = hash['#{k}']" unless k=='self' }.compact.join(';') + ';binding'
+      if obj = frame_self(frame)
+        obj.instance_eval code
+      else
+        eval code, TOPLEVEL_BINDING
+      end
+    end
+
+    def handler
+      Debugger.handler or raise 'No interface loaded'
+    end
+
+    def at_breakpoint(breakpoint)
+      handler.at_breakpoint(self, breakpoint)
+    end
+
+    def at_catchpoint(excpt)
+      handler.at_catchpoint(self, excpt)
+    end
+
+    def at_tracing(file, line)
+      @tracing_started = true if File.identical?(file, File.join(Debugger::INITIAL_DIR, Debugger::PROG_SCRIPT))
+      handler.at_tracing(self, file, line) if @tracing_started
+    end
+
+    def at_line(file, line)
+      handler.at_line(self, file, line)
+    end
+
+    def at_return(file, line)
+      handler.at_return(self, file, line)
+    end
+  end
+  
+  @reload_source_on_change = false
+  @tracing_started = false
+  
+  class << self
+    # interface modules provide +handler+ object
+    attr_accessor :handler
+    
+    # if <tt>true</tt>, checks the modification time of source files and reloads if it was modified
+    attr_accessor :reload_source_on_change
+
+    attr_accessor :last_exception
+    Debugger.last_exception = nil
+    
+    #
+    # Interrupts the current thread
+    #
+    def interrupt
+      current_context.interrupt
+    end
+    
+    #
+    # Interrupts the last debugged thread
+    #
+    def interrupt_last
+      if context = last_context
+        return nil unless context.thread.alive?
+        context.interrupt
+      end
+      context
+    end
+    
+    def source_reload
+      LineCache::clear_file_cache
+    end
+    
+    # Get line +line_number+ from file named +filename+. Return "\n"
+    # there was a problem. Leaking blanks are stripped off.
+    def line_at(filename, line_number) # :nodoc:
+      @reload_on_change=nil unless defined?(@reload_on_change)
+      line = LineCache::getline(filename, line_number, @reload_on_change)
+      return "\n" unless line
+      return "#{line.gsub(/^\s+/, '').chomp}\n"
+    end
+
+    #
+    # Activates the post-mortem mode. There are two ways of using it:
+    # 
+    # == Global post-mortem mode
+    # By calling Debugger.post_mortem method without a block, you install
+    # at_exit hook that intercepts any unhandled by your script exceptions
+    # and enables post-mortem mode.
+    #
+    # == Local post-mortem mode
+    #
+    # If you know that a particular block of code raises an exception you can
+    # enable post-mortem mode by wrapping this block with Debugger.post_mortem, e.g.
+    #
+    #   def offender
+    #      raise 'error'
+    #   end
+    #   Debugger.post_mortem do
+    #      ...
+    #      offender
+    #      ...
+    #   end
+    def post_mortem
+      if block_given?
+        old_post_mortem = self.post_mortem?
+        begin
+          self.post_mortem = true
+          yield
+        rescue Exception => exp
+          handle_post_mortem(exp)
+          raise
+        ensure
+          self.post_mortem = old_post_mortem
+        end
+      else
+        return if post_mortem?
+        self.post_mortem = true
+        debug_at_exit do
+          handle_post_mortem($!) if $! && post_mortem?
+        end
+      end
+    end
+    
+    def handle_post_mortem(exp)
+      return if !exp || !exp.__debug_context || 
+        exp.__debug_context.stack_size == 0
+      Debugger.suspend
+      orig_tracing = Debugger.tracing, Debugger.current_context.tracing
+      Debugger.tracing = Debugger.current_context.tracing = false
+      Debugger.last_exception = exp
+      handler.at_line(exp.__debug_context, exp.__debug_file, exp.__debug_line)
+    ensure
+      Debugger.tracing, Debugger.current_context.tracing = orig_tracing
+      Debugger.resume
+    end
+    # private :handle_post_mortem
+  end
+  
+  class DebugThread # :nodoc:
+  end
+  
+  class ThreadsTable # :nodoc:
+  end
+
+  # Debugger.start(options) -> bool
+  # Debugger.start(options) { ... } -> obj
+  #
+  # If it's called without a block it returns +true+, unless debugger
+  # was already started.  If a block is given, it starts debugger and
+  # yields to block. When the block is finished executing it stops
+  # the debugger with Debugger.stop method.
+  #
+  # If a block is given, it starts debugger and yields to block. When
+  # the block is finished executing it stops the debugger with
+  # Debugger.stop method. Inside the block you will probably want to
+  # have a call to Debugger.debugger. For example:
+  #
+  #     Debugger.start{debugger; foo}  # Stop inside of foo
+  #
+  # Also, ruby-debug only allows
+  # one invocation of debugger at a time; nested Debugger.start's
+  # have no effect and you can't use this inside the debugger itself.
+  #
+  # <i>Note that if you want to stop debugger, you must call
+  # Debugger.stop as many time as you called Debugger.start
+  # method.</i>
+  # 
+  # +options+ is a hash used to set various debugging options.
+  # Set :init true if you want to save ARGV and some variables which
+  # make a debugger restart possible. Only the first time :init is set true
+  # will values get set. Since ARGV is saved, you should make sure 
+  # it hasn't been changed before the (first) call. 
+  # Set :post_mortem true if you want to enter post-mortem debugging
+  # on an uncaught exception. Once post-mortem debugging is set, it can't
+  # be unset.
+  def start(options={}, &block)
+    options = Debugger::DEFAULT_START_SETTINGS.merge(options)
+    if options[:init]
+      Debugger.const_set('ARGV', ARGV.clone) unless 
+        defined? Debugger::ARGV
+      Debugger.const_set('PROG_SCRIPT', $0) unless 
+        defined? Debugger::PROG_SCRIPT
+      Debugger.const_set('INITIAL_DIR', Dir.pwd) unless 
+        defined? Debugger::INITIAL_DIR
+    end
+    Debugger.tracing = options[:tracing] unless options[:tracing].nil?
+    retval = Debugger.started? ? block && block.call(self) : Debugger.start_(&block) 
+    if options[:post_mortem]
+      post_mortem
+    end
+    return retval
+  end
+  module_function :start
+end
+
+module Kernel
+
+  # Enters the debugger in the current thread after _steps_ line events occur.
+  # Before entering the debugger startup script is read.
+  #
+  # Setting _steps_ to 0 will cause a break in the debugger subroutine
+  # and not wait for a line event to occur. You will have to go "up 1"
+  # in order to be back in your debugged program rather than the
+  # debugger. Settings _steps_ to 0 could be useful you want to stop
+  # right after the last statement in some scope, because the next
+  # step will take you out of some scope.
+
+  # If a block is given (and the debugger hasn't been started, we run the 
+  # block under the debugger. Alas, when a block is given, we can't support
+  # running the startup script or support the steps option. FIXME.
+  def debugger(steps = 1, &block)
+    if block
+      Debugger.start({}, &block)
+    else
+      Debugger.start unless Debugger.started?
+      Debugger.run_init_script(StringIO.new)
+      if 0 == steps
+        Debugger.current_context.stop_frame = 0
+      else
+        Debugger.current_context.stop_next = steps
+      end
+    end
+  end
+  alias breakpoint debugger unless respond_to?(:breakpoint)
+  
+  #
+  # Returns a binding of n-th call frame
+  #
+  def binding_n(n = 0)
+    Debugger.skip do
+      if RUBY_VERSION < "1.9"
+        Debugger.current_context.frame_binding(n+2)
+      else
+        Debugger.current_context.frame_binding(n+1)
+      end
+    end
+  end
+end
+
+class Exception # :nodoc:
+  attr_reader :__debug_file, :__debug_line, :__debug_binding, :__debug_context
+end
+
+class Module
+  #
+  # Wraps the +meth+ method with Debugger.start {...} block.
+  #
+  def debug_method(meth)
+    old_meth = "__debugee_#{meth}"
+    old_meth = "#{$1}_set" if old_meth =~ /^(.+)=$/
+    alias_method old_meth.to_sym, meth
+    class_eval <<-EOD
+    def #{meth}(*args, &block)
+      Debugger.start do
+        debugger 2
+        #{old_meth}(*args, &block)
+      end
+    end
+    EOD
+  end
+  
+  #
+  # Wraps the +meth+ method with Debugger.post_mortem {...} block.
+  #
+  def post_mortem_method(meth)
+    old_meth = "__postmortem_#{meth}"
+    old_meth = "#{$1}_set" if old_meth =~ /^(.+)=$/
+    alias_method old_meth.to_sym, meth
+    class_eval <<-EOD
+    def #{meth}(*args, &block)
+      Debugger.start do |dbg|
+        dbg.post_mortem do
+          #{old_meth}(*args, &block)
+        end
+      end
+    end
+    EOD
+  end
+end

data/rdbg.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+#!/usr/bin/env ruby
+# $Id: rdbg.rb 756 2008-03-13 02:15:04Z rockyb $
+
+# Use this to run rdebug without installing it.  We assume that the
+# library directories are stored at the same level the directory
+# this program. 
+module RDebugRunner
+  def runner(stdout=nil)
+
+    # Add libraries to load path.
+    dirname=File.dirname(__FILE__)
+    libs = %w(ext lib cli)
+    libs.each { |lib| $:.unshift File.join(dirname, lib) }
+
+    rdebug=ENV['RDEBUG'] || File.join(dirname, 'bin', 'rdebug')
+    if stdout
+      old_stdout = $stdout
+      $stdout.reopen(stdout)
+    else
+      old_stdout = nil
+    end
+    load(rdebug, true)
+    $stdout.reopen(old_stdout) if old_stdout
+    
+    # Remove those libraries we just added.
+    1.upto(libs.size) {$:.shift}
+  end
+  module_function :runner
+end
+if __FILE__ == $0 
+  RDebugRunner.runner
+end

data/runner.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+ruby=${RUBY:-ruby}
+dir=`dirname $0`
+rdebug=${RDEBUG:-${dir}/bin/rdebug}
+$ruby -I${dir}/ext:${dir}/lib:${dir}/cli -- $rdebug $*
+exit $?

data/svn2cl_usermap

@@ -0,0 +1,3 @@
+andersl:Anders Lindgren
+kent:Kent Sibilev
+rockyb:Rocky Bernstein

data/test/.cvsignore

@@ -0,0 +1 @@
+config.private.yaml

data/test/base/base.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# Some tests of Debugger module in C extension ruby_debug 
+class TestRubyDebug < Test::Unit::TestCase
+  $:.unshift File.join(File.dirname(__FILE__), '..', '..', 'ext')
+  require 'ruby_debug'
+  $:.shift
+
+  # test current_context
+  def test_current_context
+    assert_equal(false, Debugger.started?, 
+                 'debugger should not initially be started.')
+    Debugger.start_
+    assert(Debugger.started?, 
+           'debugger should now be started.')
+    assert_equal(__LINE__, Debugger.current_context.frame_line)
+    assert_equal(nil, Debugger.current_context.frame_args_info,
+                 'no frame args info.')
+    assert_equal(Debugger.current_context.frame_file, 
+                 Debugger.current_context.frame_file(0))
+    assert_equal(File.basename(__FILE__),
+                 File.basename(Debugger.current_context.frame_file))
+    assert_raises(ArgumentError) {Debugger.current_context.frame_file(1, 2)}
+    assert_raises(ArgumentError) {Debugger.current_context.frame_file(10)}
+    assert_equal(1, Debugger.current_context.stack_size)
+    assert_equal(TestRubyDebug, Debugger.current_context.frame_class)
+    assert_equal(false, Debugger.current_context.dead?, 'Not dead yet!')
+    Debugger.stop
+    assert_equal(false, Debugger.started?, 
+                 'Debugger should no longer be started.')
+  end
+
+  # Test initial variables and setting/getting state.
+  def test_debugger_base
+    assert_equal(false, Debugger.started?, 
+                 'Debugger should not initially be started.')
+    Debugger.start_
+    assert(Debugger.started?, 
+           'Debugger should now be started.')
+    assert_equal(false, Debugger.debug,
+                 'Debug variable should not be set.')
+    assert_equal(false, Debugger.post_mortem?,
+                 'Post mortem debugging should not be set.')
+    a = Debugger.contexts
+    assert_equal(1, a.size, 
+                 'There should only be one context.')
+    assert_equal(Array, a.class, 
+                 'Context should be an array.')
+    Debugger.stop
+    assert_equal(false, Debugger.started?, 
+                 'debugger should no longer be started.')
+  end
+
+  # Test breakpoint handling
+  def test_breakpoints
+    Debugger.start_
+    assert_equal(0, Debugger.breakpoints.size,
+                 'There should not be any breakpoints set.')
+    brk = Debugger.add_breakpoint(__FILE__, 1)
+    assert_equal(Debugger::Breakpoint, brk.class,
+                 'Breakpoint should have been set and returned.')
+    assert_equal(1, Debugger.breakpoints.size,
+                 'There should now be one breakpoint set.')
+    Debugger.remove_breakpoint(0)
+    assert_equal(1, Debugger.breakpoints.size,
+                 'There should still be one breakpoint set.')
+    Debugger.remove_breakpoint(1)
+    assert_equal(0, Debugger.breakpoints.size,
+                 'There should no longer be any breakpoints set.')
+    Debugger.stop
+  end
+end
+

data/test/base/binding.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+# Test binding_n command
+class TestBinding < Test::Unit::TestCase
+
+  SRC_DIR = File.expand_path(File.dirname(__FILE__)) unless 
+    defined?(SRC_DIR)
+  %w(ext lib).each do |dir|
+    $:.unshift File.join(SRC_DIR, '..', '..', dir)
+  end
+  require File.join(SRC_DIR, '..', '..', 'lib', 'ruby-debug-base')
+  $:.shift; $:.shift
+
+  def test_basic
+    def inside_fn
+      s = 'some other string'
+      b2 = Kernel::binding_n(1)
+      y2 = eval('s', b2)
+      assert_equal('this is a test', y2)
+    end
+    s = 'this is a test'
+    Debugger.start
+    b = Kernel::binding_n(0)
+    y = eval('s', b)
+    assert_equal(y, s)
+    inside_fn
+    Debugger.stop
+  end
+end