debugger-linecache 1.0.0

data/lib/tracelines19.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# $Id$
+begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug' ; Debugger.start(:post-mortem => true)
+
+module TraceLineNumbers
+  @@SRC_DIR = File.expand_path(File.dirname(__FILE__))
+  begin
+    require File.join(@@SRC_DIR, '..', 'ext\trace_nums', 'trace_nums19')
+  rescue LoadError
+    # MSWindows seems to put this in lib rather than ext.
+    require File.join(@@SRC_DIR, '..', 'lib', 'trace_nums19')
+  end
+
+  # Return an array of lines numbers that could be 
+  # stopped at given a file name of a Ruby program.
+  def lnums_for_file(file)
+    lnums_for_str(File.read(file))
+  end
+  module_function :lnums_for_file
+
+  # Return an array of lines numbers that could be 
+  # stopped at given a file name of a Ruby program.
+  # We assume the each line has \n at the end. If not 
+  # set the newline parameters to \n.
+  def lnums_for_str_array(string_array, newline='')
+    lnums_for_str(string_array.join(newline))
+  end
+  module_function :lnums_for_str_array
+end
+
+if __FILE__ == $0
+  SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+  # test_file = '../test/rcov-bug.rb'
+  test_file = '../test/lnum-data/begin1.rb'
+  if  File.exists?(test_file)
+    puts TraceLineNumbers.lnums_for_file(test_file).inspect 
+    load(test_file, 0) # for later
+  end
+  puts TraceLineNumbers.lnums_for_file(__FILE__).inspect
+  unless SCRIPT_LINES__.empty?
+    key = SCRIPT_LINES__.keys.first
+    puts key
+    puts SCRIPT_LINES__[key]
+    puts TraceLineNumbers.lnums_for_str_array(SCRIPT_LINES__[key]).inspect
+  end
+end

data/svn2cl_usermap

@@ -0,0 +1 @@
+rockyb:Rocky Bernstein

data/test/data/begin1.rb

@@ -0,0 +1,3 @@
+# [ 2 ]
+begin
+end

data/test/data/begin2.rb

@@ -0,0 +1,3 @@
+# [ 2, 2 ]
+begin begin end end
+  

data/test/data/begin3.rb

@@ -0,0 +1,6 @@
+# [ 2, 3 ]
+begin
+  begin
+  end
+end 
+

data/test/data/block1.rb

@@ -0,0 +1,7 @@
+# [2, 2, 3, 4, 6, 6]
+if true
+  puts '3'
+  puts '4'
+end
+if true
+end

data/test/data/block2.rb

@@ -0,0 +1,4 @@
+# [2, 4, 4]
+def foo(&block)
+end
+foo{4}

data/test/data/case1.rb

@@ -0,0 +1,6 @@
+# [ 2, 3, 4 ]
+case 2
+when 3
+when 4
+else
+end

data/test/data/case2.rb

@@ -0,0 +1,5 @@
+# [ 5, 3, 4 ]
+case 
+when 3 != 3
+when 4 != 4
+end

data/test/data/case3.rb

@@ -0,0 +1,5 @@
+# [2, 3, 4]
+case "2"
+when Array
+when Fixnum
+end

data/test/data/case4.rb

@@ -0,0 +1,4 @@
+# [2, 3, 3]
+case "2"
+when Array, Fixnum
+end

data/test/data/case5.rb

@@ -0,0 +1,10 @@
+# [3, 4, 5, 6, 7, 9]
+# Note: lines 5 and 7 won't appear in a trace.
+case '3'
+when '4'
+  x = 5
+when '6'
+  x = 7
+else
+  x = 9
+end

data/test/data/class1.rb

@@ -0,0 +1,5 @@
+# [3, 4]
+class
+  A 
+  class B ; 
+  end end

data/test/data/comments1.rb

@@ -0,0 +1,6 @@
+# []
+
+ # space here and in next line
+
+ 
+

data/test/data/def1.rb

@@ -0,0 +1,9 @@
+# [3, 4, 8]
+def 
+  a ; end
+def b 
+end
+def c(
+      a=7,
+      b=8)
+end

data/test/data/each1.rb

@@ -0,0 +1,3 @@
+# [ 2 ]
+[2].each { }
+

data/test/data/end.rb

@@ -0,0 +1,3 @@
+# [ 3 ]
+# POSTEXE
+END { }

data/test/data/for1.rb

@@ -0,0 +1,4 @@
+# [ 2, 3 ]
+for i in [2] 
+  i
+end

