mercurial: comparison mercurial/manifest.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 propertycache = util.propertycache
 # Allow tests to more easily test the alternate path in manifestdict.fastdelta()
 FASTDELTA_TEXTDIFF_THRESHOLD = 1000
 def _parse(data):
 # 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
 if len(n) > 40:
 yield f, bin(n[:40]), n[40:]
 else:
 yield f, bin(n), ''
 def _text(it):
 files = []
 lines = []
 for f, n, fl in it:
 files.append(f)
 # 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)
 class lazymanifestiter(object):
 def __init__(self, lm):
 self.pos = 0
 self.lm = lm
 zeropos = data.find('\x00', pos)
 return data[pos:zeropos]
 __next__ = next
 class lazymanifestiterentries(object):
 def __init__(self, lm):
 self.lm = lm
 self.pos = 0
 raise StopIteration
 if pos == -1:
 self.pos += 1
 return data
 zeropos = data.find('\x00', pos)
-hashval = unhexlify(data, self.lm.extrainfo[self.pos],
+hashval = unhexlify(data, self.lm.extrainfo[self.pos], zeropos + 1, 40)
-zeropos + 1, 40)
 flags = self.lm._getflags(data, self.pos, zeropos)
 self.pos += 1
 return (data[pos:zeropos], hashval, flags)
 __next__ = next
 def unhexlify(data, extra, pos, length):
-s = bin(data[pos:pos + length])
+s = bin(data[pos : pos + length])
 if extra:
-s += chr(extra & 0xff)
+s += chr(extra & 0xFF)
 return s
 def _cmp(a, b):
 return (a > b) - (a < b)
 class _lazymanifest(object):
 """A pure python manifest backed by a byte string.  It is supplimented with
 internal lists as it is modified, until it is compacted back to a pure byte
 string.
 sorted by filename.
 ``extradata`` is a list of (key, hash, flags) for entries that were added or
 modified since the manifest was created or compacted.
 """
-def __init__(self, data, positions=None, extrainfo=None, extradata=None,
-hasremovals=False):
+def __init__(
+self,
+data,
+positions=None,
+extrainfo=None,
+extradata=None,
+hasremovals=False,
+):
 if positions is None:
 self.positions = self.findlines(data)
 self.extrainfo = [0] * len(self.positions)
 self.data = data
 self.extradata = []
 return []
 pos = data.find("\n")
 if pos == -1 or data[-1:] != '\n':
 raise ValueError("Manifest did not end in a newline.")
 positions = [0]
-prev = data[:data.find('\x00')]
+prev = data[: data.find('\x00')]
 while pos < len(data) - 1 and pos != -1:
 positions.append(pos + 1)
-nexts = data[pos + 1:data.find('\x00', pos + 1)]
+nexts = data[pos + 1 : data.find('\x00', pos + 1)]
 if nexts < prev:
 raise ValueError("Manifest lines not in sorted order.")
 prev = nexts
 pos = data.find("\n", pos + 1)
 return positions
 return self.data, pos
 return self.extradata[-pos - 1], -1
 def _getkey(self, pos):
 if pos >= 0:
-return self.data[pos:self.data.find('\x00', pos + 1)]
+return self.data[pos : self.data.find('\x00', pos + 1)]
 return self.extradata[-pos - 1][0]
 def bsearch(self, key):
 first = 0
 last = len(self.positions) - 1
 while first <= last:
-midpoint = (first + last)//2
+midpoint = (first + last) // 2
 nextpos = self.positions[midpoint]
 candidate = self._getkey(nextpos)
 r = _cmp(key, candidate)
 if r == 0:
 return midpoint
 # done for performance reasons
 first = 0
 last = len(self.positions) - 1
 while first <= last:
-midpoint = (first + last)//2
+midpoint = (first + last) // 2
 nextpos = self.positions[midpoint]
 candidate = self._getkey(nextpos)
 r = _cmp(key, candidate)
 if r == 0:
 return (midpoint, True)
 def __delitem__(self, key):
 needle, found = self.bsearch2(key)
 if not found:
 raise KeyError
 cur = self.positions[needle]
