ruby-debug 0.10.5.rc1 → 0.10.5.rc2

data/test/example/file with space.rb

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

data/test/example/gcd.rb

@@ -1,18 +0,0 @@
-#!/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

@@ -1,47 +0,0 @@
-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

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

data/test/example/null.rb

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

data/test/example/output.rb

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

data/test/example/pm-bug.rb

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

data/test/example/pm.rb

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

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

data/test/gcd-dbg-nox.rb

@@ -1,31 +0,0 @@
-# This program is *NOT* supposed to be executable, but called
-# via ruby (in order to test that restart provides a funky $:).
-# This program is used to test that 'restart' works when we didn't call
-# the debugger initially.
-
-TOP_SRC_DIR = File.join(File.expand_path(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')
-require 'ruby-debug'
-Debugger.init
-
-# GCD. We assume positive numbers
-def gcd(a, b)
-  # Make: a <= b
-  debugger
-  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/gcd-dbg.rb

@@ -1,30 +0,0 @@
-#!/usr/bin/env ruby
-# This program is used to test that 'restart' works when we didn't call
-# the debugger initially.
-
-TOP_SRC_DIR = File.join(File.expand_path(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")
-require 'ruby-debug'
-Debugger.start
-
-# GCD. We assume positive numbers
-def gcd(a, b)
-  # Make: a <= b
-  debugger
-  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/helper.rb

@@ -1,167 +0,0 @@
-# Some common routines used in testing.
-
-require 'rubygems'
-require 'test/unit'
-
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
-$LOAD_PATH.unshift File.expand_path("../../cli", __FILE__)
-require 'ruby-debug'
-
-require 'fileutils'
-require 'yaml'
-
-# begin require 'rubygems' rescue LoadError end
-# require 'ruby-debug'; Debugger.start
-
-module TestHelper
-  def run_debugger(testname, args = '', opts = {})
-    Dir.chdir(File.dirname(__FILE__)) do
-      rightfile = opts[:rightfile] || rightfile(testname)
-      outfile   = opts[:outfile]   || "#{testname}.out"
-      debug_pgm = opts[:runner]    || 'tdebug.rb'
-      filter    = opts[:filter]
-
-      if File.exists?(outfile)
-        FileUtils.rm(outfile)
-      end
-
-      ENV['RDEBUG'] = debug_pgm
-      ENV['TERM']   = ''
-
-      # The EMACS environment variable(s) cause output to 
-      # get prefaced with null which will mess up file compares.
-      # So turn off EMACS output processing.
-      ENV['EMACS'] = ENV['INSIDE_EMACS'] = nil
-
-      cmd = "#{load_ruby} #{load_params} ../rdbg.rb #{args} > #{outfile}"
-      puts "'#{cmd}'" if $DEBUG
-      `#{cmd}`
-
-      got_lines     = File.read(outfile).split(/\n/)
-      correct_lines = File.read(rightfile).split(/\n/)
-      filter.call(got_lines, correct_lines) if filter
-
-      if cheap_diff(got_lines, correct_lines)
-        FileUtils.rm(outfile)
-        return true
-      end
-
-      false
-    end
-  end
-
-  def rightfile(testname)
-    jruby_file = File.join('data', "#{testname}-jruby.right")
-    if defined?(JRUBY_VERSION) && File.exists?(jruby_file)
-      jruby_file
-    else
-      File.join('data', "#{testname}.right")
-    end
-  end
-
-  def cheap_diff(got_lines, correct_lines)
-    if $DEBUG
-      got_lines.each_with_index do |line, i|
-        printf "%3d %s\n", i+1, line
-      end
-    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
-    if correct_lines.size != got_lines.size
-      puts("difference in number of lines: " + 
-           "#{correct_lines.size} vs. #{got_lines.size}")
-      return false
-    end
-    return true
-  end
-
-  # FIXME: using this causes the same test to get run several times 
-  # and some tests fail probably because of a lack of environment isolation.
-  # Many tests follow a basic pattern: run the debugger with a given
-  # debugger script and compare output produced. The following creates
-  # this kind of test.
-  def add_test(base_name, src_dir, script_name=nil, cmd=nil, test_name=nil)
-    puts "+++ Adding #{base_name} ++++" if $DEBUG
-    test_name   = File.join('.', 'example', base_name) unless test_name
-    script_name = File.join('data', test_name + '.cmd') unless script_name
-    cmd         = 'gcd.rb 3 5' unless cmd
-    eval <<-EOF
-    def test_#{test_name}
-      Dir.chdir(\"#{src_dir}\") do 
-        assert_equal(true, 
-                     run_debugger(\"#{base_name}\", 
-                                  \"--script #{script_name} -- #{cmd}\"))
-      end
-    end
-    EOF
-  end
-  module_function :add_test
-               
-  # Adapted from the Ruby Cookbook, Section 6.10: Comparing two files.
-  # def diff_as_string(rightfile, checkfile, format=:unified, context_lines=3)
-  #   right_data = File.read(rightfile)
-  #   check_data = File.read(checkfile)
-  #   output = ''
-  #   diffs = Diff::LCS.diff(right_data, check_data)
-  #   return output if diffs.empty?
-  #   oldhunk = hunk = nil
-  #   file_length_difference = 0
-  #   diffs.each do |piece|
-  #     begin
-  #       hunk = Diff::LCS::Hunk.new(right_data, check_data, piece, 
-  #                                  context_lines, file_length_difference)
-  #       next unless oldhunk
-  #
-  #       # Hunks may overlap, which is why we need to be careful when our
-  #       # diff includes lines of context. Otherwise, we might print
-  #       # redundant lines.
-  #       if (context_lines > 0) and hunk.overlaps?(oldhunk)
-  #         hunk.unshift(oldhunk)
-  #         else
-  #         output << oldhunk.diff(format)
-  #       end
-  #     ensure
-  #       oldhunk = hunk
-  #       output << '\n'
-  #     end
-  #   end
-  
-  #   # Handle the last remaining hunk 
-  #   output << oldhunk.diff(format) << '\n'
-  # end
-  
-  # Loads key from the _config_._yaml_ file.
-  def config_load(key, may_be_nil=false, default_value='')
-    conf = File.join('config.private.yaml') # try private first
-    unless File.exists?(conf)
-      if defined?(JRUBY_VERSION)
-        conf = File.join('config.jruby.yaml')
-      else
-        conf = File.join('config.yaml')
-      end
-    end
-    value = YAML.load_file(conf)[key]
-    assert_not_nil(value, "#{key} is set in config.yaml") unless may_be_nil
-    value || default_value
-  end
-  module_function :config_load
-
-  def load_ruby
-    config_load('ruby', true)
-  end
-  module_function :load_ruby
-
-  def load_params
-    config_load('ruby_params', true)
-  end
-  module_function :load_params
-  
-end
-

data/test/pm-base.rb

@@ -1,22 +0,0 @@
-#!/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/rdebug-save.1

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

data/test/tdebug.rb

@@ -1,252 +0,0 @@
-#!/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.inspect} 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,
-  'frame_bind'  => 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 
-    |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") 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 |options.script| 
-    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
-Debugger.keep_frame_binding = options.frame_bind
-
-# 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.inspect} 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