fastannotate: slice strings to get single character

Behaves identically on Python 3 and Python 2.

Differential Revision: https://phab.mercurial-scm.org/D5612

hgext/fastannotate/formatter.py

@@ -1,164 +1,164
 # Copyright 2016-present Facebook. All Rights Reserved.
 #
 # format: defines the format used to output annotate result
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 from __future__ import absolute_import
 
 from mercurial import (
     encoding,
     node,
     pycompat,
     templatefilters,
     util,
 )
 from mercurial.utils import (
         dateutil,
 )
 
 # imitating mercurial.commands.annotate, not using the vanilla formatter since
 # the data structures are a bit different, and we have some fast paths.
 class defaultformatter(object):
     """the default formatter that does leftpad and support some common flags"""
 
     def __init__(self, ui, repo, opts):
         self.ui = ui
         self.opts = opts
 
         if ui.quiet:
             datefunc = dateutil.shortdate
         else:
             datefunc = dateutil.datestr
         datefunc = util.cachefunc(datefunc)
         getctx = util.cachefunc(lambda x: repo[x[0]])
         hexfunc = self._hexfunc
 
         # special handling working copy "changeset" and "rev" functions
         if self.opts.get('rev') == 'wdir()':
             orig = hexfunc
             hexfunc = lambda x: None if x is None else orig(x)
             wnode = hexfunc(repo[None].p1().node()) + '+'
             wrev = '%d' % repo[None].p1().rev()
             wrevpad = ''
             if not opts.get('changeset'): # only show + if changeset is hidden
                 wrev += '+'
                 wrevpad = ' '
             revenc = lambda x: wrev if x is None else ('%d' % x) + wrevpad
             def csetenc(x):
                 if x is None:
                     return wnode
                 return pycompat.bytestr(x) + ' '
         else:
             revenc = csetenc = pycompat.bytestr
 
         # opt name, separator, raw value (for json/plain), encoder (for plain)
         opmap = [('user', ' ', lambda x: getctx(x).user(), ui.shortuser),
                  ('number', ' ', lambda x: getctx(x).rev(), revenc),
                  ('changeset', ' ', lambda x: hexfunc(x[0]), csetenc),
                  ('date', ' ', lambda x: getctx(x).date(), datefunc),
                  ('file', ' ', lambda x: x[2], pycompat.bytestr),
                  ('line_number', ':', lambda x: x[1] + 1, pycompat.bytestr)]
         fieldnamemap = {'number': 'rev', 'changeset': 'node'}
         funcmap = [(get, sep, fieldnamemap.get(op, op), enc)
                    for op, sep, get, enc in opmap
                    if opts.get(op)]
         # no separator for first column
         funcmap[0] = list(funcmap[0])
         funcmap[0][1] = ''
         self.funcmap = funcmap
 
     def write(self, annotatedresult, lines=None, existinglines=None):
         """(annotateresult, [str], set([rev, linenum])) -> None. write output.
         annotateresult can be [(node, linenum, path)], or [(node, linenum)]
         """
         pieces = [] # [[str]]
         maxwidths = [] # [int]
 
         # calculate padding
         for f, sep, name, enc in self.funcmap:
             l = [enc(f(x)) for x in annotatedresult]
             pieces.append(l)
             if name in ['node', 'date']: # node and date has fixed size
                 l = l[:1]
             widths = pycompat.maplist(encoding.colwidth, set(l))
             maxwidth = (max(widths) if widths else 0)
             maxwidths.append(maxwidth)
 
         # buffered output
         result = ''
         for i in pycompat.xrange(len(annotatedresult)):
             for j, p in enumerate(pieces):
                 sep = self.funcmap[j][1]
                 padding = ' ' * (maxwidths[j] - len(p[i]))
                 result += sep + padding + p[i]
             if lines:
                 if existinglines is None:
                     result += ': ' + lines[i]
                 else: # extra formatting showing whether a line exists
                     key = (annotatedresult[i][0], annotatedresult[i][1])
                     if key in existinglines:
                         result += ':  ' + lines[i]
                     else:
                         result += ': ' + self.ui.label('-' + lines[i],
                                                        'diff.deleted')
 