-self.positions = self.positions[:needle] + self.positions[needle + 1:]
+self.positions = self.positions[:needle] + self.positions[needle + 1 :]
-self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1:]
+self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1 :]
 if cur >= 0:
 # This does NOT unsort the list as far as the search functions are
 # concerned, as they only examine lines mapped by self.positions.
-self.data = self.data[:cur] + '\x00' + self.data[cur + 1:]
+self.data = self.data[:cur] + '\x00' + self.data[cur + 1 :]
 self.hasremovals = True
 def __setitem__(self, key, value):
 if not isinstance(key, bytes):
 raise TypeError("setitem: manifest keys must be a byte string.")
 self.extradata.append((key, hashval, value[1]))
 self.positions[needle] = -len(self.extradata)
 else:
 # not found, put it in with extra positions
 self.extradata.append((key, hashval, value[1]))
-self.positions = (self.positions[:needle] + [-len(self.extradata)]
+self.positions = (
-+ self.positions[needle:])
+self.positions[:needle]
-self.extrainfo = (self.extrainfo[:needle] + [0] +
++ [-len(self.extradata)]
-self.extrainfo[needle:])
++ self.positions[needle:]
+)
+self.extrainfo = (
+self.extrainfo[:needle] + [0] + self.extrainfo[needle:]
+)
 def copy(self):
 # XXX call _compact like in C?
-return _lazymanifest(self.data, self.positions, self.extrainfo,
+return _lazymanifest(
-self.extradata, self.hasremovals)
+self.data,
+self.positions,
+self.extrainfo,
+self.extradata,
+self.hasremovals,
+)
 def _compact(self):
 # hopefully not called TOO often
 if len(self.extradata) == 0 and not self.hasremovals:
 return
 # A removed file has no positions[] entry, but does have an
 # overwritten first byte.  Break out and find the end of the
 # current good entry/entries if there is a removed file
 # before the next position.
-if (self.hasremovals
+if (
-and self.data.find('\n\x00', cur,
+self.hasremovals
-self.positions[i]) != -1):
+and self.data.find('\n\x00', cur, self.positions[i])
+!= -1
+):
 break
 offset += self.positions[i] - cur
 cur = self.positions[i]
 end_cut = self.data.find('\n', cur)
 for f, n, fl in self.iterentries():
 if filterfn(f):
 c[f] = n, fl
 return c
 try:
 _lazymanifest = parsers.lazymanifest
 except AttributeError:
 pass
 @interfaceutil.implementer(repository.imanifestdict)
 class manifestdict(object):
 def __init__(self, data=''):
 self._lm = _lazymanifest(data)
 if match:
 m1 = self.matches(match)
 m2 = m2.matches(match)
 return m1.filesnotin(m2)
 diff = self.diff(m2)
-files = set(filepath
+files = set(
-for filepath, hashflags in diff.iteritems()
+filepath
-if hashflags[1][0] is None)
+for filepath, hashflags in diff.iteritems()
+if hashflags[1][0] is None
+)
 return files
 @propertycache
 def _dirs(self):
 return util.dirs(self)
 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
+return len(files) < 100 and (
-(match.prefix() and all(fn in self for fn in files))))
+match.isexact()
+or (match.prefix() and all(fn in self for fn in files))
+)
 def walk(self, match):
 '''Generates matching file names.
 Equivalent to manifest.matches(match).iterkeys(), but without creating
 l = "%s\0%s%s\n" % (f, hex(h), fl)
 else:
 if start == end:
 # item we want to delete was not found, error out
 raise AssertionError(
-_("failed to remove %s from manifest") % f)
+_("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:
 else:
 # For large changes, it's much cheaper to just build the text and
 # diff it.
 arraytext = bytearray(self.text())
 deltatext = mdiff.textdiff(
-util.buffer(base), util.buffer(arraytext))
+util.buffer(base), util.buffer(arraytext)
+)
 return arraytext, deltatext
 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, a memoryview or a byte string.
 s is a byte string'''
 def advance(i, c):
