debase 0.0.2

data/ext/extconf.rb

@@ -0,0 +1,14 @@
+require "mkmf"
+
+# Allow use customization of compile options. For example, the
+# following lines could be put in config_options to to turn off
+# optimization:
+#   $CFLAGS='-fPIC -fno-strict-aliasing -g3 -ggdb -O2 -fPIC'
+config_file = File.join(File.dirname(__FILE__), 'config_options.rb')
+load config_file if File.exist?(config_file)
+
+$CFLAGS='-Wall -Werror'
+$CFLAGS+=' -g3' if ENV['debug']  
+
+dir_config("ruby")
+create_makefile("debase_internals")

data/ext/locker.c

@@ -0,0 +1,52 @@
+#include <debase_internals.h>
+static locked_thread_t *locked_head = NULL;
+static locked_thread_t *locked_tail = NULL;
+
+extern int
+is_in_locked(VALUE thread)
+{
+  locked_thread_t *node;
+
+  if(!locked_head) return 0;
+
+  for(node = locked_head; node != locked_tail; node = node->next)
+  {
+    if(node->thread == thread) return 1;
+  }
+  return 0;
+}
+
+extern void
+add_to_locked(VALUE thread)
+{
+  locked_thread_t *node;
+
+  if(is_in_locked(thread)) return;
+
+  node = ALLOC(locked_thread_t);
+  node->thread = thread;
+  node->next = NULL;
+  if(locked_tail)
+    locked_tail->next = node;
+  locked_tail = node;
+  if(!locked_head)
+    locked_head = node;
+}
+
+extern VALUE
+remove_from_locked()
+{
+  VALUE thread;
+  locked_thread_t *node;
+
+  if(locked_head == NULL)
+    return Qnil;
+
+  node = locked_head;
+  locked_head = locked_head->next;
+  if(locked_tail == node)
+    locked_tail = NULL;
+  thread = node->thread;
+  xfree(node);
+  return thread;
+}

data/lib/debase.rb

@@ -0,0 +1,57 @@
+require "debase_internals"
+require "debase/version"
+require "debase/context"
+
+module Debase
+  class << self
+    attr_accessor :handler
+
+    alias start_ setup_tracepoints
+    alias stop remove_tracepoints
+
+    # possibly deprecated options
+    attr_accessor :keep_frame_binding, :tracing
+
+    def start(options={}, &block)
+      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
+      return Debugger.started? ? block && block.call(self) : Debugger.start_(&block) 
+    end
+
+    # @param [String] file
+    # @param [Fixnum] line
+    # @param [String] expr
+    def add_breakpoint(file, line, expr=nil)
+      breakpoint = Breakpoint.new(file, line, expr)
+      breakpoints << breakpoint
+      breakpoint
+    end
+
+    def remove_breakpoint(id)
+      Breakpoint.remove breakpoints, id
+    end
+
+    def source_reload; {} end
+
+    def post_mortem?
+      false
+    end
+
+    def debug
+      false
+    end
+
+    def add_catchpoint(exception)
+      catchpoints[exception] = 0
+    end
+  end
+  
+  class DebugThread < Thread
+    def self.inherited
+      raise RuntimeError.new("Can't inherit Debugger::DebugThread class")
+    end  
+  end
+end
+
+Debugger = Debase

data/lib/debase/context.rb

@@ -0,0 +1,44 @@
+module Debase
+  class Context
+    def frame_locals(frame_no=0)
+      result = {}
+      binding = frame_binding(frame_no)
+      locals = eval("local_variables", binding)
+      locals.each {|local| result[local.to_s] = eval(local.to_s, binding)}
+      result
+    end  
+
+    def frame_class(frame_no=0)
+      frame_self(frame_no).class
+    end
+
+    def frame_args_info(frame_no=0)
+      nil
+    end
+
+    def handler
+      Debase.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
+end

data/lib/debase/version.rb

@@ -0,0 +1,3 @@
+module Debase
+  VERSION = "0.0.2" unless defined? VERSION
+end

data/test/example/a/example.rb

@@ -0,0 +1 @@
+puts "a"

data/test/example/at-exit.rb

@@ -0,0 +1,3 @@
+at_exit do
+  puts "Hello world!"
+end

data/test/example/b/example.rb

@@ -0,0 +1 @@
+puts "b"

data/test/example/bp_loop_issue.rb

@@ -0,0 +1,3 @@
+1.upto(2) {
+  sleep 0.01
+}

data/test/example/breakpoints-basename.rb

@@ -0,0 +1,2 @@
+require File.expand_path("../a/example.rb", __FILE__)
+require File.expand_path("../b/example.rb", __FILE__)

