ruby-debug-base 0.10.4-java → 0.10.5.rc1-java

data/lib/ruby-debug-base/version.rb

@@ -0,0 +1,3 @@
+module Debugger
+  VERSION = "0.10.5.rc1"
+end

data/lib/ruby-debug-base.rb

@@ -1,16 +1,15 @@
-require 'ruby_debug.jar'
-require File.join(File.dirname(__FILE__), 'tracelines')
-require File.join(File.dirname(__FILE__), 'linecache')
-
-SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
-SCRIPT_TIMESTAMPS__ = {} unless defined? SCRIPT_TIMESTAMPS__
+require 'ruby_debug'
+require 'ruby-debug-base/version'
+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?
+    :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
@@ -27,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
@@ -91,12 +90,13 @@ module Debugger
     end
     
     def source_reload
-      LineCache::clear_file_cache(true)
+      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"
@@ -164,34 +164,29 @@ module Debugger
   
   class ThreadsTable # :nodoc:
   end
-end
 
-module Kernel
+  # Debugger.start(options) -> bool
+  # Debugger.start(options) { ... } -> obj
   #
-  # Enters the debugger in the current thread after a number of
-  # _steps_ made.
+  # 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.
   #
-  def debugger(steps = 1)
-    Debugger.start unless Debugger.started?
-    Debugger.run_init_script(StringIO.new)
-    Debugger.current_context.stop_next = steps
-  end
-  alias breakpoint debugger unless respond_to?(:breakpoint)
-  
-  #  Debugger.start(options) -> bool
-  #  Debugger.start(options) { ... } -> obj
+  # 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:
   #
-  #  This method is internal and activates the debugger. Use
-  #  Debugger.start (from ruby-debug-base.rb) instead.
+  #     Debugger.start{debugger; foo}  # Stop inside of foo
   #
-  #  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.
+  # 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>
+  # <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
@@ -211,13 +206,49 @@ module Kernel
       Debugger.const_set('INITIAL_DIR', Dir.pwd) unless 
         defined? Debugger::INITIAL_DIR
     end
-    retval = Debugger.started? ? nil : Debugger.start_(&block) 
+    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.
+  #
+  # If block _block_ is given (and the debugger hasn't been started,
+  # we run the block under the debugger.  
+  #
+  # 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)
+  
   #
   # Returns a binding of n-th call frame
   #

data/test/base/base.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+require File.expand_path("../../helper", __FILE__)
+
+# Some tests of Debugger module in C extension ruby_debug 
+class TestRubyDebug < Test::Unit::TestCase
+  def test_version
+    assert(defined?(Debugger::VERSION))
+  end
+
+  # 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!')
+  ensure
+    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.')
+  ensure
+    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.')
+  ensure
+    Debugger.stop
+  end
+end
+

data/test/base/binding.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require File.expand_path("../../helper", __FILE__)
+
+# Test binding_n command
+class TestBinding < Test::Unit::TestCase
+  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(s, y)
+    inside_fn
+  ensure
+    Debugger.stop
+  end
+end

data/test/base/catchpoint.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require File.expand_path("../../helper", __FILE__)
+
+# Test catchpoint in C ruby_debug extension.
+  
+class TestRubyDebugCatchpoint < Test::Unit::TestCase
+  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)
+  ensure
+    Debugger.stop
+  end
+end

data/test/base/load.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require File.expand_path("../../helper", __FILE__)
+
+# Test of Debugger.debug_load in C extension ruby_debug.so
+class TestDebugLoad < Test::Unit::TestCase
+  class << self
+    def at_line(file, line)
+      @@at_line = [File.basename(file), line]
+    end
+  end
+
+  class Debugger::Context
+    def at_line(file, line)
+      TestDebugLoad::at_line(file, line)
+    end
+  end
+
+  def test_debug_load
+    src_dir = File.dirname(__FILE__)
+    prog_script = File.join(src_dir, '..', 'example', 'gcd.rb')
+
+    # Without stopping
+    bt = Debugger.debug_load(prog_script, false)
+    assert_equal(nil, bt)
+    assert(Debugger.started?)
+    Debugger.stop
+
+    # With stopping
+    bt = Debugger.debug_load(prog_script, true)
+    assert_equal(nil, bt)
+    assert_equal(['gcd.rb', 4], @@at_line)
+    assert(Debugger.started?)
+    Debugger.stop
+
+    # Test that we get a proper backtrace on a script that raises 'abc'
+    prog_script = File.join(src_dir, '..', 'example', 'raise.rb')
+    bt = Debugger.debug_load(prog_script, false)
+    assert_equal('abc', bt.to_s)
+    assert(Debugger.started?)
+    Debugger.stop
+  ensure
+    Debugger.stop if Debugger.started?
+  end
+end

data/test/base/reload_bug.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require File.expand_path("../../helper", __FILE__)
+
+class TestReloadBug < Test::Unit::TestCase
+  def test_reload_bug
+    assert_equal({}, Debugger::source_reload)
+  end
+end

metadata

@@ -1,47 +1,72 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-debug-base
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-    - 0
-    - 10
-    - 4
-  version: 0.10.4
+  prerelease: 7
+  version: 0.10.5.rc1
 platform: java
 authors: 
-  - debug-commons team
+  - Kent Sibilev
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-11-10 00:00:00 -06:00
+date: 2011-10-19 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: linecache
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0.3"
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: rake-compiler
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id002
 description: |
-  Java extension to make fast ruby debugger run on JRuby.
-  It is the same what ruby-debug-base is for native Ruby.
+  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: 
+email: ksibilev@yahoo.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+  - README
+  - ext/ruby_debug.c
 files: 
   - AUTHORS
-  - ChangeLog
-  - lib/linecache.rb
-  - lib/linecache-ruby.rb
+  - CHANGES
+  - LICENSE
+  - README
+  - Rakefile
   - lib/ruby-debug-base.rb
+  - lib/ruby-debug-base/version.rb
+  - test/base/base.rb
+  - test/base/binding.rb
+  - test/base/catchpoint.rb
+  - test/base/load.rb
+  - test/base/reload_bug.rb
+  - ext/ruby_debug.c
+  - ext/extconf.rb
   - lib/ruby_debug.jar
-  - lib/tracelines.rb
-  - MIT-LICENSE
-  - Rakefile
-  - README
 has_rdoc: true
-homepage: http://rubyforge.org/projects/debug-commons/
+homepage: http://rubyforge.org/projects/ruby-debug/
 licenses: []
 
 post_install_message: 
@@ -54,23 +79,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+        version: 1.8.2
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+        version: 1.3.1
 requirements: []
 
-rubyforge_project: debug-commons
-rubygems_version: 1.3.7
+rubyforge_project: ruby-debug
+rubygems_version: 1.5.1
 signing_key: 
 specification_version: 3
-summary: Java implementation of Fast Ruby Debugger
-test_files: []
-
+summary: Fast Ruby debugger - core component
+test_files: 
+  - test/base/base.rb
+  - test/base/binding.rb
+  - test/base/catchpoint.rb
+  - test/base/load.rb
+  - test/base/reload_bug.rb