270 lines
9.2 KiB
Python
270 lines
9.2 KiB
Python
import re
|
|
from django.conf import settings
|
|
from django.utils.encoding import force_unicode
|
|
from django.utils.functional import allow_lazy
|
|
from django.utils.translation import ugettext_lazy
|
|
from htmlentitydefs import name2codepoint
|
|
|
|
# Capitalizes the first letter of a string.
|
|
capfirst = lambda x: x and force_unicode(x)[0].upper() + force_unicode(x)[1:]
|
|
capfirst = allow_lazy(capfirst, unicode)
|
|
|
|
def wrap(text, width):
|
|
"""
|
|
A word-wrap function that preserves existing line breaks and most spaces in
|
|
the text. Expects that existing line breaks are posix newlines.
|
|
"""
|
|
text = force_unicode(text)
|
|
def _generator():
|
|
it = iter(text.split(' '))
|
|
word = it.next()
|
|
yield word
|
|
pos = len(word) - word.rfind('\n') - 1
|
|
for word in it:
|
|
if "\n" in word:
|
|
lines = word.split('\n')
|
|
else:
|
|
lines = (word,)
|
|
pos += len(lines[0]) + 1
|
|
if pos > width:
|
|
yield '\n'
|
|
pos = len(lines[-1])
|
|
else:
|
|
yield ' '
|
|
if len(lines) > 1:
|
|
pos = len(lines[-1])
|
|
yield word
|
|
return u''.join(_generator())
|
|
wrap = allow_lazy(wrap, unicode)
|
|
|
|
def truncate_words(s, num):
|
|
"Truncates a string after a certain number of words."
|
|
s = force_unicode(s)
|
|
length = int(num)
|
|
words = s.split()
|
|
if len(words) > length:
|
|
words = words[:length]
|
|
if not words[-1].endswith('...'):
|
|
words.append('...')
|
|
return u' '.join(words)
|
|
truncate_words = allow_lazy(truncate_words, unicode)
|
|
|
|
def truncate_html_words(s, num):
|
|
"""
|
|
Truncates html to a certain number of words (not counting tags and
|
|
comments). Closes opened tags if they were correctly closed in the given
|
|
html.
|
|
"""
|
|
s = force_unicode(s)
|
|
length = int(num)
|
|
if length <= 0:
|
|
return u''
|
|
html4_singlets = ('br', 'col', 'link', 'base', 'img', 'param', 'area', 'hr', 'input')
|
|
# Set up regular expressions
|
|
re_words = re.compile(r'&.*?;|<.*?>|(\w[\w-]*)', re.U)
|
|
re_tag = re.compile(r'<(/)?([^ ]+?)(?: (/)| .*?)?>')
|
|
# Count non-HTML words and keep note of open tags
|
|
pos = 0
|
|
ellipsis_pos = 0
|
|
words = 0
|
|
open_tags = []
|
|
while words <= length:
|
|
m = re_words.search(s, pos)
|
|
if not m:
|
|
# Checked through whole string
|
|
break
|
|
pos = m.end(0)
|
|
if m.group(1):
|
|
# It's an actual non-HTML word
|
|
words += 1
|
|
if words == length:
|
|
ellipsis_pos = pos
|
|
continue
|
|
# Check for tag
|
|
tag = re_tag.match(m.group(0))
|
|
if not tag or ellipsis_pos:
|
|
# Don't worry about non tags or tags after our truncate point
|
|
continue
|
|
closing_tag, tagname, self_closing = tag.groups()
|
|
tagname = tagname.lower() # Element names are always case-insensitive
|
|
if self_closing or tagname in html4_singlets:
|
|
pass
|
|
elif closing_tag:
|
|
# Check for match in open tags list
|
|
try:
|
|
i = open_tags.index(tagname)
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
# SGML: An end tag closes, back to the matching start tag, all unclosed intervening start tags with omitted end tags
|
|
open_tags = open_tags[i+1:]
|
|
else:
|
|
# Add it to the start of the open tags list
|
|
open_tags.insert(0, tagname)
|
|
if words <= length:
|
|
# Don't try to close tags if we don't need to truncate
|
|
return s
|
|
out = s[:ellipsis_pos] + ' ...'
|
|
# Close any tags still open
|
|
for tag in open_tags:
|
|
out += '</%s>' % tag
|
|
# Return string
|
|
return out
|
|
truncate_html_words = allow_lazy(truncate_html_words, unicode)
|
|
|
|
def get_valid_filename(s):
|
|
"""
|
|
Returns the given string converted to a string that can be used for a clean
|
|
filename. Specifically, leading and trailing spaces are removed; other
|
|
spaces are converted to underscores; and anything that is not a unicode
|
|
alphanumeric, dash, underscore, or dot, is removed.
|
|
>>> get_valid_filename("john's portrait in 2004.jpg")
|
|
u'johns_portrait_in_2004.jpg'
|
|
"""
|
|
s = force_unicode(s).strip().replace(' ', '_')
|
|
return re.sub(r'(?u)[^-\w.]', '', s)
|
|
get_valid_filename = allow_lazy(get_valid_filename, unicode)
|
|
|
|
def get_text_list(list_, last_word=ugettext_lazy(u'or')):
|
|
"""
|
|
>>> get_text_list(['a', 'b', 'c', 'd'])
|
|
u'a, b, c or d'
|
|
>>> get_text_list(['a', 'b', 'c'], 'and')
|
|
u'a, b and c'
|
|
>>> get_text_list(['a', 'b'], 'and')
|
|
u'a and b'
|
|
>>> get_text_list(['a'])
|
|
u'a'
|
|
>>> get_text_list([])
|
|
u''
|
|
"""
|
|
if len(list_) == 0: return u''
|
|
if len(list_) == 1: return force_unicode(list_[0])
|
|
return u'%s %s %s' % (', '.join([force_unicode(i) for i in list_][:-1]), force_unicode(last_word), force_unicode(list_[-1]))
|
|
get_text_list = allow_lazy(get_text_list, unicode)
|
|
|
|
def normalize_newlines(text):
|
|
return force_unicode(re.sub(r'\r\n|\r|\n', '\n', text))
|
|
normalize_newlines = allow_lazy(normalize_newlines, unicode)
|
|
|
|
def recapitalize(text):
|
|
"Recapitalizes text, placing caps after end-of-sentence punctuation."
|
|
text = force_unicode(text).lower()
|
|
capsRE = re.compile(r'(?:^|(?<=[\.\?\!] ))([a-z])')
|
|
text = capsRE.sub(lambda x: x.group(1).upper(), text)
|
|
return text
|
|
recapitalize = allow_lazy(recapitalize)
|
|
|
|
def phone2numeric(phone):
|
|
"Converts a phone number with letters into its numeric equivalent."
|
|
letters = re.compile(r'[A-PR-Y]', re.I)
|
|
char2number = lambda m: {'a': '2', 'c': '2', 'b': '2', 'e': '3',
|
|
'd': '3', 'g': '4', 'f': '3', 'i': '4', 'h': '4', 'k': '5',
|
|
'j': '5', 'm': '6', 'l': '5', 'o': '6', 'n': '6', 'p': '7',
|
|
's': '7', 'r': '7', 'u': '8', 't': '8', 'w': '9', 'v': '8',
|
|
'y': '9', 'x': '9'}.get(m.group(0).lower())
|
|
return letters.sub(char2number, phone)
|
|
phone2numeric = allow_lazy(phone2numeric)
|
|
|
|
# From http://www.xhaus.com/alan/python/httpcomp.html#gzip
|
|
# Used with permission.
|
|
def compress_string(s):
|
|
import cStringIO, gzip
|
|
zbuf = cStringIO.StringIO()
|
|
zfile = gzip.GzipFile(mode='wb', compresslevel=6, fileobj=zbuf)
|
|
zfile.write(s)
|
|
zfile.close()
|
|
return zbuf.getvalue()
|
|
|
|
ustring_re = re.compile(u"([\u0080-\uffff])")
|
|
|
|
def javascript_quote(s, quote_double_quotes=False):
|
|
|
|
def fix(match):
|
|
return r"\u%04x" % ord(match.group(1))
|
|
|
|
if type(s) == str:
|
|
s = s.decode('utf-8')
|
|
elif type(s) != unicode:
|
|
raise TypeError, s
|
|
s = s.replace('\\', '\\\\')
|
|
s = s.replace('\r', '\\r')
|
|
s = s.replace('\n', '\\n')
|
|
s = s.replace('\t', '\\t')
|
|
s = s.replace("'", "\\'")
|
|
if quote_double_quotes:
|
|
s = s.replace('"', '"')
|
|
return str(ustring_re.sub(fix, s))
|
|
javascript_quote = allow_lazy(javascript_quote, unicode)
|
|
|
|
# Expression to match some_token and some_token="with spaces" (and similarly
|
|
# for single-quoted strings).
|
|
smart_split_re = re.compile(r"""
|
|
([^\s"]*"(?:[^"\\]*(?:\\.[^"\\]*)*)"\S*|
|
|
[^\s']*'(?:[^'\\]*(?:\\.[^'\\]*)*)'\S*|
|
|
\S+)""", re.VERBOSE)
|
|
|
|
def smart_split(text):
|
|
r"""
|
|
Generator that splits a string by spaces, leaving quoted phrases together.
|
|
Supports both single and double quotes, and supports escaping quotes with
|
|
backslashes. In the output, strings will keep their initial and trailing
|
|
quote marks and escaped quotes will remain escaped (the results can then
|
|
be further processed with unescape_string_literal()).
|
|
|
|
>>> list(smart_split(r'This is "a person\'s" test.'))
|
|
[u'This', u'is', u'"a person\\\'s"', u'test.']
|
|
>>> list(smart_split(r"Another 'person\'s' test."))
|
|
[u'Another', u"'person\\'s'", u'test.']
|
|
>>> list(smart_split(r'A "\"funky\" style" test.'))
|
|
[u'A', u'"\\"funky\\" style"', u'test.']
|
|
"""
|
|
text = force_unicode(text)
|
|
for bit in smart_split_re.finditer(text):
|
|
yield bit.group(0)
|
|
smart_split = allow_lazy(smart_split, unicode)
|
|
|
|
def _replace_entity(match):
|
|
text = match.group(1)
|
|
if text[0] == u'#':
|
|
text = text[1:]
|
|
try:
|
|
if text[0] in u'xX':
|
|
c = int(text[1:], 16)
|
|
else:
|
|
c = int(text)
|
|
return unichr(c)
|
|
except ValueError:
|
|
return match.group(0)
|
|
else:
|
|
try:
|
|
return unichr(name2codepoint[text])
|
|
except (ValueError, KeyError):
|
|
return match.group(0)
|
|
|
|
_entity_re = re.compile(r"&(#?[xX]?(?:[0-9a-fA-F]+|\w{1,8}));")
|
|
|
|
def unescape_entities(text):
|
|
return _entity_re.sub(_replace_entity, text)
|
|
unescape_entities = allow_lazy(unescape_entities, unicode)
|
|
|
|
def unescape_string_literal(s):
|
|
r"""
|
|
Convert quoted string literals to unquoted strings with escaped quotes and
|
|
backslashes unquoted::
|
|
|
|
>>> unescape_string_literal('"abc"')
|
|
'abc'
|
|
>>> unescape_string_literal("'abc'")
|
|
'abc'
|
|
>>> unescape_string_literal('"a \"bc\""')
|
|
'a "bc"'
|
|
>>> unescape_string_literal("'\'ab\' c'")
|
|
"'ab' c"
|
|
"""
|
|
if s[0] not in "\"'" or s[-1] != s[0]:
|
|
raise ValueError("Not a string literal: %r" % s)
|
|
quote = s[0]
|
|
return s[1:-1].replace(r'\%s' % quote, quote).replace(r'\\', '\\')
|
|
unescape_string_literal = allow_lazy(unescape_string_literal)
|