mercurial-scm/hg: mercurial/manifest.py comparison

comparison mercurial/manifest.py @ 43077:687b865b95ad

formatting: byteify all mercurial/ and hgext/ string literals Done with python3.7 contrib/byteify-strings.py -i $(hg files 'set:mercurial/**.py - mercurial/thirdparty/** + hgext/**.py - hgext/fsmonitor/pywatchman/** - mercurial/__init__.py') black -l 80 -t py33 -S $(hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**" - hgext/fsmonitor/pywatchman/**') # skip-blame mass-reformatting only Differential Revision: https://phab.mercurial-scm.org/D6972

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:48:39 -0400
parents	2372284d9457
children	c59eb1560c44

comparison

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 # 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':
+if data and data[-1:] != b'\n':
-raise ValueError('Manifest did not end in a newline.')
+raise ValueError(b'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.')
+raise ValueError(b'Manifest lines not in sorted order.')
 prev = l
-f, n = l.split('\0')
+f, n = l.split(b'\0')
 if len(n) > 40:
 yield f, bin(n[:40]), n[40:]
 else:
-yield f, bin(n), ''
+yield f, bin(n), b''
 def _text(it):
 files = []
 lines = []
 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))
+lines.append(b"%s\0%s%s\n" % (f, hex(n), fl))
 _checkforbidden(files)
-return ''.join(lines)
+return b''.join(lines)
 class lazymanifestiter(object):
 def __init__(self, lm):
 self.pos = 0
 raise StopIteration
 if pos == -1:
 self.pos += 1
 return data[0]
 self.pos += 1
-zeropos = data.find('\x00', pos)
+zeropos = data.find(b'\x00', pos)
 return data[pos:zeropos]
 __next__ = next
 except IndexError:
 raise StopIteration
 if pos == -1:
 self.pos += 1
 return data
-zeropos = data.find('\x00', pos)
+zeropos = data.find(b'\x00', pos)
 hashval = unhexlify(data, self.lm.extrainfo[self.pos], zeropos + 1, 40)
 flags = self.lm._getflags(data, self.pos, zeropos)
 self.pos += 1
 return (data[pos:zeropos], hashval, flags)
 self.hasremovals = hasremovals
 def findlines(self, data):
 if not data:
 return []
-pos = data.find("\n")
+pos = data.find(b"\n")
-if pos == -1 or data[-1:] != '\n':
+if pos == -1 or data[-1:] != b'\n':
-raise ValueError("Manifest did not end in a newline.")
+raise ValueError(b"Manifest did not end in a newline.")
 positions = [0]
-prev = data[: data.find('\x00')]
+prev = data[: data.find(b'\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(b'\x00', pos + 1)]
 if nexts < prev:
-raise ValueError("Manifest lines not in sorted order.")
+raise ValueError(b"Manifest lines not in sorted order.")
 prev = nexts
-pos = data.find("\n", pos + 1)
+pos = data.find(b"\n", pos + 1)
 return positions
 def _get(self, index):
 # get the position encoded in pos:
 #   positive number is an index in 'data'
 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(b'\x00', pos + 1)]
 return self.extradata[-pos - 1][0]
 def bsearch(self, key):
 first = 0
 last = len(self.positions) - 1
 def __contains__(self, key):
 return self.bsearch(key) != -1
 def _getflags(self, data, needle, pos):
 start = pos + 41
-end = data.find("\n", start)
+end = data.find(b"\n", start)
 if end == -1:
 end = len(data) - 1
 if start == end:
-return ''
+return b''
 return self.data[start:end]
 def __getitem__(self, key):
 if not isinstance(key, bytes):
-raise TypeError("getitem: manifest keys must be a bytes.")
+raise TypeError(b"getitem: manifest keys must be a bytes.")
 needle = self.bsearch(key)
 if needle == -1:
 raise KeyError
 data, pos = self._get(needle)
 if pos == -1:
 return (data[1], data[2])
-zeropos = data.find('\x00', pos)
+zeropos = data.find(b'\x00', pos)
 assert 0 <= needle <= len(self.positions)
 assert len(self.extrainfo) == len(self.positions)
 hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, 40)
 flags = self._getflags(data, needle, zeropos)
 return (hashval, flags)
 self.positions = self.positions[:needle] + self.positions[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] + b'\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.")
