manifest.py
230 lines
| 8.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 _ | ||
|
r18821 | import mdiff, parsers, error, revlog, util, dicthelpers | ||
|
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()) | ||||
|
r6743 | def set(self, f, flags): | ||
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 | ||||
|
r18821 | def flagsdiff(self, d2): | ||
return dicthelpers.diff(self._flags, d2._flags, "") | ||||
|
r2831 | |||
|
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 | |||
|
r4995 | def parse(self, lines): | ||
mfdict = manifestdict() | ||||
|
r6389 | parsers.parse_manifest(mfdict, mfdict._flags, lines) | ||
|
r4995 | return mfdict | ||
|
r3196 | |||
def readdelta(self, node): | ||||
|
r7362 | r = self.rev(node) | ||
|
r12011 | return self.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) | ||
|
r4995 | mapping = self.parse(text) | ||
|
r18604 | self._mancache[node] = (mapping, arraytext) | ||
|
r2835 | return mapping | ||
|
r1089 | |||
|
r2320 | def _search(self, 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 | ||||
|
r17426 | they indicate the proper sorted insertion point. | ||
|
r2320 | |||
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 | ||||
|
r7405 | if not s: | ||
return (lo, lo) | ||||
|
r2320 | lenm = len(m) | ||
if not hi: | ||||
hi = lenm | ||||
while lo < hi: | ||||
mid = (lo + hi) // 2 | ||||
start = mid | ||||
|
r10282 | while start > 0 and m[start - 1] != '\n': | ||
|
r2320 | 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] | ||||
|
r11763 | if s == found: | ||
|
r2320 | # we know that after the null there are 40 bytes of sha1 | ||
end = advance(end + 40, '\n') | ||||
|
r10282 | return (lo, end + 1) | ||
|
r2320 | else: | ||
return (lo, lo) | ||||
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) | ||
start, end = self._search(text, f) | ||||
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 | |||
|
r2841 | def add(self, map, transaction, link, p1=None, p2=None, | ||
|
r1089 | changed=None): | ||
# apply the changes collected during the bisect loop to our addlist | ||||
|
r1534 | # return a delta suitable for addrevision | ||
def addlistdelta(addlist, x): | ||||
|
r17983 | # 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] | ||||
|
r9413 | if content: | ||
|
r17983 | newaddlist += array.array('c', content) | ||
currentposition = end | ||||
newaddlist += addlist[currentposition:] | ||||
deltatext = "".join(struct.pack(">lll", start, end, len(content)) | ||||
|
r16683 | + content for start, end, content in x) | ||
|
r17983 | return deltatext, newaddlist | ||
|
r1089 | |||
|
r6765 | def checkforbidden(l): | ||
for f in l: | ||||
if '\n' in f or '\r' in f: | ||||
|
r7633 | raise error.RevlogError( | ||
|
r8077 | _("'\\n' and '\\r' disallowed in filenames: %r") % f) | ||
|
r3607 | |||
|
r9414 | # if we're using the cache, make sure it is valid and | ||
|
r1089 | # parented by the same node we're diffing against | ||
|
r18604 | if not (changed and p1 and (p1 in self._mancache)): | ||
|
r8209 | files = sorted(map) | ||
|
r6765 | checkforbidden(files) | ||
|
r3607 | |||
|
r1651 | # if this is changed to support newlines in filenames, | ||
# be sure to check the templates/ dir again (especially *-raw.tmpl) | ||||
|
r7634 | hex, flags = revlog.hex, map.flags | ||
|
r14632 | text = ''.join("%s\0%s%s\n" % (f, hex(map[f]), flags(f)) | ||
|
r9420 | for f in files) | ||
arraytext = array.array('c', text) | ||||
|
r1089 | cachedelta = None | ||
else: | ||||
|
r9415 | added, removed = changed | ||
|
r18604 | addlist = self._mancache[p1][1] | ||
|
r1089 | |||
|
r9415 | 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() | ||
delta = [] | ||||
|
r1534 | dstart = None | ||
dend = None | ||||
dline = [""] | ||||
start = 0 | ||||
# zero copy representation of addlist as a buffer | ||||
|
r15657 | addbuf = util.buffer(addlist) | ||
|
r1089 | |||
|
r1534 | # start with a readonly loop that finds the offset of | ||
# each line and creates the deltas | ||||
|
r9415 | for f, todelete in work: | ||
|
r1089 | # bs will either be the index of the item or the insert point | ||
|
r2320 | start, end = self._search(addbuf, f, start) | ||
|
r9415 | if not todelete: | ||
|
r14632 | l = "%s\0%s%s\n" % (f, revlog.hex(map[f]), map.flags(f)) | ||
|
r1089 | else: | ||
|
r9415 | if start == end: | ||
# item we want to delete was not found, error out | ||||
raise AssertionError( | ||||
_("failed to remove %s from manifest") % f) | ||||
|
r1534 | l = "" | ||
|
r13031 | if dstart is not None and dstart <= start and dend >= start: | ||
|
r1534 | if dend < end: | ||
dend = end | ||||
if l: | ||||
dline.append(l) | ||||
|
r1089 | else: | ||
|
r13031 | if dstart is not None: | ||
|
r1534 | delta.append([dstart, dend, "".join(dline)]) | ||
dstart = start | ||||
dend = end | ||||
dline = [l] | ||||
|
r1089 | |||
|
r13031 | if dstart is not None: | ||
|
r1534 | delta.append([dstart, dend, "".join(dline)]) | ||
# apply the delta to the addlist, and get a delta for addrevision | ||||
|
r17983 | deltatext, addlist = addlistdelta(addlist, delta) | ||
cachedelta = (self.rev(p1), deltatext) | ||||
|
r9414 | arraytext = addlist | ||
|
r15657 | text = util.buffer(arraytext) | ||
|
r1534 | |||
|
r9420 | n = self.addrevision(text, transaction, link, p1, p2, cachedelta) | ||
|
r18604 | self._mancache[n] = (map, arraytext) | ||
|
r1089 | |||
return n | ||||