amp 0.5.0

data/lib/amp/repository/verification.rb

@@ -0,0 +1,431 @@
+module Amp
+  module Repositories
+    ##
+    # This module adds verification to Mercurial repositories.
+    #
+    # The main public method provided is #verify. The rest are support methods that
+    # will keep to themselves.
+    #
+    # This is directly ported from verify.py from the Mercurial source. This is for
+    # the simple reason that, because we are re-implementing Mercurial, we should
+    # rely on their verification over our own. If we discover bugs in their
+    # verification, we'll patch them and send in the patches to selenic, but for now, we'll
+    # trust that theirs is on the money.
+    module Verification
+      
+      ##
+      # Runs a verification sweep on the repository.
+      #
+      # @return [VerificationResult] the results of the verification, which
+      #   includes error messages, warning counts, and so on.
+      def verify
+        result = Verifier.new(self).verify
+      end
+      
+      ##
+      # Handles all logic for verifying a single repository and collecting the results.
+      #
+      # Public interface: initialize with a repository and run #verify.
+      class Verifier
+        attr_accessor :repository
+        alias_method :repo, :repository
+        
+        attr_reader :changelog, :manifest
+        
+        ##
+        # Creates a new Verifier. The Verifier can verify a Mercurial repository.
+        # 
+        # @param [Repository] repo the repository this verifier will examine
+        def initialize(repo)
+          @repository = repo
+          @result = VerificationResult.new(0, 0, 0, 0, 0)
+          
+          @bad_revisions = {}
+          @changelog = repo.changelog
+          @manifest  = repo.manifest
+        end
+        
+        ##
+        # Runs a verification sweep on the repository this verifier is handling.
+        #
+        # @return [VerificationResult] the results of the verification, which
+        #   includes error messages, warning counts, and so on.
+        def verify
+          # Maps manifest node IDs to the link revision to which they belong
+          manifest_linkrevs = Hash.new {|h,k| h[k] = []}
+          
+          # Maps filenames to a list of link revisions (global revision #s) in which
+          # that file was changed
+          file_linkrevs = Hash.new {|h, k| h[k] = []}
+          
+          # file_node_ids stores a hash for each file. The hash stored maps that file's node IDs
+          # (the node stored in the file log itself) to the global "link revision index" - the
+          # revision index in the changelog (and the one the user always sees)
+          file_node_ids = Hash.new {|h, k| h[k] = {}}
+          
+          verify_changelog(manifest_linkrevs, file_linkrevs)
+          verify_manifest(manifest_linkrevs,  file_node_ids)
+          verify_crosscheck(manifest_linkrevs, file_linkrevs, file_node_ids)
+          UI.status("checking files")
+          store_files = verify_store
+          verify_files(file_linkrevs, file_node_ids, store_files)
+          @result
+        end
+        
+        ##
+        # Verifies the changelog. Updates acceptable file_linkrevs and manifest_linkrevs
+        # along the way, since the changelog knows which files have been changed when,
+        # and which manifest entries go with which changelog entries.
+        #
+        # @param [Hash] manifest_linkrevs the mapping between manifest node IDs and changelog
+        #   revision numbers
+        # @param [Hash] file_linkrevs a mapping between filenames and a list of changelog
+        #   revision numbers where the file was modified, added, or deleted.
+        def verify_changelog(manifest_linkrevs, file_linkrevs)
+          Amp::UI.status("checking changelog...")
+          check_revlog(@changelog, "changelog")
+          seen = {}
+          # can't use the nice #each because it assumes functioning changelog and whatnot
+          @changelog.size.times do |idx|
+            node = @changelog.node_id_for_index idx
+            check_entry(@changelog, idx, node, seen, [idx], "changelog")
+            begin
+              changelog_entry = @changelog.read(node)
+              manifest_linkrevs[changelog_entry.first] << idx
+              changelog_entry[3].each {|f| file_linkrevs[f] << idx}
+            rescue Exception => err
+              exception(idx, "unpacking changeset #{node.short_hex}:", err, "changelog")
+            end
+          end
+          @result.changesets = @changelog.size
+        end
+        
+        ##
+        # Verifies the manifest and its nodes. Also updates file_node_ids to store the
+        # node ID of files at given points in the manifest's history.
+        #
+        # @param [Hash] manifest_linkrevs the mapping between manifest node IDs and changelog
+        #   revision numbers
+        # @param [Hash] file_node_ids maps filenames to a mapping from file node IDs to global
+        #   link revisions.
+        def verify_manifest(manifest_linkrevs, file_node_ids)
+          Amp::UI.status("checking manifests...")
+          check_revlog(@manifest, "manifest")
+          seen = {}
+          
+          @manifest.size.times do |idx|
+            node = @manifest.node_id_for_index idx
+            link_rev = check_entry(@manifest, idx, node, seen, manifest_linkrevs[node], "manifest")
+            manifest_linkrevs.delete node
+            
+            begin
+              @manifest.read_delta(node).each do |filename, file_node|
+                if filename.empty?
+                  error(link_rev, "file without name in manifest")
+                elsif filename != "/dev/null"
+                  file_node_map = file_node_ids[filename]
+                  file_node_map[file_node] ||= idx
+                end
+              end
+            rescue Exception => err
+              exception(idx, "reading manfiest delta #{node.short_hex}", err, "manifest")
+            end
+          end
+        end
+        
+        ##
+        # Crosschecks the changelog agains the manifest and vice-versa. There should be no
+        # remaining unmatched manifest node IDs, nor any files not in file_node_map.
+        # A few other checks, too.
+        #
+        # @param [Hash] manifest_linkrevs the mapping between manifest node IDs and changelog
+        #   revision numbers
+        # @param [Hash] file_linkrevs a mapping between filenames and a list of changelog
+        #   revision numbers where the file was modified, added, or deleted.
+        # @param [Hash] file_node_ids maps filenames to a mapping from file node IDs to global
+        #   link revisions.
+        def verify_crosscheck(manifest_linkrevs, file_linkrevs, file_node_ids)
+          Amp::UI.status("crosschecking files in changesets and manifests")
+          
+          # Check for node IDs found in the changelog, but not the manifest
+          if @manifest.any?
+            # check for any manifest node IDs we found in changesets, but not in the manifest
+            manifest_linkrevs.map {|node, idx| [idx, node]}.sort.each do |idx, node|
+              error(idx, "changeset refers to unknown manifest #{node.short_hex}")
+            end
+            
+            # check for any file node IDs we found in the changeset, but not in the manifest
+            file_linkrevs.sort.each do |file, _|
+              if file_node_ids[file].empty?
+                error(file_linkrevs[file].first, "in changeset but not in manifest", file)
+              end
+            end
+          end
+          
+          # Check for node IDs found in the manifest, but not the changelog.
+          if @changelog.any?
+            file_node_ids.map {|file,_| file}.sort.each do |file|
+              unless file_linkrevs[file]
+                begin
+                  filelog = @repository.file(file)
+                  link_rev = file_node_ids[file].map {|node| filelog.link_revision_for_index(filelog.revision_index_for_node(node))}.min
+                rescue
+                  link_rev = nil
+                end
+                error(link_rev, "in manifest but not in changeset", file)
+              end
+            end
+          end
+        end
+        
+        ##
+        # Verifies the store, and returns a hash with names of files that are OK
+        #
+        # @return [Hash<String => Boolean>] a hash with filenames as keys and "true" or "false"
+        #   as values, indicating whether the file exists and is accessible
+        def verify_store
+          store_files = {}
+          @repository.store.datafiles.each do |file, encoded_filename, size|
+            if file.nil? || file.empty?
+              error(nil, "can't decode filename from store: #{encoded_filename}")
+            elsif size > 0
+              store_files[file] = true
+            end
+          end
+          store_files
+        end
+        
+        ##
+        # Verifies the individual file logs one by one.
+        #
+        # @param [Hash] file_linkrevs a mapping between filenames and a list of changelog
+        #   revision numbers where the file was modified, added, or deleted.
+        # @param [Hash] file_node_ids maps filenames to a mapping from file node IDs to global
+        #   link revisions.
+        # @param [Hash] store_files a mapping keeping track of which file logs are in the store
+        def verify_files(file_linkrevs, file_node_ids, store_files)
+          files = (file_node_ids.keys + file_linkrevs.keys).uniq.sort
+          @result.files = files.size
+          files.each do |file|
+            link_rev = file_linkrevs[file].first
+            
+            begin
+              file_log = @repository.file(file) 
+            rescue Exception => err
+              error(link_rev, "broken revlog! (#{err})", file)
+              next
+            end
+            
+            file_log.files.each do |ff|
+              unless store_files.delete(ff)
+                error(link_rev, "missing revlog!", ff)
+              end
+            end
+            
+            verify_filelog(file, file_log, file_linkrevs, file_node_ids)
+          end
+        end
+        
+        ##
+        # Verifies a single file log. This is a complicated process - we need to cross-
+        # check a lot of data, which is why this has been extracted into its own method.
+        #
+        # @param [String] filename the name of the file we're verifying
+        # @param [FileLog] file_log the file log we're verifying
+        # @param [Hash] file_linkrevs a mapping between filenames and a list of changelog
+        #   revision numbers where the file was modified, added, or deleted.
+        # @param [Hash] file_node_ids maps filenames to a mapping from file node IDs to global
+        #   link revisions.
+        def verify_filelog(file, file_log, file_linkrevs, file_node_ids)
+          check_revlog(file_log, file)
+          seen = {}
+          file_log.index_size.times do |idx|
+            @result.revisions += 1
+            node = file_log.node_id_for_index(idx)
+            link_rev = check_entry(file_log, idx, node, seen, file_linkrevs[file], file)
+            
+            # Make sure that one of the manifests referenced the node ID. If not, one of our
+            # manifests is wrong!
+            if file_node_ids[file]
+              if @manifest.any? && !file_node_ids[file][node]
+                error(link_rev, "#{node.short_hex} not found in manifests", file)
+              else
+                file_node_ids[file].delete node
+              end
+            end
+            
+            # Make sure the size of the uncompressed file is correct.
+            begin
+              text = file_log.read node
+              rename_info = file_log.renamed? node
+              if text.size != file_log.uncompressed_size_for_index(idx)
+                if file_log.decompress_revision(node).size != file_log.uncompressed_size_for_index(idx)
+                  error(link_rev, "unpacked size is #{text.size}, #{file_log.size(idx)} expected", file)
+                end
+              end
+            rescue Exception => err
+              exception(link_rev, "unpacking #{node.short_hex}", err, file)
+            end
+            
+            # Check if we screwed up renaming a file (like lost the source revlog or something)
+            begin
+              if rename_info && rename_info.any?
+                filelog_src = @repository.file(rename_info.first)
+                if filelog_src.index_size == 0
+                  error(link_rev, "empty or missing copy source revlog "+
+                                  "#{rename_info[0]}, #{rename_info[1].short_hex}", file)
+                elsif rename_info[1] == RevlogSupport::Node::NULL_ID
+                  warn("#{file}@#{link_rev}: copy source revision is NULL_ID "+
+                       "#{rename_info[0]}:#{rename_info[1].short_hex}", file)
+                else
+                  rev = filelog_src.revision_index_for_node(rename_info[1])
+                end
+              end
+            rescue Exception => err
+              exception(link_rev, "checking rename of #{node.short_hex}", err, file)
+            end
+          end
+          
+          # Final cross-check
+          if file_node_ids[file] && file_node_ids[file].any?
+            file_node_ids[file].map { |node, link_rev| 
+              [@manifest.link_revision_for_index(link_rev), node]
+            }.sort.each do |link_rev, node|
+              error(link_rev, "#{node.short_hex} in manifests not found", file)
+            end
+          end
+        end
+        
+        private
+        
+        ##
+        # Checks a revlog for inconsistencies with the main format, such as
+        # having trailing bytes or incorrect formats
+        #
+        # @param [Revlog] log the log we will be verifying
+        # @param [String] name the name of the file this log is stored in
+        def check_revlog(log, name)
+          #p name
+          if log.empty? && (@changelog.any? || @revlog.any?)
+            return error(0, "#{name} is empty or missing")
+          end
+          
+          size_diffs = log.checksize
+          # checksize returns a hash with these keys: index_diff, data_diff
+          if size_diffs[:data_diff] != 0
+            error(nil, "data size off by #{size_diffs[:data_diff]} bytes", name) 
+          end
+          if size_diffs[:index_diff] != 0
+            error(nil, "index off by #{size_diffs[:index_diff]} bytes", name)
+          end
+          
+          v0 = RevlogSupport::Support::REVLOG_VERSION_0
+          if log.index.version != v0
+            warn("#{name} uses revlog format 1. changelog uses format 0.") if @changelog.index.version == v0
+          elsif log.index.version == v0
+            warn("#{name} uses revlog format 0. that's really old.")
+          end
+        end
+        
+        ##
+        # Checks a single entry in a revision log for inconsistencies.
+        #
+        # @param [Revlog] log the revision log we're examining
+        # @param [Fixnum] revision the index # of the revision being examined
+        # @param [String] node the node ID of the revision being examined
+        # @param [Hash] seen the list of node IDs we've already seen
+        # @param [Array] ok_link_revisions the acceptable link revisions for the given entry
+        # @param [String] filename the name of the file containing the revlog
+        def check_entry(log, revision, node, seen, ok_link_revisions, filename)
+          link_rev = log.link_revision_for_index log.revision_index_for_node(node)
+          # is the link_revision invalid?
+          if link_rev < 0 || (changelog.any? && ! ok_link_revisions.include?(link_rev))
+            problem = (link_rev < 0 || link_rev >= changelog.size) ? "nonexistent" : "unexpected"
+            error(nil, "revision #{revision} points to #{problem} changeset #{link_rev}", filename)
+            
+            if ok_link_revisions.any?
+              warn("(expected #{ok_link_revisions.join(" ")})")
+            end
+            link_rev = nil # don't use this link_revision, because it's clearly wrong.
+          end
+          
+          begin
+            log.parents_for_node(node).each do |parent|
+              if !seen[parent] && parent != RevlogSupport::Node::NULL_ID
+                error(link_rev, "unknown parent #{parent.short_hex} of #{node.short_hex}", filename)
+              end
+            end
+          rescue StandardError => e 
+            # TODO: do real exception handling
+            exception(link_rev, "error checking parents of #{node.short_hex}: ", e, filename)
+          end
+          
+          if seen[node]
+            error(link_rev, "duplicate revision #{revision} (#{seen[node]})", filename)
+          end
+          seen[node] = revision
+          return link_rev
+        end
+        
+        ##
+        # Produce an error based on an exception. Matches mercurial's.
+        #
+        # @param [Fixnum] revision the link-revision the error is associated with
+        # @param [String, #to_s] message the message to print with the error
+        # @param [Exception] exception the exception that raised this error
+        # @param [String, #to_s] filename (nil) the name of the file with an error.
+        #     nil for changelog/manifest
+        def exception(revision, message, exception, filename)
+          if exception.kind_of?(Interrupt)
+            UI.warn("interrupted")
+            raise
+          end
+          error(revision, "#{message} #{exception}\n", filename)
+        end
+        
+        ##
+        # Produce an error that looks like Mercurial's
+        # meh compatibility makes me sad
+        #
+        # @param [Fixnum] revision the link-revision the error is associated with
+        # @param [String, #to_s] message the message to print with the error
+        # @param [String, #to_s] filename (nil) the name of the file with an error.
+        #     nil for changelog/manifest
+        def error(revision, message, filename = nil)
+          if revision
+            @bad_revisions[revision] = true
+          else
+            revision = "?"
+          end
+          new_message = "#{revision}: #{message}"
+          new_message = "#{filename}@#{new_message}" if filename
+          UI.say new_message
+          @result.errors += 1
+        end
+        
+        ##
+        # Adds a warning to the results
+        #
+        # @param [String, #to_s] message the user's warning
+        def warn(message)
+          UI.say "warning: #{message}"
+          @result.warnings += 1
+        end
+      end
+      
+      ##
+      # Simple struct that handles the results of a verification.
+      class VerificationResult < Struct.new(:warnings, :errors, :revisions, :files, :changesets)
+        def initialize(*args)
+          super(*args)
+          @warnings   = 0
+          @errors     = 0
+          @revisions  = 0
+          @files      = 0
+          @changesets = 0
+        end
+      end
+      
+    end
+  end
+end

