ruby-debug-base193 0.0.1

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
+      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)
+      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/test/base/base.rb

@@ -0,0 +1,56 @@
+#!/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(Debugger.started?, 
+           'debugger should now be started.')
+    assert_equal(__LINE__, Debugger.current_context.frame_line)
+    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(7, Debugger.current_context.stack_size)
+    assert_equal(TestRubyDebug, Debugger.current_context.frame_class)
+    assert_equal(false, Debugger.current_context.dead?, 'Not dead yet!')
+  end
+
+  # Test initial variables and setting/getting state.
+  def test_debugger_base
+    assert(Debugger.started?, 
+           'Debugger should now be started.')
+    assert_equal(false, Debugger.debug,
+                 'Debug variable 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.')
+  end
+
+  # Test breakpoint handling
+  def test_breakpoints
+    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.')
+  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,23 @@
+#!/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_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)
+  end
+
+end
+

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-debug-base193
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Kent Sibilev
+- Mark Moseley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: columnize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        - 1
+        version: 0.3.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby_core_source
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 4
+        version: 0.1.4
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: linecache193
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 1
+        version: 0.0.1
+  type: :runtime
+  version_requirements: *id003
+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: mark@fast-software.com
+executables: []
+
+extensions: 
+- ext/ruby_debug/extconf.rb
+extra_rdoc_files: 
+- README
+- ext/ruby_debug/ruby_debug.c
+files: 
+- AUTHORS
+- CHANGES
+- LICENSE
+- README
+- Rakefile
+- ext/ruby_debug/extconf.rb
+- ext/ruby_debug/breakpoint.c
+- ext/ruby_debug/ruby_debug.h
+- ext/ruby_debug/ruby_debug.c
+- lib/ruby-debug-base.rb
+- lib/ChangeLog
+- test/base/base.rb
+- test/base/binding.rb
+- test/base/catchpoint.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/ruby-debug19/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 2
+      version: 1.8.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ruby-debug19
+rubygems_version: 1.3.6
+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