manifest.py
268 lines
| 9.4 KiB
| text/x-python
|
PythonLexer
/ mercurial / manifest.py
|
r1089 | # manifest.py - manifest revision class for mercurial | ||
# | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r1089 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r1089 | |||
|
r3891 | from i18n import _ | ||
|
r22965 | import mdiff, parsers, error, revlog, util | ||
|
r8312 | import array, struct | ||
|
r1089 | |||
|
r2835 | class manifestdict(dict): | ||
|
r2857 | def __init__(self, mapping=None, flags=None): | ||
|
r10282 | if mapping is None: | ||
mapping = {} | ||||
if flags is None: | ||||
flags = {} | ||||
|
r2831 | dict.__init__(self, mapping) | ||
|
r2839 | self._flags = flags | ||
|
r2834 | def flags(self, f): | ||
|
r2839 | return self._flags.get(f, "") | ||
|
r16646 | def withflags(self): | ||
return set(self._flags.keys()) | ||||
|
r22942 | def setflag(self, f, flags): | ||
"""Set the flags (symlink, executable) for path f.""" | ||||
|
r6743 | self._flags[f] = flags | ||
|
r2831 | def copy(self): | ||
|
r9416 | return manifestdict(self, dict.copy(self._flags)) | ||
|
r21879 | def intersectfiles(self, files): | ||
'''make a new manifestdict with the intersection of self with files | ||||
The algorithm assumes that files is much smaller than self.''' | ||||
ret = manifestdict() | ||||
for fn in files: | ||||
if fn in self: | ||||
ret[fn] = self[fn] | ||||
flags = self._flags.get(fn, None) | ||||
if flags: | ||||
ret._flags[fn] = flags | ||||
return ret | ||||
|
r22964 | |||
def diff(self, m2): | ||||
'''Finds changes between the current manifest and m2. The result is | ||||
returned as a dict with filename as key and values of the form | ||||
|
r22966 | ((n1,fl1),(n2,fl2)), where n1/n2 is the nodeid in the current/other | ||
|
r22965 | manifest and fl1/fl2 is the flag in the current/other manifest. Where | ||
the file does not exist, the nodeid will be None and the flags will be | ||||
the empty string.''' | ||||
diff = {} | ||||
for fn, n1 in self.iteritems(): | ||||
fl1 = self._flags.get(fn, '') | ||||
n2 = m2.get(fn, None) | ||||
fl2 = m2._flags.get(fn, '') | ||||
if n2 is None: | ||||
fl2 = '' | ||||
if n1 != n2 or fl1 != fl2: | ||||
|
r22966 | diff[fn] = ((n1, fl1), (n2, fl2)) | ||
|
r22965 | |||
for fn, n2 in m2.iteritems(): | ||||
if fn not in self: | ||||
fl2 = m2._flags.get(fn, '') | ||||
|
r22966 | diff[fn] = ((None, ''), (n2, fl2)) | ||
|
r22965 | |||
return diff | ||||
|
r2831 | |||
|
r22929 | def text(self): | ||
|
r22943 | """Get the full data of this manifest as a bytestring.""" | ||
|
r22929 | fl = sorted(self) | ||
_checkforbidden(fl) | ||||
hex, flags = revlog.hex, self.flags | ||||
# if this is changed to support newlines in filenames, | ||||
# be sure to check the templates/ dir again (especially *-raw.tmpl) | ||||
return ''.join("%s\0%s%s\n" % (f, hex(self[f]), flags(f)) for f in fl) | ||||
|
r22408 | |||
|
r22931 | def fastdelta(self, base, changes): | ||
"""Given a base manifest text as an array.array and a list of changes | ||||
relative to that text, compute a delta that can be used by revlog. | ||||
""" | ||||
delta = [] | ||||
dstart = None | ||||
dend = None | ||||
dline = [""] | ||||
start = 0 | ||||
# zero copy representation of base as a buffer | ||||
addbuf = util.buffer(base) | ||||
# start with a readonly loop that finds the offset of | ||||
# each line and creates the deltas | ||||
for f, todelete in changes: | ||||
# bs will either be the index of the item or the insert point | ||||
start, end = _msearch(addbuf, f, start) | ||||
if not todelete: | ||||
l = "%s\0%s%s\n" % (f, revlog.hex(self[f]), self.flags(f)) | ||||
else: | ||||
if start == end: | ||||
# item we want to delete was not found, error out | ||||
raise AssertionError( | ||||
_("failed to remove %s from manifest") % f) | ||||
l = "" | ||||
if dstart is not None and dstart <= start and dend >= start: | ||||
if dend < end: | ||||
dend = end | ||||
if l: | ||||
dline.append(l) | ||||
else: | ||||
if dstart is not None: | ||||
delta.append([dstart, dend, "".join(dline)]) | ||||
dstart = start | ||||
dend = end | ||||
dline = [l] | ||||
if dstart is not None: | ||||
delta.append([dstart, dend, "".join(dline)]) | ||||
# apply the delta to the base, and get a delta for addrevision | ||||
deltatext, arraytext = _addlistdelta(base, delta) | ||||
return arraytext, deltatext | ||||
|
r22930 | def _msearch(m, s, lo=0, hi=None): | ||
'''return a tuple (start, end) that says where to find s within m. | ||||
If the string is found m[start:end] are the line containing | ||||
that string. If start == end the string was not found and | ||||
they indicate the proper sorted insertion point. | ||||
m should be a buffer or a string | ||||
s is a string''' | ||||
def advance(i, c): | ||||
while i < lenm and m[i] != c: | ||||
i += 1 | ||||
return i | ||||
if not s: | ||||
return (lo, lo) | ||||
lenm = len(m) | ||||
if not hi: | ||||
hi = lenm | ||||
while lo < hi: | ||||
mid = (lo + hi) // 2 | ||||
start = mid | ||||
while start > 0 and m[start - 1] != '\n': | ||||
start -= 1 | ||||
end = advance(start, '\0') | ||||
if m[start:end] < s: | ||||
# we know that after the null there are 40 bytes of sha1 | ||||
# this translates to the bisect lo = mid + 1 | ||||
lo = advance(end + 40, '\n') + 1 | ||||
else: | ||||
# this translates to the bisect hi = mid | ||||
hi = start | ||||
end = advance(lo, '\0') | ||||
found = m[lo:end] | ||||
if s == found: | ||||
# we know that after the null there are 40 bytes of sha1 | ||||
end = advance(end + 40, '\n') | ||||
return (lo, end + 1) | ||||
else: | ||||
return (lo, lo) | ||||
|
r22415 | def _checkforbidden(l): | ||
|
r22408 | """Check filenames for illegal characters.""" | ||
for f in l: | ||||
if '\n' in f or '\r' in f: | ||||
raise error.RevlogError( | ||||
_("'\\n' and '\\r' disallowed in filenames: %r") % f) | ||||
|
r22409 | # apply the changes collected during the bisect loop to our addlist | ||
# return a delta suitable for addrevision | ||||
|
r22415 | def _addlistdelta(addlist, x): | ||
|
r22409 | # for large addlist arrays, building a new array is cheaper | ||
# than repeatedly modifying the existing one | ||||
currentposition = 0 | ||||
newaddlist = array.array('c') | ||||
for start, end, content in x: | ||||
newaddlist += addlist[currentposition:start] | ||||
if content: | ||||
newaddlist += array.array('c', content) | ||||
currentposition = end | ||||
newaddlist += addlist[currentposition:] | ||||
deltatext = "".join(struct.pack(">lll", start, end, len(content)) | ||||
+ content for start, end, content in x) | ||||
return deltatext, newaddlist | ||||
|
r22786 | def _parse(lines): | ||
mfdict = manifestdict() | ||||
parsers.parse_manifest(mfdict, mfdict._flags, lines) | ||||
return mfdict | ||||
|
r22409 | |||
|
r7634 | class manifest(revlog.revlog): | ||
|
r4258 | def __init__(self, opener): | ||
|
r20075 | # we expect to deal with not more than four revs at a time, | ||
# during a commit --amend | ||||
self._mancache = util.lrucachedict(4) | ||||
|
r7634 | revlog.revlog.__init__(self, opener, "00manifest.i") | ||
|
r1089 | |||
|
r3196 | def readdelta(self, node): | ||
|
r7362 | r = self.rev(node) | ||
|
r22786 | return _parse(mdiff.patchtext(self.revdiff(self.deltaparent(r), r))) | ||
|
r3223 | |||
|
r13711 | def readfast(self, node): | ||
'''use the faster of readdelta or read''' | ||||
r = self.rev(node) | ||||
|
r14208 | deltaparent = self.deltaparent(r) | ||
if deltaparent != revlog.nullrev and deltaparent in self.parentrevs(r): | ||||
|
r13711 | return self.readdelta(node) | ||
return self.read(node) | ||||
|
r1089 | def read(self, node): | ||
|
r7634 | if node == revlog.nullid: | ||
return manifestdict() # don't upset local cache | ||||
|
r18604 | if node in self._mancache: | ||
return self._mancache[node][0] | ||||
|
r1089 | text = self.revision(node) | ||
|
r9414 | arraytext = array.array('c', text) | ||
|
r22786 | mapping = _parse(text) | ||
|
r18604 | self._mancache[node] = (mapping, arraytext) | ||
|
r2835 | return mapping | ||
|
r1089 | |||
|
r2320 | def find(self, node, f): | ||
'''look up entry for a single file efficiently. | ||||
|
r4159 | return (node, flags) pair if found, (None, None) if not.''' | ||
|
r18604 | if node in self._mancache: | ||
mapping = self._mancache[node][0] | ||||
return mapping.get(f), mapping.flags(f) | ||||
|
r2320 | text = self.revision(node) | ||
|
r22930 | start, end = _msearch(text, f) | ||
|
r2320 | if start == end: | ||
return None, None | ||||
l = text[start:end] | ||||
f, n = l.split('\0') | ||||
|
r7634 | return revlog.bin(n[:40]), n[40:-1] | ||
|
r2320 | |||
|
r22787 | def add(self, map, transaction, link, p1, p2, added, removed): | ||
|
r22788 | if p1 in self._mancache: | ||
# If our first parent is in the manifest cache, we can | ||||
# compute a delta here using properties we know about the | ||||
# manifest up-front, which may save time later for the | ||||
# revlog layer. | ||||
|
r1089 | |||
|
r22415 | _checkforbidden(added) | ||
|
r1089 | # combine the changed lists into one list for sorting | ||
|
r9415 | work = [(x, False) for x in added] | ||
work.extend((x, True) for x in removed) | ||||
|
r17428 | # this could use heapq.merge() (from Python 2.6+) or equivalent | ||
|
r9415 | # since the lists are already sorted | ||
|
r1089 | work.sort() | ||
|
r22931 | arraytext, deltatext = map.fastdelta(self._mancache[p1][1], work) | ||
cachedelta = self.rev(p1), deltatext | ||||
|
r15657 | text = util.buffer(arraytext) | ||
|
r22788 | else: | ||
# The first parent manifest isn't already loaded, so we'll | ||||
# just encode a fulltext of the manifest and pass that | ||||
# through to the revlog layer, and let it handle the delta | ||||
# process. | ||||
|
r22929 | text = map.text() | ||
|
r22788 | arraytext = array.array('c', text) | ||
cachedelta = None | ||||
|
r1534 | |||
|
r9420 | n = self.addrevision(text, transaction, link, p1, p2, cachedelta) | ||
|
r18604 | self._mancache[n] = (map, arraytext) | ||
|
r1089 | |||
return n | ||||