templates: extract function to `stringutil` for getting first line of text

It's surprisingly hard to get the first line from a string, so let's
have our own function in `stringutil` for it.

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

mercurial/templatefilters.py

@@ -1,554 +1,551 b''
 # templatefilters.py - common template expansion filters
 #
 # Copyright 2005-2008 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import os
 import re
 import time
 
 from .i18n import _
 from .node import hex
 from . import (
     encoding,
     error,
     pycompat,
     registrar,
     smartset,
     templateutil,
     url,
     util,
 )
 from .utils import (
     cborutil,
     dateutil,
     stringutil,
 )
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 # filters are callables like:
 #   fn(obj)
 # with:
 #   obj - object to be filtered (text, date, list and so on)
 filters = {}
 
 templatefilter = registrar.templatefilter(filters)
 
 
 @templatefilter(b'addbreaks', intype=bytes)
 def addbreaks(text):
     """Any text. Add an XHTML "<br />" tag before the end of
     every line except the last.
     """
     return text.replace(b'\n', b'<br/>\n')
 
 
 agescales = [
     (b"year", 3600 * 24 * 365, b'Y'),
     (b"month", 3600 * 24 * 30, b'M'),
     (b"week", 3600 * 24 * 7, b'W'),
     (b"day", 3600 * 24, b'd'),
     (b"hour", 3600, b'h'),
     (b"minute", 60, b'm'),
     (b"second", 1, b's'),
 ]
 
 
 @templatefilter(b'age', intype=templateutil.date)
 def age(date, abbrev=False):
     """Date. Returns a human-readable date/time difference between the
     given date/time and the current date/time.
     """
 
     def plural(t, c):
         if c == 1:
             return t
         return t + b"s"
 
     def fmt(t, c, a):
         if abbrev:
             return b"%d%s" % (c, a)
         return b"%d %s" % (c, plural(t, c))
 
     now = time.time()
     then = date[0]
     future = False
     if then > now:
         future = True
         delta = max(1, int(then - now))
         if delta > agescales[0][1] * 30:
             return b'in the distant future'
     else:
         delta = max(1, int(now - then))
         if delta > agescales[0][1] * 2:
             return dateutil.shortdate(date)
 
     for t, s, a in agescales:
         n = delta // s
         if n >= 2 or s == 1:
             if future:
                 return b'%s from now' % fmt(t, n, a)
             return b'%s ago' % fmt(t, n, a)
 
 
 @templatefilter(b'basename', intype=bytes)
 def basename(path):
     """Any text. Treats the text as a path, and returns the last
     component of the path after splitting by the path separator.
     For example, "foo/bar/baz" becomes "baz" and "foo/bar//" becomes "".
     """
     return os.path.basename(path)
 
 
 def _tocborencodable(obj):
     if isinstance(obj, smartset.abstractsmartset):
         return list(obj)
     return obj
 
 
 @templatefilter(b'cbor')
 def cbor(obj):
     """Any object. Serializes the object to CBOR bytes."""
     # cborutil is stricter about type than json() filter
     obj = pycompat.rapply(_tocborencodable, obj)
     return b''.join(cborutil.streamencode(obj))
 
 
 @templatefilter(b'commondir')
 def commondir(filelist):
     """List of text. Treats each list item as file name with /
     as path separator and returns the longest common directory
     prefix shared by all list items.
     Returns the empty string if no common prefix exists.
 
     The list items are not normalized, i.e. "foo/../bar" is handled as
     file "bar" in the directory "foo/..". Leading slashes are ignored.
 
     For example, ["foo/bar/baz", "foo/baz/bar"] becomes "foo" and
     ["foo/bar", "baz"] becomes "".
     """
 
     def common(a, b):
         if len(a) > len(b):
             a = b[: len(a)]
         elif len(b) > len(a):
             b = b[: len(a)]
         if a == b:
             return a
         for i in pycompat.xrange(len(a)):
             if a[i] != b[i]:
                 return a[:i]
         return a
 
     try:
         if not filelist:
             return b""
         dirlist = [f.lstrip(b'/').split(b'/')[:-1] for f in filelist]
         if len(dirlist) == 1:
             return b'/'.join(dirlist[0])
         a = min(dirlist)
         b = max(dirlist)
         # The common prefix of a and b is shared with all
         # elements of the list since Python sorts lexicographical
         # and [1, x] after [1].
         return b'/'.join(common(a, b))
     except TypeError:
         raise error.ParseError(_(b'argument is not a list of text'))
 
 
 @templatefilter(b'count')
 def count(i):
     """List or text. Returns the length as an integer."""
     try:
         return len(i)
     except TypeError:
         raise error.ParseError(_(b'not countable'))
 
 
 @templatefilter(b'dirname', intype=bytes)
 def dirname(path):
     """Any text. Treats the text as a path, and strips the last
     component of the path after splitting by the path separator.
     """
     return os.path.dirname(path)
 
 
 @templatefilter(b'domain', intype=bytes)
 def domain(author):
     """Any text. Finds the first string that looks like an email
     address, and extracts just the domain component. Example: ``User
     <[e-mail]>`` becomes ``example.com``.
     """
     f = author.find(b'@')
     if f == -1:
         return b''
     author = author[f + 1 :]
     f = author.find(b'>')
     if f >= 0:
         author = author[:f]
     return author
 
 
 @templatefilter(b'email', intype=bytes)
 def email(text):
     """Any text. Extracts the first string that looks like an email
     address. Example: ``User <[e-mail]>`` becomes
     ``[e-mail]``.
     """
     return stringutil.email(text)
 
 
 @templatefilter(b'escape', intype=bytes)
 def escape(text):
     """Any text. Replaces the special XML/XHTML characters "&", "<"
     and ">" with XML entities, and filters out NUL characters.
     """
     return url.escape(text.replace(b'\0', b''), True)
 
 
 para_re = None
 space_re = None
 
 
 def fill(text, width, initindent=b'', hangindent=b''):
     '''fill many paragraphs with optional indentation.'''
     global para_re, space_re
     if para_re is None:
         para_re = re.compile(b'(\n\n|\n\\s*[-*]\\s*)', re.M)
         space_re = re.compile(br'  +')
 
     def findparas():
         start = 0
         while True:
             m = para_re.search(text, start)
             if not m:
                 uctext = encoding.unifromlocal(text[start:])
                 w = len(uctext)
                 while w > 0 and uctext[w - 1].isspace():
                     w -= 1
                 yield (
                     encoding.unitolocal(uctext[:w]),
                     encoding.unitolocal(uctext[w:]),
                 )
                 break
             yield text[start : m.start(0)], m.group(1)
             start = m.end(1)
 
     return b"".join(
         [
             stringutil.wrap(
                 space_re.sub(b' ', stringutil.wrap(para, width)),
                 width,
                 initindent,
                 hangindent,
             )
             + rest
             for para, rest in findparas()
         ]
     )
 
 
 @templatefilter(b'fill68', intype=bytes)
 def fill68(text):
     """Any text. Wraps the text to fit in 68 columns."""
     return fill(text, 68)
 
 
 @templatefilter(b'fill76', intype=bytes)
 def fill76(text):
     """Any text. Wraps the text to fit in 76 columns."""
     return fill(text, 76)
 
 
 @templatefilter(b'firstline', intype=bytes)
 def firstline(text):
     """Any text. Returns the first line of text."""