-while i < lenm and m[i:i + 1] != c:
+while i < lenm and m[i : i + 1] != 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:start] != '\n':
+while start > 0 and m[start - 1 : start] != '\n':
 start -= 1
 end = advance(start, '\0')
 if bytes(m[start:end]) < s:
 # we know that after the null there are 40 bytes of sha1
 # this translates to the bisect lo = mid + 1
 end = advance(end + 40, '\n')
 return (lo, end + 1)
 else:
 return (lo, lo)
 def _checkforbidden(l):
 """Check filenames for illegal characters."""
 for f in l:
 if '\n' in f or '\r' in f:
 raise error.StorageError(
 _("'\\n' and '\\r' disallowed in filenames: %r")
-% pycompat.bytestr(f))
+% pycompat.bytestr(f)
+)
 # apply the changes collected during the bisect loop to our addlist
 # return a delta suitable for addrevision
 def _addlistdelta(addlist, x):
 currentposition = end
 newaddlist += addlist[currentposition:]
-deltatext = "".join(struct.pack(">lll", start, end, len(content))
+deltatext = "".join(
-+ content for start, end, content in x)
+struct.pack(">lll", start, end, len(content)) + content
+for start, end, content in x
+)
 return deltatext, newaddlist
 def _splittopdir(f):
 if '/' in f:
 dir, subpath = f.split('/', 1)
 return dir + '/', subpath
 else:
 return '', f
 _noop = lambda s: None
 class treemanifest(object):
 def __init__(self, dir='', text=''):
 self._dir = dir
 self._node = nullid
 self._lazydirs = {}
 # Using _lazymanifest here is a little slower than plain old dicts
 self._files = {}
 self._flags = {}
 if text:
 def readsubtree(subdir, subm):
-raise AssertionError('treemanifest constructor only accepts '
+raise AssertionError(
-'flat manifests')
+'treemanifest constructor only accepts ' 'flat manifests'
+)
 self.parse(text, readsubtree)
-self._dirty = True # Mark flat manifest dirty after parsing
+self._dirty = True  # Mark flat manifest dirty after parsing
 def _subpath(self, path):
 return self._dir + path
 def _loadalllazy(self):
 return not self._isempty()
 __bool__ = __nonzero__
 def _isempty(self):
-self._load() # for consistency; already loaded by all callers
+self._load()  # for consistency; already loaded by all callers
 # See if we can skip loading everything.
-if self._files or (self._dirs and
+if self._files or (
-any(not m._isempty() for m in self._dirs.values())):
+self._dirs and any(not m._isempty() for m in self._dirs.values())
+):
 return False
 self._loadalllazy()
-return (not self._dirs or
+return 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):
-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, hex(self._node),
+self._dir,
-bool(self._loadfunc is _noop),
+hex(self._node),
-self._dirty, id(self)))
+bool(self._loadfunc is _noop),
+self._dirty,
+id(self),
+)
 def dir(self):
 '''The directory that this tree manifest represents, including a
 trailing '/'. Empty string for the repo root directory.'''
 return self._dir
 self._dirty = False
 def iterentries(self):
 self._load()
 self._loadalllazy()
-for p, n in sorted(itertools.chain(self._dirs.items(),
+for p, n in sorted(
-self._files.items())):
+itertools.chain(self._dirs.items(), self._files.items())
+):
 if p in self._files:
 yield self._subpath(p), n, self._flags.get(p, '')
 else:
 for x in n.iterentries():
 yield x
 def items(self):
 self._load()
 self._loadalllazy()
-for p, n in sorted(itertools.chain(self._dirs.items(),
+for p, n in sorted(
-self._files.items())):
+itertools.chain(self._dirs.items(), self._files.items())
+):
 if p in self._files:
 yield self._subpath(p), n
 else:
 for f, sn in n.iteritems():
 yield f, sn
 self._loadlazy(dir)
 if dir not in self._dirs:
 self._dirs[dir] = treemanifest(self._subpath(dir))
 self._dirs[dir].__setitem__(subpath, n)
 else:
-self._files[f] = n[:21] # to match manifestdict's behavior
+self._files[f] = n[:21]  # to match manifestdict's behavior
 self._dirty = True
 def _load(self):
 if self._loadfunc is not _noop:
 lf, self._loadfunc = self._loadfunc, _noop
 def copy(self):
 copy = treemanifest(self._dir)
 copy._node = self._node
 copy._dirty = self._dirty
 if self._copyfunc is _noop:
 def _copyfunc(s):
 self._load()