data/test/example/brkpt-class-bug.rb

@@ -0,0 +1,8 @@
+class A
+  def A.show
+    puts "hi"
+  end
+end
+x = 1
+A.show
+y = 2

data/test/example/classes.rb

@@ -0,0 +1,11 @@
+class Mine
+  def initialize
+    @myvar = 'init'
+  end
+  def mymethod(a, b=5, &block)
+  end
+  def self.classmeth
+  end
+end
+me = Mine.new
+metoo = Mine(new)

data/test/example/dollar-0.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# A test to see that rdebug set's $0 properly.
+puts $0
+puts $PROGRAM_NAME
+puts __FILE__
+

data/test/example/except-bug1.rb

@@ -0,0 +1,4 @@
+def foo(n)
+  1/0
+end
+foo(5)

data/test/example/file with space.rb

@@ -0,0 +1 @@
+puts 'Ha!'

data/test/example/gcd.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# GCD. We assume positive numbers
+def gcd(a, b)
+  # Make: a <= b
+  if a > b
+    a, b = [b, a]
+  end
+
+  return nil if a <= 0
+
+  if a == 1 or b-a == 0
+    return a
+  end
+  return gcd(b-a, a)
+end
+
+gcd(3,5)

data/test/example/info-var-bug.rb

@@ -0,0 +1,47 @@
+class Lousy_inspect
+  attr_accessor :var
+  def inspect    # An unhelpful inspect
+    throw "Foo"  # Raises an exception
+  end
+  def initialize
+    @var = 'initialized'
+  end
+end
+class Lousy_inspect_and_to_s
+  attr_accessor :var
+  def inspect    # An unhelpful inspect
+    throw "Foo"  # Raises an exception
+  end
+  def to_s       # An unhelpful to_s
+    throw "bar"  # Raises an exception
+  end
+  def initialize
+    @var = 'initialized'  # Something to inspect
+  end
+end
+
+# Something that will be passed objects with
+# bad inspect or to_s methods
+class UnsuspectingClass
+  @@Const = 'A constant'
+  @@var = 'a class variable'
+  def initialize(a)
+    @a = a      # "info locals" will try to use
+                # inspect or to_s here
+    @b = 5
+  end
+end
+def test_Lousy_inspect
+  x = Lousy_inspect.new
+  return x
+end
+def test_lousy_inspect_and_to_s
+  x = Lousy_inspect_and_to_s.new
+  return x
+end
+x = test_Lousy_inspect
+y = test_lousy_inspect_and_to_s
+UnsuspectingClass.new(10)
+UnsuspectingClass.new(x)
+UnsuspectingClass.new(y)
+y = 2

data/test/example/info-var-bug2.rb

@@ -0,0 +1,2 @@
+s = '<%= PRODUCT[:name] %>'
+y = 0

data/test/example/null.rb

@@ -0,0 +1 @@
+# Nothing here. Move along.

data/test/example/output.rb

@@ -0,0 +1,2 @@
+puts "one"
+puts "two"

data/test/example/pm-bug.rb

@@ -0,0 +1,3 @@
+a = 1
+@x = 2
+raise

data/test/example/pm.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# Test Debugger.catchpoint and post-mortem handling
+def zero_div
+  x = 5
+  1/0
+end
+x = 2
+zero_div
+raise RuntimeError
+x = 3
+

data/test/example/raise.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+raise "abc"

data/test/helper.rb

@@ -0,0 +1,2 @@
+require "test-unit"
+require "debase"

data/test/test_base.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+require File.expand_path("helper", File.dirname(__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(15)}
+    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(brk.id)
+    assert_equal(0, Debugger.breakpoints.size,
+                 'There should no longer be any breakpoints set.')
+  ensure
+    Debugger.stop
+  end
+end
+

data/test/test_breakpoints.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require File.expand_path("helper", File.dirname(__FILE__))
+
+# Some tests of Debugger module in C extension ruby_debug
+class TestBreakpoints < Test::Unit::TestCase
+  def test_find
+    Debugger.start
+    Debugger.add_breakpoint("foo.rb", 11, nil)
+    assert_not_nil(Debugger::Breakpoint.find(Debugger.breakpoints, "foo.rb", 11, binding))
+    assert_nil(Debugger::Breakpoint.find(Debugger.breakpoints, "bar.rb", 11, binding))
+    assert_nil(Debugger::Breakpoint.find(Debugger.breakpoints, "foo.rb", 10, binding))
+    Debugger.stop
+  end
+end

data/test/test_catchpoint.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require File.expand_path("helper", File.dirname(__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