-    try:
-        return text.splitlines()[0]
-    except IndexError:
-        return b''
+    return stringutil.firstline(text)
 
 
 @templatefilter(b'hex', intype=bytes)
 def hexfilter(text):
     """Any text. Convert a binary Mercurial node identifier into
     its long hexadecimal representation.
     """
     return hex(text)
 
 
 @templatefilter(b'hgdate', intype=templateutil.date)
 def hgdate(text):
     """Date. Returns the date as a pair of numbers: "1157407993
     25200" (Unix timestamp, timezone offset).
     """
     return b"%d %d" % text
 
 
 @templatefilter(b'isodate', intype=templateutil.date)
 def isodate(text):
     """Date. Returns the date in ISO 8601 format: "2009-08-18 13:00
     +0200".
     """
     return dateutil.datestr(text, b'%Y-%m-%d %H:%M %1%2')
 
 
 @templatefilter(b'isodatesec', intype=templateutil.date)
 def isodatesec(text):
     """Date. Returns the date in ISO 8601 format, including
     seconds: "2009-08-18 13:00:13 +0200". See also the rfc3339date
     filter.
     """
     return dateutil.datestr(text, b'%Y-%m-%d %H:%M:%S %1%2')
 
 
 def indent(text, prefix, firstline=b''):
     '''indent each non-empty line of text after first with prefix.'''
     lines = text.splitlines()
     num_lines = len(lines)
     endswithnewline = text[-1:] == b'\n'
 
     def indenter():
         for i in pycompat.xrange(num_lines):
             l = lines[i]
             if l.strip():
                 yield prefix if i else firstline
             yield l
             if i < num_lines - 1 or endswithnewline:
                 yield b'\n'
 
     return b"".join(indenter())
 
 
 @templatefilter(b'json')
 def json(obj, paranoid=True):
     """Any object. Serializes the object to a JSON formatted text."""
     if obj is None:
         return b'null'
     elif obj is False:
         return b'false'
     elif obj is True:
         return b'true'
     elif isinstance(obj, (int, int, float)):
         return pycompat.bytestr(obj)
     elif isinstance(obj, bytes):
         return b'"%s"' % encoding.jsonescape(obj, paranoid=paranoid)
     elif isinstance(obj, type(u'')):
         raise error.ProgrammingError(
             b'Mercurial only does output with bytes: %r' % obj
         )
     elif util.safehasattr(obj, b'keys'):
         out = [
             b'"%s": %s'
             % (encoding.jsonescape(k, paranoid=paranoid), json(v, paranoid))
             for k, v in sorted(obj.items())
         ]
         return b'{' + b', '.join(out) + b'}'
     elif util.safehasattr(obj, b'__iter__'):
         out = [json(i, paranoid) for i in obj]
         return b'[' + b', '.join(out) + b']'
     raise error.ProgrammingError(b'cannot encode %r' % obj)
 
 
 @templatefilter(b'lower', intype=bytes)
 def lower(text):
     """Any text. Converts the text to lowercase."""
     return encoding.lower(text)
 
 
 @templatefilter(b'nonempty', intype=bytes)
 def nonempty(text):
     """Any text. Returns '(none)' if the string is empty."""
     return text or b"(none)"
 
 
 @templatefilter(b'obfuscate', intype=bytes)
 def obfuscate(text):
     """Any text. Returns the input text rendered as a sequence of
     XML entities.
     """
     text = str(text, pycompat.sysstr(encoding.encoding), r'replace')
     return b''.join([b'&#%d;' % ord(c) for c in text])
 
 
 @templatefilter(b'permissions', intype=bytes)
 def permissions(flags):
     if b"l" in flags:
         return b"lrwxrwxrwx"
     if b"x" in flags:
         return b"-rwxr-xr-x"
     return b"-rw-r--r--"
 
 
 @templatefilter(b'person', intype=bytes)
 def person(author):
     """Any text. Returns the name before an email address,
     interpreting it as per RFC 5322.
     """
     return stringutil.person(author)
 
 
 @templatefilter(b'revescape', intype=bytes)
 def revescape(text):
     """Any text. Escapes all "special" characters, except @.
     Forward slashes are escaped twice to prevent web servers from prematurely
     unescaping them. For example, "@foo bar/baz" becomes "@foo%20bar%252Fbaz".
     """
     return urlreq.quote(text, safe=b'/@').replace(b'/', b'%252F')
 
 
 @templatefilter(b'rfc3339date', intype=templateutil.date)
 def rfc3339date(text):
     """Date. Returns a date using the Internet date format
     specified in RFC 3339: "2009-08-18T13:00:13+02:00".
     """
     return dateutil.datestr(text, b"%Y-%m-%dT%H:%M:%S%1:%2")
 
 
 @templatefilter(b'rfc822date', intype=templateutil.date)
 def rfc822date(text):
     """Date. Returns a date using the same format used in email
     headers: "Tue, 18 Aug 2009 13:00:13 +0200".
     """
     return dateutil.datestr(text, b"%a, %d %b %Y %H:%M:%S %1%2")
 
 
 @templatefilter(b'short', intype=bytes)
 def short(text):
     """Changeset hash. Returns the short form of a changeset hash,
     i.e. a 12 hexadecimal digit string.
     """
     return text[:12]
 
 
 @templatefilter(b'shortbisect', intype=bytes)
 def shortbisect(label):
     """Any text. Treats `label` as a bisection status, and
     returns a single-character representing the status (G: good, B: bad,
     S: skipped, U: untested, I: ignored). Returns single space if `text`
     is not a valid bisection status.
     """
     if label:
         return label[0:1].upper()
     return b' '
 
 
 @templatefilter(b'shortdate', intype=templateutil.date)
 def shortdate(text):
     """Date. Returns a date like "2006-09-18"."""
     return dateutil.shortdate(text)
 
 
 @templatefilter(b'slashpath', intype=bytes)
 def slashpath(path):
     """Any text. Replaces the native path separator with slash."""
     return util.pconvert(path)
 
 
 @templatefilter(b'splitlines', intype=bytes)
 def splitlines(text):
     """Any text. Split text into a list of lines."""
     return templateutil.hybridlist(text.splitlines(), name=b'line')
 
 
 @templatefilter(b'stringescape', intype=bytes)
 def stringescape(text):
     return stringutil.escapestr(text)
 
 
 @templatefilter(b'stringify', intype=bytes)
 def stringify(thing):
     """Any type. Turns the value into text by converting values into
     text and concatenating them.
     """
     return thing  # coerced by the intype
 
 
 @templatefilter(b'stripdir', intype=bytes)
 def stripdir(text):
     """Treat the text as path and strip a directory level, if
     possible. For example, "foo" and "foo/bar" becomes "foo".
     """
     dir = os.path.dirname(text)
     if dir == b"":
         return os.path.basename(text)
     else:
         return dir
 
 
 @templatefilter(b'tabindent', intype=bytes)
 def tabindent(text):
     """Any text. Returns the text, with every non-empty line
     except the first starting with a tab character.
     """
     return indent(text, b'\t')
 
 
 @templatefilter(b'upper', intype=bytes)
 def upper(text):
     """Any text. Converts the text to uppercase."""
     return encoding.upper(text)
 
 
 @templatefilter(b'urlescape', intype=bytes)
 def urlescape(text):
     """Any text. Escapes all "special" characters. For example,
     "foo bar" becomes "foo%20bar".
     """
     return urlreq.quote(text)
 
 
 @templatefilter(b'user', intype=bytes)
 def userfilter(text):
     """Any text. Returns a short representation of a user name or email
     address."""
     return stringutil.shortuser(text)
 
 
 @templatefilter(b'emailuser', intype=bytes)
 def emailuser(text):
     """Any text. Returns the user portion of an email address."""
     return stringutil.emailuser(text)
 
 
 @templatefilter(b'utf8', intype=bytes)
 def utf8(text):
     """Any text. Converts from the local character encoding to UTF-8."""
     return encoding.fromlocal(text)
 
 
 @templatefilter(b'xmlescape', intype=bytes)
 def xmlescape(text):
     text = (
         text.replace(b'&', b'&amp;')
         .replace(b'<', b'&lt;')
         .replace(b'>', b'&gt;')
         .replace(b'"', b'&quot;')
         .replace(b"'", b'&#39;')
     )  # &apos; invalid in HTML
     return re.sub(b'[\x00-\x08\x0B\x0C\x0E-\x1F]', b' ', text)
 
 
 def websub(text, websubtable):
     """:websub: Any text. Only applies to hgweb. Applies the regular
     expression replacements defined in the websub section.
     """
     if websubtable:
         for regexp, format in websubtable:
             text = regexp.sub(format, text)
     return text
 
 
 def loadfilter(ui, extname, registrarobj):
     """Load template filter from specified registrarobj"""
     for name, func in registrarobj._table.items():
         filters[name] = func
 
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = filters.values()