data/test/data/if1.rb

@@ -0,0 +1,4 @@
+# [ 2, 2 ]
+x = true ? 1 : 2
+  
+

data/test/data/if2.rb

@@ -0,0 +1,4 @@
+# [ 2, 2 ]
+x = 2 if false
+  
+

data/test/data/if3.rb

@@ -0,0 +1,9 @@
+# [ 2, 3, 4, 4, 5, 6]
+lines = ''
+opts = {:print_source => true}
+if opts[:print_source]
+    puts 5
+    puts lines
+end
+  
+

data/test/data/if4.rb

@@ -0,0 +1,14 @@
+# [ 6, 7, 7, 10, 8]
+
+# Running through Tracer will not give the line numbers in the same
+# order. Also note 9 before 7. This is because in the parse tree
+# != has been turned into == with the branches switched.
+[true, false].each do |t|
+  if t != true
+    8
+  else
+    10
+  end
+end
+  
+

data/test/data/if5.rb

@@ -0,0 +1,7 @@
+# [2, 4, 4]
+x=2 
+x=3 if x='a' or
+  false
+# What's weird here is we get two stops on line 4 and both times x is
+# 4. In Ruby 1.9 we don't get *any* line traces.
+

data/test/data/if6.rb

@@ -0,0 +1,4 @@
+# [ 2, 2 ]
+x = 2 if x=3
+  
+

data/test/data/if7.rb

@@ -0,0 +1,8 @@
+# [ 2, 3, 4, 6, 6 ]
+def f()
+  y=1
+  true
+end
+x = 2 if f()
+  
+

data/test/data/match.rb

@@ -0,0 +1,3 @@
+# [ 3 ]
+# MATCH -- FIXME we are not getting a match token.
+/.*/

data/test/data/match3.rb

@@ -0,0 +1,5 @@
+# [ 5 ]
+# MATCH3 
+3 =~ /
+  x*
+/

data/test/data/match3a.rb

@@ -0,0 +1,6 @@
+# [ 3, 6 ]
+# MATCH3 
+y = 3
+4 =~ /
+  #{y}*
+/

data/test/data/not-lit.rb

@@ -0,0 +1,6 @@
+# [ 4, 6 ]
+# not and lit
+3 
+not 4
+not 
+  6

