| hg-reviewers |
The revlog module re-exports some node.* symbols courtesy of
importing them. Let's access the node.* symbols via our local
import.
| Lint Skipped |
| Unit Tests Skipped |
| import itertools | import itertools | ||||
| import struct | import struct | ||||
| import weakref | import weakref | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | |||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| mdiff, | mdiff, | ||||
| policy, | policy, | ||||
| pycompat, | pycompat, | ||||
| repository, | repository, | ||||
| revlog, | revlog, | ||||
| if len(n) > 40: | if len(n) > 40: | ||||
| yield f, bin(n[:40]), n[40:] | yield f, bin(n[:40]), n[40:] | ||||
| else: | else: | ||||
| yield f, bin(n), '' | yield f, bin(n), '' | ||||
| def _text(it): | def _text(it): | ||||
| files = [] | files = [] | ||||
| lines = [] | lines = [] | ||||
| _hex = revlog.hex | |||||
| for f, n, fl in it: | for f, n, fl in it: | ||||
| files.append(f) | files.append(f) | ||||
| # if this is changed to support newlines in filenames, | # if this is changed to support newlines in filenames, | ||||
| # be sure to check the templates/ dir again (especially *-raw.tmpl) | # be sure to check the templates/ dir again (especially *-raw.tmpl) | ||||
| lines.append("%s\0%s%s\n" % (f, _hex(n), fl)) | lines.append("%s\0%s%s\n" % (f, hex(n), fl)) | ||||
| _checkforbidden(files) | _checkforbidden(files) | ||||
| return ''.join(lines) | return ''.join(lines) | ||||
| class lazymanifestiter(object): | class lazymanifestiter(object): | ||||
| def __init__(self, lm): | def __init__(self, lm): | ||||
| self.pos = 0 | self.pos = 0 | ||||
| self.lm = lm | self.lm = lm | ||||
| if len(changes) < 1000: | if len(changes) < 1000: | ||||
| # start with a readonly loop that finds the offset of | # start with a readonly loop that finds the offset of | ||||
| # each line and creates the deltas | # each line and creates the deltas | ||||
| for f, todelete in changes: | for f, todelete in changes: | ||||
| # bs will either be the index of the item or the insert point | # bs will either be the index of the item or the insert point | ||||
| start, end = _msearch(addbuf, f, start) | start, end = _msearch(addbuf, f, start) | ||||
| if not todelete: | if not todelete: | ||||
| h, fl = self._lm[f] | h, fl = self._lm[f] | ||||
| l = "%s\0%s%s\n" % (f, revlog.hex(h), fl) | l = "%s\0%s%s\n" % (f, hex(h), fl) | ||||
| else: | else: | ||||
| if start == end: | if start == end: | ||||
| # item we want to delete was not found, error out | # item we want to delete was not found, error out | ||||
| raise AssertionError( | raise AssertionError( | ||||
| _("failed to remove %s from manifest") % f) | _("failed to remove %s from manifest") % f) | ||||
| l = "" | l = "" | ||||
| if dstart is not None and dstart <= start and dend >= start: | if dstart is not None and dstart <= start and dend >= start: | ||||
| if dend < end: | if dend < end: | ||||
| else: | else: | ||||
| return '', f | return '', f | ||||
| _noop = lambda s: None | _noop = lambda s: None | ||||
| class treemanifest(object): | class treemanifest(object): | ||||
| def __init__(self, dir='', text=''): | def __init__(self, dir='', text=''): | ||||
| self._dir = dir | self._dir = dir | ||||
| self._node = revlog.nullid | self._node = nullid | ||||
| self._loadfunc = _noop | self._loadfunc = _noop | ||||
| self._copyfunc = _noop | self._copyfunc = _noop | ||||
| self._dirty = False | self._dirty = False | ||||
| self._dirs = {} | self._dirs = {} | ||||
| # Using _lazymanifest here is a little slower than plain old dicts | # Using _lazymanifest here is a little slower than plain old dicts | ||||
| self._files = {} | self._files = {} | ||||
| self._flags = {} | self._flags = {} | ||||
| if text: | if text: | ||||
| def _isempty(self): | def _isempty(self): | ||||
| self._load() # for consistency; already loaded by all callers | self._load() # for consistency; already loaded by all callers | ||||
| return (not self._files and (not self._dirs or | return (not self._files and (not self._dirs or | ||||
| all(m._isempty() for m in self._dirs.values()))) | all(m._isempty() for m in self._dirs.values()))) | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<treemanifest dir=%s, node=%s, loaded=%s, dirty=%s at 0x%x>' % | return ('<treemanifest dir=%s, node=%s, loaded=%s, dirty=%s at 0x%x>' % | ||||
| (self._dir, revlog.hex(self._node), | (self._dir, hex(self._node), | ||||
| bool(self._loadfunc is _noop), | bool(self._loadfunc is _noop), | ||||
| self._dirty, id(self))) | self._dirty, id(self))) | ||||
| def dir(self): | def dir(self): | ||||
| '''The directory that this tree manifest represents, including a | '''The directory that this tree manifest represents, including a | ||||
| trailing '/'. Empty string for the repo root directory.''' | trailing '/'. Empty string for the repo root directory.''' | ||||
| return self._dir | return self._dir | ||||
| def writesubtrees(self, m1, m2, writesubtree): | def writesubtrees(self, m1, m2, writesubtree): | ||||
| self._load() # for consistency; should never have any effect here | self._load() # for consistency; should never have any effect here | ||||
| m1._load() | m1._load() | ||||
| m2._load() | m2._load() | ||||
| emptytree = treemanifest() | emptytree = treemanifest() | ||||
| for d, subm in self._dirs.iteritems(): | for d, subm in self._dirs.iteritems(): | ||||
| subp1 = m1._dirs.get(d, emptytree)._node | subp1 = m1._dirs.get(d, emptytree)._node | ||||
| subp2 = m2._dirs.get(d, emptytree)._node | subp2 = m2._dirs.get(d, emptytree)._node | ||||
| if subp1 == revlog.nullid: | if subp1 == nullid: | ||||
| subp1, subp2 = subp2, subp1 | subp1, subp2 = subp2, subp1 | ||||
| writesubtree(subm, subp1, subp2) | writesubtree(subm, subp1, subp2) | ||||
| def walksubtrees(self, matcher=None): | def walksubtrees(self, matcher=None): | ||||
| """Returns an iterator of the subtrees of this manifest, including this | """Returns an iterator of the subtrees of this manifest, including this | ||||
| manifest itself. | manifest itself. | ||||
| If `matcher` is provided, it only returns subtrees that match. | If `matcher` is provided, it only returns subtrees that match. | ||||
| # Side-effect is LookupError is raised if node doesn't exist. | # Side-effect is LookupError is raised if node doesn't exist. | ||||
| self._revlog.rev(node) | self._revlog.rev(node) | ||||
| if self._treemanifests: | if self._treemanifests: | ||||
| m = treemanifestctx(self, '', node) | m = treemanifestctx(self, '', node) | ||||
| else: | else: | ||||
| m = manifestctx(self, node) | m = manifestctx(self, node) | ||||
| if node != revlog.nullid: | if node != nullid: | ||||
| mancache = self._dirmancache.get(tree) | mancache = self._dirmancache.get(tree) | ||||
| if not mancache: | if not mancache: | ||||
| mancache = util.lrucachedict(self._cachesize) | mancache = util.lrucachedict(self._cachesize) | ||||
| self._dirmancache[tree] = mancache | self._dirmancache[tree] = mancache | ||||
| mancache[node] = m | mancache[node] = m | ||||
| return m | return m | ||||
| def getstorage(self, tree): | def getstorage(self, tree): | ||||
| return memmf | return memmf | ||||
| @propertycache | @propertycache | ||||
| def parents(self): | def parents(self): | ||||
| return self._revlog().parents(self._node) | return self._revlog().parents(self._node) | ||||
| def read(self): | def read(self): | ||||
| if self._data is None: | if self._data is None: | ||||
| if self._node == revlog.nullid: | if self._node == nullid: | ||||
| self._data = manifestdict() | self._data = manifestdict() | ||||
| else: | else: | ||||
| rl = self._revlog() | rl = self._revlog() | ||||
| if self._node in rl._fulltextcache: | if self._node in rl._fulltextcache: | ||||
| text = pycompat.bytestr(rl._fulltextcache[self._node]) | text = pycompat.bytestr(rl._fulltextcache[self._node]) | ||||
| else: | else: | ||||
| text = rl.revision(self._node) | text = rl.revision(self._node) | ||||
| arraytext = bytearray(text) | arraytext = bytearray(text) | ||||
| rl._fulltextcache[self._node] = arraytext | rl._fulltextcache[self._node] = arraytext | ||||
| self._data = manifestdict(text) | self._data = manifestdict(text) | ||||
| return self._data | return self._data | ||||
| def readfast(self, shallow=False): | def readfast(self, shallow=False): | ||||
| '''Calls either readdelta or read, based on which would be less work. | '''Calls either readdelta or read, based on which would be less work. | ||||
| readdelta is called if the delta is against the p1, and therefore can be | readdelta is called if the delta is against the p1, and therefore can be | ||||
| read quickly. | read quickly. | ||||
| If `shallow` is True, nothing changes since this is a flat manifest. | If `shallow` is True, nothing changes since this is a flat manifest. | ||||
| ''' | ''' | ||||
| rl = self._revlog() | rl = self._revlog() | ||||
| r = rl.rev(self._node) | r = rl.rev(self._node) | ||||
| deltaparent = rl.deltaparent(r) | deltaparent = rl.deltaparent(r) | ||||
| if deltaparent != revlog.nullrev and deltaparent in rl.parentrevs(r): | if deltaparent != nullrev and deltaparent in rl.parentrevs(r): | ||||
| return self.readdelta() | return self.readdelta() | ||||
| return self.read() | return self.read() | ||||
| def readdelta(self, shallow=False): | def readdelta(self, shallow=False): | ||||
| '''Returns a manifest containing just the entries that are present | '''Returns a manifest containing just the entries that are present | ||||
| in this manifest, but not in its p1 manifest. This is efficient to read | in this manifest, but not in its p1 manifest. This is efficient to read | ||||
| if the revlog delta is already p1. | if the revlog delta is already p1. | ||||
| if not narrowmatch.always(): | if not narrowmatch.always(): | ||||
| if not narrowmatch.visitdir(self._dir[:-1] or '.'): | if not narrowmatch.visitdir(self._dir[:-1] or '.'): | ||||
| return excludedmanifestrevlog(self._dir) | return excludedmanifestrevlog(self._dir) | ||||
| return self._manifestlog.getstorage(self._dir) | return self._manifestlog.getstorage(self._dir) | ||||
| def read(self): | def read(self): | ||||
| if self._data is None: | if self._data is None: | ||||
| rl = self._revlog() | rl = self._revlog() | ||||
| if self._node == revlog.nullid: | if self._node == nullid: | ||||
| self._data = treemanifest() | self._data = treemanifest() | ||||
| elif rl._treeondisk: | elif rl._treeondisk: | ||||
| m = treemanifest(dir=self._dir) | m = treemanifest(dir=self._dir) | ||||
| def gettext(): | def gettext(): | ||||
| return rl.revision(self._node) | return rl.revision(self._node) | ||||
| def readsubtree(dir, subm): | def readsubtree(dir, subm): | ||||
| # Set verify to False since we need to be able to create | # Set verify to False since we need to be able to create | ||||
| # subtrees for trees that don't exist on disk. | # subtrees for trees that don't exist on disk. | ||||
| read quickly. | read quickly. | ||||
| If `shallow` is True, it only returns the entries from this manifest, | If `shallow` is True, it only returns the entries from this manifest, | ||||
| and not any submanifests. | and not any submanifests. | ||||
| ''' | ''' | ||||
| rl = self._revlog() | rl = self._revlog() | ||||
| r = rl.rev(self._node) | r = rl.rev(self._node) | ||||
| deltaparent = rl.deltaparent(r) | deltaparent = rl.deltaparent(r) | ||||
| if (deltaparent != revlog.nullrev and | if (deltaparent != nullrev and | ||||
| deltaparent in rl.parentrevs(r)): | deltaparent in rl.parentrevs(r)): | ||||
| return self.readdelta(shallow=shallow) | return self.readdelta(shallow=shallow) | ||||
| if shallow: | if shallow: | ||||
| return manifestdict(rl.revision(self._node)) | return manifestdict(rl.revision(self._node)) | ||||
| else: | else: | ||||
| return self.read() | return self.read() | ||||