mercurial/utils/stringutil.py

@@ -1,967 +1,975 b''
 # stringutil.py - utility for generic string formatting, parsing, etc.
 #
 #  Copyright 2005 K. Thananchayan <[e-mail]>
 #  Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #  Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import ast
 import codecs
 import re as remod
 import textwrap
 import types
 
 from ..i18n import _
 from ..thirdparty import attr
 
 from .. import (
     encoding,
     error,
     pycompat,
 )
 
 # regex special chars pulled from https://bugs.python.org/issue29995
 # which was part of Python 3.7.
 _respecial = pycompat.bytestr(b'()[]{}?*+-|^$\\.&~# \t\n\r\v\f')
 _regexescapemap = {ord(i): (b'\\' + i).decode('latin1') for i in _respecial}
 regexbytesescapemap = {i: (b'\\' + i) for i in _respecial}
 
 
 def reescape(pat):
     """Drop-in replacement for re.escape."""
     # NOTE: it is intentional that this works on unicodes and not
     # bytes, as it's only possible to do the escaping with
     # unicode.translate, not bytes.translate. Sigh.
     wantuni = True
     if isinstance(pat, bytes):
         wantuni = False
         pat = pat.decode('latin1')
     pat = pat.translate(_regexescapemap)
     if wantuni:
         return pat
     return pat.encode('latin1')
 
 
 def pprint(o, bprefix=False, indent=0, level=0):
     """Pretty print an object."""
     return b''.join(pprintgen(o, bprefix=bprefix, indent=indent, level=level))
 
 
 def pprintgen(o, bprefix=False, indent=0, level=0):
     """Pretty print an object to a generator of atoms.
 
     ``bprefix`` is a flag influencing whether bytestrings are preferred with
     a ``b''`` prefix.
 
     ``indent`` controls whether collections and nested data structures
     span multiple lines via the indentation amount in spaces. By default,
     no newlines are emitted.
 
     ``level`` specifies the initial indent level. Used if ``indent > 0``.
     """
 
     if isinstance(o, bytes):
         if bprefix:
             yield b"b'%s'" % escapestr(o)
         else:
             yield b"'%s'" % escapestr(o)
     elif isinstance(o, bytearray):
         # codecs.escape_encode() can't handle bytearray, so escapestr fails
         # without coercion.
         yield b"bytearray['%s']" % escapestr(bytes(o))
     elif isinstance(o, list):
         if not o:
             yield b'[]'
             return
 
         yield b'['
 
         if indent:
             level += 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         for i, a in enumerate(o):
             for chunk in pprintgen(
                 a, bprefix=bprefix, indent=indent, level=level
             ):
                 yield chunk
 
             if i + 1 < len(o):
                 if indent:
                     yield b',\n'
                     yield b' ' * (level * indent)
                 else:
                     yield b', '
 
         if indent:
             level -= 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         yield b']'
     elif isinstance(o, dict):
         if not o:
             yield b'{}'
             return
 
         yield b'{'
 
         if indent:
             level += 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         for i, (k, v) in enumerate(sorted(o.items())):
             for chunk in pprintgen(
                 k, bprefix=bprefix, indent=indent, level=level
             ):
                 yield chunk
 
             yield b': '
 
             for chunk in pprintgen(
                 v, bprefix=bprefix, indent=indent, level=level
             ):
                 yield chunk
 
             if i + 1 < len(o):
                 if indent:
                     yield b',\n'
                     yield b' ' * (level * indent)
                 else:
                     yield b', '
 
         if indent:
             level -= 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         yield b'}'
     elif isinstance(o, set):
         if not o:
             yield b'set([])'
             return
 
         yield b'set(['
 
         if indent:
             level += 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         for i, k in enumerate(sorted(o)):
             for chunk in pprintgen(
                 k, bprefix=bprefix, indent=indent, level=level
             ):
                 yield chunk
 
             if i + 1 < len(o):
                 if indent:
                     yield b',\n'
                     yield b' ' * (level * indent)
                 else:
                     yield b', '
 
         if indent:
             level -= 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         yield b'])'
     elif isinstance(o, tuple):
         if not o:
             yield b'()'
             return
 
         yield b'('
 
         if indent:
             level += 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         for i, a in enumerate(o):
             for chunk in pprintgen(
                 a, bprefix=bprefix, indent=indent, level=level
             ):
                 yield chunk
 
             if i + 1 < len(o):
                 if indent:
                     yield b',\n'
                     yield b' ' * (level * indent)
                 else:
                     yield b', '
 
         if indent:
             level -= 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         yield b')'
     elif isinstance(o, types.GeneratorType):
         # Special case of empty generator.
         try:
             nextitem = next(o)
         except StopIteration:
             yield b'gen[]'
             return
 
         yield b'gen['
 
         if indent:
             level += 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         last = False
 
         while not last:
             current = nextitem
 
             try:
                 nextitem = next(o)
             except StopIteration:
                 last = True
 
             for chunk in pprintgen(
                 current, bprefix=bprefix, indent=indent, level=level
             ):
                 yield chunk
 
             if not last:
                 if indent:
                     yield b',\n'
                     yield b' ' * (level * indent)
                 else:
                     yield b', '
 
         if indent:
             level -= 1
             yield b'\n'
             yield b' ' * (level * indent)
 
         yield b']'
     else:
         yield pycompat.byterepr(o)
 
 
 def prettyrepr(o):
     """Pretty print a representation of a possibly-nested object"""
     lines = []
     rs = pycompat.byterepr(o)
     p0 = p1 = 0
     while p0 < len(rs):
         # '... field=<type ... field=<type ...'
         #      ~~~~~~~~~~~~~~~~
         #      p0    p1        q0    q1
         q0 = -1
         q1 = rs.find(b'<', p1 + 1)
         if q1 < 0:
             q1 = len(rs)
             # pytype: disable=wrong-arg-count
             # TODO: figure out why pytype doesn't recognize the optional start
             #  arg
         elif q1 > p1 + 1 and rs.startswith(b'=', q1 - 1):
             # pytype: enable=wrong-arg-count
             # backtrack for ' field=<'
             q0 = rs.rfind(b' ', p1 + 1, q1 - 1)
         if q0 < 0:
             q0 = q1
         else:
             q0 += 1  # skip ' '
         l = rs.count(b'<', 0, p0) - rs.count(b'>', 0, p0)
         assert l >= 0
         lines.append((l, rs[p0:q0].rstrip()))
         p0, p1 = q0, q1
     return b'\n'.join(b'  ' * l + s for l, s in lines)
 
 
 def buildrepr(r):
     """Format an optional printable representation from unexpanded bits
 
     ========  =================================
     type(r)   example
     ========  =================================
     tuple     ('<not %r>', other)
     bytes     '<branch closed>'
     callable  lambda: '<branch %r>' % sorted(b)
     object    other
     ========  =================================
     """
     if r is None:
         return b''
     elif isinstance(r, tuple):
         return r[0] % pycompat.rapply(pycompat.maybebytestr, r[1:])
     elif isinstance(r, bytes):
         return r
     elif callable(r):
         return r()
     else:
         return pprint(r)
 
 
 def binary(s):
     """return true if a string is binary data"""
     return bool(s and b'\0' in s)
 
 
 def _splitpattern(pattern):
     if pattern.startswith(b're:'):
         return b're', pattern[3:]
     elif pattern.startswith(b'literal:'):
         return b'literal', pattern[8:]
     return b'literal', pattern
 
 
 def stringmatcher(pattern, casesensitive=True):
     """
     accepts a string, possibly starting with 're:' or 'literal:' prefix.
     returns the matcher name, pattern, and matcher function.
     missing or unknown prefixes are treated as literal matches.
 
     helper for tests:
     >>> def test(pattern, *tests):
     ...     kind, pattern, matcher = stringmatcher(pattern)
     ...     return (kind, pattern, [bool(matcher(t)) for t in tests])
     >>> def itest(pattern, *tests):
     ...     kind, pattern, matcher = stringmatcher(pattern, casesensitive=False)
     ...     return (kind, pattern, [bool(matcher(t)) for t in tests])
 
     exact matching (no prefix):
     >>> test(b'abcdefg', b'abc', b'def', b'abcdefg')
     ('literal', 'abcdefg', [False, False, True])
 
     regex matching ('re:' prefix)
     >>> test(b're:a.+b', b'nomatch', b'fooadef', b'fooadefbar')
     ('re', 'a.+b', [False, False, True])
 
     force exact matches ('literal:' prefix)
     >>> test(b'literal:re:foobar', b'foobar', b're:foobar')
     ('literal', 're:foobar', [False, True])
 
     unknown prefixes are ignored and treated as literals
     >>> test(b'foo:bar', b'foo', b'bar', b'foo:bar')
     ('literal', 'foo:bar', [False, False, True])
 
     case insensitive regex matches
     >>> itest(b're:A.+b', b'nomatch', b'fooadef', b'fooadefBar')
     ('re', 'A.+b', [False, False, True])
 
     case insensitive literal matches
     >>> itest(b'ABCDEFG', b'abc', b'def', b'abcdefg')
     ('literal', 'ABCDEFG', [False, False, True])
     """
     kind, pattern = _splitpattern(pattern)
     if kind == b're':
         try:
             flags = 0
             if not casesensitive:
                 flags = remod.I
             regex = remod.compile(pattern, flags)
         except remod.error as e:
             raise error.ParseError(
                 _(b'invalid regular expression: %s') % forcebytestr(e)
             )
         return kind, pattern, regex.search
     elif kind == b'literal':
         if casesensitive:
             match = pattern.__eq__
         else:
             ipat = encoding.lower(pattern)
             match = lambda s: ipat == encoding.lower(s)
         return kind, pattern, match
 
     raise error.ProgrammingError(b'unhandled pattern kind: %s' % kind)
 
 
 def substringregexp(pattern, flags=0):
     """Build a regexp object from a string pattern possibly starting with
     're:' or 'literal:' prefix.
 
     helper for tests:
     >>> def test(pattern, *tests):
     ...     regexp = substringregexp(pattern)
     ...     return [bool(regexp.search(t)) for t in tests]
     >>> def itest(pattern, *tests):
     ...     regexp = substringregexp(pattern, remod.I)
     ...     return [bool(regexp.search(t)) for t in tests]
 
     substring matching (no prefix):
     >>> test(b'bcde', b'abc', b'def', b'abcdefg')
     [False, False, True]
 
     substring pattern should be escaped:
     >>> substringregexp(b'.bc').pattern
     '\\\\.bc'
     >>> test(b'.bc', b'abc', b'def', b'abcdefg')
     [False, False, False]
 
     regex matching ('re:' prefix)
     >>> test(b're:a.+b', b'nomatch', b'fooadef', b'fooadefbar')
     [False, False, True]
 
     force substring matches ('literal:' prefix)
     >>> test(b'literal:re:foobar', b'foobar', b're:foobar')
     [False, True]
 
     case insensitive literal matches
     >>> itest(b'BCDE', b'abc', b'def', b'abcdefg')
     [False, False, True]
 
     case insensitive regex matches
     >>> itest(b're:A.+b', b'nomatch', b'fooadef', b'fooadefBar')
     [False, False, True]
     """
     kind, pattern = _splitpattern(pattern)
     if kind == b're':
         try:
             return remod.compile(pattern, flags)
         except remod.error as e:
             raise error.ParseError(
                 _(b'invalid regular expression: %s') % forcebytestr(e)
             )
     elif kind == b'literal':
         return remod.compile(remod.escape(pattern), flags)
 
     raise error.ProgrammingError(b'unhandled pattern kind: %s' % kind)
 
 
 def shortuser(user):
     """Return a short representation of a user name or email address."""
     f = user.find(b'@')
     if f >= 0:
         user = user[:f]
     f = user.find(b'<')
     if f >= 0:
         user = user[f + 1 :]
     f = user.find(b' ')
     if f >= 0:
         user = user[:f]
     f = user.find(b'.')
     if f >= 0:
         user = user[:f]
     return user
 
 
 def emailuser(user):
     """Return the user portion of an email address."""
     f = user.find(b'@')
     if f >= 0:
         user = user[:f]
     f = user.find(b'<')
     if f >= 0:
         user = user[f + 1 :]
     return user
 
 
 def email(author):
     '''get email of author.'''
     r = author.find(b'>')
     if r == -1:
         r = None
     return author[author.find(b'<') + 1 : r]
 
 
 def person(author):
     """Returns the name before an email address,
     interpreting it as per RFC 5322
 
     >>> person(b'foo@bar')
     'foo'
     >>> person(b'Foo Bar <foo@bar>')
     'Foo Bar'
     >>> person(b'"Foo Bar" <foo@bar>')
     'Foo Bar'
     >>> person(b'"Foo \"buz\" Bar" <foo@bar>')
     'Foo "buz" Bar'
     >>> # The following are invalid, but do exist in real-life
     ...
     >>> person(b'Foo "buz" Bar <foo@bar>')
     'Foo "buz" Bar'
     >>> person(b'"Foo Bar <foo@bar>')
     'Foo Bar'
     """
     if b'@' not in author:
         return author
     f = author.find(b'<')
     if f != -1:
         return author[:f].strip(b' "').replace(b'\\"', b'"')
     f = author.find(b'@')
     return author[:f].replace(b'.', b' ')
 
 
 @attr.s(hash=True)
 class mailmapping:
     """Represents a username/email key or value in
     a mailmap file"""
 
     email = attr.ib()
     name = attr.ib(default=None)
 
 
 def _ismailmaplineinvalid(names, emails):
     """Returns True if the parsed names and emails
     in a mailmap entry are invalid.
 
     >>> # No names or emails fails
     >>> names, emails = [], []
     >>> _ismailmaplineinvalid(names, emails)
     True
     >>> # Only one email fails
     >>> emails = [b'[e-mail]']
     >>> _ismailmaplineinvalid(names, emails)
     True
     >>> # One email and one name passes
     >>> names = [b'Test Name']
     >>> _ismailmaplineinvalid(names, emails)
     False
     >>> # No names but two emails passes
     >>> names = []
     >>> emails = [b'[e-mail]', b'[e-mail]']
     >>> _ismailmaplineinvalid(names, emails)
     False
     """
     return not emails or not names and len(emails) < 2
 
 
 def parsemailmap(mailmapcontent):
     """Parses data in the .mailmap format
 
     >>> mmdata = b"\\n".join([
     ... b'# Comment',
     ... b'Name <[e-mail]>',
     ... b'<[e-mail]> <[e-mail]>',
     ... b'Name <[e-mail]> <[e-mail]>',
     ... b'Name <[e-mail]> Commit <[e-mail]>',
     ... ])
     >>> mm = parsemailmap(mmdata)
     >>> for key in sorted(mm.keys()):
     ...     print(key)
     mailmapping(email='[e-mail]', name=None)
     mailmapping(email='[e-mail]', name=None)
     mailmapping(email='[e-mail]', name=None)
     mailmapping(email='[e-mail]', name='Commit')
     >>> for val in sorted(mm.values()):
     ...     print(val)
     mailmapping(email='[e-mail]', name='Name')
     mailmapping(email='[e-mail]', name=None)
     mailmapping(email='[e-mail]', name='Name')
     mailmapping(email='[e-mail]', name='Name')
     """
     mailmap = {}
 
     if mailmapcontent is None:
         return mailmap
 
     for line in mailmapcontent.splitlines():
 
         # Don't bother checking the line if it is a comment or
         # is an improperly formed author field
         if line.lstrip().startswith(b'#'):
             continue
 
         # names, emails hold the parsed emails and names for each line
         # name_builder holds the words in a persons name
         names, emails = [], []
         namebuilder = []
 
         for element in line.split():
             if element.startswith(b'#'):
                 # If we reach a comment in the mailmap file, move on
                 break
 
             elif element.startswith(b'<') and element.endswith(b'>'):
                 # We have found an email.
                 # Parse it, and finalize any names from earlier
                 emails.append(element[1:-1])  # Slice off the "<>"
 
                 if namebuilder:
                     names.append(b' '.join(namebuilder))
                     namebuilder = []
 
                 # Break if we have found a second email, any other
                 # data does not fit the spec for .mailmap
                 if len(emails) > 1:
                     break
 
             else:
                 # We have found another word in the committers name
                 namebuilder.append(element)
 
         # Check to see if we have parsed the line into a valid form
         # We require at least one email, and either at least one
         # name or a second email
         if _ismailmaplineinvalid(names, emails):
             continue
 
         mailmapkey = mailmapping(
             email=emails[-1],
             name=names[-1] if len(names) == 2 else None,
         )
 
         mailmap[mailmapkey] = mailmapping(
             email=emails[0],
             name=names[0] if names else None,
         )
 
     return mailmap
 
 
 def mapname(mailmap, author):
     """Returns the author field according to the mailmap cache, or
     the original author field.
 
     >>> mmdata = b"\\n".join([
     ...     b'# Comment',
     ...     b'Name <[e-mail]>',
     ...     b'<[e-mail]> <[e-mail]>',
     ...     b'Name <[e-mail]> <[e-mail]>',
     ...     b'Name <[e-mail]> Commit <[e-mail]>',
     ... ])
     >>> m = parsemailmap(mmdata)
     >>> mapname(m, b'Commit <[e-mail]>')
     'Name <[e-mail]>'
     >>> mapname(m, b'Name <[e-mail]>')
     'Name <[e-mail]>'
     >>> mapname(m, b'Commit <[e-mail]>')
     'Name <[e-mail]>'
     >>> mapname(m, b'Commit <[e-mail]>')
     'Name <[e-mail]>'
     >>> mapname(m, b'Unknown Name <[e-mail]>')
     'Unknown Name <[e-mail]>'
     """
     # If the author field coming in isn't in the correct format,
     # or the mailmap is empty just return the original author field
     if not isauthorwellformed(author) or not mailmap:
         return author
 
     # Turn the user name into a mailmapping
     commit = mailmapping(name=person(author), email=email(author))
 
     try:
         # Try and use both the commit email and name as the key
         proper = mailmap[commit]
 
     except KeyError:
         # If the lookup fails, use just the email as the key instead
         # We call this commit2 as not to erase original commit fields
         commit2 = mailmapping(email=commit.email)
         proper = mailmap.get(commit2, mailmapping(None, None))
 
     # Return the author field with proper values filled in
     return b'%s <%s>' % (
         proper.name if proper.name else commit.name,
         proper.email if proper.email else commit.email,
     )
 
 
 _correctauthorformat = remod.compile(br'^[^<]+\s<[^<>]+@[^<>]+>$')
 
 
 def isauthorwellformed(author):
     """Return True if the author field is well formed
     (ie "Contributor Name <[e-mail]>")
 
     >>> isauthorwellformed(b'Good Author <[e-mail]>')
     True
     >>> isauthorwellformed(b'Author <[e-mail]>')
     True
     >>> isauthorwellformed(b'Bad Author')
     False
     >>> isauthorwellformed(b'Bad Author <[e-mail]')
     False
     >>> isauthorwellformed(b'Bad Author [e-mail]')
     False
     >>> isauthorwellformed(b'<[e-mail]>')
     False
     >>> isauthorwellformed(b'Bad Author <author>')
     False
     """
     return _correctauthorformat.match(author) is not None
 
 
