linecache19-patched 0.5.13

data/README

@@ -0,0 +1,50 @@
+= LineCache - A module to read and cache file information of a Ruby program.
+
+== SYNOPSIS
+
+The LineCache module allows one to get any line from any file, caching
+the lines and file information on first access to the file. Although
+the file may be any file, the common use is when the file is a Ruby
+script since parsing of the file is done to figure out where the
+statement boundaries are.
+
+The routines here may be is useful when a small random sets of lines
+are read from a single file, in particular in a debugger to show
+source lines.
+
+== Summary
+
+  require 'linecache'
+  lines = LineCache::getlines('/tmp/myruby.rb')
+  # The following lines have same effect as the above.
+  $: << '/tmp'
+  Dir.chdir('/tmp') {lines = LineCache::getlines('myruby.rb')
+
+  line = LineCache::getline('/tmp/myruby.rb', 6)
+  # Note lines[6] == line (if /tmp/myruby.rb has 6 lines)
+
+  LineCache::clear_file_cache
+  LineCache::clear_file_cache('/tmp/myruby.rb')
+  LineCache::update_cache   # Check for modifications of all cached files.
+
+== Credits
+
+  This is a port of the module of the same name from the Python distribution.
+
+  The idea for how TraceLineNumbers works, and some code was taken
+  from ParseTree by Ryan Davis.
+
+== Other stuff
+
+Author::   Rocky Bernstein <rockyb@rubyforge.net>
+License::  Copyright (c) 2007, 2008 Rocky Bernstein
+           Released under the GNU GPL 2 license
+
+== Warranty
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+$Id$

data/lib/linecache19.rb

@@ -0,0 +1,409 @@
+#!/usr/bin/env ruby
+# $Id$
+# 
+#   Copyright (C) 2007, 2008 Rocky Bernstein <rockyb@rubyforge.net>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+#    02110-1301 USA.
+#
+
+# Author::    Rocky Bernstein  (mailto:rockyb@rubyforge.net)
+#
+# = linecache
+# A module to read and cache lines of a Ruby program. 
+# == Version
+# :include:VERSION
+
+# == SYNOPSIS
+#
+# The LineCache module allows one to get any line from any file,
+# caching lines of the file on first access to the file. Although the 
+# file may be any file, the common use is when the file is a Ruby
+# script since parsing of the file is done to figure out where the
+# statement boundaries are.
+#
+# The routines here may be is useful when a small random sets of lines
+# are read from a single file, in particular in a debugger to show
+# source lines.
+#
+#
+#  require 'linecache19'
+#  lines = LineCache::getlines('/tmp/myruby.rb')
+#  # The following lines have same effect as the above.
+#  $: << '/tmp'
+#  Dir.chdir('/tmp') {lines = LineCache::getlines('myruby.rb')
+#
+#  line = LineCache::getline('/tmp/myruby.rb', 6)
+#  # Note lines[6] == line (if /tmp/myruby.rb has 6 lines)
+#
+#  LineCache::clear_file_cache
+#  LineCache::clear_file_cache('/tmp/myruby.rb')
+#  LineCache::update_cache   # Check for modifications of all cached files.
+#
+# Some parts of the interface is derived from the Python module of the
+# same name.
+#
+
+# Defining SCRIPT_LINES__ causes Ruby to cache the lines of files
+# it reads. The key the setting of __FILE__ at the time when Ruby does
+# its read. LineCache keeps a separate copy of the lines elsewhere
+# and never destroys SCRIPT_LINES__
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+require 'digest/sha1'
+require 'set'
+
+begin require 'rubygems' rescue LoadError end
+require 'tracelines19'
+# require 'ruby-debug' ; Debugger.start
+
+# = module LineCache
+# A module to read and cache lines of a Ruby program. 
+module LineCache
+  LineCacheInfo = Struct.new(:stat, :line_numbers, :lines, :path, :sha1) unless
+    defined?(LineCacheInfo)
+ 
+  # The file cache. The key is a name as would be given by Ruby for 
+  # __FILE__. The value is a LineCacheInfo object. 
+  @@file_cache = {} 
+  
+  # Maps a string filename (a String) to a key in @@file_cache (a
+  # String).
+  #
+  # One important use of @@file2file_remap is mapping the a full path
+  # of a file into the name stored in @@file_cache or given by Ruby's
+  # __FILE__. Applications such as those that get input from users,
+  # may want canonicalize a file name before looking it up. This map
+  # gives a way to do that.
+  #
+  # Another related use is when a template system is used.  Here we'll
+  # probably want to remap not only the file name but also line
+  # ranges. Will probably use this for that, but I'm not sure.
+  @@file2file_remap = {} 
+  @@file2file_remap_lines = {}
+  
+  # Clear the file cache entirely.
+  def clear_file_cache()
+    @@file_cache = {}
+    @@file2file_remap = {}
+    @@file2file_remap_lines = {}
+  end
+  module_function :clear_file_cache
+
+  # Return an array of cached file names
+  def cached_files()
+    @@file_cache.keys
+  end
+  module_function :cached_files
+
+  # Discard cache entries that are out of date. If +filename+ is +nil+
+  # all entries in the file cache +@@file_cache+ are checked.
+  # If we don't have stat information about a file, which can happen
+  # if the file was read from SCRIPT_LINES__ but no corresponding file
+  # is found, it will be kept. Return a list of invalidated filenames.
+  # nil is returned if a filename was given but not found cached.
+  def checkcache(filename=nil, use_script_lines=false)
+    
+    if !filename
+      filenames = @@file_cache.keys()
+    elsif @@file_cache.member?(filename)
+      filenames = [filename]
+    else
+      return nil
+    end
+
+    result = []
+    for filename in filenames
+      next unless @@file_cache.member?(filename)
+      path = @@file_cache[filename].path
+      if File.exist?(path)
+        cache_info = @@file_cache[filename].stat
+        stat = File.stat(path)
+        if stat && 
+            (cache_info.size != stat.size or cache_info.mtime != stat.mtime)
+          result << filename
+          update_cache(filename, use_script_lines)
+        end
+      end
+    end
+    return result
+  end
+  module_function :checkcache
+
+  # Cache filename if it's not already cached.
+  # Return the expanded filename for it in the cache
+  # or nil if we can't find the file.
+  def cache(filename, reload_on_change=false)
+    if @@file_cache.member?(filename)
+      checkcache(filename) if reload_on_change
+    else
+      update_cache(filename, true)
+    end
+    if @@file_cache.member?(filename)
+      @@file_cache[filename].path
+    else
+      nil
+    end
+  end
+  module_function :cache
+      
+  # Return true if filename is cached
+  def cached?(filename)
+    @@file_cache.member?(unmap_file(filename))
+  end
+  module_function :cached?
+
+  def cached_script?(filename)
+    # In 1.8.6, the SCRIPT_LINES__ filename key can be unqualified
+    # In 1.9.1 it's the fully qualified name
+    if RUBY_VERSION < "1.9"
+      SCRIPT_LINES__.member?(unmap_file(filename))
+    else
+      SCRIPT_LINES__.member?(File.expand_path(unmap_file(filename)))
+    end
+  end
+  module_function :cached_script?
+      
+  def empty?(filename)
+    filename=unmap_file(filename)
+    @@file_cache[filename].lines.empty?
+  end
+  module_function :empty?
+
+  # Get line +line_number+ from file named +filename+. Return nil if
+  # there was a problem. If a file named filename is not found, the
+  # function will look for it in the $: array.
+  # 
+  # Examples:
+  # 
+  #  lines = LineCache::getline('/tmp/myfile.rb')
+  #  # Same as above
+  #  $: << '/tmp'
+  #  lines = LineCache.getlines('myfile.rb')
+  #
+  def getline(filename, line_number, reload_on_change=true)
+    filename = unmap_file(filename)
+    filename, line_number = unmap_file_line(filename, line_number)
+    lines = getlines(filename, reload_on_change)
+    if lines and (1..lines.size) === line_number
+        return lines[line_number-1]
+    else
+        return nil
+    end
+  end
+  module_function :getline
+
+  # Read lines of +filename+ and cache the results. However +filename+ was
+  # previously cached use the results from the cache. Return nil
+  # if we can't get lines
+  def getlines(filename, reload_on_change=false)
+    filename = unmap_file(filename)
+    checkcache(filename) if reload_on_change
+    if @@file_cache.member?(filename)
+      return @@file_cache[filename].lines
+    else
+      update_cache(filename, true)
+      return @@file_cache[filename].lines if @@file_cache.member?(filename)
+    end
+  end
+  module_function :getlines
+
+  # Return full filename path for filename
+  def path(filename)
+    filename = unmap_file(filename)
+    return nil unless @@file_cache.member?(filename)
+    @@file_cache[filename].path
+  end
+  module_function :path
+
+  def remap_file(from_file, to_file)
+    @@file2file_remap[to_file] = from_file
+  end
+  module_function :remap_file
+
+  def remap_file_lines(from_file, to_file, range, start)
+    range = (range..range) if range.is_a?(Fixnum)
+    to_file = from_file unless to_file
+    if @@file2file_remap_lines[to_file] 
+      # FIXME: need to check for overwriting ranges: whether
+      # they intersect or one encompasses another.
+      @@file2file_remap_lines[to_file] << [from_file, range, start]
+    else
+      @@file2file_remap_lines[to_file]  = [[from_file, range, start]]
+    end
+  end
+  module_function :remap_file_lines
+  
+  # Return SHA1 of filename.
+  def sha1(filename)
+    filename = unmap_file(filename)
+    return nil unless @@file_cache.member?(filename)
+    return @@file_cache[filename].sha1.hexdigest if 
+      @@file_cache[filename].sha1
+    sha1 = Digest::SHA1.new
+    @@file_cache[filename].lines.each do |line|
+      sha1 << line
+    end
+    @@file_cache[filename].sha1 = sha1
+    sha1.hexdigest
+  end
+  module_function :sha1
+      
+  # Return the number of lines in filename
+  def size(filename)
+    filename = unmap_file(filename)
+    return nil unless @@file_cache.member?(filename)
+    @@file_cache[filename].lines.length
+  end
+  module_function :size
+
+  # Return File.stat in the cache for filename.
+  def stat(filename)
+    return nil unless @@file_cache.member?(filename)
+    @@file_cache[filename].stat
+  end
+  module_function :stat
+
+  # Return an Array of breakpoints in filename.
+  # The list will contain an entry for each distinct line event call
+  # so it is possible (and possibly useful) for a line number appear more
+  # than once.
+  def trace_line_numbers(filename, reload_on_change=false)
+    fullname = cache(filename, reload_on_change)
+    return nil unless fullname
+    e = @@file_cache[filename]
+    unless e.line_numbers
+      e.line_numbers = 
+        TraceLineNumbers.lnums_for_str_array(e.lines)
+      e.line_numbers = false unless e.line_numbers
+    end
+    e.line_numbers
+  end
+  module_function :trace_line_numbers
+    
+  def unmap_file(file)
+    @@file2file_remap[file] ? @@file2file_remap[file] : file
+  end
+  module_function :unmap_file
+
+  def unmap_file_line(file, line)
+    if @@file2file_remap_lines[file]
+      @@file2file_remap_lines[file].each do |from_file, range, start|
+        if range === line
+          from_file = from_file || file 
+          return [from_file, start+line-range.begin] 
+        end
+      end
+    end
+    return [file, line]
+  end
+  module_function :unmap_file_line
+
+  # Update a cache entry.  If something's
+  # wrong, return nil. Return true if the cache was updated and false
+  # if not.  If use_script_lines is true, use that as the source for the
+  # lines of the file
+  def update_cache(filename, use_script_lines=false)
+
+    return nil unless filename
+
+    @@file_cache.delete(filename)
+    path = File.expand_path(filename)
+    
+    if use_script_lines
+      list = [filename]
+      list << @@file2file_remap[path] if @@file2file_remap[path]
+      list.each do |name| 
+        if !SCRIPT_LINES__[name].nil? && SCRIPT_LINES__[name] != true
+          begin 
+            stat = File.stat(name)
+          rescue
+            stat = nil
+          end
+          lines = SCRIPT_LINES__[name]
+          @@file_cache[filename] = LineCacheInfo.new(stat, nil, lines, path, nil)
+          @@file2file_remap[path] = filename
+          return true
+        end
+      end
+    end
+      
+    if File.exist?(path)
+      stat = File.stat(path)
+    elsif File.basename(filename) == filename
+      # try looking through the search path.
+      stat = nil
+      for dirname in $:
+        path = File.join(dirname, filename)
+        if File.exist?(path)
+            stat = File.stat(path)
+            break
+        end
+      end
+      return false unless stat
+    end
+    begin
+      fp = File.open(path, 'r')
+      lines = fp.readlines()
+      fp.close()
+    rescue 
+      ##  print '*** cannot open', path, ':', msg
+      return nil
+    end
+    @@file_cache[filename] = LineCacheInfo.new(File.stat(path), nil, lines,
+                                               path, nil)
+    @@file2file_remap[path] = filename
+    return true
+  end
+
+  module_function :update_cache
+
+end
+
+# example usage
+if __FILE__ == $0 
+  def yes_no(var) 
+    return var ? "" : "not "
+  end
+
+  lines = LineCache::getlines(__FILE__)
+  puts "#{__FILE__} has #{LineCache.size(__FILE__)} lines"
+  line = LineCache::getline(__FILE__, 6)
+  puts "The 6th line is\n#{line}" 
+  line = LineCache::remap_file(__FILE__, 'another_name')
+  puts LineCache::getline('another_name', 7)
+
+  puts("Files cached: #{LineCache::cached_files.inspect}")
+  LineCache::update_cache(__FILE__)
+  LineCache::checkcache(__FILE__)
+  puts "#{__FILE__} has #{LineCache::size(__FILE__)} lines"
+  puts "#{__FILE__} trace line numbers:\n" + 
+    "#{LineCache::trace_line_numbers(__FILE__).to_a.sort.inspect}"
+  puts("#{__FILE__} is %scached." % 
+       yes_no(LineCache::cached?(__FILE__)))
+  puts LineCache::stat(__FILE__).inspect
+  puts "Full path: #{LineCache::path(__FILE__)}"
+  LineCache::checkcache # Check all files in the cache
+  LineCache::clear_file_cache 
+  puts("#{__FILE__} is now %scached." % 
+       yes_no(LineCache::cached?(__FILE__)))
+  digest = SCRIPT_LINES__.select{|k,v| k =~ /digest.rb$/}
+  puts digest.first[0] if digest
+  line = LineCache::getline(__FILE__, 7)
+  puts "The 7th line is\n#{line}" 
+  LineCache::remap_file_lines(__FILE__, 'test2', (10..20), 6)
+  puts LineCache::getline('test2', 10)
+  puts "Remapped 10th line of test2 is\n#{line}" 
+end

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,53 @@
+--- !ruby/object:Gem::Specification
+name: linecache19-patched
+version: !ruby/object:Gem::Version
+  version: 0.5.13
+  prerelease: 
+platform: ruby
+authors:
+- Do Not Use
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-13 00:00:00.000000000 Z
+dependencies: []
+description: Do not use
+email: noreply@noemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README
+- lib/linecache19.rb
+- lib/tracelines19.rb
+- test/lnum-diag.rb
+- test/parse-show.rb
+- test/rcov-bug.rb
+- test/short-file
+- test/test-linecache.rb
+- test/test-tracelines.rb
+homepage: http://github.com/robmathews/linecache19-0.5.13
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: Do no use
+test_files: []