372 lines
13 KiB
Python
372 lines
13 KiB
Python
"""HTML utilities suitable for global use."""
|
|
|
|
import re
|
|
from urllib.parse import (
|
|
parse_qsl, quote, unquote, urlencode, urlsplit, urlunsplit,
|
|
)
|
|
|
|
from django.utils.encoding import force_text
|
|
from django.utils.functional import keep_lazy, keep_lazy_text
|
|
from django.utils.http import RFC3986_GENDELIMS, RFC3986_SUBDELIMS
|
|
from django.utils.safestring import SafeData, SafeText, mark_safe
|
|
from django.utils.text import normalize_newlines
|
|
|
|
from .html_parser import HTMLParseError, HTMLParser
|
|
|
|
# Configuration for urlize() function.
|
|
TRAILING_PUNCTUATION_RE = re.compile(
|
|
'^' # Beginning of word
|
|
'(.*?)' # The URL in word
|
|
'([.,:;!]+)' # Allowed non-wrapping, trailing punctuation
|
|
'$' # End of word
|
|
)
|
|
WRAPPING_PUNCTUATION = [('(', ')'), ('<', '>'), ('[', ']'), ('<', '>'), ('"', '"'), ('\'', '\'')]
|
|
|
|
# List of possible strings used for bullets in bulleted lists.
|
|
DOTS = ['·', '*', '\u2022', '•', '•', '•']
|
|
|
|
unencoded_ampersands_re = re.compile(r'&(?!(\w+|#\d+);)')
|
|
word_split_re = re.compile(r'''([\s<>"']+)''')
|
|
simple_url_re = re.compile(r'^https?://\[?\w', re.IGNORECASE)
|
|
simple_url_2_re = re.compile(r'^www\.|^(?!http)\w[^@]+\.(com|edu|gov|int|mil|net|org)($|/.*)$', re.IGNORECASE)
|
|
simple_email_re = re.compile(r'^\S+@\S+\.\S+$')
|
|
|
|
|
|
@keep_lazy(str, SafeText)
|
|
def escape(text):
|
|
"""
|
|
Returns the given text with ampersands, quotes and angle brackets encoded
|
|
for use in HTML.
|
|
|
|
This function always escapes its input, even if it's already escaped and
|
|
marked as such. This may result in double-escaping. If this is a concern,
|
|
use conditional_escape() instead.
|
|
"""
|
|
return mark_safe(
|
|
force_text(text).replace('&', '&').replace('<', '<')
|
|
.replace('>', '>').replace('"', '"').replace("'", ''')
|
|
)
|
|
|
|
|
|
_js_escapes = {
|
|
ord('\\'): '\\u005C',
|
|
ord('\''): '\\u0027',
|
|
ord('"'): '\\u0022',
|
|
ord('>'): '\\u003E',
|
|
ord('<'): '\\u003C',
|
|
ord('&'): '\\u0026',
|
|
ord('='): '\\u003D',
|
|
ord('-'): '\\u002D',
|
|
ord(';'): '\\u003B',
|
|
ord('\u2028'): '\\u2028',
|
|
ord('\u2029'): '\\u2029'
|
|
}
|
|
|
|
# Escape every ASCII character with a value less than 32.
|
|
_js_escapes.update((ord('%c' % z), '\\u%04X' % z) for z in range(32))
|
|
|
|
|
|
@keep_lazy(str, SafeText)
|
|
def escapejs(value):
|
|
"""Hex encodes characters for use in JavaScript strings."""
|
|
return mark_safe(force_text(value).translate(_js_escapes))
|
|
|
|
|
|
def conditional_escape(text):
|
|
"""
|
|
Similar to escape(), except that it doesn't operate on pre-escaped strings.
|
|
|
|
This function relies on the __html__ convention used both by Django's
|
|
SafeData class and by third-party libraries like markupsafe.
|
|
"""
|
|
if hasattr(text, '__html__'):
|
|
return text.__html__()
|
|
else:
|
|
return escape(text)
|
|
|
|
|
|
def format_html(format_string, *args, **kwargs):
|
|
"""
|
|
Similar to str.format, but passes all arguments through conditional_escape,
|
|
and calls 'mark_safe' on the result. This function should be used instead
|
|
of str.format or % interpolation to build up small HTML fragments.
|
|
"""
|
|
args_safe = map(conditional_escape, args)
|
|
kwargs_safe = {k: conditional_escape(v) for (k, v) in kwargs.items()}
|
|
return mark_safe(format_string.format(*args_safe, **kwargs_safe))
|
|
|
|
|
|
def format_html_join(sep, format_string, args_generator):
|
|
"""
|
|
A wrapper of format_html, for the common case of a group of arguments that
|
|
need to be formatted using the same format string, and then joined using
|
|
'sep'. 'sep' is also passed through conditional_escape.
|
|
|
|
'args_generator' should be an iterator that returns the sequence of 'args'
|
|
that will be passed to format_html.
|
|
|
|
Example:
|
|
|
|
format_html_join('\n', "<li>{} {}</li>", ((u.first_name, u.last_name)
|
|
for u in users))
|
|
"""
|
|
return mark_safe(conditional_escape(sep).join(
|
|
format_html(format_string, *tuple(args))
|
|
for args in args_generator))
|
|
|
|
|
|
@keep_lazy_text
|
|
def linebreaks(value, autoescape=False):
|
|
"""Converts newlines into <p> and <br />s."""
|
|
value = normalize_newlines(force_text(value))
|
|
paras = re.split('\n{2,}', value)
|
|
if autoescape:
|
|
paras = ['<p>%s</p>' % escape(p).replace('\n', '<br />') for p in paras]
|
|
else:
|
|
paras = ['<p>%s</p>' % p.replace('\n', '<br />') for p in paras]
|
|
return '\n\n'.join(paras)
|
|
|
|
|
|
class MLStripper(HTMLParser):
|
|
def __init__(self):
|
|
HTMLParser.__init__(self)
|
|
self.reset()
|
|
self.fed = []
|
|
|
|
def handle_data(self, d):
|
|
self.fed.append(d)
|
|
|
|
def handle_entityref(self, name):
|
|
self.fed.append('&%s;' % name)
|
|
|
|
def handle_charref(self, name):
|
|
self.fed.append('&#%s;' % name)
|
|
|
|
def get_data(self):
|
|
return ''.join(self.fed)
|
|
|
|
|
|
def _strip_once(value):
|
|
"""
|
|
Internal tag stripping utility used by strip_tags.
|
|
"""
|
|
s = MLStripper()
|
|
try:
|
|
s.feed(value)
|
|
except HTMLParseError:
|
|
return value
|
|
try:
|
|
s.close()
|
|
except HTMLParseError:
|
|
return s.get_data() + s.rawdata
|
|
else:
|
|
return s.get_data()
|
|
|
|
|
|
@keep_lazy_text
|
|
def strip_tags(value):
|
|
"""Returns the given HTML with all tags stripped."""
|
|
# Note: in typical case this loop executes _strip_once once. Loop condition
|
|
# is redundant, but helps to reduce number of executions of _strip_once.
|
|
value = force_text(value)
|
|
while '<' in value and '>' in value:
|
|
new_value = _strip_once(value)
|
|
if len(new_value) >= len(value):
|
|
# _strip_once was not able to detect more tags
|
|
break
|
|
value = new_value
|
|
return value
|
|
|
|
|
|
@keep_lazy_text
|
|
def strip_spaces_between_tags(value):
|
|
"""Returns the given HTML with spaces between tags removed."""
|
|
return re.sub(r'>\s+<', '><', force_text(value))
|
|
|
|
|
|
def smart_urlquote(url):
|
|
"Quotes a URL if it isn't already quoted."
|
|
def unquote_quote(segment):
|
|
segment = unquote(segment)
|
|
# Tilde is part of RFC3986 Unreserved Characters
|
|
# http://tools.ietf.org/html/rfc3986#section-2.3
|
|
# See also http://bugs.python.org/issue16285
|
|
segment = quote(segment, safe=RFC3986_SUBDELIMS + RFC3986_GENDELIMS + '~')
|
|
return force_text(segment)
|
|
|
|
# Handle IDN before quoting.
|
|
try:
|
|
scheme, netloc, path, query, fragment = urlsplit(url)
|
|
except ValueError:
|
|
# invalid IPv6 URL (normally square brackets in hostname part).
|
|
return unquote_quote(url)
|
|
|
|
try:
|
|
netloc = netloc.encode('idna').decode('ascii') # IDN -> ACE
|
|
except UnicodeError: # invalid domain part
|
|
return unquote_quote(url)
|
|
|
|
if query:
|
|
# Separately unquoting key/value, so as to not mix querystring separators
|
|
# included in query values. See #22267.
|
|
query_parts = [(unquote(q[0]), unquote(q[1]))
|
|
for q in parse_qsl(query, keep_blank_values=True)]
|
|
# urlencode will take care of quoting
|
|
query = urlencode(query_parts)
|
|
|
|
path = unquote_quote(path)
|
|
fragment = unquote_quote(fragment)
|
|
|
|
return urlunsplit((scheme, netloc, path, query, fragment))
|
|
|
|
|
|
@keep_lazy_text
|
|
def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
|
|
"""
|
|
Converts any URLs in text into clickable links.
|
|
|
|
Works on http://, https://, www. links, and also on links ending in one of
|
|
the original seven gTLDs (.com, .edu, .gov, .int, .mil, .net, and .org).
|
|
Links can have trailing punctuation (periods, commas, close-parens) and
|
|
leading punctuation (opening parens) and it'll still do the right thing.
|
|
|
|
If trim_url_limit is not None, the URLs in the link text longer than this
|
|
limit will be truncated to trim_url_limit-3 characters and appended with
|
|
an ellipsis.
|
|
|
|
If nofollow is True, the links will get a rel="nofollow" attribute.
|
|
|
|
If autoescape is True, the link text and URLs will be autoescaped.
|
|
"""
|
|
safe_input = isinstance(text, SafeData)
|
|
|
|
def trim_url(x, limit=trim_url_limit):
|
|
if limit is None or len(x) <= limit:
|
|
return x
|
|
return '%s...' % x[:max(0, limit - 3)]
|
|
|
|
def unescape(text, trail):
|
|
"""
|
|
If input URL is HTML-escaped, unescape it so as we can safely feed it to
|
|
smart_urlquote. For example:
|
|
http://example.com?x=1&y=<2> => http://example.com?x=1&y=<2>
|
|
"""
|
|
unescaped = (text + trail).replace(
|
|
'&', '&').replace('<', '<').replace(
|
|
'>', '>').replace('"', '"').replace(''', "'")
|
|
if trail and unescaped.endswith(trail):
|
|
# Remove trail for unescaped if it was not consumed by unescape
|
|
unescaped = unescaped[:-len(trail)]
|
|
elif trail == ';':
|
|
# Trail was consumed by unescape (as end-of-entity marker), move it to text
|
|
text += trail
|
|
trail = ''
|
|
return text, unescaped, trail
|
|
|
|
def trim_punctuation(lead, middle, trail):
|
|
"""
|
|
Trim trailing and wrapping punctuation from `middle`. Return the items
|
|
of the new state.
|
|
"""
|
|
# Continue trimming until middle remains unchanged.
|
|
trimmed_something = True
|
|
while trimmed_something:
|
|
trimmed_something = False
|
|
|
|
# Trim trailing punctuation.
|
|
match = TRAILING_PUNCTUATION_RE.match(middle)
|
|
if match:
|
|
middle = match.group(1)
|
|
trail = match.group(2) + trail
|
|
trimmed_something = True
|
|
|
|
# Trim wrapping punctuation.
|
|
for opening, closing in WRAPPING_PUNCTUATION:
|
|
if middle.startswith(opening):
|
|
middle = middle[len(opening):]
|
|
lead += opening
|
|
trimmed_something = True
|
|
# Keep parentheses at the end only if they're balanced.
|
|
if (middle.endswith(closing) and
|
|
middle.count(closing) == middle.count(opening) + 1):
|
|
middle = middle[:-len(closing)]
|
|
trail = closing + trail
|
|
trimmed_something = True
|
|
return lead, middle, trail
|
|
|
|
words = word_split_re.split(force_text(text))
|
|
for i, word in enumerate(words):
|
|
if '.' in word or '@' in word or ':' in word:
|
|
# lead: Current punctuation trimmed from the beginning of the word.
|
|
# middle: Current state of the word.
|
|
# trail: Current punctuation trimmed from the end of the word.
|
|
lead, middle, trail = '', word, ''
|
|
# Deal with punctuation.
|
|
lead, middle, trail = trim_punctuation(lead, middle, trail)
|
|
|
|
# Make URL we want to point to.
|
|
url = None
|
|
nofollow_attr = ' rel="nofollow"' if nofollow else ''
|
|
if simple_url_re.match(middle):
|
|
middle, middle_unescaped, trail = unescape(middle, trail)
|
|
url = smart_urlquote(middle_unescaped)
|
|
elif simple_url_2_re.match(middle):
|
|
middle, middle_unescaped, trail = unescape(middle, trail)
|
|
url = smart_urlquote('http://%s' % middle_unescaped)
|
|
elif ':' not in middle and simple_email_re.match(middle):
|
|
local, domain = middle.rsplit('@', 1)
|
|
try:
|
|
domain = domain.encode('idna').decode('ascii')
|
|
except UnicodeError:
|
|
continue
|
|
url = 'mailto:%s@%s' % (local, domain)
|
|
nofollow_attr = ''
|
|
|
|
# Make link.
|
|
if url:
|
|
trimmed = trim_url(middle)
|
|
if autoescape and not safe_input:
|
|
lead, trail = escape(lead), escape(trail)
|
|
trimmed = escape(trimmed)
|
|
middle = '<a href="%s"%s>%s</a>' % (escape(url), nofollow_attr, trimmed)
|
|
words[i] = mark_safe('%s%s%s' % (lead, middle, trail))
|
|
else:
|
|
if safe_input:
|
|
words[i] = mark_safe(word)
|
|
elif autoescape:
|
|
words[i] = escape(word)
|
|
elif safe_input:
|
|
words[i] = mark_safe(word)
|
|
elif autoescape:
|
|
words[i] = escape(word)
|
|
return ''.join(words)
|
|
|
|
|
|
def avoid_wrapping(value):
|
|
"""
|
|
Avoid text wrapping in the middle of a phrase by adding non-breaking
|
|
spaces where there previously were normal spaces.
|
|
"""
|
|
return value.replace(" ", "\xa0")
|
|
|
|
|
|
def html_safe(klass):
|
|
"""
|
|
A decorator that defines the __html__ method. This helps non-Django
|
|
templates to detect classes whose __str__ methods return SafeText.
|
|
"""
|
|
if '__html__' in klass.__dict__:
|
|
raise ValueError(
|
|
"can't apply @html_safe to %s because it defines "
|
|
"__html__()." % klass.__name__
|
|
)
|
|
if '__str__' not in klass.__dict__:
|
|
raise ValueError(
|
|
"can't apply @html_safe to %s because it doesn't "
|
|
"define __str__()." % klass.__name__
|
|
)
|
|
klass_str = klass.__str__
|
|
klass.__str__ = lambda self: mark_safe(klass_str(self))
|
|
klass.__html__ = lambda self: str(self)
|
|
return klass
|