binding: Updates Jinja2 from 2.7.1 to 2.8.

third_party/jinja2/filters.py

 # -*- coding: utf-8 -*-
 """
     jinja2.filters
     ~~~~~~~~~~~~~~
 
     Bundled jinja filters.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
 import re
 import math
 
 from random import choice
 from operator import itemgetter
 from itertools import groupby
 from jinja2.utils import Markup, escape, pformat, urlize, soft_unicode, \
      unicode_urlencode
 from jinja2.runtime import Undefined
 from jinja2.exceptions import FilterArgumentError
-from jinja2._compat import next, imap, string_types, text_type, iteritems
+from jinja2._compat import imap, string_types, text_type, iteritems
 
 
 _word_re = re.compile(r'\w+(?u)')
 
 
 def contextfilter(f):
     """Decorator for marking context dependent filters. The current
     :class:`Context` will be passed as first argument.
     """
     f.contextfilter = True
@@ skipping 55 matching lines @@
     if isinstance(value, dict):
         itemiter = iteritems(value)
     elif not isinstance(value, string_types):
         try:
             itemiter = iter(value)
         except TypeError:
             pass
     if itemiter is None:
         return unicode_urlencode(value)
     return u'&'.join(unicode_urlencode(k) + '=' +
-                     unicode_urlencode(v) for k, v in itemiter)
+                     unicode_urlencode(v, for_qs=True)
+                     for k, v in itemiter)
 
 
 @evalcontextfilter
 def do_replace(eval_ctx, 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:
 
@@ skipping 68 matching lines @@
     lowercase.
     """
     return soft_unicode(s).capitalize()
 
 
 def do_title(s):
     """Return a titlecased version of the value. I.e. words will start with
     uppercase letters, all remaining characters are lowercase.
     """
     rv = []
