filelog: make metadata method private

mercurial/context.py

@@ -1,131 +1,131 b''
 # context.py - changeset and file context objects for mercurial
 #
 # Copyright 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import *
 
 class changectx(object):
     """A changecontext object makes access to data related to a particular
     changeset convenient."""
     def __init__(self, repo, changeid):
         """changeid is a revision number, node, or tag"""
         self._repo = repo
 
         self._node = self._repo.lookup(changeid)
         self._rev = self._repo.changelog.rev(self._node)
 
     def changeset(self):
         try:
             return self._changeset
         except AttributeError:
             self._changeset = self._repo.changelog.read(self.node())
             return self._changeset
 
     def manifest(self):
         try:
             return self._manifest
         except AttributeError:
             self._manifest = self._repo.manifest.read(self.changeset()[0])
             return self._manifest
 
     def rev(self): return self._rev
     def node(self): return self._node
     def user(self): return self.changeset()[1]
     def date(self): return self.changeset()[2]
     def files(self): return self.changeset()[3]
     def description(self): return self.changeset()[4]
 
     def parents(self):
         """return contexts for each parent changeset"""
         p = self._repo.changelog.parents(self._node)
         return [ changectx(self._repo, x) for x in p ]
 
     def children(self):
         """return contexts for each child changeset"""
         c = self._repo.changelog.children(self._node)
         return [ changectx(self._repo, x) for x in c ]
 
     def filenode(self, path):
         node, flag = self._repo.manifest.find(self.changeset()[0], path)
         return node
 
     def filectx(self, path, fileid=None):
         """get a file context from this changeset"""
         if fileid is None:
             fileid = self.filenode(path)
         return filectx(self._repo, path, fileid=fileid)
 
     def filectxs(self):
         """generate a file context for each file in this changeset's
            manifest"""
         mf = self.manifest()
         m = mf.keys()
         m.sort()
         for f in m:
             yield self.filectx(f, fileid=mf[f])
 
 class filectx(object):
     """A filecontext object makes access to data related to a particular
        filerevision convenient."""
     def __init__(self, repo, path, changeid=None, fileid=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         self._repo = repo
         self._path = path
 
         assert changeid or fileid
 
         if not fileid:
             # if given a changeset id, go ahead and look up the file
             self._changeid = changeid
             self._changectx = self.changectx()
             self._filelog = self._repo.file(self._path)
             self._filenode = self._changectx.filenode(self._path)
         else:
             # else be lazy
             self._filelog = self._repo.file(self._path)
             self._filenode = self._filelog.lookup(fileid)
             self._changeid = self._filelog.linkrev(self._filenode)
         self._filerev = self._filelog.rev(self._filenode)
 
     def changectx(self):
         try:
             return self._changectx
         except AttributeError:
             self._changectx = changectx(self._repo, self._changeid)
             return self._changectx
 
     def filerev(self): return self._filerev
     def filenode(self): return self._filenode
     def filelog(self): return self._filelog
 
     def rev(self): return self.changectx().rev()
     def node(self): return self.changectx().node()
     def user(self): return self.changectx().user()
     def date(self): return self.changectx().date()
     def files(self): return self.changectx().files()
     def description(self): return self.changectx().description()
     def manifest(self): return self.changectx().manifest()
 
     def data(self): return self._filelog.read(self._filenode)
-    def metadata(self): return self._filelog.readmeta(self._filenode)
     def renamed(self): return self._filelog.renamed(self._filenode)
     def path(self): return self._path
 
     def parents(self):
         p = [ (self._path, n) for n in self._filelog.parents(self._filenode) ]
         r = self.renamed()
+
         if r:
             p[0] = r
         return [ filectx(self._repo, p, fileid=n) for p,n in p if n != nullid ]
 
     def children(self):
         # hard for renames
         c = self._filelog.children(self._filenode)
         return [ filectx(self._repo, self._path, fileid=x) for x in c ]
 
     def annotate(self):
         return self._filelog.annotate(self._filenode)

mercurial/filelog.py

@@ -1,155 +1,155 b''
 # filelog.py - file history class for mercurial
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from revlog import *
 from demandload import *
 demandload(globals(), "bdiff os")
 
 class filelog(revlog):
     def __init__(self, opener, path, defversion=REVLOG_DEFAULT_VERSION):
         revlog.__init__(self, opener,
                         os.path.join("data", self.encodedir(path + ".i")),
                         os.path.join("data", self.encodedir(path + ".d")),
                         defversion)
 
     # This avoids a collision between a file named foo and a dir named
     # foo.i or foo.d
     def encodedir(self, path):
         return (path
                 .replace(".hg/", ".hg.hg/")
                 .replace(".i/", ".i.hg/")
                 .replace(".d/", ".d.hg/"))
 
     def decodedir(self, path):
         return (path
                 .replace(".d.hg/", ".d/")
                 .replace(".i.hg/", ".i/")
                 .replace(".hg.hg/", ".hg/"))
 
     def read(self, node):
         t = self.revision(node)
         if not t.startswith('\1\n'):
             return t
         s = t.index('\1\n', 2)
         return t[s+2:]
 
-    def readmeta(self, node):
+    def _readmeta(self, node):
         t = self.revision(node)
         if not t.startswith('\1\n'):
             return {}
         s = t.index('\1\n', 2)
         mt = t[2:s]
         m = {}
         for l in mt.splitlines():
             k, v = l.split(": ", 1)
             m[k] = v
         return m
 
     def add(self, text, meta, transaction, link, p1=None, p2=None):
         if meta or text.startswith('\1\n'):
             mt = ""
             if meta:
                 mt = [ "%s: %s\n" % (k, v) for k,v in meta.items() ]
             text = "\1\n%s\1\n%s" % ("".join(mt), text)
         return self.addrevision(text, transaction, link, p1, p2)
 
     def renamed(self, node):
         if self.parents(node)[0] != nullid:
             return False
-        m = self.readmeta(node)
+        m = self._readmeta(node)
         if m and m.has_key("copy"):
             return (m["copy"], bin(m["copyrev"]))
         return False
 
     def size(self, rev):
         """return the size of a given revision"""
 
         # for revisions with renames, we have to go the slow way
         node = self.node(rev)
         if self.renamed(node):
             return len(self.read(node))
 
         return revlog.size(self, rev)
 
     def cmp(self, node, text):
         """compare text with a given file revision"""
 
         # for renames, we have to go the slow way
         if self.renamed(node):
             t2 = self.read(node)
             return t2 != text
 
         return revlog.cmp(self, node, text)
 
     def annotate(self, node):
 
         def decorate(text, rev):
             return ([rev] * len(text.splitlines()), text)
 
         def pair(parent, child):
             for a1, a2, b1, b2 in bdiff.blocks(parent[1], child[1]):
                 child[0][b1:b2] = parent[0][a1:a2]
             return child
 
         # find all ancestors
         needed = {(self, node):1}
         files = [self]
         visit = [(self, node)]
         while visit:
             f, n = visit.pop(0)
             rn = f.renamed(n)
             if rn:
                 f, n = rn
                 f = filelog(self.opener, f, self.defversion)
                 files.insert(0, f)
                 if (f, n) not in needed:
                     needed[(f, n)] = 1
                 else:
                     needed[(f, n)] += 1
             for p in f.parents(n):
                 if p == nullid:
                     continue
                 if (f, p) not in needed:
                     needed[(f, p)] = 1
                     visit.append((f, p))
                 else:
                     # count how many times we'll use this
                     needed[(f, p)] += 1
 
         # sort by revision (per file) which is a topological order
         visit = []
         for f in files:
             fn = [(f.rev(n[1]), f, n[1]) for n in needed.keys() if n[0] == f]
             fn.sort()
             visit.extend(fn)
         hist = {}
 
         for i in range(len(visit)):
             r, f, n = visit[i]
             curr = decorate(f.read(n), f.linkrev(n))
             if r == -1:
                 continue
             parents = f.parents(n)
             # follow parents across renames
             if r < 1 and i > 0:
                 j = i
                 while j > 0 and visit[j][1] == f:
                     j -= 1
                 parents = (visit[j][2],)
                 f = visit[j][1]
             else:
                 parents = f.parents(n)
             for p in parents:
                 if p != nullid:
                     curr = pair(hist[p], curr)
                     # trim the history of unneeded revs
                     needed[(f, p)] -= 1
                     if not needed[(f, p)]:
                         del hist[p]
             hist[n] = curr
 
         return zip(hist[n][0], hist[n][1].splitlines(1))