+raise TypeError(b"setitem: manifest keys must be a byte string.")
 if not isinstance(value, tuple) or len(value) != 2:
-raise TypeError("Manifest values must be a tuple of (node, flags).")
+raise TypeError(
+b"Manifest values must be a tuple of (node, flags)."
+)
 hashval = value[0]
 if not isinstance(hashval, bytes) or not 20 <= len(hashval) <= 22:
-raise TypeError("node must be a 20-byte byte string")
+raise TypeError(b"node must be a 20-byte byte string")
 flags = value[1]
 if len(hashval) == 22:
 hashval = hashval[:-1]
 if not isinstance(flags, bytes) or len(flags) > 1:
-raise TypeError("flags must a 0 or 1 byte string, got %r", flags)
+raise TypeError(b"flags must a 0 or 1 byte string, got %r", flags)
 needle, found = self.bsearch2(key)
 if found:
 # put the item
 pos = self.positions[needle]
 if pos < 0:
 # 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
-and self.data.find('\n\x00', cur, self.positions[i])
+and self.data.find(b'\n\x00', cur, self.positions[i])
 != -1
 ):
 break
 offset += self.positions[i] - cur
 cur = self.positions[i]
-end_cut = self.data.find('\n', cur)
+end_cut = self.data.find(b'\n', cur)
 if end_cut != -1:
 end_cut += 1
 offset += end_cut - cur
 l.append(self.data[last_cut:end_cut])
 else:
 self.positions[i] = offset
 if len(t[1]) > 20:
 self.extrainfo[i] = ord(t[1][21])
 offset += len(l[-1])
 i += 1
-self.data = ''.join(l)
+self.data = b''.join(l)
 self.hasremovals = False
 self.extradata = []
 def _pack(self, d):
-return d[0] + '\x00' + hex(d[1][:20]) + d[2] + '\n'
+return d[0] + b'\x00' + hex(d[1][:20]) + d[2] + b'\n'
 def text(self):
 self._compact()
 return self.data
 # XXX think whether efficiency matters here
 diff = {}
 for fn, e1, flags in self.iterentries():
 if fn not in m2:
-diff[fn] = (e1, flags), (None, '')
+diff[fn] = (e1, flags), (None, b'')
 else:
 e2 = m2[fn]
 if (e1, flags) != e2:
 diff[fn] = (e1, flags), e2
 elif clean:
 diff[fn] = None
 for fn, e2, flags in m2.iterentries():
 if fn not in self:
-diff[fn] = (None, ''), (e2, flags)
+diff[fn] = (None, b''), (e2, flags)
 return diff
 def iterentries(self):
 return lazymanifestiterentries(self)
 def __len__(self):
 return len(self.positions)
 def filtercopy(self, filterfn):
 # XXX should be optimized
-c = _lazymanifest('')
+c = _lazymanifest(b'')
 for f, n, fl in self.iterentries():
 if filterfn(f):
 c[f] = n, fl
 return c
 pass
 @interfaceutil.implementer(repository.imanifestdict)
 class manifestdict(object):
-def __init__(self, data=''):
+def __init__(self, data=b''):
 self._lm = _lazymanifest(data)
 def __getitem__(self, key):
 return self._lm[key][0]
 return len(self._lm) != 0
 __bool__ = __nonzero__
 def __setitem__(self, key, node):
-self._lm[key] = node, self.flags(key, '')
+self._lm[key] = node, self.flags(key, b'')
 def __contains__(self, key):
 if key is None:
 return False
 return key in self._lm
 if match(fn):
 yield fn
 # for dirstate.walk, files=[''] means "walk the whole tree".
 # follow that here, too
-fset.discard('')
+fset.discard(b'')
 for fn in sorted(fset):
 if not self.hasdir(fn):
 match.bad(fn, None)
 try:
 return self._lm[key][0]
 except KeyError:
 return default
