ruby-debug 0.10.0 → 0.10.1

data/test/raise.rb

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

data/test/tdebug.rb

@@ -1,20 +1,68 @@
 #!/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.expand_path(File.dirname(__FILE__), "..")) unless 
+TOP_SRC_DIR = File.join(File.dirname(__FILE__), "..") unless 
   defined?(TOP_SRC_DIR)
 
-$: << File.join(TOP_SRC_DIR, "ext")
-$: << File.join(TOP_SRC_DIR, "lib")
-$: << File.join(TOP_SRC_DIR, "cli")
+$:.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
+    $0[0..-1] = d0
+  end
+  bt = Debugger.debug_load(Debugger::PROG_SCRIPT, !options.nostop)
+  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,
   'frame_bind'  => false,
   'no-quit'     => false,
   'no-stop'     => false,
@@ -37,23 +85,31 @@ EOB
   opts.separator ""
   opts.separator "Options:"
   opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") do 
-    |Debugger::annotate|
+    |Debugger.annotate|
   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("--keep-frame-binding", "Keep frame bindings") do 
     options.frame_bind = 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") {
+  opts.on("--no-quit", "Do not quit when script finishes") do
     options.noquit = true
-  }
-  opts.on("-n", "--no-stop", "Do not stop when script is loaded") {options.nostop = 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("-m", "--post-mortem", "Activate post-mortem mode") {options.post_mortem = true}
   opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
     $LOAD_PATH.unshift(path)
   end
@@ -72,7 +128,7 @@ EOB
     end
   end
   opts.on("-x", "--trace", "Turn on line tracing") {options.tracing = true}
-  ENV['EMACS'] = nil
+  ENV['EMACS'] = nil unless options.emacs
   opts.separator ""
   opts.separator "Common options:"
   opts.on_tail("--help", "Show this message") do
@@ -101,9 +157,10 @@ begin
   end
   rdebug_path = File.expand_path($0)
   if RUBY_PLATFORM =~ /mswin/
-    rdebug_path += ".cmd" unless rdebug_path =~ /\.cmd$/i
+    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
@@ -117,7 +174,7 @@ if ARGV.empty?
   exit if $VERBOSE and not options.verbose_long
   puts opts
   puts
-  puts "Must specify a script to run"
+  puts 'Must specify a script to run'
   exit(-1)
 end
   
@@ -138,9 +195,12 @@ Debugger.start
 Debugger.post_mortem if options.post_mortem
 
 # Set up an interface to read commands from a debugger script file.
-Debugger.interface = Debugger::ScriptInterface.new(options.script, 
-                                                   STDOUT, true)
-Debugger.tracing = options.nostop = true if options.tracing
+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 
@@ -164,33 +224,21 @@ if options.script
 end
 # activate post-mortem
 Debugger.post_mortem if options.post_mortem
-Debugger.tracing = options.nostop = true if options.tracing
+options.stop = false 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
 if options.noquit
-  while true do
-    Debugger.stop if Debugger.started?
-    begin
-      Debugger.debug_load Debugger::PROG_SCRIPT, !options.nostop
-    rescue
-      print $!.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
-      print "Uncaught exception: #{$!}\n"
-    end
-    # FIXME: add status for whether we are interactive or not.
-    # if STDIN.tty? and !options.nostop
-    if !options.nostop
-      print "The program has finished and will be restarted.\n"
-    else
-      break
-    end
+  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
-  Debugger.debug_load Debugger::PROG_SCRIPT, !options.nostop
+  debug_program(options)
 end

data/test/test-annotate.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'fileutils'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test annotate handling.
+class TestAnnotate < Test::Unit::TestCase
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='annotate'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- gcd.rb 3 5"))
+    end
+  end
+end

data/test/test-break-bad.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test (mostly) invalid breakpoint commands
+class TestBadBreak < Test::Unit::TestCase
+
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='break_bad'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- gcd.rb 3 5"))
+    end
+  end
+end

data/test/test-breakpoints.rb

@@ -1,28 +1,25 @@
 #!/usr/bin/env ruby
-require "test/unit"
-require "fileutils"
+require 'test/unit'
 
-# require "rubygems"
-# require "ruby-debug"
-# Debugger.start
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
 
-SRC_DIR = File.expand_path(File.dirname(__FILE__)) + "/" unless 
-  defined?(SRC_DIR)
-
-require File.join(SRC_DIR, "helper.rb")
+# Test breakpoint commands
+class TestBreakpoints < Test::Unit::TestCase
 
-include TestHelper
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
 
-# Test frame commands
-class TestBreakpoints < Test::Unit::TestCase
-  require 'stringio'
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
 
-  # Test commands in stepping.rb
   def test_basic
-    Dir.chdir(SRC_DIR) do 
+    testname='breakpoints'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
       assert_equal(true, 
-                   run_debugger("breakpoints", 
-                                "--script breakpoints.cmd -- gcd.rb 3 5"))
+                   run_debugger(testname,
+                                "--script #{script} -- gcd.rb 3 5"))
     end
   end
 end