-s._lazydirs = {d: (p, n, r, True) for
+s._lazydirs = {
-d, (p, n, r, c) in self._lazydirs.iteritems()}
+d: (p, n, r, True)
+for d, (p, n, r, c) in self._lazydirs.iteritems()
+}
 sdirs = s._dirs
 for d, v in self._dirs.iteritems():
 sdirs[d] = v.copy()
 s._files = dict.copy(self._files)
 s._flags = dict.copy(self._flags)
 if self._loadfunc is _noop:
 _copyfunc(copy)
 else:
 copy._copyfunc = _copyfunc
 else:
 m1 = self.matches(match)
 m2 = m2.matches(match)
 return m1.filesnotin(m2)
 files = set()
 def _filesnotin(t1, t2):
 if t1._node == t2._node and not t1._dirty and not t2._dirty:
 return
 t1._load()
 t2._load()
 def read(self, gettext, readsubtree):
 def _load_for_read(s):
 s.parse(gettext(), readsubtree)
 s._dirty = False
 self._loadfunc = _load_for_read
 def writesubtrees(self, m1, m2, writesubtree, match):
-self._load() # for consistency; should never have any effect here
+self._load()  # for consistency; should never have any effect here
 m1._load()
 m2._load()
 emptytree = treemanifest()
 def getnode(m, d):
 ld = m._lazydirs.get(d)
 if ld:
 return ld[1]
 return m._dirs.get(d, emptytree)._node
 # OPT: use visitchildrenset to avoid loading everything.
 self._loadalllazy()
 for d, subm in self._dirs.iteritems():
 for subtree in subm.walksubtrees(matcher=matcher):
 yield subtree
 class manifestfulltextcache(util.lrucachedict):
 """File-backed LRU cache for the manifest cache
 File consists of entries, up to EOF:
 def write(self):
 if not self._dirty or self._opener is None:
 return
 # rotate backwards to the first used node
-with self._opener(self._file, 'w', atomictemp=True, checkambig=True
+with self._opener(
-) as fp:
+self._file, 'w', atomictemp=True, checkambig=True
+) as fp:
 node = self._head.prev
 while True:
 if node.key in self._cache:
 fp.write(node.key)
 fp.write(struct.pack('>L', len(node.value)))
 if clear_persisted_data:
 self._dirty = True
 self.write()
 self._read = False
 # and upper bound of what we expect from compression
 # (real live value seems to be "3")
 MAXCOMPRESSION = 3
 @interfaceutil.implementer(repository.imanifeststorage)
 class manifestrevlog(object):
 '''A revlog that stores manifest texts. This is responsible for caching the
 full-text manifest contents.
 '''
-def __init__(self, opener, tree='', dirlogcache=None, indexfile=None,
-treemanifest=False):
+def __init__(
+self,
+opener,
+tree='',
+dirlogcache=None,
+indexfile=None,
+treemanifest=False,
+):
 """Constructs a new manifest revlog
 `indexfile` - used by extensions to have two manifests at once, like
 when transitioning between flatmanifeset and treemanifests.
 if tree:
 self._dirlogcache = dirlogcache
 else:
 self._dirlogcache = {'': self}
-self._revlog = revlog.revlog(opener, indexfile,
+self._revlog = revlog.revlog(
-# only root indexfile is cached
+opener,
-checkambig=not bool(tree),
+indexfile,
-mmaplargeindex=True,
+# only root indexfile is cached
-upperboundcomp=MAXCOMPRESSION)
+checkambig=not bool(tree),
+mmaplargeindex=True,
+upperboundcomp=MAXCOMPRESSION,
+)
 self.index = self._revlog.index
 self.version = self._revlog.version
 self._generaldelta = self._revlog._generaldelta
 def dirlog(self, d):
 if d:
 assert self._treeondisk
 if d not in self._dirlogcache:
-mfrevlog = manifestrevlog(self.opener, d,
+mfrevlog = manifestrevlog(
-self._dirlogcache,
+self.opener, d, self._dirlogcache, treemanifest=self._treeondisk
-treemanifest=self._treeondisk)
+)
 self._dirlogcache[d] = mfrevlog
 return self._dirlogcache[d]
