ruby-debug-base 0.10.0-mswin32 → 0.10.4-mswin32

data/lib/ruby-debug-base.rb

@@ -1,9 +1,17 @@
 require 'ruby_debug.so'
-
-SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
-SCRIPT_TIMESTAMPS__ = {} unless defined? SCRIPT_TIMESTAMPS__
+require 'rubygems'
+require 'linecache'
 
 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
@@ -18,7 +26,7 @@ module Debugger
 
     def hbinding(frame)
       hash = frame_locals(frame)
-      code = hash.keys.map{|k| "#{k} = hash['#{k}']"}.join(';') + ';binding'
+      code = hash.keys.map{|k| "#{k} = hash['#{k}']" unless k=='self' }.compact.join(';') + ';binding'
       if obj = frame_self(frame)
         obj.instance_eval code
       else
@@ -45,6 +53,10 @@ module Debugger
     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
@@ -55,6 +67,9 @@ module Debugger
     
     # 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
@@ -74,42 +89,17 @@ module Debugger
       context
     end
     
-    def source_for(file) # :nodoc:
-      finder = lambda do
-        if File.exists?(file)
-          if SCRIPT_LINES__[file].nil? || SCRIPT_LINES__[file] == true
-            SCRIPT_LINES__[file] = File.readlines(file)
-          end
-
-          change_time = File.stat(file).mtime
-          SCRIPT_TIMESTAMPS__[file] ||= change_time
-          if @reload_source_on_change && SCRIPT_TIMESTAMPS__[file] < change_time
-            SCRIPT_LINES__[file] = File.readlines(file)
-          end
-
-          SCRIPT_LINES__[file]
-        end
-      end
-      
-      Dir.chdir(File.dirname($0)){finder.call} || finder.call ||
-        (SCRIPT_LINES__[file] == true ? nil : SCRIPT_LINES__[file])
-    end
-    
     def source_reload
-      SCRIPT_LINES__.keys.each do |file|
-        next unless File.exists?(file)
-        SCRIPT_LINES__[file] = nil
-      end
+      LineCache::clear_file_cache
     end
     
-    def line_at(file, line) # :nodoc:
-      lines = source_for(file)
-      if lines
-        line = lines[line-1]
-        return "\n" unless line
-        return "#{line.gsub(/^\s+/, '').chomp}\n"
-      end
-      return "\n"
+    # 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
 
     #
@@ -155,16 +145,18 @@ module Debugger
     end
     
     def handle_post_mortem(exp)
-      return if exp.__debug_context.stack_size == 0
+      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
+    # private :handle_post_mortem
   end
   
   class DebugThread # :nodoc:
@@ -172,17 +164,88 @@ module Debugger
   
   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, a user-defined
+  # startup script is may be 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.
   #
-  # Enters the debugger in the current thread after a number of
-  # _steps_ made.
+  # If block _block_ is given (and the debugger hasn't been started,
+  # we run the block under the debugger.  
   #
-  def debugger(steps = 1)
-    Debugger.start unless Debugger.started?
-    Debugger.run_init_script(StringIO.new)
-    Debugger.current_context.stop_next = steps
+  # FIXME: Alas, when a block is given, we can't support running the
+  # startup script or support the steps option.
+  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)
   

data/test/{test-ruby-debug-base.rb → base/base.rb}

@@ -1,75 +1,73 @@
 #!/usr/bin/env ruby
-require "test/unit"
+require 'test/unit'
 
-$: << File.expand_path(File.dirname(__FILE__)) + '/../ext'
-$: << File.expand_path(File.dirname(__FILE__)) + '/../lib'
-require "ruby_debug"
-
-# Test of C extension ruby_debug.so
+# Some tests of Debugger module in C extension ruby_debug 
 class TestRubyDebug < Test::Unit::TestCase
-  include Debugger
+  $:.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
+                 'debugger should not initially be started.')
+    Debugger.start_
     assert(Debugger.started?, 
-           "debugger should now be started.")
-    assert_equal(19, Debugger.current_context.frame_line)
+           '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.")
+                 'no frame args info.')
     assert_equal(Debugger.current_context.frame_file, 
                  Debugger.current_context.frame_file(0))
-    assert_equal("test-ruby-debug-base.rb",
+    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!")
+    assert_equal(false, Debugger.current_context.dead?, 'Not dead yet!')
     Debugger.stop
     assert_equal(false, Debugger.started?, 
-                 "Debugger should no longer be 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
+                 'Debugger should not initially be started.')
+    Debugger.start_
     assert(Debugger.started?, 
-           "Debugger should now be started.")
+           'Debugger should now be started.')
     assert_equal(false, Debugger.debug,
-                 "Debug variable should not be set.")
+                 'Debug variable should not be set.')
     assert_equal(false, Debugger.post_mortem?,
-                 "Post mortem debugging should not be set.")
+                 'Post mortem debugging should not be set.')
     a = Debugger.contexts
     assert_equal(1, a.size, 
-                 "There should only be one context.")
+                 'There should only be one context.')
     assert_equal(Array, a.class, 
-                 "Context should be an array.")
+                 'Context should be an array.')
     Debugger.stop
     assert_equal(false, Debugger.started?, 
-                 "debugger should no longer be started.")
+                 'debugger should no longer be started.')
   end
 
   # Test breakpoint handling
   def test_breakpoints
