debugger 1.0.0.rc1

data/test/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
+  x
+end
+def test_lousy_inspect_and_to_s
+  x = Lousy_inspect_and_to_s.new
+  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/info-var-bug2.rb

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

data/test/jump.rb

@@ -0,0 +1,14 @@
+def foo
+  j = 0
+  [1,2,3,4,5].each { |i|
+    j = i
+    [10,11,12].each { |k|
+      j = j + k
+      puts j
+    }
+  }
+  puts j
+end
+
+foo
+puts "done"

data/test/jump2.rb

@@ -0,0 +1,27 @@
+def foo3(arg)
+  arg = arg + 3
+  puts arg
+  arg = arg/0 if arg > 10
+  rescue
+    puts "r3"
+end
+
+def foo2(arg)
+  arg = arg + 2
+  foo3(arg)
+  puts arg
+  rescue
+    puts "r2"
+end
+
+def foo1(arg)
+  arg = arg + 1
+  foo2(arg)
+  puts arg
+  rescue
+    puts "r1"
+end
+
+foo1(0)
+foo2(10)
+puts "done"

data/test/next.rb

@@ -0,0 +1,18 @@
+def foo
+  a = 1
+  puts "Stop here"
+  b = 2
+end
+
+a = 1
+if a == 1
+  a += 2
+  puts a
+end
+foo
+b = 2
+b += 2
+puts "one"
+c = 4
+puts "two"
+

data/test/null.rb

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

data/test/output.rb

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

data/test/pm-base.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# Test post-mortem handling using only ruby-debug-base.
+src_dir = File.dirname(__FILE__)
+%w(ext lib cli).each do |dir|
+  $:.unshift  File.join(src_dir, '..', dir)
+end
+require 'ruby-debug-base'
+
+class CommandProcessor
+  def at_line(context, file, line)
+    puts 'file: %s, line: %s' % [ File.basename(file), line ]
+    exit!
+  end
+end
+
+Debugger.start(:post_mortem => true)
+Debugger.handler = CommandProcessor.new
+def zero_div
+  1/0
+end
+zero_div
+

data/test/pm-bug.rb

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

data/test/pm-catch.rb

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

data/test/pm-catch2.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# Test Debugger.catchpoint 
+def bar(arg)
+  puts "bar begin"
+  1/0 if arg
+  raise ZeroDivisionError
+  puts "bar end"
+end
+
+def foo
+  puts "foo begin"
+  yield 1
+  puts "foo end"
+rescue ZeroDivisionError
+  puts "rescue"
+end
+
+def zero_div(arg)
+  x = 5
+  foo { |i| bar(i) }
+  x + arg
+rescue ZeroDivisionError
+  "zero_div rescue"
+end
+
+puts zero_div(10)
+puts "done"

data/test/pm-catch3.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# Test catching uncaught exceptions
+def get_exception(arg)
+  result = case arg
+    when 0 then LoadError
+    when 1 then ZeroDivisionError
+    when 2 then NoMethodError
+    else RuntimeError
+  end
+  return result
+end
+
+def bar(arg)
+  $var = $var + "bar begin:"
+  1/0 if arg
+  if false
+    raise LoadError
+  end
+  $var = $var + "bar end:"
+end
+
+def foo(arg)
+  $var = $var + "foo begin:"
+  yield arg
+  $var = $var + "foo end:"
+rescue get_exception(0), NameError
+  $var = $var + "foo rescue:"
+ensure
+  $var = $var + "foo ensure:"
+end
+
+def zero_div(arg)
+  x = 5
+  foo(arg) { |i| bar(i) }
+  x + arg
+rescue get_exception(arg)
+  $var = $var + "zero_div rescue:"
+  return "divide by zero"
+end
+
+$var = "start1:"
+puts zero_div(1)
+puts $var
+$var = "start2:"
+puts zero_div(2)
+puts $var
+puts "done"

data/test/pm.rb

@@ -0,0 +1,11 @@
+#!/ursr/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/raise.rb

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

data/test/rdebug-save.1

@@ -0,0 +1,7 @@
+break gcd.rb:10
+break gcd.rb:12 if a > b
+set autoeval on
+set basename off
+set debuggertesting off
+set autolist off
+set autoirb off

data/test/runall

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+#-*- Ruby -*-
+debug_opt = '-d ' if $DEBUG or 'd' == ARGV[0]
+for file in Dir.glob("test-*.rb")  do 
+  puts "=" * 50
+  puts "== running #{file}..."
+  system("ruby #{file}");
+end
+if ARGV[0] == "really"
+   system("(cd test && ruby #{debug_opt}runall)")
+   system("(cd examples && ruby #{debug_opt}runall)")
+end

