binding: Updates Jinja2 from 2.7.1 to 2.8.

third_party/jinja2/utils.py

 # -*- coding: utf-8 -*-
 """
     jinja2.utils
     ~~~~~~~~~~~~
 
     Utility functions.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
 import re
 import errno
 from collections import deque
+from threading import Lock
 from jinja2._compat import text_type, string_types, implements_iterator, \
-     allocate_lock, url_quote
+     url_quote
 
 
 _word_split_re = re.compile(r'(\s+)')
 _punctuation_re = re.compile(
     '^(?P<lead>(?:%s)*)(?P<middle>.*?)(?P<trail>(?:%s)*)$' % (
         '|'.join(map(re.escape, ('(', '<', '&lt;'))),
         '|'.join(map(re.escape, ('.', ',', ')', '>', '\n', '&gt;')))
     )
 )
 _simple_email_re = re.compile(r'^\S+@[a-zA-Z0-9._-]+\.[a-zA-Z0-9._-]+$')
@@ skipping 116 matching lines @@
             raise
 
 
 def open_if_exists(filename, mode='rb'):
     """Returns a file descriptor for the filename if that file exists,
     otherwise `None`.
     """
     try:
         return open(filename, mode)
     except IOError as e:
-        if e.errno not in (errno.ENOENT, errno.EISDIR):
+        if e.errno not in (errno.ENOENT, errno.EISDIR, errno.EINVAL):
             raise
 
 
 def object_type_repr(obj):
     """Returns the name of the object's type.  For some recognized
     singletons the name of the object is returned instead. (For
     example for `None` and `Ellipsis`).
     """
     if obj is None:
         return 'None'
@@ skipping 12 matching lines @@
     builtin `pprint`.
     """
     try:
         from pretty import pretty
         return pretty(obj, verbose=verbose)
     except ImportError:
         from pprint import pformat
         return pformat(obj)
 
 
-def urlize(text, trim_url_limit=None, nofollow=False):
+def urlize(text, trim_url_limit=None, nofollow=False, target=None):
     """Converts any URLs in text into clickable links. Works on http://,
     https:// and www. links. 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 link text will be limited
     to trim_url_limit characters.
 
     If nofollow is True, the URLs in link text will get a rel="nofollow"
     attribute.
+
+    If target is not None, a target attribute will be added to the link.
     """
     trim_url = lambda x, limit=trim_url_limit: limit is not None \
                          and (x[:limit] + (len(x) >=limit and '...'
                          or '')) or x
     words = _word_split_re.split(text_type(escape(text)))
     nofollow_attr = nofollow and ' rel="nofollow"' or ''
+    if target is not None and isinstance(target, string_types):
+        target_attr = ' target="%s"' % target
+    else:
+        target_attr = ''
     for i, word in enumerate(words):
         match = _punctuation_re.match(word)
         if match:
             lead, middle, trail = match.groups()
             if middle.startswith('www.') or (
                 '@' not in middle and
                 not middle.startswith('http://') and
                 not middle.startswith('https://') and
                 len(middle) > 0 and
                 middle[0] in _letters + _digits and (
                     middle.endswith('.org') or
                     middle.endswith('.net') or
                     middle.endswith('.com')
                 )):
-                middle = '<a href="http://%s"%s>%s</a>' % (middle,
-                    nofollow_attr, trim_url(middle))
+                middle = '<a href="http://%s"%s%s>%s</a>' % (middle,
+                    nofollow_attr, target_attr, trim_url(middle))
             if middle.startswith('http://') or \
                middle.startswith('https://'):
-                middle = '<a href="%s"%s>%s</a>' % (middle,
-                    nofollow_attr, trim_url(middle))
+                middle = '<a href="%s"%s%s>%s</a>' % (middle,
+                    nofollow_attr, target_attr, trim_url(middle))
             if '@' in middle and not middle.startswith('www.') and \
                not ':' in middle and _simple_email_re.match(middle):
                 middle = '<a href="mailto:%s">%s</a>' % (middle, middle)
             if lead + middle + trail != word:
                 words[i] = lead + middle + trail
     return u''.join(words)
 
 
 def generate_lorem_ipsum(n=5, html=True, min=20, max=100):
-    """Generate some lorem impsum for the template."""
+    """Generate some lorem ipsum for the template."""
     from jinja2.constants import LOREM_IPSUM_WORDS
     from random import choice, randrange
     words = LOREM_IPSUM_WORDS.split()
     result = []
 
     for _ in range(n):
         next_capitalized = True
         last_comma = last_fullstop = 0
         word = None
         last = None
@@ skipping 27 matching lines @@
             p = p[:-1] + '.'
         elif not p.endswith('.'):
             p += '.'
         result.append(p)
 
     if not html:
         return u'\n\n'.join(result)
     return Markup(u'\n'.join(u'<p>%s</p>' % escape(x) for x in result))
 
 
-def unicode_urlencode(obj, charset='utf-8'):
+def unicode_urlencode(obj, charset='utf-8', for_qs=False):
     """URL escapes a single bytestring or unicode string with the
     given charset if applicable to URL safe quoting under all rules
     that need to be considered under all supported Python versions.
 
     If non strings are provided they are converted to their unicode
     representation first.
     """
     if not isinstance(obj, string_types):
         obj = text_type(obj)
     if isinstance(obj, text_type):
         obj = obj.encode(charset)
-    return text_type(url_quote(obj))
+    safe = for_qs and b'' or b'/'
+    rv = text_type(url_quote(obj, safe))
+    if for_qs:
+        rv = rv.replace('%20', '+')
+    return rv
 
 
 class LRUCache(object):
     """A simple LRU Cache implementation."""
 
     # this is fast for small capacities (something below 1000) but doesn't
     # scale.  But as long as it's only used as storage for templates this
     # won't do any harm.
 
     def __init__(self, capacity):
         self.capacity = capacity
         self._mapping = {}
         self._queue = deque()
         self._postinit()
 
     def _postinit(self):
         # alias all queue methods for faster lookup
         self._popleft = self._queue.popleft
         self._pop = self._queue.pop
         self._remove = self._queue.remove
-        self._wlock = allocate_lock()
+        self._wlock = Lock()
         self._append = self._queue.append
 
     def __getstate__(self):
         return {
             'capacity':     self.capacity,
             '_mapping':     self._mapping,
             '_queue':       self._queue
         }
 
     def __setstate__(self, d):
@@ skipping 188 matching lines @@
 
     def __call__(self):
         if not self.used:
             self.used = True
             return u''
         return self.sep
 
 
 # Imported here because that's where it was in the past
 from markupsafe import Markup, escape, soft_unicode