-    Debugger.start
+    Debugger.start_
     assert_equal(0, Debugger.breakpoints.size,
-                 "There should not be any breakpoints set.")
+                 '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.")
+                 'Breakpoint should have been set and returned.')
     assert_equal(1, Debugger.breakpoints.size,
-                 "There should now be one breakpoint set.")
+                 'There should now be one breakpoint set.')
     Debugger.remove_breakpoint(0)
     assert_equal(1, Debugger.breakpoints.size,
-                 "There should still be one breakpoint set.")
+                 '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.")
+                 '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

data/test/base/catchpoint.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# Test catchpoint in C ruby_debug extension.
+  
+class TestRubyDebugCatchpoint < Test::Unit::TestCase
+
+  $:.unshift File.join(File.dirname(__FILE__), '..', '..', 'ext')
+  require 'ruby_debug'
+  $:.shift
+
+  # test current_context
+  def test_catchpoints
+    assert_raise(RuntimeError) {Debugger.catchpoints}
+    Debugger.start_
+    assert_equal({}, Debugger.catchpoints)
+    Debugger.add_catchpoint('ZeroDivisionError')
+    assert_equal({'ZeroDivisionError' => 0}, Debugger.catchpoints)
+    Debugger.add_catchpoint('RuntimeError')
+    assert_equal(['RuntimeError', 'ZeroDivisionError'], 
+                 Debugger.catchpoints.keys.sort)
+    Debugger.stop
+  end
+
+end
+

data/test/base/reload_bug.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+class TestReloadBug < Test::Unit::TestCase
+  def test_reload_bug
+    top_srcdir = File.join(File.dirname(__FILE__), '..', '..')
+    assert_equal({}, Debugger::source_reload)
+  end
+end

metadata

@@ -1,61 +1,93 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: ruby-debug-base
 version: !ruby/object:Gem::Version 
-  version: 0.10.0
-date: 2008-02-07 00:00:00 -05:00
-summary: Fast Ruby debugger - core component
-require_paths: 
-- lib
-email: ksibilev@yahoo.com
-homepage: http://rubyforge.org/projects/ruby-debug/
-rubyforge_project: ruby-debug
-description: ruby-debug is a fast implementation of the standard Ruby debugger debug.rb. It is implemented by utilizing a new Ruby C API hook. The core component  provides support that front-ends can build on. It provides breakpoint  handling, bindings for stack frames among other things.
-autorequire: ruby-debug-base
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.2
-  version: 
+  version: 0.10.4
 platform: mswin32
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Kent Sibilev
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-27 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: linecache
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.3"
+    version: 
+description: |
+  ruby-debug is a fast implementation of the standard Ruby debugger debug.rb.
+  It is implemented by utilizing a new Ruby C API hook. The core component 
+  provides support that front-ends can build on. It provides breakpoint 
+  handling, bindings for stack frames among other things.
+
+email: ksibilev@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- ext/ruby_debug.c
 files: 
 - AUTHORS
 - CHANGES
 - LICENSE
 - README
+- VERSION
 - Rakefile
-- lib/ruby-debug-base.rb
-- lib/ChangeLog
-- ext/ChangeLog
-- ext/ruby_debug.c
+- ext/breakpoint.c
 - ext/extconf.rb
+- ext/ruby_debug.c
+- ext/ruby_debug.h
+- ext/win32/breakpoint.o
+- ext/win32/ruby_debug.o
 - ext/win32/ruby_debug.so
 - ext/win32/Makefile
-- ext/win32/ruby_debug.o
-- test/test-ruby-debug-base.rb
+- lib/ChangeLog
+- lib/ruby-debug-base.rb
+- test/base/base.rb
+- test/base/binding.rb
+- test/base/catchpoint.rb
+- test/base/reload_bug.rb
 - lib/ruby_debug.so
-test_files: 
-- test/test-ruby-debug-base.rb
-rdoc_options: []
-
-extra_rdoc_files: 
-- README
-- ext/ruby_debug.c
-executables: []
+has_rdoc: true
+homepage: http://rubyforge.org/projects/ruby-debug/
+licenses: []
 
-extensions: []
+post_install_message: 
+rdoc_options: []
 
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: ruby-debug
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Fast Ruby debugger - core component
+test_files: 
+- test/base/base.rb
+- test/base/binding.rb
+- test/base/catchpoint.rb
+- test/base/reload_bug.rb