data/test/lnum-diag.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug' ; Debugger.start
+
+TEST_DIR = File.expand_path(File.dirname(__FILE__))
+TOP_SRC_DIR = File.join(TEST_DIR, '..')
+require File.join(TOP_SRC_DIR, 'lib', 'tracelines19.rb')
+
+def dump_file(file, opts)
+  puts file
+  begin
+    fp = File.open(file, 'r')
+  rescue Errno::ENOENT
+    puts "File #{file} is not readable."
+    return
+  end
+  lines = fp.read
+  if opts[:print_source]
+    puts '=' * 80
+    puts lines
+  end
+  if opts[:print_parse]
+    puts '=' * 80
+    cmd = "#{File.join(TEST_DIR, 'parse-show.rb')} #{file}"
+    system(cmd)
+  end
+  if opts[:print_trace]
+    require 'tracer'
+    puts '=' * 80
+    tracer = Tracer.new
+    tracer.add_filter lambda {|event, f, line, id, binding, klass|
+      __FILE__ != f && event == 'line'
+    }
+    tracer.on{load(file)}
+  end
+  expected_lnums = nil
+  if opts[:expect_line]
+    fp.rewind
+    first_line = fp.readline.chomp
+    expected_str = first_line[1..-1]
+    begin
+      expected_lnums = eval(expected_str, binding, __FILE__, __LINE__)
+    rescue SyntaxError
+      puts '=' * 80
+      puts "Failed reading expected values from #{file}"
+    end
+  end
+  fp.close()
+  got_lnums = TraceLineNumbers.lnums_for_str(lines)
+  if expected_lnums
+    puts "expecting: #{expected_lnums.inspect}"
+    puts '-' * 80
+    if expected_lnums 
+      if got_lnums != expected_lnums
+        puts "mismatch: #{got_lnums.inspect}"
+      else
+        puts 'Got what was expected.'
+      end
+    else
+      puts got_lnums.inspect
+    end
+  else
+    puts got_lnums.inspect
+  end
+end
+
+require 'getoptlong'
+program = File.basename($0)
+opts = {
+  :print_source => true,  # Print source file? 
+  :print_trace  => true,  # Run Tracer over file? 
+  :expect_line  => true,  # Source file has expected (correct) list of lines?
+  :print_parse  => true,  # Show ParseTree output?
+}
+
+getopts = GetoptLong.new(
+                         [ '--expect',      '-e', GetoptLong::NO_ARGUMENT ],
+                         [ '--no-expect',   '-E', GetoptLong::NO_ARGUMENT ],
+                         [ '--help',        '-h', GetoptLong::NO_ARGUMENT ],
+                         [ '--parse',       '-p', GetoptLong::NO_ARGUMENT ],
+                         [ '--no-parse',    '-P', GetoptLong::NO_ARGUMENT ],
+                         [ '--source',      '-s', GetoptLong::NO_ARGUMENT ],
+                         [ '--no-source',   '-S', GetoptLong::NO_ARGUMENT ],
+                         [ '--trace',       '-t', GetoptLong::NO_ARGUMENT ],
+                         [ '--no-trace',    '-T', GetoptLong::NO_ARGUMENT ])
+
+getopts.each do |opt, arg|
+  case opt
+    when '--help'
+    puts "usage 
+Usage: #{$program} [options] file1 file2 ...
+
+Diagnostic program to make see what TraceLineNumbers does and compare
+against other output.
+
+options:
+    -e --expect      Read source file expected comment (default)
+    -E --no-expect   Don't look for source file expected comment
+    -p --parse       Show ParseTree Output (default)
+    -P --no-parse    Don't show ParseTree output
+    -s --source      Show source file (default)
+    -S --no-source   Don't print source
+    -t --trace       Show Tracer output (default)
+    -T --no-trace    Don't show Tracer output
+"
+  when '--expect'
+    opts[:expect_line] = true
+  when '--no-expect'
+    opts[:expect_line] = false
+  when '--parse'
+    opts[:print_parse] = true
+  when '--no-parse'
+    opts[:print_parse] = false
+  when '--source'
+    opts[:print_source] = true
+  when '--no-source'
+    opts[:print_source] = false
+  when '--trace'
+    opts[:print_trace] = true
+  when '--no-trace'
+    opts[:print_trace] = false
+  else
+    puts "Unknown and ignored option #{opt}"
+  end
+end
+
+ARGV.each do |file| 
+  dump_file(file, opts)
+end

data/test/parse-show.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+begin require 'rubygems' rescue LoadError end
+require 'parse_tree'
+
+ARGV.push "-" if ARGV.empty?
+
+parse_tree = ParseTree.new(true)
+
+ARGV.each do |file|
+  ruby = file == "-" ? $stdin.read : File.read(file)
+  pp parse_tree.parse_tree_for_string(ruby, file).first
+end

data/test/rcov-bug.rb

@@ -0,0 +1,10 @@
+# [3, 10]
+# Some rcov bugs.  
+z = "
+Now is the time
+"
+
+z =~ 
+     /
+      5
+     /ix

data/test/short-file

@@ -0,0 +1,2 @@
+# This is a small test file.
+

