python-liquid 2.3.6__py3-none-any.whl → 3.0.0__py3-none-any.whl

liquid/builtin/tags/comment_tag.py

@@ -1,77 +0,0 @@
-"""The built-in _comment_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Optional
-from typing import TextIO
-
-from liquid import ast
-from liquid.exceptions import LiquidSyntaxError
-from liquid.tag import Tag
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid.context import RenderContext
-    from liquid.stream import TokenStream
-
-
-TAG_COMMENT = sys.intern("comment")
-TAG_ENDCOMMENT = sys.intern("endcomment")
-
-END_COMMENTBLOCK = frozenset((TAG_ENDCOMMENT,))
-
-
-class CommentNode(ast.Node):
-    """The built-in _comment_ tag."""
-
-    __slots__ = ("text",)
-
-    def __init__(self, token: Token, text: Optional[str] = None):
-        super().__init__(token)
-        self.text = text
-
-    def __str__(self) -> str:
-        return f"{{% comment %}}{self.text}{{% endcomment %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:  # noqa: ARG002
-        """Render the node to the output buffer."""
-        return 0
-
-
-class CommentTag(Tag):
-    """An implementation of the built-in _comment_ tag that retains comment text.
-
-    Some Liquid markup might be stripped out by the lexer, so comment text is not
-    guaranteed to be identical to that in the source document.
-    """
-
-    name = TAG_COMMENT
-    end = TAG_ENDCOMMENT
-    node_class = CommentNode
-
-    def parse(self, stream: TokenStream) -> CommentNode:
-        """Parse tokens from _stream_ into an AST node."""
-        if stream.current.kind == "COMMENT":
-            # A `{#  #}` style comment
-            return self.node_class(stream.current, text=stream.current.value)
-
-        # A block `{% comment %}`
-        token = stream.eat(TOKEN_TAG)
-        text: list[str] = []
-
-        while True:
-            if stream.current.kind == TOKEN_EOF:
-                raise LiquidSyntaxError("comment tag was never closed", token=token)
-            if (
-                stream.current.kind == TOKEN_TAG
-                and stream.current.value == TAG_ENDCOMMENT
-            ):
-                break
-            text.append(stream.current.value)
-            next(stream)
-
-        return self.node_class(token, text="".join(text))

liquid/builtin/tags/cycle_tag.py

@@ -1,132 +0,0 @@
-"""The built-in _cycle_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import Optional
-from typing import TextIO
-
-from liquid.ast import Node
-from liquid.builtin.expressions import PositionalArgument
-from liquid.builtin.expressions import parse_primitive
-from liquid.exceptions import LiquidSyntaxError
-from liquid.stringify import to_liquid_string
-from liquid.tag import Tag
-from liquid.token import TOKEN_COLON
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-from liquid.undefined import is_undefined
-
-if TYPE_CHECKING:
-    from liquid.context import RenderContext
-    from liquid.expression import Expression
-    from liquid.stream import TokenStream
-
-
-TAG_CYCLE = sys.intern("cycle")
-
-
-class CycleNode(Node):
-    """The built-in _cycle_ tag."""
-
-    __slots__ = ("group", "args")
-
-    group_by_args: bool = False
-    """If `True`, use cycle arguments as well as group name when building cycle
-    context keys."""
-
-    def __init__(
-        self, token: Token, group: Optional[Expression], args: list[Expression]
-    ):
-        super().__init__(token)
-        self.group = group
-        self.args = args
-        self.blank = False
-
-    def __str__(self) -> str:
-        name = f"{self.group.token.value}: " if self.group else ""
-        items = ", ".join(str(i) for i in self.args)
-        return f"{{% cycle {name}{items} %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        if self.group:
-            _group = self.group.evaluate(context)
-            group_name = "__UNDEFINED" if is_undefined(_group) else str(_group)
-        else:
-            group_name = ""
-
-        args = [arg.evaluate(context) for arg in self.args]
-
-        if self.group_by_args:
-            key: object = (group_name, tuple(args))
-        else:
-            key = group_name if group_name else str(args)
-
-        index = context.cycle(key, len(args))
-
-        if index >= len(args):
-            return 0
-
-        return buffer.write(
-            to_liquid_string(args[index], autoescape=context.autoescape)
-        )
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        if self.group:
-            _group = await self.group.evaluate_async(context)
-            group_name = "__UNDEFINED" if is_undefined(_group) else str(_group)
-        else:
-            group_name = ""
-
-        args = [await arg.evaluate_async(context) for arg in self.args]
-
-        if self.group_by_args:
-            key: object = (group_name, tuple(args))
-        else:
-            key = group_name if group_name else str(args)
-
-        index = context.cycle(key, len(args))
-
-        if index >= len(args):
-            return 0
-
-        return buffer.write(
-            to_liquid_string(args[index], autoescape=context.autoescape)
-        )
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        if self.group:
-            yield self.group
-        yield from self.args
-
-
-class CycleTag(Tag):
-    """The built-in _cycle_ tag."""
-
-    name = TAG_CYCLE
-    block = False
-    node_class = CycleNode
-
-    def parse(self, stream: TokenStream) -> CycleNode:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        tokens = stream.into_inner(tag=token, eat=False)
-
-        group_name: Optional[Expression] = None
-        if tokens.peek.kind == TOKEN_COLON:
-            group_name = parse_primitive(self.env, tokens)
-            tokens.eat(TOKEN_COLON)
-
-        args = PositionalArgument.parse(self.env, tokens)
-
-        if not args:
-            raise LiquidSyntaxError("expected at least one argument", token=token)
-
-        return self.node_class(token, group_name, [arg.value for arg in args])