-def add(self, m, transaction, link, p1, p2, added, removed, readtree=None,
+def add(
-match=None):
+self,
+m,
+transaction,
+link,
+p1,
+p2,
+added,
+removed,
+readtree=None,
+match=None,
+):
 if p1 in self.fulltextcache and util.safehasattr(m, 'fastdelta'):
 # 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.
 _checkforbidden(added)
 # combine the changed lists into one sorted iterator
-work = heapq.merge([(x, False) for x in sorted(added)],
+work = heapq.merge(
-[(x, True) for x in sorted(removed)])
+[(x, False) for x in sorted(added)],
+[(x, True) for x in sorted(removed)],
+)
 arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work)
 cachedelta = self._revlog.rev(p1), deltatext
 text = util.buffer(arraytext)
-n = self._revlog.addrevision(text, transaction, link, p1, p2,
+n = self._revlog.addrevision(
-cachedelta)
+text, transaction, link, p1, p2, cachedelta
+)
 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.
 if self._treeondisk:
 assert readtree, "readtree must be set for treemanifest writes"
 assert match, "match must be specified for treemanifest writes"
 m1 = readtree(self.tree, p1)
 m2 = readtree(self.tree, p2)
-n = self._addtree(m, transaction, link, m1, m2, readtree,
+n = self._addtree(
-match=match)
+m, transaction, link, m1, m2, readtree, match=match
+)
 arraytext = None
 else:
 text = m.text()
 n = self._revlog.addrevision(text, transaction, link, p1, p2)
 arraytext = bytearray(text)
 return n
 def _addtree(self, m, transaction, link, m1, m2, readtree, match):
 # If the manifest is unchanged compared to one parent,
 # don't write a new revision
-if self.tree != '' and (m.unmodifiedsince(m1) or m.unmodifiedsince(
+if self.tree != '' and (m.unmodifiedsince(m1) or m.unmodifiedsince(m2)):
-m2)):
 return m.node()
 def writesubtree(subm, subp1, subp2, match):
 sublog = self.dirlog(subm.dir())
-sublog.add(subm, transaction, link, subp1, subp2, None, None,
+sublog.add(
-readtree=readtree, match=match)
+subm,
+transaction,
+link,
+subp1,
+subp2,
+None,
+None,
+readtree=readtree,
+match=match,
+)
 m.writesubtrees(m1, m2, writesubtree, match)
 text = m.dirtext()
 n = None
 if self.tree != '':
 # Double-check whether contents are unchanged to one parent
 n = m1.node()
 elif text == m2.dirtext():
 n = m2.node()
 if not n:
-n = self._revlog.addrevision(text, transaction, link, m1.node(),
+n = self._revlog.addrevision(
-m2.node())
+text, transaction, link, m1.node(), m2.node()
+)
 # Save nodeid so parent manifest can calculate its nodeid
 m.setnode(n)
 return n
 return self._revlog.cmp(node, text)
 def deltaparent(self, rev):
 return self._revlog.deltaparent(rev)
-def emitrevisions(self, nodes, nodesorder=None,
+def emitrevisions(
-revisiondata=False, assumehaveparentrevisions=False,
+self,
-deltamode=repository.CG_DELTAMODE_STD):
+nodes,
+nodesorder=None,
+revisiondata=False,
+assumehaveparentrevisions=False,
+deltamode=repository.CG_DELTAMODE_STD,
+):
 return self._revlog.emitrevisions(
-nodes, nodesorder=nodesorder, revisiondata=revisiondata,
+nodes,
+nodesorder=nodesorder,
+revisiondata=revisiondata,
 assumehaveparentrevisions=assumehaveparentrevisions,
-deltamode=deltamode)
+deltamode=deltamode,
+)
 def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None):
-return self._revlog.addgroup(deltas, linkmapper, transaction,
+return self._revlog.addgroup(
-addrevisioncb=addrevisioncb)
+deltas, linkmapper, transaction, addrevisioncb=addrevisioncb
+)
 def rawsize(self, rev):
 return self._revlog.rawsize(rev)
 def getstrippoint(self, minlink):
 if not isinstance(destrevlog, manifestrevlog):
 raise error.ProgrammingError('expected manifestrevlog to clone()')
 return self._revlog.clone(tr, destrevlog._revlog, **kwargs)
