manifest.py
851 lines
| 26.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 _ | ||
|
r24635 | import mdiff, parsers, error, revlog, util | ||
|
r8312 | import array, struct | ||
|
r24573 | import os | ||
|
r1089 | |||
|
r24322 | propertycache = util.propertycache | ||
|
r24225 | |||
|
r24572 | def _parsev1(data): | ||
|
r24524 | # This method does a little bit of excessive-looking | ||
# precondition checking. This is so that the behavior of this | ||||
# class exactly matches its C counterpart to try and help | ||||
# prevent surprise breakage for anyone that develops against | ||||
# the pure version. | ||||
if data and data[-1] != '\n': | ||||
raise ValueError('Manifest did not end in a newline.') | ||||
prev = None | ||||
for l in data.splitlines(): | ||||
if prev is not None and prev > l: | ||||
raise ValueError('Manifest lines not in sorted order.') | ||||
prev = l | ||||
f, n = l.split('\0') | ||||
if len(n) > 40: | ||||
yield f, revlog.bin(n[:40]), n[40:] | ||||
else: | ||||
yield f, revlog.bin(n), '' | ||||
|
r24572 | def _parsev2(data): | ||
metadataend = data.find('\n') | ||||
# Just ignore metadata for now | ||||
pos = metadataend + 1 | ||||
prevf = '' | ||||
while pos < len(data): | ||||
end = data.find('\n', pos + 1) # +1 to skip stem length byte | ||||
if end == -1: | ||||
raise ValueError('Manifest ended with incomplete file entry.') | ||||
stemlen = ord(data[pos]) | ||||
items = data[pos + 1:end].split('\0') | ||||
f = prevf[:stemlen] + items[0] | ||||
if prevf > f: | ||||
raise ValueError('Manifest entries not in sorted order.') | ||||
fl = items[1] | ||||
# Just ignore metadata (items[2:] for now) | ||||
n = data[end + 1:end + 21] | ||||
yield f, n, fl | ||||
pos = end + 22 | ||||
prevf = f | ||||
def _parse(data): | ||||
"""Generates (path, node, flags) tuples from a manifest text""" | ||||
if data.startswith('\0'): | ||||
return iter(_parsev2(data)) | ||||
else: | ||||
return iter(_parsev1(data)) | ||||
|
r24573 | def _text(it, usemanifestv2): | ||
|
r24525 | """Given an iterator over (path, node, flags) tuples, returns a manifest | ||
text""" | ||||
|
r24573 | if usemanifestv2: | ||
return _textv2(it) | ||||
else: | ||||
return _textv1(it) | ||||
def _textv1(it): | ||||
|
r24525 | files = [] | ||
lines = [] | ||||
_hex = revlog.hex | ||||
for f, n, fl in it: | ||||
files.append(f) | ||||
# if this is changed to support newlines in filenames, | ||||
# be sure to check the templates/ dir again (especially *-raw.tmpl) | ||||
lines.append("%s\0%s%s\n" % (f, _hex(n), fl)) | ||||
_checkforbidden(files) | ||||
return ''.join(lines) | ||||
|
r24573 | def _textv2(it): | ||
files = [] | ||||
lines = ['\0\n'] | ||||
prevf = '' | ||||
for f, n, fl in it: | ||||
files.append(f) | ||||
stem = os.path.commonprefix([prevf, f]) | ||||
stemlen = min(len(stem), 255) | ||||
lines.append("%c%s\0%s\n%s\n" % (stemlen, f[stemlen:], fl, n)) | ||||
prevf = f | ||||
_checkforbidden(files) | ||||
return ''.join(lines) | ||||
|
r24225 | class _lazymanifest(dict): | ||
"""This is the pure implementation of lazymanifest. | ||||
It has not been optimized *at all* and is not lazy. | ||||
""" | ||||
|
r24223 | |||
|
r24225 | def __init__(self, data): | ||
dict.__init__(self) | ||||
|
r24524 | for f, n, fl in _parse(data): | ||
self[f] = n, fl | ||||
|
r24224 | |||
|
r23594 | def __setitem__(self, k, v): | ||
|
r24225 | node, flag = v | ||
assert node is not None | ||||
if len(node) > 21: | ||||
node = node[:21] # match c implementation behavior | ||||
dict.__setitem__(self, k, (node, flag)) | ||||
def __iter__(self): | ||||
|
r24298 | return iter(sorted(dict.keys(self))) | ||
|
r24225 | |||
|
r24297 | def iterkeys(self): | ||
return iter(sorted(dict.keys(self))) | ||||
|
r24298 | def iterentries(self): | ||
return ((f, e[0], e[1]) for f, e in sorted(self.iteritems())) | ||||
|
r2831 | def copy(self): | ||
|
r24225 | c = _lazymanifest('') | ||
c.update(self) | ||||
return c | ||||
def diff(self, m2, clean=False): | ||||
'''Finds changes between the current manifest and m2.''' | ||||
diff = {} | ||||
for fn, e1 in self.iteritems(): | ||||
if fn not in m2: | ||||
diff[fn] = e1, (None, '') | ||||
else: | ||||
e2 = m2[fn] | ||||
if e1 != e2: | ||||
diff[fn] = e1, e2 | ||||
elif clean: | ||||
diff[fn] = None | ||||
for fn, e2 in m2.iteritems(): | ||||
if fn not in self: | ||||
diff[fn] = (None, ''), e2 | ||||
return diff | ||||
def filtercopy(self, filterfn): | ||||
c = _lazymanifest('') | ||||
|
r24298 | for f, n, fl in self.iterentries(): | ||
|
r24225 | if filterfn(f): | ||
c[f] = n, fl | ||||
return c | ||||
def text(self): | ||||
"""Get the full data of this manifest as a bytestring.""" | ||||
|
r24573 | return _textv1(self.iterentries()) | ||
|
r24225 | |||
|
r24226 | try: | ||
_lazymanifest = parsers.lazymanifest | ||||
except AttributeError: | ||||
pass | ||||
|
r24225 | class manifestdict(object): | ||
def __init__(self, data=''): | ||||
|
r24572 | if data.startswith('\0'): | ||
#_lazymanifest can not parse v2 | ||||
self._lm = _lazymanifest('') | ||||
for f, n, fl in _parsev2(data): | ||||
self._lm[f] = n, fl | ||||
else: | ||||
self._lm = _lazymanifest(data) | ||||
|
r24225 | |||
def __getitem__(self, key): | ||||
return self._lm[key][0] | ||||
|
r24277 | def find(self, key): | ||
return self._lm[key] | ||||
|
r24225 | def __len__(self): | ||
return len(self._lm) | ||||
def __setitem__(self, key, node): | ||||
self._lm[key] = node, self.flags(key, '') | ||||
def __contains__(self, key): | ||||
return key in self._lm | ||||
def __delitem__(self, key): | ||||
del self._lm[key] | ||||
|
r24295 | def __iter__(self): | ||
|
r24298 | return self._lm.__iter__() | ||
|
r24225 | |||
def iterkeys(self): | ||||
|
r24295 | return self._lm.iterkeys() | ||
def keys(self): | ||||
return list(self.iterkeys()) | ||||
|
r24225 | |||
|
r24184 | def filesnotin(self, m2): | ||
'''Set of files in this manifest that are not in the other''' | ||||
|
r24298 | files = set(self) | ||
files.difference_update(m2) | ||||
|
r24184 | return files | ||
|
r24322 | @propertycache | ||
def _dirs(self): | ||||
|
r24635 | return util.dirs(self) | ||
|
r24322 | |||
def dirs(self): | ||||
return self._dirs | ||||
|
r24324 | def hasdir(self, dir): | ||
return dir in self._dirs | ||||
|
r24685 | def _filesfastpath(self, match): | ||
'''Checks whether we can correctly and quickly iterate over matcher | ||||
files instead of over manifest files.''' | ||||
files = match.files() | ||||
return (len(files) < 100 and (match.isexact() or | ||||
(not match.anypats() and util.all(fn in self for fn in files)))) | ||||
|
r24646 | def walk(self, match): | ||
'''Generates matching file names. | ||||
Equivalent to manifest.matches(match).iterkeys(), but without creating | ||||
an entirely new manifest. | ||||
It also reports nonexistent files by marking them bad with match.bad(). | ||||
''' | ||||
|
r24683 | if match.always(): | ||
for f in iter(self): | ||||
yield f | ||||
return | ||||
|
r24646 | fset = set(match.files()) | ||
# avoid the entire walk if we're only looking for specific files | ||||
|
r24685 | if self._filesfastpath(match): | ||
|
r24667 | for fn in sorted(fset): | ||
yield fn | ||||
|
r24682 | return | ||
|
r24646 | |||
for fn in self: | ||||
if fn in fset: | ||||
# specified pattern is the exact name | ||||
fset.remove(fn) | ||||
if match(fn): | ||||
yield fn | ||||
# for dirstate.walk, files=['.'] means "walk the whole tree". | ||||
# follow that here, too | ||||
fset.discard('.') | ||||
for fn in sorted(fset): | ||||
if not self.hasdir(fn): | ||||
match.bad(fn, None) | ||||
|
r23305 | def matches(self, match): | ||
'''generate a new manifest filtered by the match argument''' | ||||
if match.always(): | ||||
return self.copy() | ||||
|
r24685 | if self._filesfastpath(match): | ||
|
r24666 | m = manifestdict() | ||
lm = self._lm | ||||
for fn in match.files(): | ||||
if fn in lm: | ||||
m._lm[fn] = lm[fn] | ||||
return m | ||||
|
r23305 | |||
|
r24700 | m = manifestdict() | ||
|
r24664 | m._lm = self._lm.filtercopy(match) | ||
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. | ||||
''' | ||||
|
r24225 | return self._lm.diff(m2._lm, clean) | ||
def setflag(self, key, flag): | ||||
self._lm[key] = self[key], flag | ||||
def get(self, key, default=None): | ||||
try: | ||||
return self._lm[key][0] | ||||
except KeyError: | ||||
return default | ||||
|
r22965 | |||
|
r24225 | def flags(self, key, default=''): | ||
try: | ||||
return self._lm[key][1] | ||||
except KeyError: | ||||
return default | ||||
|
r22965 | |||
|
r24225 | def copy(self): | ||
|
r24700 | c = manifestdict() | ||
|
r24225 | c._lm = self._lm.copy() | ||
return c | ||||
def iteritems(self): | ||||
|
r24298 | return (x[:2] for x in self._lm.iterentries()) | ||
|
r2831 | |||
|
r24573 | def text(self, usemanifestv2=False): | ||
if usemanifestv2: | ||||
return _textv2(self._lm.iterentries()) | ||||
else: | ||||
# use (probably) native version for v1 | ||||
return self._lm.text() | ||||
|
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: | ||||
|
r24225 | h, fl = self._lm[f] | ||
l = "%s\0%s%s\n" % (f, revlog.hex(h), fl) | ||||
|
r22931 | 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 | ||||
|
r24401 | def _splittopdir(f): | ||
if '/' in f: | ||||
dir, subpath = f.split('/', 1) | ||||
return dir + '/', subpath | ||||
else: | ||||
return '', f | ||||
class treemanifest(object): | ||||
|
r24403 | def __init__(self, dir='', text=''): | ||
self._dir = dir | ||||
|
r24401 | self._dirs = {} | ||
# Using _lazymanifest here is a little slower than plain old dicts | ||||
self._files = {} | ||||
self._flags = {} | ||||
|
r24524 | for f, n, fl in _parse(text): | ||
|
r24401 | self[f] = n | ||
if fl: | ||||
self.setflag(f, fl) | ||||
|
r24403 | def _subpath(self, path): | ||
return self._dir + path | ||||
|
r24401 | def __len__(self): | ||
size = len(self._files) | ||||
for m in self._dirs.values(): | ||||
size += m.__len__() | ||||
return size | ||||
|
r24551 | def _isempty(self): | ||
return (not self._files and (not self._dirs or | ||||
util.all(m._isempty() for m in self._dirs.values()))) | ||||
|
r24403 | def __str__(self): | ||
return '<treemanifest dir=%s>' % self._dir | ||||
|
r24401 | def iteritems(self): | ||
for p, n in sorted(self._dirs.items() + self._files.items()): | ||||
if p in self._files: | ||||
|
r24403 | yield self._subpath(p), n | ||
|
r24401 | else: | ||
|
r24403 | for f, sn in n.iteritems(): | ||
yield f, sn | ||||
|
r24401 | |||
def iterkeys(self): | ||||
for p in sorted(self._dirs.keys() + self._files.keys()): | ||||
if p in self._files: | ||||
|
r24403 | yield self._subpath(p) | ||
|
r24401 | else: | ||
for f in self._dirs[p].iterkeys(): | ||||
|
r24403 | yield f | ||
|
r24401 | |||
def keys(self): | ||||
return list(self.iterkeys()) | ||||
def __iter__(self): | ||||
return self.iterkeys() | ||||
def __contains__(self, f): | ||||
if f is None: | ||||
return False | ||||
dir, subpath = _splittopdir(f) | ||||
if dir: | ||||
if dir not in self._dirs: | ||||
return False | ||||
return self._dirs[dir].__contains__(subpath) | ||||
else: | ||||
return f in self._files | ||||
def get(self, f, default=None): | ||||
dir, subpath = _splittopdir(f) | ||||
if dir: | ||||
if dir not in self._dirs: | ||||
return default | ||||
return self._dirs[dir].get(subpath, default) | ||||
else: | ||||
return self._files.get(f, default) | ||||
def __getitem__(self, f): | ||||
dir, subpath = _splittopdir(f) | ||||
if dir: | ||||
return self._dirs[dir].__getitem__(subpath) | ||||
else: | ||||
return self._files[f] | ||||
def flags(self, f): | ||||
dir, subpath = _splittopdir(f) | ||||
if dir: | ||||
if dir not in self._dirs: | ||||
return '' | ||||
return self._dirs[dir].flags(subpath) | ||||
else: | ||||
if f in self._dirs: | ||||
return '' | ||||
return self._flags.get(f, '') | ||||
def find(self, f): | ||||
dir, subpath = _splittopdir(f) | ||||
if dir: | ||||
return self._dirs[dir].find(subpath) | ||||
else: | ||||
return self._files[f], self._flags.get(f, '') | ||||
def __delitem__(self, f): | ||||
dir, subpath = _splittopdir(f) | ||||
if dir: | ||||
self._dirs[dir].__delitem__(subpath) | ||||
# If the directory is now empty, remove it | ||||
|
r24551 | if self._dirs[dir]._isempty(): | ||
|
r24401 | del self._dirs[dir] | ||
else: | ||||
del self._files[f] | ||||
if f in self._flags: | ||||
del self._flags[f] | ||||
def __setitem__(self, f, n): | ||||
assert n is not None | ||||
dir, subpath = _splittopdir(f) | ||||
if dir: | ||||
if dir not in self._dirs: | ||||
|
r24403 | self._dirs[dir] = treemanifest(self._subpath(dir)) | ||
|
r24401 | self._dirs[dir].__setitem__(subpath, n) | ||
else: | ||||
|
r24467 | self._files[f] = n[:21] # to match manifestdict's behavior | ||
|
r24401 | |||
def setflag(self, f, flags): | ||||
"""Set the flags (symlink, executable) for path f.""" | ||||
dir, subpath = _splittopdir(f) | ||||
if dir: | ||||
if dir not in self._dirs: | ||||
|
r24403 | self._dirs[dir] = treemanifest(self._subpath(dir)) | ||
|
r24401 | self._dirs[dir].setflag(subpath, flags) | ||
else: | ||||
self._flags[f] = flags | ||||
def copy(self): | ||||
|
r24403 | copy = treemanifest(self._dir) | ||
|
r24401 | for d in self._dirs: | ||
copy._dirs[d] = self._dirs[d].copy() | ||||
copy._files = dict.copy(self._files) | ||||
copy._flags = dict.copy(self._flags) | ||||
return copy | ||||
def filesnotin(self, m2): | ||||
'''Set of files in this manifest that are not in the other''' | ||||
|
r24405 | files = set() | ||
def _filesnotin(t1, t2): | ||||
for d, m1 in t1._dirs.iteritems(): | ||||
if d in t2._dirs: | ||||
m2 = t2._dirs[d] | ||||
_filesnotin(m1, m2) | ||||
else: | ||||
files.update(m1.iterkeys()) | ||||
for fn in t1._files.iterkeys(): | ||||
if fn not in t2._files: | ||||
files.add(t1._subpath(fn)) | ||||
_filesnotin(self, m2) | ||||
|
r24401 | return files | ||
@propertycache | ||||
def _alldirs(self): | ||||
|
r24635 | return util.dirs(self) | ||
|
r24401 | |||
def dirs(self): | ||||
return self._alldirs | ||||
def hasdir(self, dir): | ||||
|
r24406 | topdir, subdir = _splittopdir(dir) | ||
if topdir: | ||||
if topdir in self._dirs: | ||||
return self._dirs[topdir].hasdir(subdir) | ||||
return False | ||||
return (dir + '/') in self._dirs | ||||
|
r24401 | |||
|
r24646 | def walk(self, match): | ||
'''Generates matching file names. | ||||
Equivalent to manifest.matches(match).iterkeys(), but without creating | ||||
an entirely new manifest. | ||||
It also reports nonexistent files by marking them bad with match.bad(). | ||||
''' | ||||
|
r24683 | if match.always(): | ||
for f in iter(self): | ||||
yield f | ||||
return | ||||
|
r24646 | fset = set(match.files()) | ||
|
r24647 | for fn in self._walk(match): | ||
|
r24646 | if fn in fset: | ||
# specified pattern is the exact name | ||||
fset.remove(fn) | ||||
|
r24647 | yield fn | ||
|
r24646 | |||
# for dirstate.walk, files=['.'] means "walk the whole tree". | ||||
# follow that here, too | ||||
fset.discard('.') | ||||
for fn in sorted(fset): | ||||
if not self.hasdir(fn): | ||||
match.bad(fn, None) | ||||
|
r24670 | def _walk(self, match, alldirs=False): | ||
'''Recursively generates matching file names for walk(). | ||||
Will visit all subdirectories if alldirs is True, otherwise it will | ||||
only visit subdirectories for which match.visitdir is True.''' | ||||
if not alldirs: | ||||
# substring to strip trailing slash | ||||
visit = match.visitdir(self._dir[:-1] or '.') | ||||
if not visit: | ||||
return | ||||
alldirs = (visit == 'all') | ||||
|
r24647 | |||
# yield this dir's files and walk its submanifests | ||||
for p in sorted(self._dirs.keys() + self._files.keys()): | ||||
if p in self._files: | ||||
fullp = self._subpath(p) | ||||
if match(fullp): | ||||
yield fullp | ||||
else: | ||||
|
r24670 | for f in self._dirs[p]._walk(match, alldirs): | ||
|
r24647 | yield f | ||
|
r24401 | def matches(self, match): | ||
'''generate a new manifest filtered by the match argument''' | ||||
if match.always(): | ||||
return self.copy() | ||||
|
r24552 | return self._matches(match) | ||
|
r24636 | def _matches(self, match, alldirs=False): | ||
|
r24552 | '''recursively generate a new manifest filtered by the match argument. | ||
|
r24636 | |||
Will visit all subdirectories if alldirs is True, otherwise it will | ||||
only visit subdirectories for which match.visitdir is True.''' | ||||
|
r24552 | |||
ret = treemanifest(self._dir) | ||||
|
r24636 | if not alldirs: | ||
# substring to strip trailing slash | ||||
visit = match.visitdir(self._dir[:-1] or '.') | ||||
if not visit: | ||||
return ret | ||||
alldirs = (visit == 'all') | ||||
|
r24552 | |||
for fn in self._files: | ||||
fullp = self._subpath(fn) | ||||
if not match(fullp): | ||||
continue | ||||
ret._files[fn] = self._files[fn] | ||||
if fn in self._flags: | ||||
ret._flags[fn] = self._flags[fn] | ||||
for dir, subm in self._dirs.iteritems(): | ||||
|
r24636 | m = subm._matches(match, alldirs) | ||
|
r24552 | if not m._isempty(): | ||
ret._dirs[dir] = m | ||||
return ret | ||||
|
r24401 | |||
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. | ||||
''' | ||||
|
r24404 | result = {} | ||
emptytree = treemanifest() | ||||
def _diff(t1, t2): | ||||
for d, m1 in t1._dirs.iteritems(): | ||||
m2 = t2._dirs.get(d, emptytree) | ||||
_diff(m1, m2) | ||||
for d, m2 in t2._dirs.iteritems(): | ||||
if d not in t1._dirs: | ||||
_diff(emptytree, m2) | ||||
|
r24401 | |||
|
r24404 | for fn, n1 in t1._files.iteritems(): | ||
fl1 = t1._flags.get(fn, '') | ||||
n2 = t2._files.get(fn, None) | ||||
fl2 = t2._flags.get(fn, '') | ||||
if n1 != n2 or fl1 != fl2: | ||||
result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2)) | ||||
elif clean: | ||||
result[t1._subpath(fn)] = None | ||||
|
r24401 | |||
|
r24404 | for fn, n2 in t2._files.iteritems(): | ||
if fn not in t1._files: | ||||
fl2 = t2._flags.get(fn, '') | ||||
result[t2._subpath(fn)] = ((None, ''), (n2, fl2)) | ||||
|
r24401 | |||
|
r24404 | _diff(self, m2) | ||
return result | ||||
|
r24401 | |||
|
r24573 | def text(self, usemanifestv2=False): | ||
|
r24401 | """Get the full data of this manifest as a bytestring.""" | ||
|
r24525 | flags = self.flags | ||
|
r24573 | return _text(((f, self[f], flags(f)) for f in self.keys()), | ||
usemanifestv2) | ||||
|
r24401 | |||
|
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 | ||||
|
r24402 | usetreemanifest = False | ||
|
r24526 | usemanifestv2 = False | ||
|
r24033 | opts = getattr(opener, 'options', None) | ||
if opts is not None: | ||||
cachesize = opts.get('manifestcachesize', cachesize) | ||||
|
r24402 | usetreemanifest = opts.get('usetreemanifest', usetreemanifest) | ||
|
r24571 | usemanifestv2 = opts.get('manifestv2', usemanifestv2) | ||
|
r24033 | self._mancache = util.lrucachedict(cachesize) | ||
|
r7634 | revlog.revlog.__init__(self, opener, "00manifest.i") | ||
|
r24701 | self._treeinmem = usetreemanifest | ||
self._treeondisk = usetreemanifest | ||||
|
r24526 | self._usemanifestv2 = usemanifestv2 | ||
|
r24402 | |||
def _newmanifest(self, data=''): | ||||
|
r24701 | if self._treeinmem: | ||
|
r24403 | return treemanifest('', data) | ||
|
r24402 | return manifestdict(data) | ||
|
r1089 | |||
|
r24528 | def _slowreaddelta(self, node): | ||
r0 = self.deltaparent(self.rev(node)) | ||||
m0 = self.read(self.node(r0)) | ||||
m1 = self.read(node) | ||||
md = self._newmanifest() | ||||
for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).iteritems(): | ||||
if n1: | ||||
md[f] = n1 | ||||
if fl1: | ||||
md.setflag(f, fl1) | ||||
return md | ||||
|
r3196 | def readdelta(self, node): | ||
|
r24701 | if self._usemanifestv2 or self._treeondisk: | ||
|
r24528 | return self._slowreaddelta(node) | ||
|
r7362 | r = self.rev(node) | ||
|
r24224 | d = mdiff.patchtext(self.revdiff(self.deltaparent(r), r)) | ||
|
r24402 | return self._newmanifest(d) | ||
|
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: | ||
|
r24402 | return self._newmanifest() # 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) | ||
|
r24402 | m = self._newmanifest(text) | ||
|
r24147 | 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.''' | ||
|
r24292 | m = self.read(node) | ||
|
r24225 | try: | ||
|
r24292 | return m.find(f) | ||
|
r24225 | except KeyError: | ||
|
r2320 | return None, None | ||
|
r24147 | def add(self, m, transaction, link, p1, p2, added, removed): | ||
|
r24701 | if (p1 in self._mancache and not self._treeinmem | ||
|
r24527 | and not self._usemanifestv2): | ||
|
r22788 | # 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. | ||||
|
r24573 | text = m.text(self._usemanifestv2) | ||
|
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 | ||||