mercurial-scm/hg: hgext/fastannotate/context.py comparison

comparison hgext/fastannotate/context.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	eef9a2d67051

comparison

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 pl = [p for p in pl if p.path() == f.path()]
 # renamed filectx won't have a filelog yet, so set it
 # from the cache to save time
 for p in pl:
-if not '_filelog' in p.__dict__:
+if not b'_filelog' in p.__dict__:
 p._filelog = _getflog(f._repo, p.path())
 return pl
 # extracted from mercurial.context.basefilectx.annotate. slightly modified
 # so it takes a fctx instead of a pair of text and fctx.
 def _decorate(fctx):
 text = fctx.data()
-linecount = text.count('\n')
+linecount = text.count(b'\n')
-if text and not text.endswith('\n'):
+if text and not text.endswith(b'\n'):
 linecount += 1
 return ([(fctx, i) for i in pycompat.xrange(linecount)], text)
 # extracted from mercurial.context.basefilectx.annotate. slightly modified
 # calculating diff here.
 def _pair(parent, child, blocks):
 for (a1, a2, b1, b2), t in blocks:
 # Changed blocks ('!') or blocks made only of blank lines ('~')
 # belong to the child.
-if t == '=':
+if t == b'=':
 child[0][b1:b2] = parent[0][a1:a2]
 return child
 # like scmutil.revsingle, but with lru cache, so their states (like manifests)
 fctx = ctx[path]
 else:
 fctx = repo.filectx(path, changeid=ctx.rev())
 else:
 fctx = ctx[path]