data/test/scope-var.rb

@@ -0,0 +1,29 @@
+require 'ruby_debug'
+def scope1(arg1, arg2)
+  s1_var1 = 123
+  s1_var2 = "scope1"
+  scope2
+end
+
+def scope2
+  s2_var1 = 456
+  s2_var2 = "scope2"
+  0.upto(5) do |i|
+    j = i * 10
+    scope3
+  end
+end
+
+def scope3
+  s3_var1 = 789
+  s3_var2 = "scope3"
+  puts eval("s3_var1", Debugger.current_context.frame_binding(0))
+  puts eval("i", Debugger.current_context.frame_binding(1))
+  puts eval("j", Debugger.current_context.frame_binding(1))
+  puts eval("s2_var1", Debugger.current_context.frame_binding(2))
+  puts eval("s1_var1", Debugger.current_context.frame_binding(3))
+  puts eval("s0_var1", Debugger.current_context.frame_binding(4))
+end
+
+s0_var1 = 1357;
+scope1(111, 222)

data/test/tdebug.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+# -*- Ruby -*-
+# This is a hacked down copy of rdebug which can be used for testing
+# FIXME: use the real rdebug script - DRY.
+
+require 'stringio'
+require 'rubygems'
+require 'optparse'
+require "ostruct"
+
+TOP_SRC_DIR = File.join(File.dirname(__FILE__), "..") unless 
+  defined?(TOP_SRC_DIR)
+
+$:.unshift File.join(TOP_SRC_DIR, "ext")
+$:.unshift File.join(TOP_SRC_DIR, "lib")
+$:.unshift File.join(TOP_SRC_DIR, "cli")
+
+def debug_program(options)
+  # Make sure Ruby script syntax checks okay.
+  # Otherwise we get a load message that looks like rdebug has 
+  # a problem. 
+  output = `ruby -c "#{Debugger::PROG_SCRIPT}" 2>&1`
+  if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+    puts output
+    exit $?.exitstatus 
+  end
+  print "\032\032starting\n" if Debugger.annotate and Debugger.annotate > 2
+  unless options.no_rewrite_program
+    # Set $0 so things like __FILE == $0 work.
+    # A more reliable way to do this is to put $0 = __FILE__ *after*
+    # loading the script to be debugged.  For this, adding a debug hook
+    # for the first time and then switching to the debug hook that's
+    # normally used would be helpful. Doing this would also help other
+    # first-time initializations such as reloading debugger state
+    # after a restart. 
+
+    # However This is just a little more than I want to take on right
+    # now, so I think I'll stick with the slightly hacky approach.
+    $RDEBUG_0 = $0
+
+    # cygwin does some sort of funky truncation on $0 ./abcdef => ./ab
+    # probably something to do with 3-letter extension truncation.
+    # The hacky workaround is to do slice assignment. Ugh.
+    d0 = if '.' == File.dirname(Debugger::PROG_SCRIPT) and
+             Debugger::PROG_SCRIPT[0..0] != '.'
+           File.join('.', Debugger::PROG_SCRIPT)
+         else
+           Debugger::PROG_SCRIPT
+         end
+    if $0.frozen?
+      $0 = d0
+    else
+      $0[0..-1] = d0
+    end
+  end
+
+  # Record where we are we can know if the call stack has been
+  # truncated or not.
+  Debugger.start_sentinal=caller(0)[1]
+
+  bt = Debugger.debug_load(Debugger::PROG_SCRIPT, !options.nostop, false)
+  if bt
+    if options.post_mortem
+      Debugger.handle_post_mortem(bt)
+    else
+      print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+      print "Uncaught exception: #{bt}\n"
+    end
+  end
+end
+
+options = OpenStruct.new(
+  'annotate'    => false,
+  'emacs'       => false,
+  'no-quit'     => false,
+  'no-stop'     => false,
+  'nx'          => false,
+  'post_mortem' => false,
+  'script'      => nil,
+  'tracing'     => false,
+  'verbose_long'=> false,
+  'wait'        => false
+)
+
+require "ruby-debug"
+
+program = File.basename($0)
+opts = OptionParser.new do |opts|
+  opts.banner = <<EOB
+#{program} #{Debugger::VERSION}
+Usage: #{program} [options] <script.rb> -- <script.rb parameters>
+EOB
+  opts.separator ""
+  opts.separator "Options:"
+  opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") do |s|
+    Debugger.annotate = s
+  end
+  opts.on("-d", "--debug", "Set $DEBUG=true") {$DEBUG = true}
+  opts.on("--emacs-basic", "Activates basic Emacs mode") do 
+    ENV['EMACS'] = '1'
+    options.emacs = true
+  end
+  opts.on("-m", "--post-mortem", "Activate post-mortem mode") do 
+    options.post_mortem = true
+  end
+  opts.on("--no-control", "Do not automatically start control thread") do 
+    options.control = false
+  end
+  opts.on("--no-quit", "Do not quit when script finishes") do
+    options.noquit = true
+  end
+  opts.on("--no-stop", "Do not stop when script is loaded") do 
+    options.nostop = true
+  end
+  opts.on("-nx", "Not run debugger initialization files (e.g. .rdebugrc") do
+    options.nx = true
+  end
+  opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
+    $LOAD_PATH.unshift(path)
+  end
+  opts.on("-r", "--require SCRIPT", String,
+          "Require the library, before executing your script") do |name|
+    if name == 'debug'
+      puts "ruby-debug is not compatible with Ruby's 'debug' library. This option is ignored."
+    else
+      require name
+    end
+  end
+  opts.on("--script FILE", String, "Name of the script file to run") do |s|
+    options.script = s
+    unless File.exists?(options.script)
+      puts "Script file '#{options.script}' is not found"
+      exit
+    end
+  end
+  opts.on("-x", "--trace", "Turn on line tracing") {options.tracing = true}
+  ENV['EMACS'] = nil unless options.emacs
+  opts.separator ""
+  opts.separator "Common options:"
+  opts.on_tail("--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on_tail("--version", 
+               "Print the version") do
+    puts "ruby-debug #{Debugger::VERSION}"
+    exit
+  end
+  opts.on("--verbose", "Turn on verbose mode") do
+    $VERBOSE = true
+    options.verbose_long = true
+  end
+  opts.on_tail("-v", 
+               "Print version number, then turn on verbose mode") do
+    puts "ruby-debug #{Debugger::VERSION}"
+    $VERBOSE = true
+  end
+end
+
+begin
+  if not defined? Debugger::ARGV
+    Debugger::ARGV = ARGV.clone
+  end
+  rdebug_path = File.expand_path($0)
+  if RUBY_PLATFORM =~ /mswin/
+    rdebug_path += '.cmd' unless rdebug_path =~ /\.cmd$/i
+  end
+  Debugger::RDEBUG_SCRIPT = rdebug_path
+  Debugger::RDEBUG_FILE = __FILE__
+  Debugger::INITIAL_DIR = Dir.pwd
+  opts.parse! ARGV
+rescue StandardError => e
+  puts opts
+  puts
+  puts e.message
+  exit(-1)
+end
+
+if ARGV.empty?
+  exit if $VERBOSE and not options.verbose_long
+  puts opts
+  puts
+  puts 'Must specify a script to run'
+  exit(-1)
+end
+  
+# save script name
+Debugger::PROG_SCRIPT = ARGV.shift
+
+# install interruption handler
+trap('INT') { Debugger.interrupt_last }
+
+# set options
+Debugger.wait_connection = false
+
+# Add Debugger trace hook.
+Debugger.start
+
+# start control thread
+Debugger.start_control(options.host, options.cport) if options.control
+
+# activate post-mortem
+Debugger.post_mortem if options.post_mortem
+
+# Set up an interface to read commands from a debugger script file.
+if options.script
+  Debugger.interface = Debugger::ScriptInterface.new(options.script, 
+                                                     STDOUT, true)
+end
+options.nostop = true if options.tracing
+Debugger.tracing = options.tracing
+
+# Make sure Ruby script syntax checks okay.
+# Otherwise we get a load message that looks like rdebug has 
+# a problem. 
+output = `ruby -c #{Debugger::PROG_SCRIPT} 2>&1`
+if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+  puts output
+  exit $?.exitstatus 
+end
+
+# load initrc script (e.g. .rdebugrc)
+Debugger.run_init_script(StringIO.new) unless options.nx
+
+# run startup script if specified
+if options.script
+  Debugger.run_script(options.script)
+end
+# activate post-mortem
+Debugger.post_mortem if options.post_mortem
+options.stop = false if options.tracing
+Debugger.tracing = options.tracing
+
+if options.noquit
+  if Debugger.started?
+    until Debugger.stop do end
+  end
+  debug_program(options)
+  print "The program finished.\n" unless 
+    Debugger.annotate.to_i > 1 # annotate has its own way
+  interface = Debugger::LocalInterface.new
+  # Not sure if ControlCommandProcessor is really the right
+  # thing to use. CommandProcessor requires a state.
+  processor = Debugger::ControlCommandProcessor.new(interface)
+  processor.process_commands
+else
+  debug_program(options)
+end