data/test/test-condition.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test condition command
+class TestBreakpoints < Test::Unit::TestCase
+
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='condition'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- gcd.rb 3 5"))
+    end
+  end
+end

data/test/test-ctrl.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug' ; Debugger.start
+
+require 'test/unit'
+SRC_DIR = File.dirname(__FILE__) unless 
+  defined?(SRC_DIR)
+%w(ext lib cli).each do |dir|
+  $: <<  File.join(SRC_DIR, '..', dir)
+end
+require 'ruby_debug'
+require File.join(SRC_DIR, '..', 'cli', 'ruby-debug')
+
+# Test Local Control Interface
+class TestCtrl < Test::Unit::TestCase
+
+  def cheap_diff(got_lines, correct_lines, outfile)
+    if correct_lines.size != got_lines.size
+      puts "Size difference #{correct_lines.size} vs. #{got_lines.size}"
+      File.open(outfile, 'w') {|f| f.puts got_lines}
+      return false
+    end
+    correct_lines.each_with_index do |line, i|
+      correct_lines[i].chomp!
+      if got_lines[i] != correct_lines[i]
+        puts "difference found at line #{i+1}"
+        puts "got : #{got_lines[i]}"
+        puts "need: #{correct_lines[i]}"
+        return false
+      end
+    end
+  end
+
+  require 'stringio'
+
+  # Test initial variables and setting/getting state.
+  def test_ctrl
+    ENV['COLUMNS'] = '80'
+    ENV['EMACS'] = nil
+    testbase = 'ctrl'
+    out = StringIO.new('', 'w')
+    Dir.chdir(SRC_DIR) do
+      script = File.join('data', "#{testbase}.cmd")
+      interface = Debugger::ScriptInterface.new(script, out)
+      processor = Debugger::ControlCommandProcessor.new(interface)
+      processor.process_commands
+      got_lines = out.string.split("\n")
+      right_file = File.join('data', "#{testbase}.right")
+      correct_lines = File.readlines(right_file)
+      assert cheap_diff(got_lines, correct_lines, "#{testbase}.out")
+    end
+  end
+end

data/test/test-display.rb

@@ -1,26 +1,26 @@
 #!/usr/bin/env ruby
-require "test/unit"
-require "fileutils"
+require 'test/unit'
 
-# require "rubygems" ; require "ruby-debug"
-# Debugger.start
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
 
-SRC_DIR = File.expand_path(File.dirname(__FILE__)) + "/" unless 
-  defined?(SRC_DIR)
+# Test Display commands
+class TestDisplay < Test::Unit::TestCase
 
-require File.join(SRC_DIR, "helper.rb")
-include TestHelper
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
 
-# Test info commands
-class TestDisplay < Test::Unit::TestCase
-  require 'stringio'
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
 
-  # Test commands in stepping.rb
+  # Test commands in display.rb
   def test_basic
-    Dir.chdir(SRC_DIR) do 
+    testname='display'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
       assert_equal(true, 
-                   run_debugger("display", 
-                                "--script display.cmd -- gcd.rb 3 5"))
+                   run_debugger(testname, 
+                                "--script #{script} -- gcd.rb 3 5"))
     end
   end
 end

data/test/test-dollar-0.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test --no-stop and $0 setting.
+class TestDollar0 < Test::Unit::TestCase
+  
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='breakpoints'
+    Dir.chdir(@@SRC_DIR) do 
+      home_save = ENV['HOME']
+      ENV['HOME'] = '.'
+      assert_equal(true, 
+                   run_debugger('dollar-0', 
+                                '-nx --no-stop ./dollar-0.rb',
+                                nil, nil, false, '../bin/rdebug'))
+      # Ruby's __FILE__ seems to prepend ./ when no directory was added.
+      assert_equal(true, 
+                   run_debugger('dollar-0a', 
+                                '-nx --no-stop dollar-0.rb',
+                                nil, nil, false, '../bin/rdebug'))
+      # Ruby's __FILE__ seems to prepend ./ when no directory was added.
+      assert_equal(true, 
+                   run_debugger('dollar-0b', 
+                                '-nx --no-stop ' + 
+                                File.join('..', 'test', 'dollar-0.rb'),
+                                nil, nil, false, '../bin/rdebug'))
+      ENV['HOME'] = home_save
+    end
+  end
+end