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

liquid/builtin/tags/case_tag.py

@@ -1,287 +0,0 @@
-"""The built-in _case_ tag."""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import TextIO
-from typing import Union
-
-from liquid.ast import BlockNode
-from liquid.ast import Node
-from liquid.builtin.expressions import parse_primitive
-from liquid.builtin.expressions.logical import _eq  # type: ignore
-from liquid.exceptions import LiquidSyntaxError
-from liquid.expression import Expression
-from liquid.parser import get_parser
-from liquid.tag import Tag
-from liquid.token import TOKEN_COMMA
-from liquid.token import TOKEN_EOF
-from liquid.token import TOKEN_OR
-from liquid.token import TOKEN_TAG
-from liquid.token import Token
-
-if TYPE_CHECKING:
-    from liquid import Environment
-    from liquid import TokenStream
-    from liquid.context import RenderContext
-
-
-TAG_CASE = sys.intern("case")
-TAG_ENDCASE = sys.intern("endcase")
-TAG_WHEN = sys.intern("when")
-TAG_ELSE = sys.intern("else")
-
-ENDWHENBLOCK = frozenset((TAG_ENDCASE, TAG_WHEN, TAG_ELSE, TOKEN_EOF))
-ENDCASEBLOCK = frozenset((TAG_ENDCASE, TAG_ELSE))
-
-
-class CaseNode(Node):
-    """The built-in _case_ tag."""
-
-    __slots__ = ("blocks", "expression")
-
-    def __init__(
-        self,
-        token: Token,
-        expression: Expression,
-        blocks: list[Union[MultiExpressionBlockNode, BlockNode]],
-    ):
-        super().__init__(token)
-        self.expression = expression
-        self.blocks = blocks
-
-        self.blank = all(node.blank for node in self.blocks)
-
-        for node in self.blocks:
-            node.blank = self.blank
-            if isinstance(node, MultiExpressionBlockNode):
-                node.block.blank = self.blank
-
-    def __str__(self) -> str:
-        blocks: list[str] = []
-        for block in self.blocks:
-            if isinstance(block, BlockNode):
-                blocks.append(f"{{% else %}}{block}")
-            else:
-                blocks.append(str(block))
-
-        blocks_ = "".join(blocks)
-
-        return f"{{% case {self.expression} %}}\n{blocks_}{{% endcase %}}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        count = 0
-        default = True
-
-        for block in self.blocks:
-            # Always render truthy `when` blocks, no matter the order.
-            if isinstance(block, MultiExpressionBlockNode):
-                count_ = block.render(context, buffer)
-                if count_ >= 0:
-                    default = False
-                    count += count_
-            # Only render `else` blocks if all preceding `when` blocks are falsy.
-            # Multiple `else` blocks are OK.
-            elif default:
-                count += block.render(context, buffer)
-
-        return count
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        count = 0
-        default = True
-
-        for block in self.blocks:
-            # Always render truthy `when` blocks, no matter the order.
-            if isinstance(block, MultiExpressionBlockNode):
-                count_ = await block.render_async(context, buffer)
-                if count_ >= 0:
-                    default = False
-                    count += count_
-            # Only render `else` blocks if all preceding `when` blocks are falsy.
-            # Multiple `else` blocks are OK.
-            elif default:
-                count += await block.render_async(context, buffer)
-
-        return count
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        yield from self.blocks
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        yield self.expression
-
-
-class CaseTag(Tag):
-    """The built-in _case_ tag."""
-
-    name = TAG_CASE
-    end = TAG_ENDCASE
-    node_class = CaseNode
-
-    def __init__(self, env: Environment):
-        super().__init__(env)
-        self.parser = get_parser(self.env)
-
-    def parse(self, stream: TokenStream) -> Node:
-        """Parse tokens from _stream_ into an AST node."""
-        token = stream.eat(TOKEN_TAG)
-        tokens = stream.into_inner(tag=token)
-        left = parse_primitive(self.env, tokens)
-        tokens.expect_eos()
-
-        # Eat whitespace or junk between `case` and when/else/endcase
-        while (
-            stream.current.kind not in (TOKEN_TAG, TOKEN_EOF)
-            and stream.current.value not in ENDWHENBLOCK
-        ):
-            next(stream)
-
-        parse_block = get_parser(self.env).parse_block
-        blocks: list[Union[MultiExpressionBlockNode, BlockNode]] = []
-
-        while not stream.current.is_tag(TAG_ENDCASE):
-            if stream.current.is_tag(TAG_ELSE):
-                next(stream)
-                blocks.append(parse_block(stream, ENDWHENBLOCK))
-            elif stream.current.is_tag(TAG_WHEN):
-                alternative_token = next(stream)
-                expressions = self._parse_when_expression(
-                    stream.into_inner(tag=alternative_token)
-                )
-                alternative_block = parse_block(stream, ENDWHENBLOCK)
-
-                blocks.append(
-                    MultiExpressionBlockNode(
-                        alternative_token,
-                        alternative_block,
-                        _AnyExpression(alternative_token, left, expressions),
-                    )
-                )
-            else:
-                raise LiquidSyntaxError(
-                    f"unexpected tag {stream.current.value!r}", token=stream.current
-                )
-
-        stream.expect(TOKEN_TAG, TAG_ENDCASE)
-
-        return self.node_class(
-            token,
-            left,
-            blocks,
-        )
-
-    def _parse_when_expression(self, stream: TokenStream) -> list[Expression]:
-        expressions: list[Expression] = [parse_primitive(self.env, stream)]
-        while stream.current.kind in (TOKEN_COMMA, TOKEN_OR):
-            next(stream)
-            try:
-                expressions.append(parse_primitive(self.env, stream))
-            except LiquidSyntaxError:
-                # Use expressions we have so far an discard the rest.
-                return expressions
-
-        return expressions
-
-
-class _AnyExpression(Expression):
-    __slots__ = (
-        "left",
-        "expressions",
-    )
-
-    def __init__(
-        self, token: Token, left: Expression, expressions: list[Expression]
-    ) -> None:
-        super().__init__(token)
-        self.left = left
-        self.expressions = expressions
-
-    def __str__(self) -> str:
-        return ", ".join(str(expr) for expr in self.expressions)
-
-    def evaluate(self, context: RenderContext) -> list[bool]:
-        left = self.left.evaluate(context)
-        return [_eq(left, right.evaluate(context)) for right in self.expressions]
-
-    async def evaluate_async(self, context: RenderContext) -> list[bool]:
-        left = await self.left.evaluate_async(context)
-        return [
-            _eq(left, await right.evaluate_async(context)) for right in self.expressions
-        ]
-
-    def children(self) -> list[Expression]:
-        return self.expressions
-
-
-class MultiExpressionBlockNode(Node):
-    """A node containing a sequence of nodes guarded by a choice of expressions."""
-
-    __slots__ = ("block", "expression")
-
-    def __init__(
-        self,
-        token: Token,
-        block: BlockNode,
-        expression: _AnyExpression,
-    ) -> None:
-        super().__init__(token)
-        self.block = block
-        self.expression = expression
-        self.blank = self.block.blank
-
-    def __str__(self) -> str:
-        return f"{{% when {self.expression} %}}{self.block}"
-
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        """Render the node to the output buffer."""
-        matches = self.expression.evaluate(context)
-
-        if any(matches):
-            return sum(
-                [self.block.render(context, buffer) for _ in range(matches.count(True))]
-            )
-
-        return -1
-
-    async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
-    ) -> int:
-        """Render the node to the output buffer."""
-        matches = await self.expression.evaluate_async(context)
-
-        if any(matches):
-            return sum(
-                [
-                    await self.block.render_async(context, buffer)
-                    for _ in range(matches.count(True))
-                ]
-            )
-
-        return -1
-
-    def children(
-        self,
-        static_context: RenderContext,  # noqa: ARG002
-        *,
-        include_partials: bool = True,  # noqa: ARG002
-    ) -> Iterable[Node]:
-        """Return this node's children."""
-        yield self.block
-
-    def expressions(self) -> Iterable[Expression]:
-        """Return this node's expressions."""
-        yield self.expression

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)