-            if result[-1] != '\n':
+            if result[-1:] != '\n':
                 result += '\n'
 
         self.ui.write(result)
 
     @util.propertycache
     def _hexfunc(self):
         if self.ui.debugflag or self.opts.get('long_hash'):
             return node.hex
         else:
             return node.short
 
     def end(self):
         pass
 
 class jsonformatter(defaultformatter):
     def __init__(self, ui, repo, opts):
         super(jsonformatter, self).__init__(ui, repo, opts)
         self.ui.write('[')
         self.needcomma = False
 
     def write(self, annotatedresult, lines=None, existinglines=None):
         if annotatedresult:
             self._writecomma()
 
         pieces = [(name, map(f, annotatedresult))
                   for f, sep, name, enc in self.funcmap]
         if lines is not None:
             pieces.append(('line', lines))
         pieces.sort()
 
         seps = [','] * len(pieces[:-1]) + ['']
 
         result = ''
         lasti = len(annotatedresult) - 1
         for i in pycompat.xrange(len(annotatedresult)):
             result += '\n {\n'
             for j, p in enumerate(pieces):
                 k, vs = p
                 result += ('  "%s": %s%s\n'
                            % (k, templatefilters.json(vs[i], paranoid=False),
                               seps[j]))
             result += ' }%s' % ('' if i == lasti else ',')
         if lasti >= 0:
             self.needcomma = True
 
         self.ui.write(result)
 
     def _writecomma(self):
         if self.needcomma:
             self.ui.write(',')
             self.needcomma = False
 
     @util.propertycache
     def _hexfunc(self):
         return node.hex
 
     def end(self):
         self.ui.write('\n]\n')

hgext/fastannotate/protocol.py

@@ -1,228 +1,228
 # Copyright 2016-present Facebook. All Rights Reserved.
 #
 # protocol: logic for a server providing fastannotate support
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 from __future__ import absolute_import
 
 import contextlib
 import os
 
 from mercurial.i18n import _
 from mercurial import (
     error,
     extensions,
     hg,
     util,
     wireprotov1peer,
     wireprotov1server,
 )
 from . import context
 
 # common
 
 def _getmaster(ui):
     """get the mainbranch, and enforce it is set"""
     master = ui.config('fastannotate', 'mainbranch')
     if not master:
         raise error.Abort(_('fastannotate.mainbranch is required '
                             'for both the client and the server'))
     return master
 
 # server-side
 
 def _capabilities(orig, repo, proto):
     result = orig(repo, proto)
     result.append('getannotate')
     return result
 
 def _getannotate(repo, proto, path, lastnode):
     # output:
     #   FILE := vfspath + '\0' + str(size) + '\0' + content
     #   OUTPUT := '' | FILE + OUTPUT
     result = ''
     buildondemand = repo.ui.configbool('fastannotate', 'serverbuildondemand',
                                        True)
     with context.annotatecontext(repo, path) as actx:
         if buildondemand:
             # update before responding to the client
             master = _getmaster(repo.ui)
             try:
                 if not actx.isuptodate(master):
                     actx.annotate(master, master)
             except Exception:
                 # non-fast-forward move or corrupted. rebuild automically.
                 actx.rebuild()
                 try:
                     actx.annotate(master, master)
                 except Exception:
                     actx.rebuild() # delete files
             finally:
                 # although the "with" context will also do a close/flush, we
                 # need to do it early so we can send the correct respond to
                 # client.
                 actx.close()
         # send back the full content of revmap and linelog, in the future we
         # may want to do some rsync-like fancy updating.
         # the lastnode check is not necessary if the client and the server
         # agree where the main branch is.
         if actx.lastnode != lastnode:
             for p in [actx.revmappath, actx.linelogpath]:
                 if not os.path.exists(p):
                     continue
                 content = ''
                 with open(p, 'rb') as f:
                     content = f.read()
                 vfsbaselen = len(repo.vfs.base + '/')
                 relpath = p[vfsbaselen:]
                 result += '%s\0%d\0%s' % (relpath, len(content), content)
     return result
 
 def _registerwireprotocommand():
     if 'getannotate' in wireprotov1server.commands:
         return
     wireprotov1server.wireprotocommand(
         'getannotate', 'path lastnode')(_getannotate)
 
 def serveruisetup(ui):
     _registerwireprotocommand()
     extensions.wrapfunction(wireprotov1server, '_capabilities', _capabilities)
 
 # client-side
 
 def _parseresponse(payload):
     result = {}
     i = 0
     l = len(payload) - 1
     state = 0 # 0: vfspath, 1: size
     vfspath = size = ''
     while i < l:
-        ch = payload[i]
+        ch = payload[i:i + 1]
         if ch == '\0':
             if state == 1:
                 result[vfspath] = buffer(payload, i + 1, int(size))
                 i += int(size)
                 state = 0
                 vfspath = size = ''
             elif state == 0:
                 state = 1
         else:
             if state == 1:
                 size += ch
             elif state == 0:
                 vfspath += ch
         i += 1
     return result
 
 def peersetup(ui, peer):
     class fastannotatepeer(peer.__class__):
         @wireprotov1peer.batchable
         def getannotate(self, path, lastnode=None):
             if not self.capable('getannotate'):
                 ui.warn(_('remote peer cannot provide annotate cache\n'))
                 yield None, None
             else:
                 args = {'path': path, 'lastnode': lastnode or ''}
                 f = wireprotov1peer.future()
                 yield args, f
                 yield _parseresponse(f.value)
     peer.__class__ = fastannotatepeer
 
 @contextlib.contextmanager
 def annotatepeer(repo):
     ui = repo.ui
 
     remotepath = ui.expandpath(
         ui.config('fastannotate', 'remotepath', 'default'))
     peer = hg.peer(ui, {}, remotepath)
 
     try:
         yield peer
     finally:
         peer.close()
 
 def clientfetch(repo, paths, lastnodemap=None, peer=None):
     """download annotate cache from the server for paths"""
     if not paths:
         return
 
     if peer is None:
         with annotatepeer(repo) as peer:
             return clientfetch(repo, paths, lastnodemap, peer)
 
     if lastnodemap is None:
         lastnodemap = {}
 
     ui = repo.ui
     results = []
     with peer.commandexecutor() as batcher:
         ui.debug('fastannotate: requesting %d files\n' % len(paths))
         for p in paths:
             results.append(batcher.callcommand(
                 'getannotate',
                 {'path': p, 'lastnode':lastnodemap.get(p)}))
 
         for result in results:
             r = result.result()
             # TODO: pconvert these paths on the server?
             r = {util.pconvert(p): v for p, v in r.iteritems()}
             for path in sorted(r):
                 # ignore malicious paths
                 if (not path.startswith('fastannotate/')
                     or '/../' in (path + '/')):
                     ui.debug('fastannotate: ignored malicious path %s\n' % path)
                     continue
                 content = r[path]
                 if ui.debugflag:
                     ui.debug('fastannotate: writing %d bytes to %s\n'
                              % (len(content), path))
                 repo.vfs.makedirs(os.path.dirname(path))
                 with repo.vfs(path, 'wb') as f:
                     f.write(content)
 
 def _filterfetchpaths(repo, paths):
     """return a subset of paths whose history is long and need to fetch linelog
     from the server. works with remotefilelog and non-remotefilelog repos.
     """
     threshold = repo.ui.configint('fastannotate', 'clientfetchthreshold', 10)
     if threshold <= 0:
         return paths
 
     result = []
     for path in paths:
         try:
             if len(repo.file(path)) >= threshold:
                 result.append(path)
         except Exception: # file not found etc.
             result.append(path)
 
     return result
 
 def localreposetup(ui, repo):
     class fastannotaterepo(repo.__class__):
         def prefetchfastannotate(self, paths, peer=None):
             master = _getmaster(self.ui)
             needupdatepaths = []
             lastnodemap = {}
             try:
                 for path in _filterfetchpaths(self, paths):
                     with context.annotatecontext(self, path) as actx:
                         if not actx.isuptodate(master, strict=False):
                             needupdatepaths.append(path)
                             lastnodemap[path] = actx.lastnode
                 if needupdatepaths:
                     clientfetch(self, needupdatepaths, lastnodemap, peer)
             except Exception as ex:
                 # could be directory not writable or so, not fatal
                 self.ui.debug('fastannotate: prefetch failed: %r\n' % ex)
     repo.__class__ = fastannotaterepo
 
 def clientreposetup(ui, repo):
     _registerwireprotocommand()
     if repo.local():
         localreposetup(ui, repo)
     # TODO: this mutates global state, but only if at least one repo
     # has the extension enabled. This is probably bad for hgweb.
     if peersetup not in hg.wirepeersetupfuncs:
         hg.wirepeersetupfuncs.append(peersetup)