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

liquid/tags/decrement.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..tokens import TOKEN_TAG_END
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Expression, Markup, Partial
+    from .._parser import Parser
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class DecrementTag:
+    blank = False
+    tag = "decrement"
+
+    __slots__ = ("name", "token")
+
+    def __init__(self, token: Token, name: Name) -> None:
+        self.token = token
+        self.name = name
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        name = parser.parse_identifier()
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        return DecrementTag(token, name)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buffer.write(str(context.decrement(self.name.value)))
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buffer.write(str(context.decrement(self.name.value)))
+
+    def children(self) -> list[Markup]:
+        return []
+
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return [self.name]
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []

liquid/tags/doc.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..tokens import TOKEN_COMMENT, TOKEN_TAG_END, token_value
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Expression, Markup, Partial
+    from .._parser import Parser
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class DocTag:
+    blank = True
+    tag = "doc"
+
+    __slots__ = ("text", "token")
+
+    def __init__(self, token: Token, text: str) -> None:
+        self.token = token
+        self.text = text
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        comment = parser.eat(TOKEN_COMMENT)
+        parser.eat_tag_prefix("enddoc")
+        return DocTag(token, token_value(comment, parser.source))
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        return None
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        return None
+
+    def children(self) -> list[Markup]:
+        return []
+
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []

liquid/tags/echo.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..tokens import TOKEN_TAG_END
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Expression, Markup, Partial
+    from .._parser import Parser
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class EchoTag:
+    blank = False
+    tag = "echo"
+
+    __slots__ = ("expression", "token")
+
+    def __init__(self, token: Token, expression: Expression) -> None:
+        self.token = token
+        self.expression = expression
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        expr = parser.parse_filtered_expression()
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        return EchoTag(token, expr)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buffer.write(
+            context.env.serialize(
+                self.expression.evaluate(context), context, self.expression.span
+            )
+        )
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        buffer.write(
+            context.env.serialize(
+                await self.expression.evaluate_async(context),
+                context,
+                self.expression.span,
+            )
+        )
+
+    def children(self) -> list[Markup]:
+        return []
+
+    def expressions(self) -> list[Expression]:
+        return [self.expression]
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []

liquid/tags/else_.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._markup import is_blank_block, render_block, render_block_async
+from ..expressions import BooleanLiteral
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Block, Expression, Markup, Partial
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class ElseBlock:
+    tag = "else"
+
+    __slots__ = ("blank", "block", "expression", "token")
+
+    def __init__(self, token: Token, block: Block) -> None:
+        self.token = token
+        self.block = block
+        self.blank = is_blank_block(self.block)
+        self.expression = BooleanLiteral(token, True)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        render_block(self.block, context, buffer)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        await render_block_async(self.block, context, buffer)
+
+    def children(self) -> list[Markup]:
+        return [node for node in self.block if not isinstance(node, str)]
+
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    def filter_strings(self) -> None:
+        markup: Block = [node for node in self.block if not isinstance(node, str)]
+        self.block = markup

liquid/tags/error.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Expression, Markup, Partial
+    from ..exceptions import LiquidSyntaxError
+    from ..expressions import Name
+    from ..tokens import Token
+
+
+class ErrorNode:
+    blank = True
+    tag = ""
+
+    __slots__ = ("error", "token")
+
+    def __init__(self, token: Token, err: LiquidSyntaxError) -> None:
+        self.token = token
+        self.error = err
+
+    def __str__(self) -> str:
+        return self.error.detailed_message()
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        if context.capture_errors:
+            raise self.error
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        if context.capture_errors:
+            raise self.error
+
+    def children(self) -> list[Markup]:
+        return []
+
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def block_scope(self) -> list[Name]:
+        return []
+
+    def template_scope(self) -> list[Name]:
+        return []
+
+    def partials(self, context: RenderContext) -> list[Partial]:
+        return []
+
+    async def partials_async(self, context: RenderContext) -> list[Partial]:
+        return []