-def flags(self, key, default=''):
+def flags(self, key, default=b''):
 try:
 return self._lm[key][1]
 except KeyError:
 return default
 relative to that text, compute a delta that can be used by revlog.
 """
 delta = []
 dstart = None
 dend = None
-dline = [""]
+dline = [b""]
 start = 0
 # zero copy representation of base as a buffer
 addbuf = util.buffer(base)
 changes = list(changes)
 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:
 h, fl = self._lm[f]
-l = "%s\0%s%s\n" % (f, hex(h), fl)
+l = b"%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
+_(b"failed to remove %s from manifest") % f
 )
-l = ""
+l = b""
 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)])
+delta.append([dstart, dend, b"".join(dline)])
 dstart = start
 dend = end
 dline = [l]
 if dstart is not None:
-delta.append([dstart, dend, "".join(dline)])
+delta.append([dstart, dend, b"".join(dline)])
 # apply the delta to the base, and get a delta for addrevision
 deltatext, arraytext = _addlistdelta(base, delta)
 else:
 # For large changes, it's much cheaper to just build the text and
 # diff it.
 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] != b'\n':
 start -= 1
-end = advance(start, '\0')
+end = advance(start, b'\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
-lo = advance(end + 40, '\n') + 1
+lo = advance(end + 40, b'\n') + 1
 else:
 # this translates to the bisect hi = mid
 hi = start
-end = advance(lo, '\0')
+end = advance(lo, b'\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')
+end = advance(end + 40, b'\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:
+if b'\n' in f or b'\r' in f:
 raise error.StorageError(
-_("'\\n' and '\\r' disallowed in filenames: %r")
+_(b"'\\n' and '\\r' disallowed in filenames: %r")
 % pycompat.bytestr(f)
 )
 # apply the changes collected during the bisect loop to our addlist
 currentposition = end
 newaddlist += addlist[currentposition:]
-deltatext = "".join(
+deltatext = b"".join(
-struct.pack(">lll", start, end, len(content)) + content
+struct.pack(b">lll", start, end, len(content)) + content
 for start, end, content in x
 )
 return deltatext, newaddlist
 def _splittopdir(f):
-if '/' in f:
+if b'/' in f:
-dir, subpath = f.split('/', 1)
+dir, subpath = f.split(b'/', 1)
-return dir + '/', subpath
+return dir + b'/', subpath
 else:
-return '', f
+return b'', f
 _noop = lambda s: None
 class treemanifest(object):
-def __init__(self, dir='', text=''):
+def __init__(self, dir=b'', text=b''):
 self._dir = dir
 self._node = nullid
 self._loadfunc = _noop
 self._copyfunc = _noop
 self._dirty = False
 self._flags = {}
 if text:
 def readsubtree(subdir, subm):
 raise AssertionError(
-'treemanifest constructor only accepts ' 'flat manifests'
+b'treemanifest constructor only accepts ' b'flat manifests'
 )
 self.parse(text, readsubtree)
 self._dirty = True  # Mark flat manifest dirty after parsing
 del self._lazydirs[d]
 def _loadchildrensetlazy(self, visit):
 if not visit:
 return None
-if visit == 'all' or visit == 'this':
+if visit == b'all' or visit == b'this':
 self._loadalllazy()
 return None
 loadlazy = self._loadlazy
 for k in visit:
-loadlazy(k + '/')
+loadlazy(k + b'/')
 return visit
 def _loaddifflazy(self, t1, t2):
 """load items in t1 and t2 if they're needed for diffing.
 return False
 self._loadalllazy()
 return not self._dirs or 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 b'<treemanifest dir=%s, node=%s, loaded=%s, dirty=%s at 0x%x>' % (
 self._dir,
 hex(self._node),
 bool(self._loadfunc is _noop),
 self._dirty,
 id(self),
 self._loadalllazy()
 for p, n in sorted(
 itertools.chain(self._dirs.items(), self._files.items())
 ):
 if p in self._files:
-yield self._subpath(p), n, self._flags.get(p, '')
+yield self._subpath(p), n, self._flags.get(p, b'')
 else:
 for x in n.iterentries():
 yield x
 def items(self):
 dir, subpath = _splittopdir(f)
 if dir:
 self._loadlazy(dir)
 if dir not in self._dirs:
-return ''
+return b''
 return self._dirs[dir].flags(subpath)
 else:
 if f in self._lazydirs or f in self._dirs:
-return ''
+return b''
-return self._flags.get(f, '')
+return self._flags.get(f, b'')
 def find(self, f):
 self._load()
 dir, subpath = _splittopdir(f)
 if dir:
 self._loadlazy(dir)
 return self._dirs[dir].find(subpath)
 else:
-return self._files[f], self._flags.get(f, '')
+return self._files[f], self._flags.get(f, b'')
 def __delitem__(self, f):
 self._load()
 dir, subpath = _splittopdir(f)
 if dir:
 if topdir:
 self._loadlazy(topdir)
 if topdir in self._dirs:
 return self._dirs[topdir].hasdir(subdir)
 return False
-dirslash = dir + '/'
+dirslash = dir + b'/'
 return dirslash in self._dirs or dirslash in self._lazydirs
 def walk(self, match):
 '''Generates matching file names.
 fset.remove(fn)
 yield fn
 # for dirstate.walk, files=[''] means "walk the whole tree".
 # follow that here, too
-fset.discard('')
+fset.discard(b'')
 for fn in sorted(fset):
 if not self.hasdir(fn):
 match.bad(fn, None)
 def _matches(self, match):
 '''recursively generate a new manifest filtered by the match argument.
 '''
 visit = match.visitchildrenset(self._dir[:-1])
-if visit == 'all':
+if visit == b'all':
 return self.copy()
 ret = treemanifest(self._dir)
 if not visit:
 return ret
 # While visitchildrenset *usually* lists only subdirs, this is
 # actually up to the matcher and may have some files in the set().
 # If visit == 'this', we should obviously look at the files in this
 # directory; if visit is a set, and fn is in it, we should inspect
 # fn (but no need to inspect things not in the set).
-if visit != 'this' and fn not in visit:
+if visit != b'this' and fn not in visit:
 continue
 fullp = self._subpath(fn)
 # visitchildrenset isn't perfect, we still need to call the regular
 # matcher code to further filter results.
 if not match(fullp):
 for d, m2 in t2._dirs.iteritems():
 if d not in t1._dirs:
 stack.append((emptytree, m2))
 for fn, n1 in t1._files.iteritems():
-fl1 = t1._flags.get(fn, '')
+fl1 = t1._flags.get(fn, b'')
 n2 = t2._files.get(fn, None)
-fl2 = t2._flags.get(fn, '')
+fl2 = t2._flags.get(fn, b'')
 if n1 != n2 or fl1 != fl2:
 result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2))
 elif clean:
 result[t1._subpath(fn)] = None
 for fn, n2 in t2._files.iteritems():
 if fn not in t1._files:
-fl2 = t2._flags.get(fn, '')
+fl2 = t2._flags.get(fn, b'')
-result[t2._subpath(fn)] = ((None, ''), (n2, fl2))
+result[t2._subpath(fn)] = ((None, b''), (n2, fl2))
 stackls = []
 _iterativediff(self, m2, stackls)
 while stackls:
 t1, t2 = stackls.pop()
 def parse(self, text, readsubtree):
 selflazy = self._lazydirs
 subpath = self._subpath
 for f, n, fl in _parse(text):
-if fl == 't':
+if fl == b't':
-f = f + '/'
+f = f + b'/'
 # False below means "doesn't need to be copied" and can use the
 # cached value from readsubtree directly.
 selflazy[f] = (subpath(f), n, readsubtree, False)
-elif '/' in f:
+elif b'/' in f:
 # This is a flat manifest, so use __setitem__ and setflag rather
 # than assigning directly to _files and _flags, so we can
 # assign a path in a subdirectory, and to mark dirty (compared
 # to nullid).
 self[f] = n
 """Get the full data of this directory as a bytestring. Make sure that
 any submanifests have been written first, so their nodeids are correct.
 """
 self._load()
 flags = self.flags
-lazydirs = [(d[:-1], v[1], 't') for d, v in self._lazydirs.iteritems()]
+lazydirs = [(d[:-1], v[1], b't') for d, v in self._lazydirs.iteritems()]
-dirs = [(d[:-1], self._dirs[d]._node, 't') for d in self._dirs]
+dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs]
 files = [(f, self._files[f], flags(f)) for f in self._files]
 return _text(sorted(dirs + files + lazydirs))
 def read(self, gettext, readsubtree):
 def _load_for_read(s):
 return m._dirs.get(d, emptytree)._node
 # let's skip investigating things that `match` says we do not need.
 visit = match.visitchildrenset(self._dir[:-1])
 visit = self._loadchildrensetlazy(visit)
-if visit == 'this' or visit == 'all':
+if visit == b'this' or visit == b'all':
 visit = None
 for d, subm in self._dirs.iteritems():
 if visit and d[:-1] not in visit:
 continue
 subp1 = getnode(m1, d)
 These are written in reverse cache order (oldest to newest).
 """
-_file = 'manifestfulltextcache'
+_file = b'manifestfulltextcache'
 def __init__(self, max):
 super(manifestfulltextcache, self).__init__(max)
 self._dirty = False
 self._read = False
 while True:
 node = fp.read(20)
 if len(node) < 20:
 break
 try:
-size = struct.unpack('>L', fp.read(4))[0]
+size = struct.unpack(b'>L', fp.read(4))[0]
 except struct.error:
 break
 value = bytearray(fp.read(size))
 if len(value) != size:
 break
 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
+self._file, b'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)))
+fp.write(struct.pack(b'>L', len(node.value)))
 fp.write(node.value)
 if node is self._head:
 break
 node = node.prev
 '''
 def __init__(
 self,
 opener,
-tree='',
+tree=b'',
 dirlogcache=None,
 indexfile=None,
 treemanifest=False,
 ):
 """Constructs a new manifest revlog
 # stacks of commits, the number can go up, hence the config knob below.
 cachesize = 4
 optiontreemanifest = False
 opts = getattr(opener, 'options', None)
 if opts is not None:
-cachesize = opts.get('manifestcachesize', cachesize)
+cachesize = opts.get(b'manifestcachesize', cachesize)
-optiontreemanifest = opts.get('treemanifest', False)
+optiontreemanifest = opts.get(b'treemanifest', False)
 self._treeondisk = optiontreemanifest or treemanifest
 self._fulltextcache = manifestfulltextcache(cachesize)
 if tree:
-assert self._treeondisk, 'opts is %r' % opts
+assert self._treeondisk, b'opts is %r' % opts
 if indexfile is None:
-indexfile = '00manifest.i'
+indexfile = b'00manifest.i'
 if tree:
-indexfile = "meta/" + tree + indexfile
+indexfile = b"meta/" + tree + indexfile
 self.tree = tree
 # The dirlogcache is kept on the root manifest log
 if tree:
 self._dirlogcache = dirlogcache
 else:
-self._dirlogcache = {'': self}
+self._dirlogcache = {b'': self}
 self._revlog = revlog.revlog(
 opener,
 indexfile,
 # only root indexfile is cached
 self.version = self._revlog.version
 self._generaldelta = self._revlog._generaldelta
 def _setupmanifestcachehooks(self, repo):
 """Persist the manifestfulltextcache on lock release"""
-if not util.safehasattr(repo, '_wlockref'):
+if not util.safehasattr(repo, b'_wlockref'):
 return
 self._fulltextcache._opener = repo.wcachevfs
 if repo._currentlock(repo._wlockref) is None:
 return
 added,
 removed,
 readtree=None,
 match=None,
 ):
-if p1 in self.fulltextcache and util.safehasattr(m, 'fastdelta'):
+if p1 in self.fulltextcache and util.safehasattr(m, b'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.
 # 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 readtree, b"readtree must be set for treemanifest writes"
-assert match, "match must be specified for treemanifest writes"
+assert match, b"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, match=match
 )
 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(m2)):
+if self.tree != b'' and (
+m.unmodifiedsince(m1) or m.unmodifiedsince(m2)
+):
 return m.node()
 def writesubtree(subm, subp1, subp2, match):
 sublog = self.dirlog(subm.dir())
 sublog.add(
 )
 m.writesubtrees(m1, m2, writesubtree, match)
 text = m.dirtext()
 n = None
-if self.tree != '':
+if self.tree != b'':
 # Double-check whether contents are unchanged to one parent
 if text == m1.dirtext():
 n = m1.node()
 elif text == m2.dirtext():
 n = m2.node()
 def files(self):
 return self._revlog.files()
 def clone(self, tr, destrevlog, **kwargs):
 if not isinstance(destrevlog, manifestrevlog):
-raise error.ProgrammingError('expected manifestrevlog to clone()')
+raise error.ProgrammingError(b'expected manifestrevlog to clone()')
 return self._revlog.clone(tr, destrevlog._revlog, **kwargs)
 def storageinfo(
 self,
 usetreemanifest = False
 cachesize = 4
 opts = getattr(opener, 'options', None)
 if opts is not None:
-usetreemanifest = opts.get('treemanifest', usetreemanifest)
+usetreemanifest = opts.get(b'treemanifest', usetreemanifest)
-cachesize = opts.get('manifestcachesize', cachesize)
+cachesize = opts.get(b'manifestcachesize', cachesize)
 self._treemanifests = usetreemanifest
 self._rootstore = rootstore
 self._rootstore._setupmanifestcachehooks(repo)
 self._narrowmatch = narrowmatch
 # A cache of the manifestctx or treemanifestctx for each directory
 self._dirmancache = {}
-self._dirmancache[''] = util.lrucachedict(cachesize)
+self._dirmancache[b''] = util.lrucachedict(cachesize)
 self._cachesize = cachesize
 def __getitem__(self, node):
 """Retrieves the manifest instance for the given node. Throws a
 LookupError if not found.
 """
-return self.get('', node)
+return self.get(b'', node)
 def get(self, tree, node, verify=True):
 """Retrieves the manifest instance for the given node. Throws a
 LookupError if not found.
 m = treemanifestctx(self, tree, node)
 else:
 raise error.Abort(
 _(
-"cannot ask for manifest directory '%s' in a flat "
+b"cannot ask for manifest directory '%s' in a flat "
-"manifest"
+b"manifest"
 )
 % tree
 )
 else:
 if verify:
 # Side-effect is LookupError is raised if node doesn't exist.
 self._rootstore.rev(node)
 if self._treemanifests:
-m = treemanifestctx(self, '', node)
+m = treemanifestctx(self, b'', node)
 else:
 m = manifestctx(self, node)
 if node != nullid:
 mancache = self._dirmancache.get(tree)
 return self.read().find(key)
 @interfaceutil.implementer(repository.imanifestrevisionwritable)
 class memtreemanifestctx(object):
-def __init__(self, manifestlog, dir=''):
+def __init__(self, manifestlog, dir=b''):
 self._manifestlog = manifestlog
 self._dir = dir
 self._treemanifest = treemanifest()
 def _storage(self):
 return self._manifestlog.getstorage(b'')
-def new(self, dir=''):
+def new(self, dir=b''):
 return memtreemanifestctx(self._manifestlog, dir=dir)
 def copy(self):
 memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
 memmf._treemanifest = self._treemanifest.copy()
 return self._data
 def node(self):
 return self._node
-def new(self, dir=''):
+def new(self, dir=b''):
 return memtreemanifestctx(self._manifestlog, dir=dir)
 def copy(self):
 memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
 memmf._treemanifest = self.read().copy()
 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/")
-self._files[''] = node
+self._files[b''] = node
-self._flags[''] = 't'
+self._flags[b''] = b't'
 # Manifests outside the narrowspec should never be modified, so avoid
 # copying. This makes a noticeable difference when there are very many
 # directories outside the narrowspec. Also, it makes sense for the copy to
 # be of the same type as the original, which would not happen with the
 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
+b'attempt to write manifest from excluded dir %s' % self._dir
 )
 class excludedmanifestrevlog(manifestrevlog):
 """Stand-in for excluded treemanifest revlogs.
 def __init__(self, dir):
 self._dir = dir
 def __len__(self):
 raise error.ProgrammingError(
-'attempt to get length of excluded dir %s' % self._dir
+b'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
+b'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
+b'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
+b'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

Mercurial > public > mercurial-scm > hg

comparison mercurial/manifest.py @ 43077:687b865b95ad