-    for item in re.compile(r'([-\s]+)(?u)').split(s):
+    for item in re.compile(r'([-\s]+)(?u)').split(soft_unicode(s)):
         if not item:
             continue
         rv.append(item[0].upper() + item[1:].lower())
     return ''.join(rv)
 
 
 def do_dictsort(value, 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|dictsort(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.
+            sort the dict by value, case insensitive
     """
     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(item):
         value = item[pos]
@@ skipping 183 matching lines @@
 def do_pprint(value, verbose=False):
     """Pretty print a variable. Useful for debugging.
 
     With Jinja 1.2 onwards you can pass it a parameter.  If this parameter
     is truthy the output will be more verbose (this requires `pretty`)
     """
     return pformat(value, verbose=verbose)
 
 
 @evalcontextfilter
-def do_urlize(eval_ctx, value, trim_url_limit=None, nofollow=False):
+def do_urlize(eval_ctx, value, trim_url_limit=None, nofollow=False,
+              target=None):
     """Converts URLs in plain text into clickable links.
 
     If you pass the filter an additional integer it will shorten the urls
     to that number. Also a third argument exists that makes the urls
     "nofollow":
 
     .. sourcecode:: jinja
 
         {{ mytext|urlize(40, true) }}
             links are shortened to 40 chars and defined with rel="nofollow"
+
+    If *target* is specified, the ``target`` attribute will be added to the
+    ``<a>`` tag:
+
+    .. sourcecode:: jinja
+
+       {{ mytext|urlize(40, target='_blank') }}
+
+    .. versionchanged:: 2.8+
+       The *target* parameter was added.
     """
-    rv = urlize(value, trim_url_limit, nofollow)
+    rv = urlize(value, trim_url_limit, nofollow, target)
     if eval_ctx.autoescape:
         rv = Markup(rv)
     return rv
 
 
 def do_indent(s, width=4, indentfirst=False):
     """Return a copy of the passed string, each line indented by
     4 spaces. The first line is not indented. If you want to
     change the number of spaces or indent the first line too
     you can pass additional parameters to the filter:
@@ skipping 14 matching lines @@
     """Return a truncated copy of the string. The length is specified
     with the first parameter which defaults to ``255``. If the second
     parameter is ``true`` the filter will cut the text at length. Otherwise
     it will discard the last word. If the text was in fact
     truncated it will append an ellipsis sign (``"..."``). If you want a
     different ellipsis sign than ``"..."`` you can specify it using the
     third parameter.
 
     .. sourcecode:: jinja
 
-        {{ "foo bar"|truncate(5) }}
+        {{ "foo bar baz"|truncate(9) }}
             -> "foo ..."
-        {{ "foo bar"|truncate(5, True) }}
-            -> "foo b..."
+        {{ "foo bar baz"|truncate(9, True) }}
+            -> "foo ba..."
+
     """
     if len(s) <= length:
         return s
     elif killwords:
-        return s[:length] + end
-    words = s.split(' ')
-    result = []
-    m = 0
-    for word in words:
-        m += len(word) + 1
-        if m > length:
-            break
-        result.append(word)
-    result.append(end)
-    return u' '.join(result)
+        return s[:length - len(end)] + end
+
+    result = s[:length - len(end)].rsplit(' ', 1)[0]
+    if len(result) < length:
+        result += ' '
+    return result + end
+
 
 @environmentfilter
 def do_wordwrap(environment, s, width=79, break_long_words=True,
                 wrapstring=None):
     """
     Return a copy of the string passed to the filter wrapped after
     ``79`` characters.  You can override this default using the first
     parameter.  If you set the second parameter to `false` Jinja will not
     split words apart if they are longer than `width`. By default, the newlines
     will be the default newlines for the environment, but this can be changed
     using the wrapstring keyword argument.
 
     .. versionadded:: 2.7
        Added support for the `wrapstring` parameter.
     """
     if not wrapstring:
         wrapstring = environment.newline_sequence
     import textwrap
     return wrapstring.join(textwrap.wrap(s, width=width, expand_tabs=False,
                                    replace_whitespace=False,
                                    break_long_words=break_long_words))
 
 
 def do_wordcount(s):
     """Count the words in that string."""
     return len(_word_re.findall(s))
 
 
-def do_int(value, default=0):
+def do_int(value, default=0, base=10):
     """Convert the value into an integer. If the
     conversion doesn't work it will return ``0``. You can
-    override this default using the first parameter.
+    override this default using the first parameter. You
+    can also override the default base (10) in the second
+    parameter, which handles input with prefixes such as
+    0b, 0o and 0x for bases 2, 8 and 16 respectively.
     """
     try:
-        return int(value)
+        return int(value, base)
     except (TypeError, ValueError):
         # this quirk is necessary so that "42.23"|int gives 42.
         try:
             return int(float(value))
         except (TypeError, ValueError):
             return default
 
 
 def do_float(value, default=0.0):
     """Convert the value into a floating point number. If the
@@ skipping 82 matching lines @@
         <table>
         {%- for row in items|batch(3, '&nbsp;') %}
           <tr>
           {%- for column in row %}
             <td>{{ column }}</td>
           {%- endfor %}
           </tr>
         {%- endfor %}
         </table>
     """
-    result = []
     tmp = []
     for item in value:
         if len(tmp) == linecount:
             yield tmp
             tmp = []
         tmp.append(item)
     if tmp:
         if fill_with is not None and len(tmp) < linecount:
             tmp += [fill_with] * (linecount - len(tmp))
         yield tmp
@@ skipping 120 matching lines @@
     """
     return Markup(value)
 
 
 def do_mark_unsafe(value):
     """Mark a value as unsafe.  This is the reverse operation for :func:`safe`."""
     return text_type(value)
 
 
 def do_reverse(value):
-    """Reverse the object or return an iterator the iterates over it the other
+    """Reverse the object or return an iterator that iterates over it the other
     way round.
     """
     if isinstance(value, string_types):
         return value[::-1]
     try:
         return reversed(value)
     except TypeError:
         try:
             rv = list(value)
             rv.reverse()
             return rv
         except TypeError:
             raise FilterArgumentError('argument must be iterable')
 
 
 @environmentfilter
 def do_attr(environment, obj, name):
     """Get an attribute of an object.  ``foo|attr("bar")`` works like
-    ``foo["bar"]`` just that always an attribute is returned and items are not
+    ``foo.bar`` just that always an attribute is returned and items are not
     looked up.
 
     See :ref:`Notes on subscriptions <notes-on-subscriptions>` for more details.
     """
     try:
         name = str(name)
     except UnicodeError:
         pass
     else:
         try:
@@ skipping 49 matching lines @@
         func = lambda item: context.environment.call_filter(
             name, item, args, kwargs, context=context)
 
     if seq:
         for item in seq:
             yield func(item)
 
 
 @contextfilter
 def do_select(*args, **kwargs):
-    """Filters a sequence of objects by appying a test to either the object
-    or the attribute and only selecting the ones with the test succeeding.
+    """Filters a sequence of objects by applying a test to the object and only
+    selecting the ones with the test succeeding.
 
     Example usage:
 
     .. sourcecode:: jinja
 
         {{ numbers|select("odd") }}
+        {{ numbers|select("odd") }}
 
     .. versionadded:: 2.7
     """
     return _select_or_reject(args, kwargs, lambda x: x, False)
 
 
 @contextfilter
 def do_reject(*args, **kwargs):
-    """Filters a sequence of objects by appying a test to either the object
-    or the attribute and rejecting the ones with the test succeeding.
+    """Filters a sequence of objects by applying a test to the object and
+    rejecting the ones with the test succeeding.
 
     Example usage:
 
     .. sourcecode:: jinja
 
         {{ numbers|reject("odd") }}
 
     .. versionadded:: 2.7
     """
     return _select_or_reject(args, kwargs, lambda x: not x, False)
 
 
 @contextfilter
 def do_selectattr(*args, **kwargs):
-    """Filters a sequence of objects by appying a test to either the object
-    or the attribute and only selecting the ones with the test succeeding.
+    """Filters a sequence of objects by applying a test to an attribute of an
+    object and only selecting the ones with the test succeeding.
 
     Example usage:
 
     .. sourcecode:: jinja
 
         {{ users|selectattr("is_active") }}
         {{ users|selectattr("email", "none") }}
 
     .. versionadded:: 2.7
     """
     return _select_or_reject(args, kwargs, lambda x: x, True)
 
 
 @contextfilter
 def do_rejectattr(*args, **kwargs):
-    """Filters a sequence of objects by appying a test to either the object
-    or the attribute and rejecting the ones with the test succeeding.
+    """Filters a sequence of objects by applying a test to an attribute of an
+    object or the attribute and rejecting the ones with the test succeeding.
 
     .. sourcecode:: jinja
 
         {{ users|rejectattr("is_active") }}
         {{ users|rejectattr("email", "none") }}
 
     .. versionadded:: 2.7
     """
     return _select_or_reject(args, kwargs, lambda x: not x, True)
 
@@ skipping 20 matching lines @@
     except LookupError:
         func = bool
 
     if seq:
         for item in seq:
             if modfunc(func(transfunc(item))):
                 yield item
 
 
 FILTERS = {
+    'abs':                  abs,
     'attr':                 do_attr,
-    'replace':              do_replace,
-    'upper':                do_upper,
+    'batch':                do_batch,
+    'capitalize':           do_capitalize,
+    'center':               do_center,
+    'count':                len,
+    'd':                    do_default,
+    'default':              do_default,
+    'dictsort':             do_dictsort,
+    'e':                    escape,
+    'escape':               escape,
+    'filesizeformat':       do_filesizeformat,
+    'first':                do_first,
+    'float':                do_float,
+    'forceescape':          do_forceescape,
+    'format':               do_format,
+    'groupby':              do_groupby,
+    'indent':               do_indent,
+    'int':                  do_int,
+    'join':                 do_join,
+    'last':                 do_last,
+    'length':               len,
+    'list':                 do_list,
     'lower':                do_lower,
-    'escape':               escape,
-    'e':                    escape,
-    'forceescape':          do_forceescape,
-    'capitalize':           do_capitalize,
-    'title':                do_title,
-    'default':              do_default,
-    'd':                    do_default,
-    'join':                 do_join,
-    'count':                len,
-    'dictsort':             do_dictsort,
-    'sort':                 do_sort,
-    'length':               len,
-    'reverse':              do_reverse,
-    'center':               do_center,
-    'indent':               do_indent,
-    'title':                do_title,
-    'capitalize':           do_capitalize,
-    'first':                do_first,
-    'last':                 do_last,
     'map':                  do_map,
+    'pprint':               do_pprint,
     'random':               do_random,
     'reject':               do_reject,
     'rejectattr':           do_rejectattr,
-    'filesizeformat':       do_filesizeformat,
-    'pprint':               do_pprint,
-    'truncate':             do_truncate,
-    'wordwrap':             do_wordwrap,
-    'wordcount':            do_wordcount,
-    'int':                  do_int,
-    'float':                do_float,
-    'string':               soft_unicode,
-    'list':                 do_list,
-    'urlize':               do_urlize,
-    'format':               do_format,
-    'trim':                 do_trim,
-    'striptags':            do_striptags,
+    'replace':              do_replace,
+    'reverse':              do_reverse,
+    'round':                do_round,
+    'safe':                 do_mark_safe,
     'select':               do_select,
     'selectattr':           do_selectattr,
     'slice':                do_slice,
-    'batch':                do_batch,
+    'sort':                 do_sort,
+    'string':               soft_unicode,
+    'striptags':            do_striptags,
     'sum':                  do_sum,
-    'abs':                  abs,
-    'round':                do_round,
-    'groupby':              do_groupby,
-    'safe':                 do_mark_safe,
+    'title':                do_title,
+    'trim':                 do_trim,
+    'truncate':             do_truncate,
+    'upper':                do_upper,
+    'urlencode':            do_urlencode,
+    'urlize':               do_urlize,
+    'wordcount':            do_wordcount,
+    'wordwrap':             do_wordwrap,
     'xmlattr':              do_xmlattr,
-    'urlencode':            do_urlencode
 }