rbx-linecache 0.44-universal-rubinius

data/test/data/if4.rb

@@ -0,0 +1,14 @@
+# [ 6, 6, 7, 8, 10]
+
+# 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, 3, 3, 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 ]
+x = 2 if x=3
+  
+

data/test/data/if7.rb

@@ -0,0 +1,8 @@
+# [ 2, 2, 3, 4, 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 @@
+# [ 3 ]
+# MATCH3 
+3 =~ /
+  x*
+/

data/test/data/match3a.rb

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

data/test/data/not-lit.rb

@@ -0,0 +1,6 @@
+# [ 3, 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', 'tracelines.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,167 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'fileutils'
+require 'tempfile'
+require 'set'
+
+# 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, 'linecache.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')
+    ## ?? Not sure if this is correct.
+    assert_equal([1], LineCache::trace_line_numbers(test_file))
+    test_file = File.join(@@TEST_DIR, 'short-file2')
+    assert_equal([1], LineCache::trace_line_numbers(test_file))
+    test_file = File.join(@@TEST_DIR, 'rcov-bug.rb')
+    assert_equal([3, 7, 8], LineCache::trace_line_numbers(test_file))
+  end
+
+  def test_sha1
+    test_file = File.join(@@TEST_DIR, 'short-file') 
+    LineCache::cache(test_file)
+    assert_equal('3e1d87f3399fc73ae5683e106bce1b5ba823fc50',
+                 LineCache::sha1(test_file))
+  end
+
+  def test_script
+    x = nil
+    line1 = "loc = Rubinius::VM::backtrace(0)[0]"
+    eval(line1 + "
+  x = LineCache::getline(loc.static_scope.script, 1)")
+    assert_equal(line1, x)
+    eval("loc = Rubinius::VM::backtrace(0)[0]
+  assert_equal(2, LineCache::size(loc.static_scope.script))")
+    string = "loc = Rubinius::VM::backtrace(0)[0]
+  LineCache::map_script(loc.static_scope.script)"
+    temp_filename = eval(string)
+    got_lines = File.open(temp_filename).readlines.join('')
+    assert_equal(string, got_lines.chomp)
+    assert_equal(1, File.unlink(temp_filename))
+  end
+
+end

data/test/test-lnum.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# $Id$
+require 'test/unit'
+
+# Test TraceLineNumbers module
+class TestLineNumbers2 < Test::Unit::TestCase
+  @@TEST_DIR = File.expand_path(File.dirname(__FILE__))
+  @@TOP_SRC_DIR = File.join(@@TEST_DIR, '..')
+  require File.join(@@TOP_SRC_DIR, 'lib', 'tracelines.rb')
+  
+  def test_all_lnum_data
+    test_dir = File.join(@@TEST_DIR, 'data')
+    Dir.chdir(test_dir) do 
+      Dir.glob('*.rb').sort.each do |f|
+        fp = File.open(f, 'r')
+        lines = fp.read
+        fp.rewind
+        first_line = fp.readline.chomp
+        fp.close()
+        expected_str = first_line[1..-1]
+        begin
+          expected_lnums = eval(expected_str, binding, __FILE__, __LINE__)
+        rescue
+          assert nil, "Failed reading expected values from #{f}"
+        else
+          got_lnums = TraceLineNumbers.lnums_for_str(lines)
+          assert_equal(expected_lnums, got_lnums, "Comparing file #{f}")
+        end
+      end
+    end
+  end
+end

data/test/test-tracelines.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# $Id: test-tracelines.rb 235 2010-12-25 14:22:47Z rockyb $
+require 'test/unit'
+require 'fileutils'
+require 'tempfile'
+
+# Test TestLineNumbers module
+class TestLineNumbers1 < 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, 'tracelines.rb')
+
+  @@rcov_file = File.join(@@TEST_DIR, 'rcov-bug.rb')
+  # File.open(@@rcov_file, 'r') {|fp|
+  #   first_line = fp.readline[1..-2]
+  #   @@rcov_lnums = eval(first_line, binding, __FILE__, __LINE__)
+  # }
+  @@rcov_lnums = [3, 7, 8]
+
+  def test_for_file
+    rcov_lines = TraceLineNumbers.lnums_for_file(@@rcov_file)
+    assert_equal(@@rcov_lnums, rcov_lines)
+  end
+
+  def test_for_string
+    string = "# Some rcov bugs.\nz = \"\nNow is the time\n\"\n\nz =~ \n     /\n      5\n     /ix\n"
+    rcov_lines = TraceLineNumbers.lnums_for_str(string)
+    check = [2, 6, 7]
+    # check = [2, 9]
+    assert_equal(check, rcov_lines)
+  end
+
+  def test_for_string_array
+    lines = File.open(@@rcov_file).readlines
+    rcov_lines = 
+      TraceLineNumbers.lnums_for_str_array(lines)
+    assert_equal(@@rcov_lnums, rcov_lines)
+  end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: rbx-linecache
+version: !ruby/object:Gem::Version 
+  hash: 83
+  prerelease: false
+  segments: 
+  - 0
+  - 44
+  version: "0.44"
+platform: universal-rubinius
+authors: 
+- R. Bernstein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rbx-require-relative
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: |
+  LineCache is a module for reading and caching lines. This may be useful for
+  example in a debugger where the same lines are shown many times.
+
+email: rockyb@rubyforge.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- lib/linecache.rb
+- lib/tracelines.rb
+files: 
+- AUTHORS
+- COPYING
+- ChangeLog
+- NEWS
+- README
+- Rakefile
+- lib/tracelines.rb
+- lib/linecache.rb
+- test/parse-show.rb
+- test/lnum-diag.rb
+- test/rcov-bug.rb
+- test/test-lnum.rb
+- test/test-linecache.rb
+- test/test-tracelines.rb
+- test/data/if1.rb
+- test/data/comments1.rb
+- test/data/not-lit.rb
+- test/data/begin2.rb
+- test/data/block2.rb
+- test/data/if6.rb
+- test/data/end.rb
+- test/data/case4.rb
+- test/data/begin1.rb
+- test/data/for1.rb
+- test/data/match.rb
+- test/data/match3a.rb
+- test/data/class1.rb
+- test/data/if3.rb
+- test/data/if5.rb
+- test/data/case1.rb
+- test/data/def1.rb
+- test/data/if7.rb
+- test/data/block1.rb
+- test/data/begin3.rb
+- test/data/case3.rb
+- test/data/case2.rb
+- test/data/each1.rb
+- test/data/if2.rb
+- test/data/match3.rb
+- test/data/if4.rb
+- test/data/case5.rb
+- test/short-file
+- test/short-file2
+has_rdoc: true
+homepage: http://wiki.github.com/rocky/rbx-trepanning
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: 
+- --title
+- LineCache 0.44 Documentation
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rocky-hacks
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Read file with caching
+test_files: 
+- test/parse-show.rb
+- test/lnum-diag.rb
+- test/rcov-bug.rb
+- test/test-lnum.rb
+- test/test-linecache.rb
+- test/test-tracelines.rb