-def storageinfo(self, exclusivefiles=False, sharedfiles=False,
+def storageinfo(
-revisionscount=False, trackedsize=False,
+self,
-storedsize=False):
+exclusivefiles=False,
+sharedfiles=False,
+revisionscount=False,
+trackedsize=False,
+storedsize=False,
+):
 return self._revlog.storageinfo(
-exclusivefiles=exclusivefiles, sharedfiles=sharedfiles,
+exclusivefiles=exclusivefiles,
-revisionscount=revisionscount, trackedsize=trackedsize,
+sharedfiles=sharedfiles,
-storedsize=storedsize)
+revisionscount=revisionscount,
+trackedsize=trackedsize,
+storedsize=storedsize,
+)
 @property
 def indexfile(self):
 return self._revlog.indexfile
 return self._revlog.opener
 @opener.setter
 def opener(self, value):
 self._revlog.opener = value
 @interfaceutil.implementer(repository.imanifestlog)
 class manifestlog(object):
 """A collection class representing the collection of manifest snapshots
 referenced by commits in the repository.
 In this situation, 'manifest' refers to the abstract concept of a snapshot
 of the list of files in the given commit. Consumers of the output of this
 class do not care about the implementation details of the actual manifests
 they receive (i.e. tree or flat or lazily loaded, etc)."""
 def __init__(self, opener, repo, rootstore, narrowmatch):
 usetreemanifest = False
 cachesize = 4
 opts = getattr(opener, 'options', None)
 self.getstorage(tree).rev(node)
 m = treemanifestctx(self, tree, node)
 else:
 raise error.Abort(
-_("cannot ask for manifest directory '%s' in a flat "
+_(
-"manifest") % tree)
+"cannot ask for manifest directory '%s' in a flat "
+"manifest"
+)
+% tree
+)
 else:
 if verify:
 # Side-effect is LookupError is raised if node doesn't exist.
 self._rootstore.rev(node)
 self._rootstore.clearcaches(clear_persisted_data=clear_persisted_data)
 def rev(self, node):
 return self._rootstore.rev(node)
 @interfaceutil.implementer(repository.imanifestrevisionwritable)
 class memmanifestctx(object):
 def __init__(self, manifestlog):
 self._manifestlog = manifestlog
 self._manifestdict = manifestdict()
 def read(self):
 return self._manifestdict
 def write(self, transaction, link, p1, p2, added, removed, match=None):
-return self._storage().add(self._manifestdict, transaction, link,
+return self._storage().add(
-p1, p2, added, removed, match=match)
+self._manifestdict,
+transaction,
+link,
+p1,
+p2,
+added,
+removed,
+match=match,
+)
 @interfaceutil.implementer(repository.imanifestrevisionstored)
 class manifestctx(object):
 """A class representing a single revision of a manifest, including its
 contents, its parent revs, and its linkrev.
 """
 def __init__(self, manifestlog, node):
 self._manifestlog = manifestlog
 self._data = None
 self._node = node
 # TODO: We eventually want p1, p2, and linkrev exposed on this class,
 # but let's add it later when something needs it and we can load it
 # lazily.
-#self.p1, self.p2 = store.parents(node)
+# self.p1, self.p2 = store.parents(node)
-#rev = store.rev(node)
+# rev = store.rev(node)
-#self.linkrev = store.linkrev(rev)
+# self.linkrev = store.linkrev(rev)
 def _storage(self):
 return self._manifestlog.getstorage(b'')
 def node(self):
 return manifestdict(d)
 def find(self, key):
 return self.read().find(key)
 @interfaceutil.implementer(repository.imanifestrevisionwritable)
 class memtreemanifestctx(object):
 def __init__(self, manifestlog, dir=''):
 self._manifestlog = manifestlog
 self._dir = dir
 return self._treemanifest
 def write(self, transaction, link, p1, p2, added, removed, match=None):
 def readtree(dir, node):
 return self._manifestlog.get(dir, node).read()
-return self._storage().add(self._treemanifest, transaction, link,
-p1, p2, added, removed, readtree=readtree,
+return self._storage().add(
-match=match)
+self._treemanifest,
+transaction,
+link,
+p1,
+p2,
+added,
+removed,
+readtree=readtree,
+match=match,
+)
 @interfaceutil.implementer(repository.imanifestrevisionstored)
 class treemanifestctx(object):
 def __init__(self, manifestlog, dir, node):
 self._manifestlog = manifestlog
 self._node = node
 # TODO: Load p1/p2/linkrev lazily. They need to be lazily loaded so that
 # we can instantiate treemanifestctx objects for directories we don't
 # have on disk.
