Ticket #7295: 7295.2.diff

django/template/__init__.py

@@ -54 +54 @@
-from django.template.context import Context, RequestContext, ContextPopException
-from django.utils.itercompat import is_iterable
-from django.utils.functional import curry, Promise
-
+, unescape_string_literal
-from django.utils.encoding import smart_unicode, force_unicode
-from django.utils.translation import ugettext as _
-from django.utils.safestring import SafeData, EscapeData, mark_safe, mark_for_escaping
@@ -431 +431 @@
-            self.pointer = i
-            return s
-
+constant_string = r"""
+(?:%(i18n_open)s%(strdq)s%(i18n_close)s|
+%(i18n_open)s%(strsq)s%(i18n_close)s|
+%(strdq)s|
+%(strsq)s)|
+%(num)s
+""" % {
+    'strdq': r'''"[^"\\]*(?:\\.[^"\\]*)*"''', # double-quoted string
+    'strsq': r"""'[^'\\]*(?:\\.[^'\\]*)*'""", # single-quoted string
+    'num': r'[-+\.]?\d[\d\.e]*', # numeric constant
+    'i18n_open' : re.escape("_("),
+    'i18n_close' : re.escape(")"),
+  }
+constant_string = constant_string.replace("\n", "")
+
-filter_raw_string = r"""
-
-
+
-^(?P<var>[%(var_chars)s]+)|
- (?:%(filter_sep)s
-     (?P<filter_name>\w+)
-         (?:%(arg_sep)s
-             (?:
-
-
+
-              (?P<var_arg>[%(var_chars)s]+)
-             )
-         )?
- )""" % {
-str': r"""[^"\\]*(?:\\.[^"\\]*)*"""
+constant': constant_string
-    'var_chars': "\w\." ,
-    'filter_sep': re.escape(FILTER_SEPARATOR),
-    'arg_sep': re.escape(FILTER_ARGUMENT_SEPARATOR),
-    'i18n_open' : re.escape("_("),
-    'i18n_close' : re.escape(")"),
-  }
-
-filter_raw_string = filter_raw_string.replace("\n", "").replace(" ", "")
-filter_re = re.compile(filter_raw_string, re.UNICODE)
-
-class FilterExpression(object):
-
+r
-    Parses a variable token and its optional filters (all as a single string),
-    and return a list of tuples of the filter name and arguments.
-    Sample:
@@ -469 +480 @@
-        >>> fe.var
-        'variable'
-
+        >>> c = {'article': {'section': u'News'}}
+        >>> def fe_test(s): return FilterExpression(s, p).resolve(c)
+        >>> fe_test('article.section')
+        u'News'
+        >>> fe_test('article.section|upper')
+        u'NEWS'
+        >>> fe_test(u'"News"')
+        u'News'
+        >>> fe_test(u"'News'")
+        u'News'
+        >>> fe_test(ur'"Some \"Good\" News"')
+        u'Some "Good" News'
+        >>> fe_test(ur"'Some \'Bad\' News'")
+        u"Some 'Bad' News"
+
+        >>> fe = FilterExpression(ur'"Some \"Good\" News"', p)
+        >>> fe.filters
+        []
+        >>> fe.var
+        u'Some "Good" News'
+
-    This class should never be instantiated outside of the
-    get_filters_from_token helper function.
+
+    The filter_re regular expression is responsible for tokenizing the filter
+    expression::
+
+        >>> def fre_test(s):
+        ...     print '|'.join(','.join("%s=%s"%(key, val) for key, val in sorted(match.groupdict().items()) if val is not None) for match in filter_re.finditer(s))
+        >>> fre_test('myvar')
+        var=myvar
+        >>> fre_test('myvar|myfilt:myarg')
+        var=myvar|filter_name=myfilt,var_arg=myarg
+        >>> fre_test(r'"Some \"Good\" News"|myfilt:"Some \"Bad\" News"')
+        constant="Some \"Good\" News"|constant_arg="Some \"Bad\" News",filter_name=myfilt
+        >>> fre_test(r"'More \'Good\' News'|myfilt:'More \'Bad\' News'")
+        constant='More \'Good\' News'|constant_arg='More \'Bad\' News',filter_name=myfilt
+
+
+        >>> p.compile_filter(r'"Some \"Good\" News"').resolve({})
+        'Some "Good" News'
-    """
-    def __init__(self, token, parser):
-        self.token = token
@@ -484 +534 @@
-                raise TemplateSyntaxError("Could not parse some characters: %s|%s|%s"  % \
-                                           (token[:upto], token[upto:start], token[start:]))
-            if var == None:
-, i18n_constant = match.group("var", "constant", "i18n_
-i18n_
-var = '"%s"' %  _(i18n_constant.replace(r'\"', '"'))
-elif constant:
-var = '"%s"' % constant.replace(r'\"', '"')
-upto = match.end()
-
+ = match.group("var", "
+
+try:
+        self.var = Variable(constant).resolve({})
+except VariableDoesNotExist:
+        self.var = None
+el
-                    raise TemplateSyntaxError("Could not find variable at start of %s" % token)
-                elif var.find(VARIABLE_ATTRIBUTE_SEPARATOR + '_') > -1 or var[0] == '_':
-                    raise TemplateSyntaxError("Variables and attributes may not begin with underscores: '%s'" % var)
+                else:
+                    self.var = Variable(var)
+                upto = match.end()
-            else:
-                filter_name = match.group("filter_name")
-                args = []
-
-
-
-
-
+
+
+
-                elif var_arg:
-                    args.append((True, Variable(var_arg)))
-                filter_func = parser.find_filter(filter_name)
@@ -511 +562 @@
-        if upto != len(token):
-            raise TemplateSyntaxError("Could not parse the remainder: '%s' from '%s'" % (token[upto:], token))
-        self.filters = filters
-        self.var = Variable(var)
-
-    def resolve(self, context, ignore_failures=False):
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-                else:
-
+
+
+
+
+
+
+
+
+
+
+
-        for func, args in self.filters:
-            arg_vals = []
-            for lookup, arg in args:
@@ -593 +646 @@
-    return Variable(path).resolve(context)
-
-class Variable(object):
-
+r
-    A template variable, resolvable against a given context. The variable may be
-    a hard-coded string (if it begins and ends with single or double quote
-    marks)::
@@ -609 +662 @@
-        >>> c.article.section = 'News'
-        >>> Variable('article.section').resolve(c)
-        u'News'
+        >>> Variable(u'"News"').resolve(c)
+        u'News'
+        >>> Variable(u"'News'").resolve(c)
+        u'News'
-
-    (The example assumes VARIABLE_ATTRIBUTE_SEPARATOR is '.')
+
+    Translated strings are also handled correctly::
+
+        >>> Variable('_(article.section)').resolve(c)
+        u'News'
+        >>> Variable('_("Good News")').resolve(c)
+        u'Good News'
+        >>> Variable("_('Better News')").resolve(c)
+        u'Better News'
+
+    Escaped quotes work correctly as well::
+
+        >>> Variable(ur'"Some \"Good\" News"').resolve(c)
+        u'Some "Good" News'
+        >>> Variable(ur"'Some \'Better\' News'").resolve(c)
+        u"Some 'Better' News"
-    """
-
-    def __init__(self, var):
@@ -645 +718 @@
-                var = var[2:-1]
-            # If it's wrapped with quotes (single or double), then
-            # we're also dealing with a literal.
-if var[0] in "\"'" and var[0] == var[-1]
-var[1:-1]
-lse
+try
+unescape_string_literal(var)
+xcept ValueError
-                # Otherwise we'll set self.lookups so that resolve() knows we're
-                # dealing with a bonafide variable
-                self.lookups = tuple(var.split(VARIABLE_ATTRIBUTE_SEPARATOR))

django/utils/text.py

@@ -209 +209 @@
-    """
-    text = force_unicode(text)
-    for bit in smart_split_re.finditer(text):
-
-
-
-
-
-
-
+
-smart_split = allow_lazy(smart_split, 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"
+
+    Would this function be more appropriate in the django.utils.text module?
+    """
+    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)