+def firstline(text):
+    """Return the first line of the input"""
+    try:
+        return text.splitlines()[0]
+    except IndexError:
+        return b''
+
+
 def ellipsis(text, maxlength=400):
     """Trim string to at most maxlength (default: 400) columns in display."""
     return encoding.trim(text, maxlength, ellipsis=b'...')
 
 
 def escapestr(s):
     if isinstance(s, memoryview):
         s = bytes(s)
     # call underlying function of s.encode('string_escape') directly for
     # Python 3 compatibility
     return codecs.escape_encode(s)[0]  # pytype: disable=module-attr
 
 
 def unescapestr(s):
     return codecs.escape_decode(s)[0]  # pytype: disable=module-attr
 
 
 def forcebytestr(obj):
     """Portably format an arbitrary object (e.g. exception) into a byte
     string."""
     try:
         return pycompat.bytestr(obj)
     except UnicodeEncodeError:
         # non-ascii string, may be lossy
         return pycompat.bytestr(encoding.strtolocal(str(obj)))
 
 
 def uirepr(s):
     # Avoid double backslash in Windows path repr()
     return pycompat.byterepr(pycompat.bytestr(s)).replace(b'\\\\', b'\\')
 
 
 # delay import of textwrap
 def _MBTextWrapper(**kwargs):
     class tw(textwrap.TextWrapper):
         """
         Extend TextWrapper for width-awareness.
 
         Neither number of 'bytes' in any encoding nor 'characters' is
         appropriate to calculate terminal columns for specified string.
 
         Original TextWrapper implementation uses built-in 'len()' directly,
         so overriding is needed to use width information of each characters.
 
         In addition, characters classified into 'ambiguous' width are
         treated as wide in East Asian area, but as narrow in other.
 
         This requires use decision to determine width of such characters.
         """
 
         def _cutdown(self, ucstr, space_left):
             l = 0
             colwidth = encoding.ucolwidth
             for i in pycompat.xrange(len(ucstr)):
                 l += colwidth(ucstr[i])
                 if space_left < l:
                     return (ucstr[:i], ucstr[i:])
             return ucstr, b''
 
         # overriding of base class
         def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
             space_left = max(width - cur_len, 1)
 
             if self.break_long_words:
                 cut, res = self._cutdown(reversed_chunks[-1], space_left)
                 cur_line.append(cut)
                 reversed_chunks[-1] = res
             elif not cur_line:
                 cur_line.append(reversed_chunks.pop())
 
         # this overriding code is imported from TextWrapper of Python 2.6
         # to calculate columns of string by 'encoding.ucolwidth()'
         def _wrap_chunks(self, chunks):
             colwidth = encoding.ucolwidth
 
             lines = []
             if self.width <= 0:
                 raise ValueError(b"invalid width %r (must be > 0)" % self.width)
 
             # Arrange in reverse order so items can be efficiently popped
             # from a stack of chucks.
             chunks.reverse()
 
             while chunks:
 
                 # Start the list of chunks that will make up the current line.
                 # cur_len is just the length of all the chunks in cur_line.
                 cur_line = []
                 cur_len = 0
 
                 # Figure out which static string will prefix this line.
                 if lines:
                     indent = self.subsequent_indent
                 else:
                     indent = self.initial_indent
 
                 # Maximum width for this line.
                 width = self.width - len(indent)
 
                 # First chunk on line is whitespace -- drop it, unless this
                 # is the very beginning of the text (i.e. no lines started yet).
                 if self.drop_whitespace and chunks[-1].strip() == '' and lines:
                     del chunks[-1]
 
                 while chunks:
                     l = colwidth(chunks[-1])
 
                     # Can at least squeeze this chunk onto the current line.
                     if cur_len + l <= width:
                         cur_line.append(chunks.pop())
                         cur_len += l
 
                     # Nope, this line is full.
                     else:
                         break
 
                 # The current line is full, and the next chunk is too big to
                 # fit on *any* line (not just this one).
                 if chunks and colwidth(chunks[-1]) > width:
                     self._handle_long_word(chunks, cur_line, cur_len, width)
 
                 # If the last chunk on this line is all whitespace, drop it.
                 if (
                     self.drop_whitespace
                     and cur_line
                     and cur_line[-1].strip() == r''
                 ):
                     del cur_line[-1]
 
                 # Convert current line back to a string and store it in list
                 # of all lines (return value).
                 if cur_line:
                     lines.append(indent + ''.join(cur_line))
 
             return lines
 
     global _MBTextWrapper
     _MBTextWrapper = tw
     return tw(**kwargs)
 
 
 def wrap(line, width, initindent=b'', hangindent=b''):
     maxindent = max(len(hangindent), len(initindent))
     if width <= maxindent:
         # adjust for weird terminal size
         width = max(78, maxindent + 1)
     line = line.decode(
         pycompat.sysstr(encoding.encoding),
         pycompat.sysstr(encoding.encodingmode),
     )
     initindent = initindent.decode(
         pycompat.sysstr(encoding.encoding),
         pycompat.sysstr(encoding.encodingmode),
     )
     hangindent = hangindent.decode(
         pycompat.sysstr(encoding.encoding),
         pycompat.sysstr(encoding.encodingmode),
     )
     wrapper = _MBTextWrapper(
         width=width, initial_indent=initindent, subsequent_indent=hangindent
     )
     return wrapper.fill(line).encode(pycompat.sysstr(encoding.encoding))
 
 
 _booleans = {
     b'1': True,
     b'yes': True,
     b'true': True,
     b'on': True,
     b'always': True,
     b'0': False,
     b'no': False,
     b'false': False,
     b'off': False,
     b'never': False,
 }
 
 
 def parsebool(s):
     """Parse s into a boolean.
 
     If s is not a valid boolean, returns None.
     """
     return _booleans.get(s.lower(), None)
 
 
 def parselist(value):
     """parse a configuration value as a list of comma/space separated strings
 
     >>> parselist(b'this,is "a small" ,test')
     ['this', 'is', 'a small', 'test']
     """
 
     def _parse_plain(parts, s, offset):
         whitespace = False
         while offset < len(s) and (
             s[offset : offset + 1].isspace() or s[offset : offset + 1] == b','
         ):
             whitespace = True
             offset += 1
         if offset >= len(s):
             return None, parts, offset
         if whitespace:
             parts.append(b'')
         if s[offset : offset + 1] == b'"' and not parts[-1]:
             return _parse_quote, parts, offset + 1
         elif s[offset : offset + 1] == b'"' and parts[-1][-1:] == b'\\':
             parts[-1] = parts[-1][:-1] + s[offset : offset + 1]
             return _parse_plain, parts, offset + 1
         parts[-1] += s[offset : offset + 1]
         return _parse_plain, parts, offset + 1
 
     def _parse_quote(parts, s, offset):
         if offset < len(s) and s[offset : offset + 1] == b'"':  # ""
             parts.append(b'')
             offset += 1
             while offset < len(s) and (
                 s[offset : offset + 1].isspace()
                 or s[offset : offset + 1] == b','
             ):
                 offset += 1
             return _parse_plain, parts, offset
 
         while offset < len(s) and s[offset : offset + 1] != b'"':
             if (
                 s[offset : offset + 1] == b'\\'
                 and offset + 1 < len(s)
                 and s[offset + 1 : offset + 2] == b'"'
             ):
                 offset += 1
                 parts[-1] += b'"'
             else:
                 parts[-1] += s[offset : offset + 1]
             offset += 1
 
         if offset >= len(s):
             real_parts = _configlist(parts[-1])
             if not real_parts:
                 parts[-1] = b'"'
             else:
                 real_parts[0] = b'"' + real_parts[0]
                 parts = parts[:-1]
                 parts.extend(real_parts)
             return None, parts, offset
 
         offset += 1
         while offset < len(s) and s[offset : offset + 1] in [b' ', b',']:
             offset += 1
 
         if offset < len(s):
             if offset + 1 == len(s) and s[offset : offset + 1] == b'"':
                 parts[-1] += b'"'
                 offset += 1
             else:
                 parts.append(b'')
         else:
             return None, parts, offset
 
         return _parse_plain, parts, offset
 
     def _configlist(s):
         s = s.rstrip(b' ,')
         if not s:
             return []
         parser, parts, offset = _parse_plain, [b''], 0
         while parser:
             parser, parts, offset = parser(parts, s, offset)
         return parts
 
     if value is not None and isinstance(value, bytes):
         result = _configlist(value.lstrip(b' ,\n'))
     else:
         result = value
     return result or []
 
 
 def evalpythonliteral(s):
     """Evaluate a string containing a Python literal expression"""
     # We could backport our tokenizer hack to rewrite '' to u'' if we want
     return ast.literal_eval(s.decode('latin1'))