Example #1
0
    def filter_stream(self, stream: TokenStream):
        for token in stream:
            if token.type != "data":
                yield token
                continue

            pos = 0
            lineno = token.lineno

            while match := REGEX_DUNDER.search(token.value, pos):
                new_pos = match.start()

                if new_pos > pos:
                    preval = token.value[pos:new_pos]
                    yield Token(lineno, "data", preval)
                    lineno += count_newlines(preval)

                yield Token(lineno, "variable_begin", "")
                yield Token(lineno, "name", match[1])
                yield Token(lineno, "pipe", "|")
                yield Token(lineno, "name", "default")
                yield Token(lineno, "lparen", "(")
                yield Token(lineno, "string", match[0])
                yield Token(lineno, "rparen", ")")
                yield Token(lineno, "variable_end", "")

                pos = match.end()

            if pos < len(token.value):
                yield Token(lineno, "data", token.value[pos:])
Example #2
0
    def filter_stream(self, stream):
        paren_stack = 0

        for token in stream:
            if token.type != "data":
                yield token
                continue

            pos = 0
            lineno = token.lineno

            while 1:
                if not paren_stack:
                    match = _outside_re.search(token.value, pos)
                else:
                    match = _inside_re.search(token.value, pos)
                if match is None:
                    break
                new_pos = match.start()
                if new_pos > pos:
                    preval = token.value[pos:new_pos]
                    yield Token(lineno, "data", preval)
                    lineno += count_newlines(preval)
                gtok = match.group()
                if gtok[0] == "\\":
                    yield Token(lineno, "data", gtok[1:])
                elif not paren_stack:
                    yield Token(lineno, "block_begin", None)
                    yield Token(lineno, "name", "trans")
                    yield Token(lineno, "block_end", None)
                    paren_stack = 1
                else:
                    if gtok == "(" or paren_stack > 1:
                        yield Token(lineno, "data", gtok)
                    paren_stack += gtok == ")" and -1 or 1
                    if not paren_stack:
                        yield Token(lineno, "block_begin", None)
                        yield Token(lineno, "name", "endtrans")
                        yield Token(lineno, "block_end", None)
                pos = match.end()

            if pos < len(token.value):
                yield Token(lineno, "data", token.value[pos:])

        if paren_stack:
            raise TemplateSyntaxError(
                "unclosed gettext expression",
                token.lineno,
                stream.name,
                stream.filename,
            )
Example #3
0
    def filter_stream(self, stream):
        paren_stack = 0

        for token in stream:
            if token.type is not 'data':
                yield token
                continue

            pos = 0
            lineno = token.lineno

            while 1:
                if not paren_stack:
                    match = _outside_re.search(token.value, pos)
                else:
                    match = _inside_re.search(token.value, pos)
                if match is None:
                    break
                new_pos = match.start()
                if new_pos > pos:
                    preval = token.value[pos:new_pos]
                    yield Token(lineno, 'data', preval)
                    lineno += count_newlines(preval)
                gtok = match.group()
                if gtok[0] == '\\':
                    yield Token(lineno, 'data', gtok[1:])
                elif not paren_stack:
                    yield Token(lineno, 'block_begin', None)
                    yield Token(lineno, 'name', 'trans')
                    yield Token(lineno, 'block_end', None)
                    paren_stack = 1
                else:
                    if gtok == '(' or paren_stack > 1:
                        yield Token(lineno, 'data', gtok)
                    paren_stack += gtok == ')' and -1 or 1
                    if not paren_stack:
                        yield Token(lineno, 'block_begin', None)
                        yield Token(lineno, 'name', 'endtrans')
                        yield Token(lineno, 'block_end', None)
                pos = match.end()

            if pos < len(token.value):
                yield Token(lineno, 'data', token.value[pos:])

        if paren_stack:
            raise TemplateSyntaxError('unclosed gettext expression',
                                      token.lineno, stream.name,
                                      stream.filename)