-if adjustctx == 'linkrev':
+if adjustctx == b'linkrev':
 introrev = fctx.linkrev()
 else:
 introrev = fctx.introrev()
 if introrev != ctx.rev():
 fctx._changeid = introrev
 # like mercurial.store.encodedir, but use linelog suffixes: .m, .l, .lock
 def encodedir(path):
 return (
-path.replace('.hg/', '.hg.hg/')
+path.replace(b'.hg/', b'.hg.hg/')
-.replace('.l/', '.l.hg/')
+.replace(b'.l/', b'.l.hg/')
-.replace('.m/', '.m.hg/')
+.replace(b'.m/', b'.m.hg/')
-.replace('.lock/', '.lock.hg/')
+.replace(b'.lock/', b'.lock.hg/')
 )
 def hashdiffopts(diffopts):
 diffoptstr = stringutil.pprint(
 followrename: follow renames, like "hg annotate -f"
 followmerge: follow p2 of a merge changeset, otherwise p2 is ignored
 """
 defaults = {
-'diffopts': None,
+b'diffopts': None,
-'followrename': True,
+b'followrename': True,
-'followmerge': True,
+b'followmerge': True,
 }
 def __init__(self, **opts):
 opts = pycompat.byteskwargs(opts)
 for k, v in self.defaults.iteritems():
 setattr(self, k, opts.get(k, v))
 @util.propertycache
 def shortstr(self):
 """represent opts in a short string, suitable for a directory name"""
-result = ''
+result = b''
 if not self.followrename:
-result += 'r0'
+result += b'r0'
 if not self.followmerge:
-result += 'm0'
+result += b'm0'
 if self.diffopts is not None:
 assert isinstance(self.diffopts, mdiff.diffopts)
 diffopthash = hashdiffopts(self.diffopts)
 if diffopthash != _defaultdiffopthash:
-result += 'i' + diffopthash
+result += b'i' + diffopthash
-return result or 'default'
+return result or b'default'
 defaultopts = annotateopts()
 @property
 def linelog(self):
 if self._linelog is None:
 if os.path.exists(self.linelogpath):
-with open(self.linelogpath, 'rb') as f:
+with open(self.linelogpath, b'rb') as f:
 try:
 self._linelog = linelogmod.linelog.fromdata(f.read())
 except linelogmod.LineLogError:
 self._linelog = linelogmod.linelog()
 else:
 def close(self):
 if self._revmap is not None:
 self._revmap.flush()
 self._revmap = None
 if self._linelog is not None:
-with open(self.linelogpath, 'wb') as f:
+with open(self.linelogpath, b'wb') as f:
 f.write(self._linelog.encode())
 self._linelog = None
 __del__ = close
 # fast path: if rev is in the main branch already
 directly, revfctx = self.canannotatedirectly(rev)
 if directly:
 if self.ui.debugflag:
 self.ui.debug(
-'fastannotate: %s: using fast path '
+b'fastannotate: %s: using fast path '
-'(resolved fctx: %s)\n'
+b'(resolved fctx: %s)\n'
 % (
 self.path,
-stringutil.pprint(util.safehasattr(revfctx, 'node')),
+stringutil.pprint(util.safehasattr(revfctx, b'node')),
 )
 )
 return self.annotatedirectly(revfctx, showpath, showlines)
 # resolve master
 # "hist", reducing its memory usage otherwise could be huge.
 initvisit = [revfctx]
 if masterfctx:
 if masterfctx.rev() is None:
 raise error.Abort(
-_('cannot update linelog to wdir()'),
+_(b'cannot update linelog to wdir()'),
-hint=_('set fastannotate.mainbranch'),
+hint=_(b'set fastannotate.mainbranch'),
 )
 initvisit.append(masterfctx)
 visit = initvisit[:]
 pcache = {}
 needed = {revfctx: 1}
 self._checklastmasterhead(f)
 if self.ui.debugflag:
 if newmainbranch:
 self.ui.debug(
-'fastannotate: %s: %d new changesets in the main'
+b'fastannotate: %s: %d new changesets in the main'
-' branch\n' % (self.path, len(newmainbranch))
+b' branch\n' % (self.path, len(newmainbranch))
 )
 elif not hist:  # no joints, no updates
 self.ui.debug(
-'fastannotate: %s: linelog cannot help in '
+b'fastannotate: %s: linelog cannot help in '
-'annotating this revision\n' % self.path
+b'annotating this revision\n' % self.path
 )
 # prepare annotateresult so we can update linelog incrementally
 self.linelog.annotate(self.linelog.maxrev)
 # 3rd DFS does the actual annotate
 visit = initvisit[:]
 progress = self.ui.makeprogress(
-'building cache', total=len(newmainbranch)
+b'building cache', total=len(newmainbranch)
 )
 while visit:
 f = visit[-1]
 if f in hist:
 visit.pop()
 progress.increment()
 bannotated = None
 if len(pl) == 2 and self.opts.followmerge:  # merge
 bannotated = curr[0]
 if blocks is None:  # no parents, add an empty one
-blocks = list(self._diffblocks('', curr[1]))
+blocks = list(self._diffblocks(b'', curr[1]))
 self._appendrev(f, blocks, bannotated)
 elif showpath:  # not append linelog, but we need to record path
 self._node2path[f.node()] = f.path()
 progress.complete()
 if not isinstance(rev, int) and rev is not None:
 hsh = {20: bytes, 40: node.bin}.get(len(rev), lambda x: None)(rev)
 if hsh is not None and (hsh, self.path) in self.revmap:
 f = hsh
 if f is None:
-adjustctx = 'linkrev' if self._perfhack else True
+adjustctx = b'linkrev' if self._perfhack else True
 f = self._resolvefctx(rev, adjustctx=adjustctx, resolverev=True)
 result = f in self.revmap
 if not result and self._perfhack:
 # redo the resolution without perfhack - as we are going to
 # do write operations, we need a correct fctx.
 revfctx = self._resolvefctx(rev, resolverev=True, adjustctx=True)
 # find a chain from rev to anything in the mainbranch
 if revfctx not in self.revmap:
 chain = [revfctx]
-a = ''
+a = b''
 while True:
 f = chain[-1]
 pl = self._parentfunc(f)
 if not pl:
 break
 for (rev, linenum), idxs in key2idxs.iteritems():
 if rev not in revlines:
 hsh = annotateresult[idxs[0]][0]
 if self.ui.debugflag:
 self.ui.debug(
-'fastannotate: reading %s line #%d '
+b'fastannotate: reading %s line #%d '
-'to resolve lines %r\n'
+b'to resolve lines %r\n'
 % (node.short(hsh), linenum, idxs)
 )
 fctx = self._resolvefctx(hsh, revmap.rev2path(rev))
 lines = mdiff.splitnewlines(fctx.data())
 revlines[rev] = lines
 assert all(x is not None for x in result)
 return result
 # run the annotate and the lines should match to the file content
 self.ui.debug(
-'fastannotate: annotate %s to resolve lines\n' % node.short(hsh)
+b'fastannotate: annotate %s to resolve lines\n'
+% node.short(hsh)
 )
 linelog.annotate(rev)
 fctx = self._resolvefctx(hsh, revmap.rev2path(rev))
 annotated = linelog.annotateresult
 lines = mdiff.splitnewlines(fctx.data())
 if len(lines) != len(annotated):
-raise faerror.CorruptedFileError('unexpected annotated lines')
+raise faerror.CorruptedFileError(b'unexpected annotated lines')
 # resolve lines from the annotate result
 for i, line in enumerate(lines):
 k = annotated[i]
 if k in key2idxs:
 for idx in key2idxs[k]:
 else:
 hsh = f.node()
 llrev = self.revmap.hsh2rev(hsh)
 if not llrev:
 raise faerror.CorruptedFileError(
-'%s is not in revmap' % node.hex(hsh)
+b'%s is not in revmap' % node.hex(hsh)
 )
 if (self.revmap.rev2flag(llrev) & revmapmod.sidebranchflag) != 0:
 raise faerror.CorruptedFileError(
-'%s is not in revmap mainbranch' % node.hex(hsh)
+b'%s is not in revmap mainbranch' % node.hex(hsh)
 )
 self.linelog.annotate(llrev)
 result = [
 (self.revmap.rev2hsh(r), l) for r, l in self.linelog.annotateresult
 ]
 def getllrev(f):
 """(fctx) -> int"""
 # f should not be a linelog revision
 if isinstance(f, int):
-raise error.ProgrammingError('f should not be an int')
+raise error.ProgrammingError(b'f should not be an int')
 # f is a fctx, allocate linelog rev on demand
 hsh = f.node()
 rev = revmap.hsh2rev(hsh)
 if rev is None:
 rev = revmap.append(hsh, sidebranch=True, path=f.path())
 # append sidebranch revisions to revmap
 siderevs = []
 siderevmap = {}  # node: int
 if bannotated is not None:
 for (a1, a2, b1, b2), op in blocks:
-if op != '=':
+if op != b'=':
 # f could be either linelong rev, or fctx.
 siderevs += [
 f
 for f, l in bannotated[b1:b2]
 if not isinstance(f, int)
 # the changeset in the main branch, could be a merge
 llrev = revmap.append(fctx.node(), path=fctx.path())
 siderevmap[fctx] = llrev
 for (a1, a2, b1, b2), op in reversed(blocks):
-if op == '=':
+if op == b'=':
 continue
 if bannotated is None:
 linelog.replacelines(llrev, a1, a2, b1, b2)
 else:
 blines = [
 return parents
 @util.propertycache
 def _perfhack(self):
-return self.ui.configbool('fastannotate', 'perfhack')
+return self.ui.configbool(b'fastannotate', b'perfhack')
 def _resolvefctx(self, rev, path=None, **kwds):
 return resolvefctx(self.repo, rev, (path or self.path), **kwds)
 """helper for getting paths for lockfile, linelog and revmap"""
 def __init__(self, repo, path, opts=defaultopts):
 # different options use different directories
 self._vfspath = os.path.join(
-'fastannotate', opts.shortstr, encodedir(path)
+b'fastannotate', opts.shortstr, encodedir(path)
 )
 self._repo = repo
 @property
 def dirname(self):
 return os.path.dirname(self._repo.vfs.join(self._vfspath))
 @property
 def linelogpath(self):
-return self._repo.vfs.join(self._vfspath + '.l')
+return self._repo.vfs.join(self._vfspath + b'.l')
 def lock(self):
-return lockmod.lock(self._repo.vfs, self._vfspath + '.lock')
+return lockmod.lock(self._repo.vfs, self._vfspath + b'.lock')
 @property
 def revmappath(self):
-return self._repo.vfs.join(self._vfspath + '.m')
+return self._repo.vfs.join(self._vfspath + b'.m')
 @contextlib.contextmanager
 def annotatecontext(repo, path, opts=defaultopts, rebuild=False):
 """context needed to perform (fast) annotate on a file
 actx.rebuild()
 yield actx
 except Exception:
 if actx is not None:
 actx.rebuild()
-repo.ui.debug('fastannotate: %s: cache broken and deleted\n' % path)
+repo.ui.debug(b'fastannotate: %s: cache broken and deleted\n' % path)
 raise
 finally:
 if actx is not None:
 actx.close()
 """like annotatecontext but get the context from a fctx. convenient when
 used in fctx.annotate
 """
 repo = fctx._repo
 path = fctx._path
-if repo.ui.configbool('fastannotate', 'forcefollow', True):
+if repo.ui.configbool(b'fastannotate', b'forcefollow', True):
 follow = True
 aopts = annotateopts(diffopts=diffopts, followrename=follow)
 return annotatecontext(repo, path, aopts, rebuild)

Mercurial > public > mercurial-scm > hg

comparison hgext/fastannotate/context.py @ 43077:687b865b95ad