-#self.p1, self.p2 = store.parents(node)
+# self.p1, self.p2 = store.parents(node)
-#rev = store.rev(node)
+# rev = store.rev(node)
-#self.linkrev = store.linkrev(rev)
+# self.linkrev = store.linkrev(rev)
 def _storage(self):
 narrowmatch = self._manifestlog._narrowmatch
 if not narrowmatch.always():
 if not narrowmatch.visitdir(self._dir[:-1]):
 if self._node == nullid:
 self._data = treemanifest()
 # TODO accessing non-public API
 elif store._treeondisk:
 m = treemanifest(dir=self._dir)
 def gettext():
 return store.revision(self._node)
 def readsubtree(dir, subm):
 # Set verify to False since we need to be able to create
 # subtrees for trees that don't exist on disk.
 return self._manifestlog.get(dir, subm, verify=False).read()
 m.read(gettext, readsubtree)
 m.setnode(self._node)
 self._data = m
 else:
 if self._node in store.fulltextcache:
 and not any submanifests.
 '''
 store = self._storage()
 r = store.rev(self._node)
 deltaparent = store.deltaparent(r)
-if (deltaparent != nullrev and
+if deltaparent != nullrev and deltaparent in store.parentrevs(r):
-deltaparent in store.parentrevs(r)):
 return self.readdelta(shallow=shallow)
 if shallow:
 return manifestdict(store.revision(self._node))
 else:
 return self.read()
 def find(self, key):
 return self.read().find(key)
 class excludeddir(treemanifest):
 """Stand-in for a directory that is excluded from the repository.
 With narrowing active on a repository that uses treemanifests,
 some sort of pseudo-manifest to surface to internals so we can
 detect a merge conflict outside the narrowspec. That's what this
 class is: it stands in for a directory whose node is known, but
 whose contents are unknown.
 """
 def __init__(self, dir, node):
 super(excludeddir, self).__init__(dir)
 self._node = node
 # Add an empty file, which will be included by iterators and such,
 # appearing as the directory itself (i.e. something like "dir/")
 # be of the same type as the original, which would not happen with the
 # super type's copy().
 def copy(self):
 return self
 class excludeddirmanifestctx(treemanifestctx):
 """context wrapper for excludeddir - see that docstring for rationale"""
 def __init__(self, dir, node):
 self._dir = dir
 self._node = node
 def read(self):
 return excludeddir(self._dir, self._node)
 def write(self, *args):
 raise error.ProgrammingError(
-'attempt to write manifest from excluded dir %s' % self._dir)
+'attempt to write manifest from excluded dir %s' % self._dir
+)
 class excludedmanifestrevlog(manifestrevlog):
 """Stand-in for excluded treemanifest revlogs.
 When narrowing is active on a treemanifest repository, we'll have
 def __init__(self, dir):
 self._dir = dir
 def __len__(self):
 raise error.ProgrammingError(
-'attempt to get length of excluded dir %s' % self._dir)
+'attempt to get length of excluded dir %s' % self._dir
+)
 def rev(self, node):
 raise error.ProgrammingError(
-'attempt to get rev from excluded dir %s' % self._dir)
+'attempt to get rev from excluded dir %s' % self._dir
+)
 def linkrev(self, node):
 raise error.ProgrammingError(
-'attempt to get linkrev from excluded dir %s' % self._dir)
+'attempt to get linkrev from excluded dir %s' % self._dir
+)
 def node(self, rev):
 raise error.ProgrammingError(
-'attempt to get node from excluded dir %s' % self._dir)
+'attempt to get node from excluded dir %s' % self._dir
+)
 def add(self, *args, **kwargs):
 # We should never write entries in dirlogs outside the narrow clone.
 # However, the method still gets called from writesubtree() in
 # _addtree(), so we need to handle it. We should possibly make that

changeset 43076	2372284d9457
parent 42814	2c4f656c8e9f
child 43077	687b865b95ad