Example #4
0
    def filter_stream(self, stream):
        paren_stack = 0

        for token in stream:
            if token.type != 'data':
                yield token
                continue

            pos = 0
            lineno = token.lineno

            while 1:
                if not paren_stack:
                    match = _outside_re.search(token.value, pos)
                else:
                    match = _inside_re.search(token.value, pos)
                if match is None:
                    break
                new_pos = match.start()
                if new_pos > pos:
                    preval = token.value[pos:new_pos]
                    yield Token(lineno, 'data', preval)
                    lineno += count_newlines(preval)
                gtok = match.group()
                if gtok[0] == '\\':
                    yield Token(lineno, 'data', gtok[1:])
                elif not paren_stack:
                    yield Token(lineno, 'block_begin', None)
                    yield Token(lineno, 'name', 'trans')
                    yield Token(lineno, 'block_end', None)
                    paren_stack = 1
                else:
                    if gtok == '(' or paren_stack > 1:
                        yield Token(lineno, 'data', gtok)
                    paren_stack += gtok == ')' and -1 or 1
                    if not paren_stack:
                        yield Token(lineno, 'block_begin', None)
                        yield Token(lineno, 'name', 'endtrans')
                        yield Token(lineno, 'block_end', None)
                pos = match.end()

            if pos < len(token.value):
                yield Token(lineno, 'data', token.value[pos:])

        if paren_stack:
            raise TemplateSyntaxError('unclosed gettext expression',
                                      token.lineno, stream.name,
                                      stream.filename)
Example #5
0
 def interpolate(self, token):
     pos = 0
     end = len(token.value)
     lineno = token.lineno
     while 1:
         match = _gettext_re.search(token.value, pos)
         if match is None:
             break
         value = token.value[pos:match.start()]
         if value:
             yield Token(lineno, "data", value)
         lineno += count_newlines(token.value)
         yield Token(lineno, "variable_begin", None)
         yield Token(lineno, "name", "gettext")
         yield Token(lineno, "lparen", None)
         yield Token(lineno, "string", match.group(1))
         yield Token(lineno, "rparen", None)
         yield Token(lineno, "variable_end", None)
         pos = match.end()
     if pos < end:
         yield Token(lineno, "data", token.value[pos:])
Example #6
0
 def interpolate(self, token):
     pos = 0
     end = len(token.value)
     lineno = token.lineno
     while 1:
         match = _gettext_re.search(token.value, pos)
         if match is None:
             break
         value = token.value[pos:match.start()]
         if value:
             yield Token(lineno, 'data', value)
         lineno += count_newlines(token.value)
         yield Token(lineno, 'variable_begin', None)
         yield Token(lineno, 'name', 'gettext')
         yield Token(lineno, 'lparen', None)
         yield Token(lineno, 'string', match.group(1))
         yield Token(lineno, 'rparen', None)
         yield Token(lineno, 'variable_end', None)
         pos = match.end()
     if pos < end:
         yield Token(lineno, 'data', token.value[pos:])
Example #7
0
 def interpolate(self, token):
     pos = 0
     end = len(token.value)
     lineno = token.lineno
     while 1:
         match = _gettext_re.search(token.value, pos)
         if match is None:
             break
         value = token.value[pos:match.start()]
         if value:
             yield Token(lineno, 'data', value)
         lineno += count_newlines(token.value)
         yield Token(lineno, 'variable_begin', None)
         yield Token(lineno, 'name', 'gettext')
         yield Token(lineno, 'lparen', None)
         yield Token(lineno, 'string', match.group(1))
         yield Token(lineno, 'rparen', None)
         yield Token(lineno, 'variable_end', None)
         pos = match.end()
     if pos < end:
         yield Token(lineno, 'data', token.value[pos:])
Example #8
0
 def interpolate(self, token):
     pos = 0
     end = len(token.value)
     lineno = token.lineno
     while 1:
         match = _gettext_re.search(token.value, pos)
         if match is None:
             break
         value = token.value[pos : match.start()]
         if value:
             yield Token(lineno, "data", value)
         lineno += count_newlines(token.value)
         yield Token(lineno, "variable_begin", None)
         yield Token(lineno, "name", "gettext")
         yield Token(lineno, "lparen", None)
         yield Token(lineno, "string", match.group(1))
         yield Token(lineno, "rparen", None)
         yield Token(lineno, "variable_end", None)
         pos = match.end()
     if pos < end:
         yield Token(lineno, "data", token.value[pos:])