linecache19 0.5.11

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/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

data/test/test-tracelines.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# $Id$
+require 'test/unit'
+require 'fileutils'
+require 'tempfile'
+
+# require 'rubygems'
+# require 'ruby-debug'; Debugger.init
+
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+# 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, 'tracelines19.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__)
+  }
+  
+  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)
+    assert_equal([2, 9], rcov_lines)
+  end
+
+  def test_for_string_array
+    load(@@rcov_file, 0) 
+    rcov_lines = 
+      TraceLineNumbers.lnums_for_str_array(SCRIPT_LINES__[@@rcov_file])
+    assert_equal(@@rcov_lnums, rcov_lines)
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: linecache19
+version: !ruby/object:Gem::Version 
+  version: 0.5.11
+platform: ruby
+authors: 
+- R. Bernstein
+- Mark Moseley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby_core_source
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.4
+    version: 
+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: mark@fast-software.com
+executables: []
+
+extensions: 
+- ext/trace_nums/extconf.rb
+extra_rdoc_files: 
+- README
+- lib/linecache19.rb
+- lib/tracelines19.rb
+files: 
+- AUTHORS
+- COPYING
+- ChangeLog
+- NEWS
+- README
+- Rakefile
+- VERSION
+- ext/trace_nums/extconf.rb
+- ext/trace_nums/trace_nums.c
+- ext/trace_nums/trace_nums.h
+- lib/linecache19.rb
+- lib/tracelines19.rb
+- test/short-file
+- test/lnum-diag.rb
+- test/parse-show.rb
+- test/rcov-bug.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/ruby-debug19
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-debug19
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Read file with caching
+test_files: 
+- test/test-linecache.rb
+- test/test-tracelines.rb