manifest.py
318 lines
| 10.9 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): | ||
|
r24146 | def __init__(self): | ||
self._flags = {} | ||||
|
r23594 | def __setitem__(self, k, v): | ||
assert v is not None | ||||
dict.__setitem__(self, k, v) | ||||
|
r2834 | def flags(self, f): | ||
|
r2839 | return self._flags.get(f, "") | ||
|
r22942 | def setflag(self, f, flags): | ||
"""Set the flags (symlink, executable) for path f.""" | ||||
|
r6743 | self._flags[f] = flags | ||
|
r2831 | def copy(self): | ||
|
r24146 | copy = manifestdict() | ||
dict.__init__(copy, self) | ||||
copy._flags = dict.copy(self._flags) | ||||
return copy | ||||
|
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 | |||
|
r24184 | def filesnotin(self, m2): | ||
'''Set of files in this manifest that are not in the other''' | ||||
files = set(self.iterkeys()) | ||||
files.difference_update(m2.iterkeys()) | ||||
return files | ||||
|
r23305 | def matches(self, match): | ||
'''generate a new manifest filtered by the match argument''' | ||||
if match.always(): | ||||
return self.copy() | ||||
files = match.files() | ||||
if (match.matchfn == match.exact or | ||||
(not match.anypats() and util.all(fn in self for fn in files))): | ||||
return self.intersectfiles(files) | ||||
|
r24147 | m = self.copy() | ||
for fn in m.keys(): | ||||
|
r23305 | if not match(fn): | ||
|
r24147 | del m[fn] | ||
return m | ||||
|
r23305 | |||
|
r23756 | def diff(self, m2, clean=False): | ||
'''Finds changes between the current manifest and m2. | ||||
Args: | ||||
m2: the manifest to which this manifest should be compared. | ||||
clean: if true, include files unchanged between these manifests | ||||
with a None value in the returned dictionary. | ||||
The result is returned as a dict with filename as key and | ||||
values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the | ||||
nodeid in the current/other 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. | ||||
''' | ||||
|
r22965 | 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)) | ||
|
r23756 | elif clean: | ||
diff[fn] = None | ||||
|
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 | ||||
|
r24215 | # Pure Python fallback | ||
def _parsemanifest(mfdict, fdict, lines): | ||||
bin = revlog.bin | ||||
for l in lines.splitlines(): | ||||
f, n = l.split('\0') | ||||
if len(n) > 40: | ||||
fdict[f] = n[40:] | ||||
mfdict[f] = bin(n[:40]) | ||||
else: | ||||
mfdict[f] = bin(n) | ||||
|
r22786 | def _parse(lines): | ||
mfdict = manifestdict() | ||||
|
r24215 | try: | ||
parsers.parse_manifest(mfdict, mfdict._flags, lines) | ||||
except AttributeError: | ||||
_parsemanifest(mfdict, mfdict._flags, lines) | ||||
|
r22786 | return mfdict | ||
|
r22409 | |||
|
r7634 | class manifest(revlog.revlog): | ||
|
r4258 | def __init__(self, opener): | ||
|
r24033 | # During normal operations, we expect to deal with not more than four | ||
# revs at a time (such as during commit --amend). When rebasing large | ||||
# stacks of commits, the number can go up, hence the config knob below. | ||||
cachesize = 4 | ||||
opts = getattr(opener, 'options', None) | ||||
if opts is not None: | ||||
cachesize = opts.get('manifestcachesize', cachesize) | ||||
self._mancache = util.lrucachedict(cachesize) | ||||
|
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) | ||
|
r24147 | m = _parse(text) | ||
self._mancache[node] = (m, arraytext) | ||||
return m | ||||
|
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: | ||
|
r24147 | m = self._mancache[node][0] | ||
return m.get(f), m.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 | |||
|
r24147 | def add(self, m, 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() | ||
|
r24147 | arraytext, deltatext = m.fastdelta(self._mancache[p1][1], work) | ||
|
r22931 | 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. | ||||
|
r24147 | text = m.text() | ||
|
r22788 | arraytext = array.array('c', text) | ||
cachedelta = None | ||||
|
r1534 | |||
|
r9420 | n = self.addrevision(text, transaction, link, p1, p2, cachedelta) | ||
|
r24147 | self._mancache[n] = (m, arraytext) | ||
|
r1089 | |||
return n | ||||