How to use the jinja.exceptions.TemplateSyntaxError function in Jinja

To help you get started, we’ve selected a few Jinja examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github pallets / jinja / jinja / parser.py View on Github external
def parse_subscript_expression(self, node):
        """
        Parse a subscript statement. Gets attributes and items from an
        object.
        """
        lineno = self.stream.lineno
        if self.stream.current.type == 'dot':
            self.stream.next()
            token = self.stream.current
            if token.type in ('name', 'integer'):
                arg = nodes.ConstantExpression(token.value, token.lineno,
                                               self.filename)
            else:
                raise TemplateSyntaxError('expected name or number',
                                          token.lineno, self.filename)
            self.stream.next()
        elif self.stream.current.type == 'lbracket':
            self.stream.next()
            args = []
            while self.stream.current.type != 'rbracket':
                if args:
                    self.stream.expect('comma')
                args.append(self.parse_subscribed_expression())
            self.stream.expect('rbracket')
            if len(args) == 1:
                arg = args[0]
            else:
                arg = nodes.TupleExpression(args, lineno, self.filename)
        else:
            raise TemplateSyntaxError('expected subscript expression',
github pallets / jinja / jinja / parser.py View on Github external
parse = self.parse_expression
        args = []
        is_tuple = False
        while True:
            if args:
                self.stream.expect('comma')
            if self.stream.current.type in tuple_edge_tokens:
                break
            args.append(parse())
            if self.stream.current.type == 'comma':
                is_tuple = True
            else:
                break
        if not is_tuple and args:
            if enforce:
                raise TemplateSyntaxError('tuple expected', lineno,
                                          self.filename)
            return args[0]
        return nodes.TupleExpression(args, lineno, self.filename)
github pallets / jinja / jinja / parser.py View on Github external
def _sanitize_tree(self, nodelist, stack, extends, body):
        """
        This is not a closure because python leaks memory if it is.  It's used
        by `parse()` to make sure blocks do not trigger unexpected behavior.
        """
        for node in nodelist:
            if extends is not None and \
                 node.__class__ is nodes.Block and \
                 stack[-1] is not body:
                for n in stack:
                    if n.__class__ is nodes.Block:
                        break
                else:
                    raise TemplateSyntaxError('misplaced block %r, '
                                              'blocks in child '
                                              'templates must be '
                                              'either top level or '
                                              'located in a block '
                                              'tag.' % node.name,
                                              node.lineno,
                                              self.filename)
            stack.append(node)
            self._sanitize_tree(node.get_child_nodes(), stack, extends, body)
            stack.pop()
github pallets / jinja / jinja / parser.py View on Github external
def process_variable():
            var_name = self.stream.expect('name')
            if var_name.value not in replacements:
                raise TemplateSyntaxError('unregistered translation variable'
                                          " '%s'." % var_name.value,
                                          var_name.lineno, self.filename)
            buf.append('%%(%s)s' % var_name.value)
github pallets / jinja / jinja / parser.py View on Github external
def parse_raw_directive(self):
        """
        Handle fake raw directive. (real raw directives are handled by
        the lexer. But if there are arguments to raw or the end tag
        is missing the parser tries to resolve this directive. In that
        case present the user a useful error message.
        """
        if self.stream:
            raise TemplateSyntaxError('raw directive does not support '
                                      'any arguments.', self.stream.lineno,
                                      self.filename)
        raise TemplateSyntaxError('missing end tag for raw directive.',
                                  self.stream.lineno, self.filename)
github pallets / jinja / jinja / parser.py View on Github external
def parse_number_expression(self):
        """
        Parse a number literal.
        """
        token = self.stream.current
        if token.type not in ('integer', 'float'):
            raise TemplateSyntaxError('integer or float literal expected',
                                      token.lineno, self.filename)
        self.stream.next()
        return nodes.ConstantExpression(token.value, token.lineno, self.filename)
github pallets / jinja / jinja / parser.py View on Github external
token.lineno, self.filename)
            self.stream.next()
        elif self.stream.current.type == 'lbracket':
            self.stream.next()
            args = []
            while self.stream.current.type != 'rbracket':
                if args:
                    self.stream.expect('comma')
                args.append(self.parse_subscribed_expression())
            self.stream.expect('rbracket')
            if len(args) == 1:
                arg = args[0]
            else:
                arg = nodes.TupleExpression(args, lineno, self.filename)
        else:
            raise TemplateSyntaxError('expected subscript expression',
                                      self.lineno, self.filename)
        return nodes.SubscriptExpression(node, arg, lineno, self.filename)