data/lib/amp/repository/versioned_file.rb

@@ -0,0 +1,475 @@
+
+module Amp
+  
+  ##
+  # This class allows you to access a file at a given revision in the repo's
+  # history. You can compare them, sort them, access the changeset, and
+  # all sorts of stuff.
+  class VersionedFile
+    include RevlogSupport::Node
+    
+    attr_accessor :file_id
+    attr_writer   :path
+    attr_writer   :change_id
+    
+    ##
+    # Creates a new {VersionedFile}. You need to pass in the repo and the path
+    # to the file, as well as one of the following: a revision index/ID, the
+    # node_id of the file's revision in the filelog, or a changeset at a given
+    # index.
+    # 
+    # @param [Repository] repo The repo we're working with
+    # @param [String] path the path to the file
+    # @param [Hash] opts the options to customize how we load this file
+    # @option [FileLog] opts :file_log (nil) The FileLog to use for loading data
+    # @option [String] opts :change_id (nil) The revision ID/index to use to
+    #   figure out which revision we're working with
+    # @option [Changeset] opts :changeset (nil) the changeset to use to figure
+    #   which revision we're working with
+    # @option [String] opts :file_id (nil) perhaps the ID of the revision in
+    #   the file_log to use?
+    def initialize(repo, path, opts={})
+      @repo, @path = repo, path
+      raise StandardError.new("specify a revision!") unless opts[:change_id] ||
+                                                            opts[:file_id]   ||
+                                                            opts[:changeset]
+      @file_log  = opts[:file_log]  if opts[:file_log]
+      @change_id = opts[:change_id] if opts[:change_id]
+      @changeset = opts[:changeset] if opts[:changeset]
+      @file_id   = opts[:file_id]   if opts[:file_id]
+      
+    end
+    
+    def <=>(other)
+      to_i <=> other.to_i
+    end
+    
+    def to_i
+      change_id
+    end
+    
+    ##
+    # Returns the changeset that this file belongs to
+    # 
+    # @return [Changeset] the changeset this file belongs to
+    def changeset
+      @changeset ||= Changeset.new @repo, change_id
+    end
+    
+    ##
+    # Dunno why this is here
+    #
+    def repo_path
+      @path
+    end
+    
+    ##
+    # The file log that tracks this file
+    # 
+    # @return [FileLog] The revision log tracking this file
+    def file_log
+      @file_log ||= @repo.file @path
+    end
+    
+    ##
+    # The revision index into the history of the repository. Could also
+    # be a node_id
+    def change_id
+      @change_id ||= @changeset.revision         if @changeset
+      @change_id ||= file_log[file_rev].link_rev unless @changeset
+      @change_id
+    end
+    
+    def file_node
+      @file_node ||= file_log.lookup_id(@file_id) if @file_id
+      @file_node ||= changeset.file_node(@path)   unless @file_id
+      @file_node ||= NULL_ID
+    end
+    
+    ##
+    # Returns the index into the file log's history for this file
+    def file_rev
+      @file_rev ||= file_log.rev(file_node)
+    end
+    
+    ##
+    # Is this a null version?
+    def nil?
+      file_node.nil?
+    end
+    
+    ##
+    # String representation.
+    def to_s
+      "#{path}@#{node.hexlify[0..11]}"
+    end
+    
+    ##
+    # IRB Inspector string representation
+    def inspect
+      "#<Versioned File: #{to_s}>"
+    end
+    
+    ##
+    # Hash value for sticking this fucker in a hash
+    def hash
+      return (path + file_id.to_s).hash
+    end
+    
+    ##
+    # Equality! Compares paths and revision indexes
+    def ==(other)
+      return false unless @path && @file_id && other.path && other.file_id
+      @path == other.path && @file_id == other.file_id
+    end
+    
+    ##
+    # Retrieves the file with a different ID
+    # 
+    # @param file_id a new file ID... still not sure what a file_id is
+    def file(file_id)
+      self.class.new @repo, @path, :file_id => file_id, :file_log => file_log
+    end
+    
+    # Gets the flags for this file (x and l)
+    def flags; changeset.flags(@path); end
+    
+    # Returns the revision index
+    def revision
+      return changeset.rev if @changeset || @change_id
+      file_log[file_rev].link_rev
+    end
+    
+    # Link-revision index
+    def linkrev; file_log[file_rev].link_rev; end
+    # Node ID for this file's revision
+    def node; changeset.node; end
+    # User who committed this revision to this file
+    def user; changeset.user; end
+    # Date this revision to this file was committed
+    def date; changeset.date; end
+    # All files in this changeset that this revision of this file was committed
+    def files; changeset.files; end
+    # The description of the commit that contained this file revision
+    def description; changeset.description; end
+    # The branch this tracked file belongs to
+    def branch; changeset.branch; end
+    # THe manifest that this file revision is from
+    def manifest; changeset.manifest; end
+    # The data in this file
+    def data; file_log.read(file_node); end
+    # The path to this file
+    def path; @path; end
+    # The size of this file
+    def size; file_log.size(file_rev); end
+    
+    ##
+    # Compares to a bit of text.
+    # Returns true if different, false for the same.
+    # (much like <=> == 0 for the same)
+    def cmp(text)
+      file_log.cmp(file_node, text)
+    end
+    
+    ##
+    # Just the opposite of #cmp
+    # 
+    # @param [VersionedFile] other what to compare to
+    # @return [Boolean] true if the two are the same
+    def ===(other)
+      !self.cmp(other.data)
+    end
+    
+    ##
+    # Has this file been renamed? If so, return some useful info
+    def renamed
+      renamed = file_log.renamed(file_node)
+      return renamed unless renamed
+      
+      return renamed if rev == linkrev
+      
+      name = path
+      fnode = file_node
+      changeset.parents.each do |p|
+        pnode = p.filenode(name)
+        next if pnode.nil?
+        return nil if fnode == pnode
+      end
+      renamed
+    end
+
+    ##
+    # What are this revised file's parents? Return them as {VersionedFile}s.
+    def parents
+      p = @path
+      fl = file_log
+      pl = file_log.parents(file_node).map {|n| [p, n, fl]}
+      
+      r = file_log.renamed(file_node)
+      pl[0] = [r[0], r[1], nil] if r
+      
+      pl.select {|parent,n,l| n != NULL_ID}.map do |parent, n, l|
+        VersionedFile.new(@repo, parent, :file_id => n, :file_log => l)
+      end
+    end
+    
+    ##
+    # What are this file's children?
+    def children
+      c = file_log.children(file_node)
+      c.map do |x|
+        VersionedFile.new(@repo, @path, :file_id => x, :file_log => file_log)
+      end  
+    end
+    
+    def annotate_decorate(text, revision, line_number = false)
+      if line_number
+        size = text.split("\n").size
+        retarr = [nil,text]
+        retarr[0] = (1..size).map {|i| [revision, i]}
+      else
+        retarr = [nil, text]
+        retarr[0] = [[revision, false]] * text.split("\n").size
+      end
+      retarr
+    end
+    
+    def annotate_diff_pair(parent, child)
+      Diffs::BinaryDiff.blocks_as_array(parent[1], child[1]).each do |a1,a2,b1,b2|
+        child[0][b1..(b2-1)] = parent[0][a1..(a2-1)]
+      end
+      child
+    end
+    
+    def annotate_get_file(path, file_id)
+      log = (path == @path) ? file_log : @repo.get_file(path)
+      return VersionedFile.new(@repo, path, :file_id => file_id, :file_log => log)
+    end
+    
+    def annotate_parents_helper(file, follow_copies = false)
+      path = file.path
+      if file.file_rev.nil?
+        parent_list = file.parents.map {|n| [n.path, n.file_rev]}
+      else
+        parent_list = file.file_log.parent_indices_for_index(file.file_rev)
+        parent_list.map! {|n| [path, n]}
+      end
+      if follow_copies
+        r = file.renamed
+        pl[0] = [r[0], @repo.get_file(r[0]).revision(r[1])] if r
+      end
+      return parent_list.select {|p, n| n != NULL_REV}.
+                         map {|p, n| annotate_get_file(p, n)}
+    end
+    
+    def annotate(follow_copies = false, line_number = false)
+      base = (revision != linkrev) ? file(file_rev) : self
+      
+      needed = {base => 1}
+      counters = {(base.path + base.file_id.to_s) => 1}
+      visit = [base]
+      files = [base.path]
+      
+      while visit.any?
+        file = visit.shift
+        annotate_parents_helper(file).each do |p|
+          unless needed.include? p
+            needed[p] = 1
+            counters[p.path + p.file_id.to_s] = 1
+            visit << p
+            files << p.path unless files.include? p.path
+          end
+        end
+      end
+      
+      visit = []
+      files.each do |f|
+        filenames = needed.keys.select {|k| k.path == f}.map {|n| [n.revision, n]}
+        visit += filenames
+      end
+      
+      hist = {}
+      lastfile = ""
+      visit.sort.each do |rev, file_ann|
+        curr = annotate_decorate(file_ann.data, file_ann, line_number)
+        annotate_parents_helper(file_ann).each do |p|
+          next if p.file_id == NULL_ID
+          curr = annotate_diff_pair(hist[p.path + p.file_id.to_s], curr)
+          counters[p.path + p.file_id.to_s] -= 1
+          hist.delete(p.path + p.file_id.to_s) if counters[p.path + p.file_id.to_s] == 0
+        end
+        hist[file_ann.path+file_ann.file_id.to_s] = curr
+        lastfile = file_ann
+      end
+      returnarr = []
+      hist[lastfile.path+lastfile.file_id.to_s].inspect # force all lazy-loading to stoppeth
+      ret = hist[lastfile.path+lastfile.file_id.to_s][0].each_with_index do |obj, i|
+        returnarr << obj + [hist[lastfile.path+lastfile.file_id.to_s][1].split_newlines[i]]
+      end
+      #   hist[lastfile.path+lastfile.file_id.to_s][0][i] + hist[lastfile.path+lastfile.file_id.to_s][1].split_newlines[i]
+      # end
+      ret = hist[lastfile.path+lastfile.file_id.to_s][0].zip(hist[lastfile.path+lastfile.file_id.to_s][1].split_newlines)
+      returnarr
+    end
+    
+    def get_parents_helper(vertex, ancestor_cache, filelog_cache)
+      return ancestor_cache[vertex] if ancestor_cache[vertex]
+      file, node = vertex
+      filelog_cache[file] = @repo.get_file(file) unless filelog_cache[file]
+      
+      filelog = filelog_cache[file]
+      parent_list = filelog.parents(node).select {|p| p != NULL_ID}.map {|p| [file, p]}
+      
+      has_renamed = filelog.renamed(node)
+      
+      parent_list << has_renamed if has_renamed
+      ancestor_cache[vertex] = parent_list
+      parent_list
+    end
+    
+    def ancestor(file_2)
+      ancestor_cache = {}
+      [self, file_2].each do |c|
+        if c.file_rev == NULL_REV || c.file_rev.nil?
+          parent_list = c.parents.map {|n| [n.path, n.file_node]}
+          ancestor_cache[[c.path, c.file_node]] = parent_list
+        end
+      end
+      
+      filelog_cache = {repo_path => file_log, file_2.repo_path => file_2.file_log}
+      a, b = [path, file_node], [file_2.path, file_2.file_node]
+      parents_proc = proc {|vertex| get_parents_helper(vertex, ancestor_cache, filelog_cache)}
+      
+      v = Graphs::AncestorCalculator.ancestors(a, b, parents_proc)
+      if v
+        file, node = v
+        return VersionedFile.new(@repo, file, :file_id => node, :file_log => filelog_cache[file])
+      end
+      return nil
+    end
+    
+  end
+  
+  ##
+  # This is a VersionedFile, except it's in the working directory, so its data
+  # is stored on disk in the actual file. Other than that, it's basically the
+  # same in its interface!
+  class VersionedWorkingFile < VersionedFile
+    
+    ##
+    # Initializes a new working dir file - slightly different semantics here
+    def initialize(repo, path, opts={})
+      @repo, @path = repo, path
+      @change_id = nil
+      @file_rev, @file_node = nil, nil
+      
+      @file_log = opts[:file_log] if opts[:file_log]
+      @changeset = opts[:working_changeset]
+    end
+    
+    ##
+    # Gets the working directory changeset
+    def changeset
+      @changeset ||= WorkingDirectoryChangeset.new(@repo)
+    end
+    
+    ##
+    # Dunno why this is here
+    def repo_path
+      @repo.dirstate.copy_map[@path] || @path
+    end
+    
+    ##
+    # Gets the file log?
+    def file_log
+      @repo.file(repo_path)
+    end
+    
+    ##
+    # String representation
+    def to_s
+      "#{path}@#{@changeset}"
+    end
+    
+    ##
+    # Returns the file at a different revision
+    def file(file_id)
+      VersionedFile.new(@repo, repo_path, :file_id => file_id, :file_log => file_log)
+    end
+    
+    ##
+    # Get what revision this is
+    def revision
+      return @changeset.revision if @changeset
+      file_log[@file_rev].link_rev
+    end
+    
+    ##
+    # Get the contents of this file
+    def data
+      data = @repo.working_read(@path)
+      data
+    end
+    
+    ##
+    # Has this file been renamed? If so give some good info.
+    def renamed
+      rp = repo_path
+      return nil if rp == @path
+      [rp, (self.changeset.parents[0].manifest[rp] || NULL_ID)]
+    end
+    
+    ##
+    # The working directory's parents are the heads, so get this file in
+    # the previous revision.
+    def parents
+      p = @path
+      rp = repo_path
+      pcl = @changeset.parents
+      fl = file_log
+      pl = [[rp, pcl[0].manifest[rp] || NULL_ID, fl]]
+      if pcl.size > 1
+        if rp != p
+          fl = nil
+        end
+        pl << [p, pcl[1].manifest[p] || NULL_ID, fl]
+      end
+      pl.select {|_, n, __| n != NULL_ID}.map do |parent, n, l|
+        VersionedFile.new(@repo, parent, :file_id => n, :file_log => l)
+      end
+    end
+    
+    ##
+    # Working directory has no children!
+    def children; []; end
+    
+    ##
+    # Returns the current size of the file
+    #
+    def size
+      File.stat(@repo.join(@path)).size
+    end
+    
+    ##
+    # Returns the date that this file was last modified.
+    def date
+      t, tz = changeset.date
+      begin
+        return [FileUtils.lstat(@repo.join(@path)).mtime, tz]
+      rescue Errno::ENOENT
+        return [t, tz]
+      end
+    end
+    
+    ##
+    # Compares to the given text. Overridden because this file is
+    # stored on disk in the actual working directory.
+    # 
+    # @param [String] text the text to compare to
+    # @return [Boolean] true if the two are different
+    def cmp(text)
+      @repo.working_read(@path) != text
+    end
+    
+  end
+end