data/test/test-linecache.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'fileutils'
+require 'tempfile'
+require 'set'
+
+# require 'rubygems'
+# require 'ruby-debug'; Debugger.start
+
+# Test LineCache module
+class TestLineCache < Test::Unit::TestCase
+  @@TEST_DIR = File.expand_path(File.dirname(__FILE__))
+  @@TOP_SRC_DIR = File.join(@@TEST_DIR, '..', 'lib')
+  require File.join(@@TOP_SRC_DIR, 'linecache19.rb')
+  
+  def setup
+    LineCache::clear_file_cache
+  end
+  
+  def test_basic
+    fp = File.open(__FILE__, 'r')
+    compare_lines = fp.readlines()
+    fp.close
+    
+    # Test getlines to read this file.
+    lines = LineCache::getlines(__FILE__)
+    assert_equal(compare_lines, lines,
+                 'We should get exactly the same lines as reading this file.')
+    
+    # Test getline to read this file. The file should now be cached,
+    # so internally a different set of routines are used.
+    test_line = 1
+    line = LineCache::getline(__FILE__, test_line)
+    assert_equal(compare_lines[test_line-1], line,
+                 'We should get exactly the same line as reading this file.')
+    
+    # Test getting the line via a relative file name
+    Dir.chdir(File.dirname(__FILE__)) do 
+      short_file = File.basename(__FILE__)
+      test_line = 10
+      line = LineCache::getline(short_file, test_line)
+      assert_equal(compare_lines[test_line-1], line,
+                   'Short filename lookup should work')
+    end
+
+    # Write a temporary file; read contents, rewrite it and check that
+    # we get a change when calling getline.
+    tf = Tempfile.new("testing")
+    test_string = "Now is the time.\n"
+    tf.puts(test_string)
+    tf.close
+    line = LineCache::getline(tf.path, 1)
+    assert_equal(test_string, line,
+                 "C'mon - a simple line test like this worked before.")
+    tf.open
+    test_string = "Now is another time.\n"
+    tf.puts(test_string)
+    tf.close
+    LineCache::checkcache
+    line = LineCache::getline(tf.path, 1)
+    assert_equal(test_string, line,
+                 "checkcache should have reread the temporary file.")
+    FileUtils.rm tf.path
+
+    LineCache::update_cache(__FILE__)
+    LineCache::clear_file_cache
+  end
+
+  def test_cached
+    assert_equal(false, LineCache::cached?(__FILE__),
+                 "file #{__FILE__} shouldn't be cached - just cleared cache.")
+    line = LineCache::getline(__FILE__, 1)
+    assert line
+    assert_equal(true, LineCache::cached?(__FILE__),
+                 "file #{__FILE__} should now be cached")
+    assert_equal(false, LineCache::cached_script?('./short-file'),
+                 "Should not find './short-file' in SCRIPT_LINES__")
+    assert_equal(true, 78 < LineCache.size(__FILE__))
+    Dir.chdir(File.dirname(__FILE__)) do 
+      load('./short-file', 0)
+      assert_equal(true, LineCache::cached_script?('./short-file'),
+                   "Should be able to find './short-file' in SCRIPT_LINES__")
+    end
+  end
+
+  def test_remap
+    LineCache::remap_file(__FILE__, 'another-name')
+    line1 = LineCache::getline('another-name', 1)
+    line2 = LineCache::getline(__FILE__, 1)
+    assert_equal(line1, line2, 'Both lines should be the same via remap_file')
+  end
+
+  def test_remap_lines
+    LineCache::remap_file_lines(__FILE__, 'test2', (10..11), 6)
+
+    line5 = LineCache::getline(__FILE__, 5)
+    LineCache::remap_file_lines(__FILE__, 'test2', 9, 5)
+    rline9  = LineCache::getline('test2', 9)
+    assert_equal(line5, rline9, 
+                 'lines should be the same via remap_file_line - remap integer')
+
+    line6 = LineCache::getline(__FILE__, 6)
+    rline10 = LineCache::getline('test2', 10)
+    assert_equal(line6, rline10, 
+                 'lines should be the same via remap_file_line - range')
+
+    line7 = LineCache::getline(__FILE__, 7)
+    rline11 = LineCache::getline('test2', 11)
+    assert_equal(line7, rline11, 
+                 'lines should be the same via remap_file_line - range')
+
+    line8 = LineCache::getline(__FILE__, 8)
+    LineCache::remap_file_lines(__FILE__, nil, 20, 8)
+    rline20 = LineCache::getline(__FILE__, 20)
+    assert_equal(line8, rline20, 
+                 'lines should be the same via remap_file_line - nil file')
+  end
+
+  def test_stat
+    assert_equal(nil, LineCache::stat(__FILE__),
+                 "stat for #{__FILE__} shouldn't be nil - just cleared cache.")
+    line = LineCache::getline(__FILE__, 1)
+    assert line
+    assert(LineCache::stat(__FILE__),
+           "file #{__FILE__} should now have a stat")
+  end
+
+  def test_path
+    assert_equal(nil, LineCache::path(__FILE__),
+                 "path for #{__FILE__} should be nil - just cleared cache.")
+    path = LineCache::cache(__FILE__)
+    assert path
+    assert_equal(path, LineCache::path(__FILE__),
+           "path of #{__FILE__} should be the same as we got before")
+  end
+
+  def test_trace_line_numbers
+    test_file = File.join(@@TEST_DIR, 'short-file')
+    assert_equal([], LineCache::trace_line_numbers(test_file))
+    test_file = File.join(@@TEST_DIR, 'rcov-bug.rb')
+    assert_equal([3, 10], LineCache::trace_line_numbers(test_file))
+  end
+
+  def test_sha1
+    test_file = File.join(@@TEST_DIR, 'short-file') 
+    LineCache::cache(test_file)
+    assert_equal('1134f95ea84a3dcc67d7d1bf41390ee1a03af6d2',
+                 LineCache::sha1(test_file))
+  end
+
+end