liquid/builtin/tags/decrement_tag.py

@@ -1,59 +0,0 @@
-"""The built-in _decrement_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import TextIO
-
-from liquid import ast
-from liquid.builtin.expressions import parse_identifier
-from liquid.tag import Tag
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid.builtin.expressions import Identifier
-    from liquid.context import RenderContext
-    from liquid.stream import TokenStream
-
-TAG_DECREMENT = sys.intern("decrement")
-
-
-class DecrementNode(ast.Node):
-    """The built-in _decrement_ tag."""
-
-    __slots__ = ("name",)
-
-    def __init__(self, token: Token, name: Identifier):
-        super().__init__(token)
-        self.name = name
-        self.blank = False
-
-    def __str__(self) -> str:
-        return f"{{% decrement {self.name} %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        return buffer.write(str(context.decrement(self.name)))
-
-    def template_scope(self) -> Iterable[Identifier]:
-        """Return variables this node adds to the template local scope."""
-        yield self.name
-
-
-class DecrementTag(Tag):
-    """The built-in _decrement_ tag."""
-
-    name = TAG_DECREMENT
-    block = False
-    node_class = DecrementNode
-
-    def parse(self, stream: TokenStream) -> DecrementNode:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        return self.node_class(
-            token,
-            name=parse_identifier(self.env, stream.into_inner(tag=token, eat=False)),
-        )

liquid/builtin/tags/doc_tag.py

@@ -1,68 +0,0 @@
-"""The built-in _doc_ tag."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from typing import Optional
-from typing import TextIO
-
-from liquid.ast import Node
-from liquid.exceptions import LiquidSyntaxError
-from liquid.tag import Tag
-from liquid.token import TOKEN_DOC
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_EXPRESSION
-from liquid.token import TOKEN_TAG
-
-if TYPE_CHECKING:
-    from liquid import RenderContext
-    from liquid import TokenStream
-    from liquid.token import Token
-
-
-class DocNode(Node):
-    """The built-in _doc_ tag."""
-
-    def __init__(self, token: Token, text: Optional[str] = None):
-        super().__init__(token)
-        self.text = text
-
-    def __str__(self) -> str:
-        return f"{{% doc %}}{self.text}{{% enddoc %}}"
-
-    def render_to_output(self, _: RenderContext, __: TextIO) -> int:
-        """Render the node to the output buffer."""
-        return 0
-
-
-class DocTag(Tag):
-    """The built-in _doc_ tag."""
-
-    block = True
-    name = "doc"
-    end = "enddoc"
-    node_class = DocNode
-
-    def parse(self, stream: TokenStream) -> DocNode:
-        """Parse tokens from _stream_ into an AST node."""
-        if stream.current.kind == TOKEN_DOC:
-            return self.node_class(stream.current, text=stream.current.value)
-
-        # This only happens if the doc tag is malformed
-        token = stream.eat(TOKEN_TAG)
-        text: list[str] = []
-
-        if stream.current.kind == TOKEN_EXPRESSION:
-            raise LiquidSyntaxError("unexpected expression", token=stream.current)
-
-        while True:
-            if stream.current.is_tag(self.name):
-                raise LiquidSyntaxError("nested doc tags are not allowed", token=token)
-            if stream.current.is_tag(self.end):
-                break
-            if stream.current.kind == TOKEN_EOF:
-                raise LiquidSyntaxError("doc tag wad never closed", token=token)
-            text.append(stream.current.value)
-            next(stream)
-
-        return self.node_class(token, text="".join(text))

liquid/builtin/tags/echo_tag.py

@@ -1,45 +0,0 @@
-"""The built-in _echo_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-
-from liquid.builtin.expressions import FilteredExpression
-from liquid.builtin.expressions import Nil
-from liquid.builtin.output import OutputNode
-from liquid.tag import Tag
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_TAG
-
-if TYPE_CHECKING:
-    from liquid.ast import Node
-    from liquid.expression import Expression
-    from liquid.stream import TokenStream
-
-TAG_ECHO = sys.intern("echo")
-
-
-class EchoNode(OutputNode):
-    """The built-in _echo_ tag."""
-
-    def __str__(self) -> str:
-        return f"{{% echo {self.expression} %}}"
-
-
-class EchoTag(Tag):
-    """The built-in _echo_ tag."""
-
-    name = TAG_ECHO
-    block = False
-    node_class = EchoNode
-
-    def parse(self, stream: TokenStream) -> Node:  # noqa: D102
-        token = stream.eat(TOKEN_TAG)
-        if stream.current.kind == TOKEN_EOF:
-            expr: Expression = Nil(stream.current)
-        else:
-            expr = FilteredExpression.parse(
-                self.env, stream.into_inner(tag=token, eat=False)
-            )
-        return self.node_class(token, expr)