def do_replace(s, old, new, count=None): """ Return a copy of the value with all occurrences of a substring replaced with a new one. The first argument is the substring that should be replaced, the second is the replacement string. If the optional third argument ``count`` is given, only the first ``count`` occurrences are replaced: .. sourcecode:: jinja {{ "Hello World"|replace("Hello", "Goodbye") }} -> Goodbye World {{ "aaaaargh"|replace("a", "d'oh, ", 2) }} -> d'oh, d'oh, aaargh """ if not isinstance(old, basestring) or \ not isinstance(new, basestring): raise FilterArgumentError('the replace filter requires ' 'string replacement arguments') if count is None: return s.replace(old, new) if not isinstance(count, (int, long)): raise FilterArgumentError('the count parameter of the ' 'replace filter requires ' 'an integer') return s.replace(old, new, count)
def do_capture(name='captured', clean=False): """ Store the value in a variable called ``captured`` or a variable with the name provided. Useful for filter blocks: .. sourcecode:: jinja {% filter capture('foo') %} ... {% endfilter %} {{ foo }} This will output "..." two times. One time from the filter block and one time from the variable. If you don't want the filter to output something you can use it in `clean` mode: .. sourcecode:: jinja {% filter capture('foo', True) %} ... {% endfilter %} {{ foo }} """ if not isinstance(name, basestring): raise FilterArgumentError('You can only capture into variables') def wrapped(env, context, value): context[name] = value if clean: return TemplateData() return value return wrapped
def do_round(precision=0, method='common'): """ Round the number to a given precision. The first parameter specifies the precision (default is ``0``), the second the rounding method: - ``'common'`` rounds either up or down - ``'ceil'`` always rounds up - ``'floor'`` always rounds down If you don't specify a method ``'common'`` is used. .. sourcecode:: jinja {{ 42.55|round }} -> 43 {{ 42.55|round(1, 'floor') }} -> 42.5 *new in Jinja 1.1* """ if not method in ('common', 'ceil', 'floor'): raise FilterArgumentError('method must be common, ceil or floor') if precision < 0: raise FilterArgumentError('precision must be a postive integer ' 'or zero.') def wrapped(env, context, value): if method == 'common': return round(value, precision) import math func = getattr(math, method) if precision: return func(value * 10 * precision) / (10 * precision) else: return func(value) return wrapped
def do_dformat(d): """ Apply python mapping string formatting on an object: .. sourcecode:: jinja {{ "Hello %(username)s!"|dformat({'username': '******'}) }} -> Hello John Doe! This is useful when adding variables to translateable string expressions. *New in Jinja 1.1* """ if not isinstance(d, dict): raise FilterArgumentError('dict required') def wrapped(env, context, value): return env.to_unicode(value) % d return wrapped
def do_dictsort(case_sensitive=False, by='key'): """ Sort a dict and yield (key, value) pairs. Because python dicts are unsorted you may want to use this function to order them by either key or value: .. sourcecode:: jinja {% for item in mydict|dictsort %} sort the dict by key, case insensitive {% for item in mydict|dicsort(true) %} sort the dict by key, case sensitive {% for item in mydict|dictsort(false, 'value') %} sort the dict by key, case insensitive, sorted normally and ordered by value. """ if by == 'key': pos = 0 elif by == 'value': pos = 1 else: raise FilterArgumentError('You can only sort by either ' '"key" or "value"') def sort_func(value, env): if isinstance(value, basestring): value = env.to_unicode(value) if not case_sensitive: value = value.lower() return value def wrapped(env, context, value): items = value.items() items.sort( lambda a, b: cmp(sort_func(a[pos], env), sort_func(b[pos], env))) return items return wrapped