--- a/mercurial/templatefilters.py Sun Oct 06 09:45:02 2019 -0400
+++ b/mercurial/templatefilters.py Sun Oct 06 09:48:39 2019 -0400
@@ -43,26 +43,26 @@
templatefilter = registrar.templatefilter(filters)
-@templatefilter('addbreaks', intype=bytes)
+@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('\n', '<br/>\n')
+ return text.replace(b'\n', b'<br/>\n')
agescales = [
- ("year", 3600 * 24 * 365, 'Y'),
- ("month", 3600 * 24 * 30, 'M'),
- ("week", 3600 * 24 * 7, 'W'),
- ("day", 3600 * 24, 'd'),
- ("hour", 3600, 'h'),
- ("minute", 60, 'm'),
- ("second", 1, 's'),
+ (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('age', intype=templateutil.date)
+@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.
@@ -71,12 +71,12 @@
def plural(t, c):
if c == 1:
return t
- return t + "s"
+ return t + b"s"
def fmt(t, c, a):
if abbrev:
- return "%d%s" % (c, a)
- return "%d %s" % (c, plural(t, c))
+ return b"%d%s" % (c, a)
+ return b"%d %s" % (c, plural(t, c))
now = time.time()
then = date[0]
@@ -85,7 +85,7 @@
future = True
delta = max(1, int(then - now))
if delta > agescales[0][1] * 30:
- return 'in the distant future'
+ return b'in the distant future'
else:
delta = max(1, int(now - then))
if delta > agescales[0][1] * 2:
@@ -95,11 +95,11 @@
n = delta // s
if n >= 2 or s == 1:
if future:
- return '%s from now' % fmt(t, n, a)
- return '%s ago' % fmt(t, n, a)
+ return b'%s from now' % fmt(t, n, a)
+ return b'%s ago' % fmt(t, n, a)
-@templatefilter('basename', intype=bytes)
+@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.
@@ -108,13 +108,13 @@
return os.path.basename(path)
-@templatefilter('cbor')
+@templatefilter(b'cbor')
def cbor(obj):
"""Any object. Serializes the object to CBOR bytes."""
return b''.join(cborutil.streamencode(obj))
-@templatefilter('commondir')
+@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
@@ -142,30 +142,30 @@
try:
if not filelist:
- return ""
- dirlist = [f.lstrip('/').split('/')[:-1] for f in filelist]
+ return b""
+ dirlist = [f.lstrip(b'/').split(b'/')[:-1] for f in filelist]
if len(dirlist) == 1:
- return '/'.join(dirlist[0])
+ 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 '/'.join(common(a, b))
+ return b'/'.join(common(a, b))
except TypeError:
- raise error.ParseError(_('argument is not a list of text'))
+ raise error.ParseError(_(b'argument is not a list of text'))
-@templatefilter('count')
+@templatefilter(b'count')
def count(i):
"""List or text. Returns the length as an integer."""
try:
return len(i)
except TypeError:
- raise error.ParseError(_('not countable'))
+ raise error.ParseError(_(b'not countable'))
-@templatefilter('dirname', intype=bytes)
+@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.
@@ -173,23 +173,23 @@
return os.path.dirname(path)
-@templatefilter('domain', intype=bytes)
+@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
<user@example.com>`` becomes ``example.com``.
"""
- f = author.find('@')
+ f = author.find(b'@')
if f == -1:
- return ''
+ return b''
author = author[f + 1 :]
- f = author.find('>')
+ f = author.find(b'>')
if f >= 0:
author = author[:f]
return author
-@templatefilter('email', intype=bytes)
+@templatefilter(b'email', intype=bytes)
def email(text):
"""Any text. Extracts the first string that looks like an email
address. Example: ``User <user@example.com>`` becomes
@@ -198,23 +198,23 @@
return stringutil.email(text)
-@templatefilter('escape', intype=bytes)
+@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('\0', ''), True)
+ return url.escape(text.replace(b'\0', b''), True)
para_re = None
space_re = None
-def fill(text, width, initindent='', hangindent=''):
+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('(\n\n|\n\\s*[-*]\\s*)', re.M)
+ para_re = re.compile(b'(\n\n|\n\\s*[-*]\\s*)', re.M)
space_re = re.compile(br' +')
def findparas():
@@ -234,10 +234,10 @@
yield text[start : m.start(0)], m.group(1)
start = m.end(1)
- return "".join(
+ return b"".join(
[
stringutil.wrap(
- space_re.sub(' ', stringutil.wrap(para, width)),
+ space_re.sub(b' ', stringutil.wrap(para, width)),
width,
initindent,
hangindent,
@@ -248,28 +248,28 @@
)
-@templatefilter('fill68', intype=bytes)
+@templatefilter(b'fill68', intype=bytes)
def fill68(text):
"""Any text. Wraps the text to fit in 68 columns."""
return fill(text, 68)
-@templatefilter('fill76', intype=bytes)
+@templatefilter(b'fill76', intype=bytes)
def fill76(text):
"""Any text. Wraps the text to fit in 76 columns."""
return fill(text, 76)
-@templatefilter('firstline', intype=bytes)
+@templatefilter(b'firstline', intype=bytes)
def firstline(text):
"""Any text. Returns the first line of text."""
try:
- return text.splitlines(True)[0].rstrip('\r\n')
+ return text.splitlines(True)[0].rstrip(b'\r\n')
except IndexError:
- return ''
+ return b''
-@templatefilter('hex', intype=bytes)
+@templatefilter(b'hex', intype=bytes)
def hexfilter(text):
"""Any text. Convert a binary Mercurial node identifier into
its long hexadecimal representation.
@@ -277,36 +277,36 @@
return node.hex(text)
-@templatefilter('hgdate', intype=templateutil.date)
+@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 "%d %d" % text
+ return b"%d %d" % text
-@templatefilter('isodate', intype=templateutil.date)
+@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, '%Y-%m-%d %H:%M %1%2')
+ return dateutil.datestr(text, b'%Y-%m-%d %H:%M %1%2')
-@templatefilter('isodatesec', intype=templateutil.date)
+@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, '%Y-%m-%d %H:%M:%S %1%2')
+ return dateutil.datestr(text, b'%Y-%m-%d %H:%M:%S %1%2')
def indent(text, prefix):
'''indent each non-empty line of text after first with prefix.'''
lines = text.splitlines()
num_lines = len(lines)
- endswithnewline = text[-1:] == '\n'
+ endswithnewline = text[-1:] == b'\n'
def indenter():
for i in pycompat.xrange(num_lines):
@@ -315,72 +315,72 @@
yield prefix
yield l
if i < num_lines - 1 or endswithnewline:
- yield '\n'
+ yield b'\n'
- return "".join(indenter())
+ return b"".join(indenter())
-@templatefilter('json')
+@templatefilter(b'json')
def json(obj, paranoid=True):
"""Any object. Serializes the object to a JSON formatted text."""
if obj is None:
- return 'null'
+ return b'null'
elif obj is False:
- return 'false'
+ return b'false'
elif obj is True:
- return 'true'
+ return b'true'
elif isinstance(obj, (int, long, float)):
return pycompat.bytestr(obj)
elif isinstance(obj, bytes):
- return '"%s"' % encoding.jsonescape(obj, paranoid=paranoid)
+ return b'"%s"' % encoding.jsonescape(obj, paranoid=paranoid)
elif isinstance(obj, type(u'')):
raise error.ProgrammingError(
- 'Mercurial only does output with bytes: %r' % obj
+ b'Mercurial only does output with bytes: %r' % obj
)
- elif util.safehasattr(obj, 'keys'):
+ elif util.safehasattr(obj, b'keys'):
out = [
- '"%s": %s'
+ b'"%s": %s'
% (encoding.jsonescape(k, paranoid=paranoid), json(v, paranoid))
for k, v in sorted(obj.iteritems())
]
- return '{' + ', '.join(out) + '}'
- elif util.safehasattr(obj, '__iter__'):
+ return b'{' + b', '.join(out) + b'}'
+ elif util.safehasattr(obj, b'__iter__'):
out = [json(i, paranoid) for i in obj]
- return '[' + ', '.join(out) + ']'
- raise error.ProgrammingError('cannot encode %r' % obj)
+ return b'[' + b', '.join(out) + b']'
+ raise error.ProgrammingError(b'cannot encode %r' % obj)
-@templatefilter('lower', intype=bytes)
+@templatefilter(b'lower', intype=bytes)
def lower(text):
"""Any text. Converts the text to lowercase."""
return encoding.lower(text)
-@templatefilter('nonempty', intype=bytes)
+@templatefilter(b'nonempty', intype=bytes)
def nonempty(text):
"""Any text. Returns '(none)' if the string is empty."""
- return text or "(none)"
+ return text or b"(none)"
-@templatefilter('obfuscate', intype=bytes)
+@templatefilter(b'obfuscate', intype=bytes)
def obfuscate(text):
"""Any text. Returns the input text rendered as a sequence of
XML entities.
"""
text = unicode(text, pycompat.sysstr(encoding.encoding), r'replace')
- return ''.join(['&#%d;' % ord(c) for c in text])
+ return b''.join([b'&#%d;' % ord(c) for c in text])
-@templatefilter('permissions', intype=bytes)
+@templatefilter(b'permissions', intype=bytes)
def permissions(flags):
- if "l" in flags:
- return "lrwxrwxrwx"
- if "x" in flags:
- return "-rwxr-xr-x"
- return "-rw-r--r--"
+ if b"l" in flags:
+ return b"lrwxrwxrwx"
+ if b"x" in flags:
+ return b"-rwxr-xr-x"
+ return b"-rw-r--r--"
-@templatefilter('person', intype=bytes)
+@templatefilter(b'person', intype=bytes)
def person(author):
"""Any text. Returns the name before an email address,
interpreting it as per RFC 5322.
@@ -388,32 +388,32 @@
return stringutil.person(author)
-@templatefilter('revescape', intype=bytes)
+@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='/@').replace('/', '%252F')
+ return urlreq.quote(text, safe=b'/@').replace(b'/', b'%252F')
-@templatefilter('rfc3339date', intype=templateutil.date)
+@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, "%Y-%m-%dT%H:%M:%S%1:%2")
+ return dateutil.datestr(text, b"%Y-%m-%dT%H:%M:%S%1:%2")
-@templatefilter('rfc822date', intype=templateutil.date)
+@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, "%a, %d %b %Y %H:%M:%S %1%2")
+ return dateutil.datestr(text, b"%a, %d %b %Y %H:%M:%S %1%2")
-@templatefilter('short', intype=bytes)
+@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.
@@ -421,7 +421,7 @@
return text[:12]
-@templatefilter('shortbisect', intype=bytes)
+@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,
@@ -430,33 +430,33 @@
"""
if label:
return label[0:1].upper()
- return ' '
+ return b' '
-@templatefilter('shortdate', intype=templateutil.date)
+@templatefilter(b'shortdate', intype=templateutil.date)
def shortdate(text):
"""Date. Returns a date like "2006-09-18"."""
return dateutil.shortdate(text)
-@templatefilter('slashpath', intype=bytes)
+@templatefilter(b'slashpath', intype=bytes)
def slashpath(path):
"""Any text. Replaces the native path separator with slash."""
return util.pconvert(path)
-@templatefilter('splitlines', intype=bytes)
+@templatefilter(b'splitlines', intype=bytes)
def splitlines(text):
"""Any text. Split text into a list of lines."""
- return templateutil.hybridlist(text.splitlines(), name='line')
+ return templateutil.hybridlist(text.splitlines(), name=b'line')
-@templatefilter('stringescape', intype=bytes)
+@templatefilter(b'stringescape', intype=bytes)
def stringescape(text):
return stringutil.escapestr(text)
-@templatefilter('stringify', intype=bytes)
+@templatefilter(b'stringify', intype=bytes)
def stringify(thing):
"""Any type. Turns the value into text by converting values into
text and concatenating them.
@@ -464,33 +464,33 @@
return thing # coerced by the intype
-@templatefilter('stripdir', intype=bytes)
+@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 == "":
+ if dir == b"":
return os.path.basename(text)
else:
return dir
-@templatefilter('tabindent', intype=bytes)
+@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, '\t')
+ return indent(text, b'\t')
-@templatefilter('upper', intype=bytes)
+@templatefilter(b'upper', intype=bytes)
def upper(text):
"""Any text. Converts the text to uppercase."""
return encoding.upper(text)
-@templatefilter('urlescape', intype=bytes)
+@templatefilter(b'urlescape', intype=bytes)
def urlescape(text):
"""Any text. Escapes all "special" characters. For example,
"foo bar" becomes "foo%20bar".
@@ -498,35 +498,35 @@
return urlreq.quote(text)
-@templatefilter('user', intype=bytes)
+@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('emailuser', intype=bytes)
+@templatefilter(b'emailuser', intype=bytes)
def emailuser(text):
"""Any text. Returns the user portion of an email address."""
return stringutil.emailuser(text)
-@templatefilter('utf8', intype=bytes)
+@templatefilter(b'utf8', intype=bytes)
def utf8(text):
"""Any text. Converts from the local character encoding to UTF-8."""
return encoding.fromlocal(text)
-@templatefilter('xmlescape', intype=bytes)
+@templatefilter(b'xmlescape', intype=bytes)
def xmlescape(text):
text = (
- text.replace('&', '&')
- .replace('<', '<')
- .replace('>', '>')
- .replace('"', '"')
- .replace("'", ''')
+ text.replace(b'&', b'&')
+ .replace(b'<', b'<')
+ .replace(b'>', b'>')
+ .replace(b'"', b'"')
+ .replace(b"'", b''')
) # ' invalid in HTML
- return re.sub('[\x00-\x08\x0B\x0C\x0E-\x1F]', ' ', text)
+ return re.sub(b'[\x00-\x08\x0B\x0C\x0E-\x1F]', b' ', text)
def websub(text, websubtable):