def patchdjango(): patch('django.http.request.QueryDict.get', TAINT_SOURCE) patch('django.http.request.QueryDict.__getitem__', TAINT_SOURCE) patch('django.db.models.sql.compiler.SQLCompiler.patch', TAINT_SOURCE) patch( 'django.utils.html.escape', TAINT_SANITIZER, set([ contexts.HTML_TEXT, contexts.HTML_QUOT_ATTR, contexts.HTML_APOS_ATTR ])) patch( 'django.utils.html.escapejs', TAINT_SANITIZER, set([ contexts.HTML_JS_DATA, contexts.HTML_QUOT_JS, contexts.HTML_APOS_JS ])) patch( 'urllib.urlencode', TAINT_SANITIZER, set([ contexts.HTML_QUOT_URI, contexts.HTML_APOS_URI, contexts.CSS_QUOT_URI, contexts.CSS_APOS_URI ])) patch( 'django.utils.six.moves.urllib.parse.urlencode', TAINT_SANITIZER, set([ contexts.HTML_QUOT_URI, contexts.HTML_APOS_URI, contexts.CSS_QUOT_URI, contexts.CSS_APOS_URI ])) patch('django.utils.html.conditional_escape', TAINT_SINK) defaultfilters.register.filter(name='safe', filter_func=stringfilter(safe), is_safe=True) patch('django.template.debug.DebugVariableNode.render', TAINT_SINK) patch('django.core.handlers.base.BaseHandler.get_response', PARSER) patch('django.template.base.FilterExpression.resolve', RESOLVER) patch('django.template.base.VariableNode.render', TAINT_SINK)
'>': '>', '\\': (escape_highlight % '\\\\'), } try: return submap[match.group()] except KeyError: return html_highlight % match.group()[1:-1] return ESCAPE_RE.sub(replace, text) WHITESPACE_RE = re.compile('^ +| +$|[\r\n\t] +| {2,}') def fancy_spaces(text): """Highlight spaces to make them easily visible""" def replace(match): fancy_space = '<span class="translation-space"> </span>' if match.group().startswith(' '): return fancy_space * len(match.group()) return match.group()[0] + fancy_space * (len(match.group()) - 1) return WHITESPACE_RE.sub(replace, text) def clean_wrapper(text): """wrapper around lxml's html cleaner that returns SafeStrings for immediate rendering in templates""" return mark_safe(clean_html(text)) def fancy_highlight(text): return mark_safe(fancy_spaces(fancy_escape(text))) register = template.Library() register.filter('clean', stringfilter(clean_wrapper)) register.filter('fancy_highlight', stringfilter(fancy_highlight))
def truncate_chars(s, num): s = force_unicode(s) length = int(num) if len(s) > length: length = length - 3 s = s[:length].strip() s += '...' return s truncate_chars = allow_lazy(truncate_chars, unicode) @register.filter def truncatechars(value, arg): """ Truncates a string after a certain number of characters, but respects word boundaries. Argument: Number of characters to truncate after. """ try: length = int(arg) except ValueError: # If the argument is not a valid integer. return value # Fail silently. return truncate_chars(value, length) truncatechars.is_safe = True truncatechars = stringfilter(truncatechars) @register.filter(name='get_class') def get_class(value): return value.__class__.__name__
from localeurl import utils register = template.Library() def chlocale(url, locale): """ Changes the URL's locale prefix if the path is not locale-independent. Otherwise removes locale prefix. """ _, path = utils.strip_script_prefix(url) _, path = utils.strip_path(path) return utils.locale_url(path, locale) chlocale = stringfilter(chlocale) register.filter('chlocale', chlocale) def rmlocale(url): """Removes the locale prefix from the URL.""" script_prefix, path = utils.strip_script_prefix(url) _, path = utils.strip_path(path) return ''.join([script_prefix, path]) rmlocale = stringfilter(rmlocale) register.filter('rmlocale', rmlocale) def locale_url(parser, token):
from django import template from django.template.defaultfilters import stringfilter from film20.oembed.core import replace register = template.Library() def oembed(input): return replace(input) oembed.is_safe = True oembed = stringfilter(oembed) register.filter('oembed', oembed) def do_oembed(parser, token): """ A node which parses everything between its two nodes, and replaces any links with OEmbed-provided objects, if possible. Supports one optional argument, which is the maximum width and height, specified like so: {% oembed 640x480 %}http://www.viddler.com/explore/SYSTM/videos/49/{% endoembed %} """ args = token.contents.split() if len(args) > 2: raise template.TemplateSyntaxError("Oembed tag takes only one (option" \ "al) argument: WIDTHxHEIGHT, where WIDTH and HEIGHT are positive " \ "integers.") if len(args) == 2: width, height = args[1].lower().split('x') if not width and height:
) def remove_js_events(match): return "".join(( match.group(1), re_attrs.sub('', match.group(2)), match.group(3), )) html = re_comments.sub("", html) html = re_tags.sub(remove_js_events, html) if "</a>" not in html: html = defaultfilters.urlizetrunc(html, "30") if "</p>" not in html: html = defaultfilters.linebreaks(html) html = defaultfilters.safe(html) return html disarm_user_input = defaultfilters.stringfilter(disarm_user_input) register.filter('disarm_user_input', disarm_user_input, is_safe=True) def humanize_url(url, letter_count): letter_count = int(letter_count) re_start = re.compile(r'^https?://') re_end = re.compile(r'/$') url = re_end.sub("", re_start.sub("", url)) if len(url) > letter_count: url = url[:letter_count - 1] + u"…" return url register.filter('humanize_url', humanize_url) def truncated_multiply(value, arg): """ Multiplies the arg with the value and returns
''' Created on 2011-11-20 @author: liwenjian ''' from django import template from django.template.defaultfilters import stringfilter register = template.Library() @register.filter def truncatestring(value, arg): try: length = int(arg) except ValueError: return value if len(value) < length: return value else: return value[0:length] + '...' truncatestring.is_safe = True truncatestring = stringfilter(truncatestring)
else: result = identifier return mark_safe(result) register.filter("link_if_url", link_if_url) def replaceunderscore(value): """ Replaces underscore with spaces """ return mark_safe(re.sub("_", " ", value)) slugify = stringfilter(replaceunderscore) register.filter("replaceunderscore", replaceunderscore, is_safe=True) 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 _lines(text): for index in range(0, len(text), width): yield text[index : index + width] + "\n" return u"".join(_lines(text))
For example:: {{ value|urlize_hashtags }} If value is "This is a #test.", the output will be "This is a <a href="[reversed url for hashtagged_item_list(request, hashtag='test')]">#test</a>.". Note that if ``urlize_hashtags`` is applied to text that already contains HTML markup, things won't work as expected. Prefer apply this filter to plain text. """ from hashtags.utils import urlize_hashtags return mark_safe(urlize_hashtags(value)) urlize_hashtags.is_safe = True urlize_hashtags = stringfilter(urlize_hashtags) def urlize_and_track_hashtags(value, object_to_track): """ Works like ``urlize_hashtags`` but you can pass a object parameter to link/relate hashtags on text with the object in question. Usage example:: {{ value|urlize_and_track_hashtags:object_to_track }} Real world example:: {{ flatpage.content|urlize_and_track_hashtags:flatpage }} **Important**: ``urlize_and_track_hashtags`` doesn't works property if your
('<', r'\u003C'), ('&', r'\u0026'), ('=', r'\u003D'), ('-', r'\u002D'), (';', r'\u003B'), (u'\u2013', r'\u2013'), (u'\u2014', r'\u2014'), (u'\u2019', r'\u2019'), (u'\u201c', r'\u201c'), (u'\u201d', r'\u201d'), (u'\u2028', r'\u2028'), (u'\u2029', r'\u2029'), (u'\xbd', r'\xbd') ) # Escape every ASCII character with a value less than 32. _js_escapes = (_base_js_escapes + tuple([('%c' % z, '\\u%04X' % z) for z in range(32)])) def escapejs(value): """ Replaces Django's built-in escaping function with one that actually works. Take from "Changeset 12781":http://code.djangoproject.com/changeset/12781 """ for bad, good in _js_escapes: value = value.replace(bad, good) return value escapejs = stringfilter(escapejs) register.filter(escapejs)
ordering = ('slug',) verbose_name = _(u'Tag') verbose_name_plural = _(u'Tags') versioning.register(Tag) def slugify(value): # normalize unicode import unicodedata value = unicodedata.normalize('NFKD', unicode(value)) # remove non-word characters misc_characters = re.compile(('[^\w]'), re.UNICODE) value = re.sub(misc_characters, '', value) return value.lower() slugify = stringfilter(slugify) class PageTagSet(models.Model): page = models.OneToOneField('pages.Page') tags = models.ManyToManyField(Tag) region = models.ForeignKey(Region, null=True) objects = models.GeoManager() def __unicode__(self): return ', '.join(map(unicode, self.tags.all())) class Meta: ordering = ('page__slug',)
truncd_val = value[:max_length] truncd_val = truncd_val.rstrip() return truncd_val + "..." return value except: return "" def stripentities(value): """Strips all HTML entities""" from django.utils.html import strip_entities return strip_entities(value) stripentities.is_safe = True stripentities = stringfilter(stripentities) register.filter(stripentities) @register.filter def friendly_date(date, include_time=False): """ Prints a human friendly date. """ delta = datetime.now() - date if delta < timedelta(seconds=60): msg = _("Just now") elif delta < timedelta(seconds=60 * 60): minutes = delta.seconds / 60 msg = ngettext('%(minutes)s minute ago', '%(minutes)s min ago',
# Copyright 2008-2012 Zuza Software Foundation # # This file is part of Pootle. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see <http://www.gnu.org/licenses/>. from django import template from django.template.defaultfilters import stringfilter from pootle_misc.baseurl import l, m, s, abs_l, get_next register = template.Library() register.filter('l', stringfilter(l)) register.filter('m', stringfilter(m)) register.filter('s', stringfilter(s)) register.filter('abs_l', stringfilter(abs_l)) register.filter('get_next', get_next)
if len(lines) > 1: pos = len(lines[-1]) yield word return u''.join(_generator()) def smartwordwrap(value, arg): """ Wraps words at specified line length. Argument: number of characters to wrap the text at. """ return wrap(value, int(arg)) smartwordwrap.is_safe = True smartwordwrap = stringfilter(smartwordwrap) register.filter(smartwordwrap) @register.filter def trunc( string, number, dots='...'): """ truncate the {string} to {number} characters print {dots} on the end if truncated usage: {{ "some text to be truncated"|trunc:6 }} results: some te... """ if not isinstance(string, str): string = str(string) if len(string) <= number: return string return string[0:number]+dots
from django import template from django.template.defaultfilters import stringfilter register = template.Library() def trim(value, num): return value[:num] trim = stringfilter(trim) register.filter(trim) @register.simple_tag def no_params(): """Expected no_params __doc__""" return "no_params - Expected result" no_params.anything = "Expected no_params __dict__" @register.simple_tag def one_param(arg): """Expected one_param __doc__""" return "one_param - Expected result: %s" % arg one_param.anything = "Expected one_param __dict__" @register.simple_tag(takes_context=False) def explicit_no_context(arg): """Expected explicit_no_context __doc__""" return "explicit_no_context - Expected result: %s" % arg explicit_no_context.anything = "Expected explicit_no_context __dict__" @register.simple_tag(takes_context=True) def no_params_with_context(context):
from django import template from django.utils.safestring import mark_safe from django.template.defaultfilters import stringfilter from django.utils.text import normalize_newlines register = template.Library() @register.filter(is_safe=True) def remove_newlines(text): """ Removes all newline characters from a block of text. """ # First normalize the newlines using Django's nifty utility normalized_text = normalize_newlines(text) # Then simply remove the newlines like so. return mark_safe(normalized_text.replace('\n', ' ')) remove_newlines = stringfilter(remove_newlines) register.filter(remove_newlines)
from pygments import highlight as hl from pygments.lexers import PythonLexer, PythonConsoleLexer, BashSessionLexer, HtmlDjangoLexer from pygments.formatters import HtmlFormatter from xml.sax.saxutils import unescape register = template.Library() @register.filter def highlight(value): """ Highlight the python code with pygments""" soup = BeautifulSoup(value) prespy = soup.findAll('pre', lang="python") prespyco = soup.findAll('pre', lang="python_console") presbs = soup.findAll('pre', lang="bash") presht = soup.findAll('pre', lang="html") for pre in prespy: pre.replaceWith(hl(unescape(pre.string), PythonLexer(), HtmlFormatter())) for pre in prespyco: pre.replaceWith(hl(unescape(pre.string), PythonConsoleLexer(), HtmlFormatter())) for pre in presbs: pre.replaceWith(hl(unescape(pre.string), BashSessionLexer(), HtmlFormatter())) for pre in presht: pre.replaceWith(hl(unescape(pre.string), HtmlDjangoLexer(), HtmlFormatter())) return soup highlight.is_safe = True highlight = stringfilter(highlight)
yield word return u''.join(_generator()) def smartwordwrap(value, arg): """ Wraps words at specified line length. Argument: number of characters to wrap the text at. """ return wrap(value, int(arg)) smartwordwrap.is_safe = True smartwordwrap = stringfilter(smartwordwrap) register.filter(smartwordwrap) @register.filter def trunc(string, number, dots='...'): """ truncate the {string} to {number} characters print {dots} on the end if truncated usage: {{ "some text to be truncated"|trunc:6 }} results: some te... """ if not isinstance(string, str): string = str(string) if len(string) <= number: return string
# normalize unicode import unicodedata value = unicodedata.normalize("NFKD", unicode(value)) # remove non-{word,space,keep} characters misc_characters = re.compile(("[^\w\s%s]" % keep), re.UNICODE) value = re.sub(misc_characters, "", value) value = value.strip() value = re.sub("[_\s]+", " ", value) return value.lower() slugify = stringfilter(slugify) def name_to_url(value): """Converts page name to its canonical URL path """ # spaces to underscore value = re.sub("[\s]", "_", value.strip()) # url-encode value = quote(value.encode("utf-8")) return mark_safe(value) name_to_url.is_safe = True name_to_url = stringfilter(name_to_url)
url = GRAVATAR_URL % gravatargs if "as" in self.other_kwargs: context[self.other_kwargs["as"]] = mark_safe(url) return "" return url def gravatar(email): """ Takes an e-mail address and returns a gravatar image URL, using properties from the django settings file. """ hashed_email = md5.new(email).hexdigest() return mark_safe( GRAVATAR_URL % { "hash": hashed_email, "rating": GRAVATAR_MAX_RATING, "size": GRAVATAR_SIZE, "default": urllib.quote_plus(GRAVATAR_DEFAULT_IMG), } ) gravatar = stringfilter(gravatar) register = template.Library() register.filter("gravatar", gravatar) register.tag("get_gravatar_url", get_gravatar_url)
"""Converts URLs in html into clickable links.""" from BeautifulSoup import BeautifulSoup ignored_tags = ['a', 'code', 'pre'] soup = BeautifulSoup(value) tags = soup.findAll(True) text_all = soup.contents for text in text_all: if text not in tags: parsed_text = urlize(text, nofollow=True, autoescape=autoescape) text.replaceWith(parsed_text) for tag in tags: if not tag.name in ignored_tags: soup_text = BeautifulSoup(str(tag)) if len(soup_text.findAll()) > 1: for child_tag in tag.contents: child_tag.replaceWith(html_urlize(str(child_tag))) elif len(soup_text.findAll()) > 0: text_list = soup_text.findAll(text=True) for text in text_list: parsed_text = urlize(text, nofollow=True, autoescape=autoescape) text.replaceWith(parsed_text) try: tag.replaceWith(str(soup_text)) except: pass return mark_safe(str(soup)) html_urlize.is_safe = True html_urlize.needs_autoescape = True html_urlize = stringfilter(html_urlize) register.filter(html_urlize)
#:coding=utf-8: from django import template from django.template.defaultfilters import stringfilter from django.utils.text import normalize_newlines register = template.Library() def replace_newlines(text, replacement=' '): """ Replaces all newline characters in a block of text. """ normalized_text = normalize_newlines(text) return normalized_text.replace('\n', replacement) replace_newlines.is_safe = True replace_newlines = stringfilter(replace_newlines) register.filter(replace_newlines)
from django.template import Library, Node from django.template.defaultfilters import stringfilter import re register = Library() def list_items(value): """ Turns paragraphs delineated with newline characters into list items wrapped in <li> and </li> HTML tags. """ items = re.split(r'[\r\n]+', value) items = ['<li>%s</li>' % p.strip() for p in items] return '\n'.join(items) paragraphs = stringfilter(list_items) register.filter(paragraphs)
string = re.sub("(?<!>)(BCP ?)0{0,3}(\d+)", "<a href=\"/doc/bcp\\2/\">\\1\\2</a>", string) string = re.sub("(?<!>)(STD ?)0{0,3}(\d+)", "<a href=\"/doc/std\\2/\">\\1\\2</a>", string) string = re.sub("(?<!>)(FYI ?)0{0,3}(\d+)", "<a href=\"/doc/fyi\\2/\">\\1\\2</a>", string) string = re.sub("(?<!>)(draft-[-0-9a-zA-Z._+]+)", "<a href=\"/doc/\\1/\">\\1</a>", string) string = re.sub("(?<!>)(conflict-review-[-0-9a-zA-Z._+]+)", "<a href=\"/doc/\\1/\">\\1</a>", string) string = re.sub("(?<!>)(status-change-[-0-9a-zA-Z._+]+)", "<a href=\"/doc/\\1/\">\\1</a>", string) return mark_safe(string) urlize_ietf_docs = stringfilter(urlize_ietf_docs) @register.filter(name='dashify') def dashify(string): """ Replace each character in string with '-', to produce an underline effect for plain text files. """ return re.sub('.', '-', string) @register.filter def underline(string): """Return string with an extra line underneath of dashes, for plain text underlining.""" return string + "\n" + ("-" * len(string))
for ul_tag in soup.find_all("ul"): for li_tag in ul_tag.find_all("li"): # li_tag.smooth() li_tag.insert_before(f"* ") li_tag.unwrap() ul_tag.unwrap() for blockquote_tag in soup.find_all("blockquote"): quote_text = re.sub(r"\n*</?blockquote>\n?", "", blockquote_tag.decode(formatter=None)) quote_text = re.sub(r"\n", "\n>", quote_text) quote_text = "\n>" + quote_text + "\n" blockquote_tag.replace_with(quote_text) for pre_tag in soup.find_all("pre"): pre_tag.insert_before("```\n") pre_tag.insert_after("```\n") pre_tag.unwrap() output = soup.decode(formatter=None) output = re.sub(r"\n\n+", "\n\n", output) if len(links) > 0: output += "\n## Links\n\n" for link in links: output += f"=>{link[0]} {link[1]}\n" return output register = template.Library() register.filter("markdown", stringfilter(smartypants_markdown)) register.filter("gemtext", stringfilter(gemtext))
#!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright 2008-2014 Zuza Software Foundation # # This file is part of Pootle. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see <http://www.gnu.org/licenses/>. from django import template from django.template.defaultfilters import stringfilter from pootle_misc.baseurl import s, get_next register = template.Library() register.filter('s', stringfilter(s)) register.filter('get_next', get_next)
unique_words.sort() return unique_words def slugify(value): """ Normalizes string, converts to lowercase, removes non-alpha chars and converts spaces to hyphens. """ import unicodedata value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore') value = unicode(re.sub('[^\w\s\-\+]', '', value).strip().lower()) return re.sub('[\-\+\s]+', '-', value) slugify = stringfilter(slugify) def slugify_uniquely(model, value): """ Generate a unique slug. Based on: http://code.djangoproject.com/wiki/SlugifyUniquely """ suffix = 0 potential = base = slugify(value) while True: if suffix: potential = "-".join([base, str(suffix)]) if not model.objects.filter(slug=potential).count(): return potential
# -*- coding: utf-8 -*- from django import template from django.template.defaultfilters import stringfilter from djangoutils.core import helpers register = template.Library() truncate = register.filter(stringfilter(helpers.truncate))
{{ value|urlize_hashtags }} If value is "This is a #test.", the output will be "This is a <a href="[reversed url for hashtagged_item_list(request, hashtag='test')]">#test</a>.". Note that if ``urlize_hashtags`` is applied to text that already contains HTML markup, things won't work as expected. Prefer apply this filter to plain text. """ from hashtags.utils import urlize_hashtags return mark_safe(urlize_hashtags(value, formatted_url)) urlize_hashtags.is_safe = True urlize_hashtags = stringfilter(urlize_hashtags) def urlize_and_track_hashtags(value, object_to_track): """ Works like ``urlize_hashtags`` but you can pass a object parameter to link/relate hashtags on text with the object in question. Usage example:: {{ value|urlize_and_track_hashtags:object_to_track }} Real world example:: {{ flatpage.content|urlize_and_track_hashtags:flatpage }}
#:coding=utf-8: from django.template import Library from django.template.defaultfilters import stringfilter from django.utils.safestring import mark_safe register = Library() def stripentities(value): """Strips all HTML entities""" from django.utils.html import strip_entities return strip_entities(value) stripentities.is_safe = True stripentities = stringfilter(stripentities) register.filter(stripentities) @register.filter def to_anchor(text, autoescape=None): from beproud.utils.html import urlize return mark_safe(urlize(text, attrs={"rel": "nofollow", "target": "_blank"}, autoescape=autoescape)) to_anchor.is_safe=True to_anchor.needs_autoescape = True to_anchor = stringfilter(to_anchor) @register.filter def to_anchortrunc(text, limit, autoescape=None): from beproud.utils.html import urlize return mark_safe(urlize(text, attrs={"rel": "nofollow", "target": "_blank"}, trim_url_limit=limit, autoescape=autoescape)) to_anchortrunc.is_safe=True to_anchortrunc.needs_autoescape = True
@register.filter @stringfilter def abbreviate_fqdn(value): return value.split(".")[0] @register.filter @stringfilter def render_os(os): try: t, flavor = os.split("+", 1) flavor = " ".join(i.capitalize() for i in flavor.split("-")) return mark_safe("%s (<em>%s</em>)" % (flavor, t)) except ValueError: return mark_safe(_("<em>Unknown or invalid OS</em>")) @register.filter def mult(value, arg): # pinched from http://code.djangoproject.com/ticket/361 return int(value) * int(arg) register.filter("hv", stringfilter(hv_prettify)) @register.filter def hvs(l): return [hv_prettify(i) for i in l]
#!/usr/bin/env python # -*- coding: utf-8 -*- from django import template from django.template.defaultfilters import stringfilter register = template.Library() def iso_flag(iso, flag_path=u""): """ Returns a full path to the ISO 3166-1 alpha-2 country code flag image. Example usage:: {{ user_profile.country.iso|iso_flag }} {{ user_profile.country.iso|iso_flag:"appmedia/flags/%s.png" }} """ from countries.utils.isoflag import iso_flag return iso_flag(iso, flag_path) iso_flag = stringfilter(iso_flag) # Syntax: register.filter(name of filter, callback) register.filter("iso_flag", iso_flag)
from django import template from django.utils.safestring import mark_safe from django.template.defaultfilters import stringfilter register = template.Library() @register.filter(is_safe=True) def add_break(text): """ Add an extra break (\n) between paragraphs. Useful for additional formatting after markdown/striptags """ return mark_safe(text.replace('\n', '\n\n')) add_break = stringfilter(add_break) register.filter(add_break)
Replaces True with true and False with false, so I can print JavaScript. """ if bool == True: return 'true' elif bool == False: return 'false' elif bool == None: return 'null' else: return '' truthjs.is_safe = True register.filter(truthjs) def trim_p(html, count=2): """ Trims a html block to the requested number of paragraphs """ grafs = [i.end() for i in re.finditer("</p>", html)] if len(grafs) < count: return html else: end = grafs[count - 1] return html[:end] trim_p = stringfilter(trim_p) register.filter(trim_p)
pee = re.sub(r'<br />(\s*</?(?:p|li|div|dl|dd|dt|th|pre|td|ul|ol)[^>]*>)', lambda m: m.group(1) if m.group(1) else "", pee) if (pee.find('<pre') != -1): def clean_pre(m): if m.group(1) and m.group(2): text = m.group(2) text = text.replace('<br />', '') text = text.replace('<p>', "\n") text = text.replace('</p>', '') text = m.group(1)+escape(text)+"</pre>" else: text = m.group(0) text = text.replace('<br />', '') text = text.replace('<p>', "\n") text = text.replace('</p>', '') return text pee = re.sub('(?is)(<pre[^>]*>)(.*?)</pre>', clean_pre, pee) pee = re.sub( r"\n</p>$", '</p>', pee) return pee linebreaks_wp = allow_lazy(linebreaks_wp, unicode) @register.filter("linebreaks_wp") @stringfilter def linebreaks_wp_filter(value, autoescape=None): """Straight up port of http://codex.wordpress.org/Function_Reference/wpautop""" autoescape = autoescape and not isinstance(value, SafeData) return mark_safe(linebreaks_wp(value, autoescape)) linebreaks_wp_filter.is_safe = True linebreaks_wp_filter.needs_autoescape = True linebreaks_wp = stringfilter(linebreaks_wp)
length = length - 3 if s[length - 1] == ' ' or s[length] == ' ': s = s[:length].strip() else: words = s[:length].split() if len(words) > 1: del words[-1] s = u' '.join(words) s += '...' return s truncate_chars = allow_lazy(truncate_chars, unicode) def truncatechars(value, arg): """ Truncates a string after a certain number of characters, but respects word boundaries. Argument: Number of characters to truncate after. """ try: length = int(arg) except ValueError: # Fail silently if the argument is not a valid integer. return value return truncate_chars(value, length) truncatechars.is_safe = True truncatechars = stringfilter(truncatechars) register.filter(truncatechars)
bracket_end = marker_end % marker start = rendered.find(bracket_start) if not start == -1: start = start + len(bracket_start) end = rendered.find(bracket_end, start) return rendered[start:end] return "" def hyde_thumbnail(url): postfix = getattr(settings, 'THUMBNAIL_FILENAME_POSTFIX', '-thumb') path, ext = url.rsplit('.', 1) return ''.join([path, postfix, '.', ext]) register.filter(stringfilter(hyde_thumbnail)) @register.filter def value_for_key(dictionary, key): if not dictionary: return "" if not dictionary.has_key(key): return "" value = dictionary[key] return value @register.filter def xmldatetime(dt): if not dt:
string = re.sub("(?<!>)(STD ?)0{0,3}(\d+)", "<a href=\"/doc/std\\2/\">\\1\\2</a>", string) string = re.sub("(?<!>)(FYI ?)0{0,3}(\d+)", "<a href=\"/doc/fyi\\2/\">\\1\\2</a>", string) string = re.sub("(?<!>)(draft-[-0-9a-zA-Z._+]+)", "<a href=\"/doc/\\1/\">\\1</a>", string) string = re.sub("(?<!>)(conflict-review-[-0-9a-zA-Z._+]+)", "<a href=\"/doc/\\1/\">\\1</a>", string) string = re.sub("(?<!>)(status-change-[-0-9a-zA-Z._+]+)", "<a href=\"/doc/\\1/\">\\1</a>", string) return mark_safe(string) urlize_ietf_docs.is_safe = True urlize_ietf_docs.needs_autoescape = True urlize_ietf_docs = stringfilter(urlize_ietf_docs) @register.filter(name='dashify') def dashify(string): """ Replace each character in string with '-', to produce an underline effect for plain text files. """ return re.sub('.', '-', string) @register.filter def underline(string): """Return string with an extra line underneath of dashes, for plain text underlining.""" return string + "\n" + ("-" * len(string))
from django import template from django.template.defaultfilters import stringfilter register = template.Library() def trim(value, num): return value[:num] trim = stringfilter(trim) register.filter(trim)
import re from django.template import Library from django.template.defaultfilters import stringfilter register = Library() TAG_RE = re.compile(r'<[^>]+>') def remove_tags(value): """ Removes all HTML tags from text. """ TAG_RE = re.compile(r'<[^>]+>') return TAG_RE.sub('', value) remove_tags = stringfilter(remove_tags) register.filter(remove_tags)
from django import template from django.conf import settings from django.contrib.contenttypes.models import ContentType from django.core.exceptions import MultipleObjectsReturned, ObjectDoesNotExist from django.core.urlresolvers import reverse from django.template.defaultfilters import stringfilter from django.utils.safestring import mark_safe from django.utils.text import capfirst from django.utils.translation import ugettext as _, get_language import atlcore.settings as atlsettings register = template.Library() def lang_flag_url(name): media_url = atlsettings.MEDIA_URL name = name.lower().strip() return u'/static/common/flags/languages/%s.gif' %name[:2] lang_flag_url = stringfilter(lang_flag_url) register.filter('lang_flag_url', lang_flag_url)
'size': size, 'default': urllib.quote_plus(default), } url = GRAVATAR_URL % gravatargs if 'as' in self.other_kwargs: context[self.other_kwargs['as']] = mark_safe(url) return '' return url def gravatar(email): """ Takes an e-mail address and returns a gravatar image URL, using properties from the django settings file. """ hashed_email = md5_constructor(email).hexdigest() return mark_safe( GRAVATAR_URL % { 'hash': hashed_email, 'rating': GRAVATAR_MAX_RATING, 'size': GRAVATAR_SIZE, 'default': urllib.quote_plus(GRAVATAR_DEFAULT_IMG), }) gravatar = stringfilter(gravatar) register = template.Library() register.filter('gravatar', gravatar) register.tag('get_gravatar_url', get_gravatar_url)
def hardwrap(value, line_length): val_len = len(value) if val_len > line_length: offset = val_len % line_length # loop backwards so as not to get tripped up by the changing string length for i in range(0, val_len, line_length): pos = val_len - i - offset if pos > 0: value = value[:pos] + "\n" + value[pos:] return value hardwrap.is_safe = True # splits string into a list of strings @register.filter("split") def split(value, sep=None): return value.split(sep) split.is_safe = True """ for flowplayer... it seems to take the safe output of escapejs and unescape it, thus stuffing itself up. this removes problem chars instead of escaping them """ @register.filter("makesafe_for_js") def makesafe_for_js(value): for bad, good in _js_escapes: value = value.replace(bad, '') return value makesafe_for_js = stringfilter(makesafe_for_js)
register = template.Library() def chlocale(url, locale): """ Changes the URL's locale prefix if the path is not locale-independent. Otherwise removes locale prefix. """ _, path = utils.strip_script_prefix(url) _, path = utils.strip_path(path) return utils.locale_url(path, locale) chlocale = stringfilter(chlocale) register.filter('chlocale', chlocale) def rmlocale(url): """Removes the locale prefix from the URL.""" script_prefix, path = utils.strip_script_prefix(url) _, path = utils.strip_path(path) return ''.join([script_prefix, path]) rmlocale = stringfilter(rmlocale) register.filter('rmlocale', rmlocale)
unique_words.sort() return unique_words def slugify(value): """ Normalizes string, converts to lowercase, removes non-alpha chars and converts spaces to hyphens. """ import unicodedata value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore') value = unicode(re.sub('[^\w\s\-\+]', '', value).strip().lower()) return re.sub('[\-\+\s]+', '-', value) slugify = stringfilter(slugify) def send_mails(subscribers, subject, message): # we don't use send_mass_mail as we don't want to leak other users email addresses for s in subscribers: if not s.bookmark: now = datetime.datetime.now() # only send out things once every 600 seconds if now - s.last_updated > datetime.timedelta(0, 600): send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [s.user.email], fail_silently=True) s.last_updated = now s.save()
from django import template from django.utils.safestring import mark_safe from django.template.defaultfilters import stringfilter from django.utils.text import normalize_newlines import logging logger = logging.getLogger(__file__) register = template.Library() def remove_newlines(text): """ Removes all newline characters from a block of text. """ # First normalize the newlines using Django's nifty utility normalized_text = normalize_newlines(text) logger.debug("NORMALIZED TEXT = %s" % normalized_text) # Then simply remove the newlines like so. return mark_safe(normalized_text.replace('\n', ' ')) remove_newlines.is_safe = True remove_newlines = stringfilter(remove_newlines) register.filter(remove_newlines)
from django.utils.functional import allow_lazy from django.utils.http import urlquote from django.utils.html import word_split_re,punctuation_re, simple_email_re from django.template.defaultfilters import stringfilter import film20.settings as settings MAX_URL_LENGTH = getattr(settings, "MAX_URL_LENGTH", None) register = Library() def urlimagize(value, autoescape=None): """Converts URLs in plain text into clickable links.""" return mark_safe(do_urlimagize(value, nofollow=True, autoescape=autoescape)) urlimagize.is_safe=True urlimagize.needs_autoescape = True urlimagize = stringfilter(urlimagize) def is_image(url): if url.endswith(".png") or url.endswith(".PNG") or url.endswith(".jpg") or url.endswith(".JPG") or url.endswith(".gif") or url.endswith(".GIF"): return True else: return False def do_urlimagize(text, trim_url_limit=MAX_URL_LENGTH, nofollow=False, autoescape=False): """ Converts any URLs in text into clickable links. Works on http://, https://, www. links and links ending in .org, .net or .com. Links can have trailing punctuation (periods, commas, close-parens) and leading punctuation (opening parens) and it'll still do the right thing.
context['page'] = original_page bracket_start = marker_start % marker bracket_end = marker_end % marker start = rendered.find(bracket_start) if not start == -1: start = start + len(bracket_start) end = rendered.find(bracket_end, start) return rendered[start:end] return "" def hyde_thumbnail(url): postfix = getattr(settings, 'THUMBNAIL_FILENAME_POSTFIX', '-thumb') path, ext = url.rsplit('.', 1) return ''.join([path, postfix, '.', ext]) register.filter(stringfilter(hyde_thumbnail)) @register.filter def value_for_key(dictionary, key): if not dictionary: return "" if not dictionary.has_key(key): return "" value = dictionary[key] return value @register.filter def xmldatetime(dt): if not dt: dt = datetime.now()
import django from django import template from django.template.defaultfilters import stringfilter register = template.Library() def truncateletters(value, arg): """ Truncates a string after a certain number of letters Argument: Number of letters to truncate after """ from django_extensions.utils.text import truncate_letters try: length = int(arg) except ValueError: # invalid literal for int() return value # Fail silently return truncate_letters(value, length) if django.get_version() >= "1.4": truncateletters = stringfilter(truncateletters) register.filter(truncateletters, is_safe=True) else: truncateletters.is_safe = True truncateletters = stringfilter(truncateletters) register.filter(truncateletters)
from sentry.models import Group from sentry.web.helpers import group_is_public from sentry.utils import to_unicode from sentry.utils.avatar import get_gravatar_url from sentry.utils.http import absolute_uri from sentry.utils.javascript import to_json from sentry.utils.safe import safe_execute from sentry.utils.strings import truncatechars from templatetag_sugar.register import tag from templatetag_sugar.parser import Name, Variable, Constant, Optional import datetime register = template.Library() truncatechars = register.filter(stringfilter(truncatechars)) truncatechars.is_safe = True register.filter(to_json) register.simple_tag(absolute_uri) @register.filter def pprint(value, break_after=10): """ break_after is used to define how often a <span> is inserted (for soft wrapping). """ value = to_unicode(value)
unique_words.append(cleanword) if is_sorted: unique_words.sort() return unique_words def slugify(value): """ Normalizes string, converts to lowercase, removes non-alpha chars and converts spaces to hyphens. """ import unicodedata value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore') value = unicode(re.sub('[^\w\s\-\+]', '', value).strip().lower()) return re.sub('[\-\+\s]+', '-', value) slugify = stringfilter(slugify) def slugify_uniquely(model, value): """ Generate a unique slug. Based on: http://code.djangoproject.com/wiki/SlugifyUniquely """ suffix = 0 potential = base = slugify(value) while True: if suffix: potential = "-".join([base, str(suffix)]) if not model.objects.filter(slug=potential).count(): return potential # we hit a conflicting slug, so bump the suffix & try again
value = url_to_name(value) # normalize unicode import unicodedata value = unicodedata.normalize('NFKD', unicode(value)) # remove non-{word,space,keep} characters misc_characters = re.compile(('[^\w\s%s]' % keep), re.UNICODE) value = re.sub(misc_characters, '', value) value = value.strip() value = re.sub('[_\s]+', ' ', value) return value.lower() slugify = stringfilter(slugify) def name_to_url(value): """Converts page name to its canonical URL path """ # spaces to underscore value = re.sub('[\s]', '_', value.strip()) # url-encode value = quote(value.encode('utf-8')) return mark_safe(value) name_to_url.is_safe = True name_to_url = stringfilter(name_to_url)
downcoded = value return downcoded def slugify2(value): """ Normalizes string, converts to lowercase, removes non-alpha characters, and converts spaces to hyphens. It is similar to built-in :filter:`slugify` but it also handles special characters in variety of languages so that they are not simply removed but properly transliterated/downcoded. """ try: value = unicodedata.normalize('NFC', value) value = downcode(value) value = unicodedata.normalize('NFD', value).encode('ascii', 'ignore') value = unicode(re.sub('[^\w\s-]', '', value).strip().lower()) return safestring.mark_safe(re.sub('[-\s]+', '-', value)) except: if settings.TEMPLATE_DEBUG: raise else: return u'' slugify2.is_safe = True slugify2 = defaultfilters.stringfilter(slugify2) register.filter(slugify2)
from sentry.web.helpers import group_is_public from sentry.utils import to_unicode from sentry.utils.avatar import get_gravatar_url from sentry.utils.http import absolute_uri from sentry.utils.javascript import to_json from sentry.utils.safe import safe_execute from sentry.utils.strings import truncatechars from templatetag_sugar.register import tag from templatetag_sugar.parser import Name, Variable, Constant, Optional SentryVersion = namedtuple('SentryVersion', ['current', 'latest', 'update_available']) register = template.Library() truncatechars = register.filter(stringfilter(truncatechars)) truncatechars.is_safe = True register.filter(to_json) register.simple_tag(absolute_uri) @register.filter def pprint(value, break_after=10): """ break_after is used to define how often a <span> is inserted (for soft wrapping). """ value = to_unicode(value)
def chmod_symbol(mod): """ Transform a os.stat().st_mode octal value to a symbolic string. ignores meta infromation like SUID, SGID or the Sticky-Bit. e.g. 40755 -> rwxr-xr-x """ try: mod = int(mod) # The django template engine gives always a unicode string except ValueError: return u"" mod = mod & 0777 # strip "meta info" mod_string = u"%o" % mod return u''.join(CHMOD_TRANS_DATA[int(num)] for num in mod_string) chmod_symbol.is_safe = True chmod_symbol = stringfilter(chmod_symbol) def get_oct(value): """ Convert an integer number to an octal string. """ try: return oct(value) except: return value get_oct.is_safe = False def human_duration(t): """