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

liquid/tags/translate.py

@@ -0,0 +1,316 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from gettext import NullTranslations
+from typing import TYPE_CHECKING, cast
+
+import markupsafe
+
+from .. import expressions
+from .._messages import MESSAGES, MessageText, Translations
+from ..exceptions import TranslationSyntaxError
+from ..expressions import Name
+from ..tokens import TOKEN_COMMA, TOKEN_TAG_END
+from .output import OutputStatement
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Block, Expression, Markup, Partial
+    from .._parser import Parser
+    from .._template import Template
+    from ..expressions import KeywordArgument
+    from ..tokens import Token
+
+RE_VARS = re.compile(r"(?<!%)%\((\w+)\)s")
+RE_WHITESPACE = re.compile(r"\s*\n\s*")
+
+
+class TranslateTag:
+    blank = False
+    tag = "translate"
+
+    default_translations = NullTranslations()
+    translations_var = "translations"
+    message_count_var = "count"
+    message_context_var = "context"
+
+    __slots__ = ("args", "plural_block", "singular_block", "token")
+
+    def __init__(
+        self,
+        token: Token,
+        args: list[KeywordArgument],
+        singular_block: MessageBlock,
+        plural_block: MessageBlock | None,
+    ) -> None:
+        self.token = token
+        self.args = args
+        self.singular_block = singular_block
+        self.plural_block = plural_block
+
+    @classmethod
+    def parse(cls, token: Token, parser: Parser) -> Markup:
+        if parser.kind() == TOKEN_COMMA:
+            # Leading commas are OK.
+            parser.next()
+
+        args = parser.parse_keyword_arguments(require_commas=True)
+
+        if parser.kind() == TOKEN_COMMA:
+            # Trailing commas are OK.
+            parser.next()
+
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        singular_block = cls.message_block(
+            parser, parser.parse_block(("endtranslate", "plural"))
+        )
+        plural_block: MessageBlock | None = None
+
+        if parser.tag("plural"):
+            parser.eat_empty_tag("plural")
+            plural_block = cls.message_block(
+                parser, parser.parse_block(("endtranslate",))
+            )
+
+        parser.eat_empty_tag("endtranslate")
+        return TranslateTag(token, args, singular_block, plural_block)
+
+    @classmethod
+    def message_block(cls, parser: Parser, block: Block) -> MessageBlock:
+        message_text: list[str] = []
+        message_vars: list[str] = []
+
+        for node in block:
+            if isinstance(node, str):
+                message_text.append(node.replace("%", "%%"))
+
+            elif isinstance(node, OutputStatement) and isinstance(
+                node.expression, expressions.Variable
+            ):
+                expr = node.expression
+
+                if not isinstance(expr.root, Name) or expr.selectors:
+                    raise TranslationSyntaxError(
+                        "expected a translation variable, found a path",
+                        token=expr.span,
+                        source=parser.source,
+                        name=parser.template_name,
+                    )
+
+                message_text.append(f"%({expr.root.value})s")
+                message_vars.append(expr.root.value)
+
+            else:
+                raise TranslationSyntaxError(
+                    "unexpected markup in translation text",
+                    token=node.token,
+                    source=parser.source,
+                    name=parser.template_name,
+                )
+
+        msg = "".join(message_text)
+        return MessageBlock(block, RE_WHITESPACE.sub(" ", msg.strip()), message_vars)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        translations = self.resolve_translations(context)
+        scope: dict[str, object] = {}
+
+        with context.extend(scope):
+            for arg in self.args:
+                scope[arg.name.value] = arg.expr.evaluate(context)
+
+            count = self.resolve_count(context, scope)
+            message_context = self.resolve_message_context(context, scope)
+
+            message_text = self.gettext(
+                translations,
+                count=count,
+                message_context=message_context,
+            )
+
+            return buffer.write(self._format_message(context, message_text))
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        translations = self.resolve_translations(context)
+        scope: dict[str, object] = {}
+
+        with context.extend(scope):
+            for arg in self.args:
+                scope[arg.name.value] = await arg.expr.evaluate_async(context)
+
+            count = self.resolve_count(context, scope)
+            message_context = self.resolve_message_context(context, scope)
+
+            message_text = self.gettext(
+                translations,
+                count=count,
+                message_context=message_context,
+            )
+
+            return buffer.write(self._format_message(context, message_text))
+
+    def resolve_translations(
+        self, context: RenderContext
+    ) -> Translations | NullTranslations:
+        """Return a translations object from the current render context."""
+        t = context.resolve(self.translations_var)
+
+        if context.env.is_nil(t):
+            return self.default_translations
+
+        return cast("Translations", t)
+
+    def resolve_count(
+        self,
+        context: RenderContext,
+        block_scope: dict[str, object],
+    ) -> int | None:
+        """Return a message count."""
+        return int(
+            context.env.to_numeric(
+                block_scope.get(self.message_count_var, 1), context, 1
+            )
+        )
+
+    def resolve_message_context(
+        self,
+        context: RenderContext,
+        block_scope: dict[str, object],
+    ) -> str | None:
+        """Return the message context string."""
+        message_context = block_scope.pop(self.message_context_var, None)
+
+        if message_context:
+            return (
+                str(message_context)
+                if not isinstance(message_context, str)
+                else message_context
+            )  # Just in case we get a Markupsafe object.
+
+        return None
+
+    def gettext(
+        self,
+        translations: Translations | NullTranslations,
+        count: int | None,
+        message_context: str | None,
+    ) -> str:
+        """Get translated text from the given translations object."""
+        if self.plural_block and count:
+            if message_context:
+                return translations.npgettext(
+                    message_context,
+                    self.singular_block.text,
+                    self.plural_block.text,
+                    count,
+                )
+
+            return translations.ngettext(
+                self.singular_block.text,
+                self.plural_block.text,
+                count,
+            )
+
+        if message_context:
+            return translations.pgettext(message_context, self.singular_block.text)
+
+        return translations.gettext(self.singular_block.text)
+
+    def children(self) -> list[Markup]:
+        result = [
+            node for node in self.singular_block.block if not isinstance(node, str)
+        ]
+
+        if self.plural_block:
+            result.extend(
+                node for node in self.plural_block.block if not isinstance(node, str)
+            )
+
+        return result
+
+    def expressions(self) -> list[Expression]:
+        return [arg.expr for arg in self.args]
+
+    def block_scope(self) -> list[Name]:
+        return [arg.name for arg in self.args]
+
+    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 messages(self, template: Template) -> Iterable[MessageText]:
+        if not self.singular_block.block:
+            return ()
+
+        message_context: Expression | None = None
+        for arg in self.args:
+            if arg.name.value == self.message_context_var:
+                message_context = arg.expr
+
+        if self.plural_block:
+            if message_context and isinstance(
+                message_context, expressions.StringLiteral
+            ):
+                funcname = "npgettext"
+                message: MESSAGES = (
+                    (message_context.value, "c"),
+                    self.singular_block.text,
+                    self.plural_block.text,
+                )
+            else:
+                funcname = "ngettext"
+                message = (
+                    self.singular_block.text,
+                    self.plural_block.text,
+                )
+        elif message_context and isinstance(message_context, expressions.StringLiteral):
+            funcname = "pgettext"
+            message = (
+                (message_context.value, "c"),
+                self.singular_block.text,
+            )
+        else:
+            funcname = "gettext"
+            message = (self.singular_block.text,)
+
+        return (
+            MessageText(
+                lineno=template.line_col(self.token)[0],
+                funcname=funcname,
+                message=message,
+            ),
+        )
+
+    def _format_message(
+        self,
+        context: RenderContext,
+        message_text: str,
+    ) -> str:
+        """Return the message string formatted with the given message variables."""
+        if context.env.autoescape:
+            message_text = markupsafe.Markup(message_text)
+
+        _vars = {
+            k: context.env.to_str(context.resolve(k), context, self.token)
+            for k in RE_VARS.findall(message_text)
+        }
+
+        return message_text % _vars
+
+
+@dataclass(slots=True)
+class MessageBlock:
+    block: Block
+    text: str
+    args: list[str]

liquid/tags/unless.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..tokens import (
+    TOKEN_TAG_END,
+    TOKEN_TAG_NAME,
+    TOKEN_TAG_START,
+)
+from .else_ import ElseBlock
+from .if_ import ElsIfBlock, IfBlock
+
+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 UnlessTag:
+    tag = ""
+
+    __slots__ = ("blank", "blocks", "token")
+
+    def __init__(
+        self, token: Token, blocks: list[UnlessBlock | ElsIfBlock | ElseBlock]
+    ) -> None:
+        self.token = token
+        self.blocks = blocks
+        self.blank = all(block.blank for block in self.blocks)
+
+        if self.blank:
+            for block in self.blocks:
+                block.filter_strings()
+
+    @classmethod
+    def parse(cls, token: Token, parser: Parser) -> Markup:
+        blocks: list[UnlessBlock | ElsIfBlock | ElseBlock] = []
+
+        parser.expect_expression()
+        expression = parser.parse_expression(infix=True, expect_end_of_expression=True)
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        block = parser.parse_block(("else", "elsif", "endunless"))
+        blocks.append(UnlessBlock(token, expression, block))
+
+        while 1:
+            tag_name = parser.tags(("else", "elsif"))
+
+            if tag_name == "elsif":
+                blocks.append(cls.parse_else_if(parser))
+            elif tag_name == "else":
+                name_token = parser.eat_tag("else")
+                blocks.append(
+                    ElseBlock(
+                        name_token, parser.parse_block(("else", "elsif", "endunless"))
+                    )
+                )
+            else:
+                break
+
+        parser.eat_empty_tag("endunless")
+        return UnlessTag(token, blocks)
+
+    @classmethod
+    def parse_else_if(cls, parser: Parser) -> ElsIfBlock:
+        parser.eat(TOKEN_TAG_START)
+        parser.skip_whitespace_control()
+        token = parser.eat(TOKEN_TAG_NAME)
+        parser.expect_expression()
+        expression = parser.parse_expression(infix=True)
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+        return ElsIfBlock(
+            token, expression, parser.parse_block(("else", "elsif", "endunless"))
+        )
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        for block in self.blocks:
+            if isinstance(block, UnlessBlock):
+                if not context.env.truthy(block.expression.evaluate(context), context):
+                    return block.render(context, buffer)
+            elif context.env.truthy(block.expression.evaluate(context), context):
+                return block.render(context, buffer)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        for block in self.blocks:
+            if isinstance(block, UnlessBlock):
+                if not context.env.truthy(
+                    await block.expression.evaluate_async(context), context
+                ):
+                    return await block.render_async(context, buffer)
+            elif context.env.truthy(
+                await block.expression.evaluate_async(context), context
+            ):
+                return await block.render_async(context, buffer)
+
+    def children(self) -> list[Markup]:
+        return list(self.blocks)
+
+    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 []
+
+
+class UnlessBlock(IfBlock):
+    tag = "unless"

liquid/tags/with_.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._markup import is_blank_block, render_block, render_block_async
+from ..tokens import TOKEN_COMMA, TOKEN_TAG_END
+
+if TYPE_CHECKING:
+    from .._context import RenderContext
+    from .._io import StringBuffer
+    from .._markup import Block, Expression, Markup, Partial
+    from .._parser import Parser
+    from ..expressions import KeywordArgument, Name
+    from ..tokens import Token
+
+
+class WithTag:
+    tag = "with"
+
+    __slots__ = ("args", "blank", "block", "token")
+
+    def __init__(self, token: Token, args: list[KeywordArgument], block: Block) -> None:
+        self.token = token
+        self.args = args
+        self.block = block
+        self.blank = is_blank_block(block)
+
+    @staticmethod
+    def parse(token: Token, parser: Parser) -> Markup:
+        if parser.kind() == TOKEN_COMMA:
+            # Leading commas are OK.
+            parser.next()
+
+        args = parser.parse_keyword_arguments(require_commas=True)
+
+        if parser.kind() == TOKEN_COMMA:
+            # Trailing commas are OK.
+            parser.next()
+
+        parser.carry_whitespace_control()
+        parser.eat(TOKEN_TAG_END)
+
+        block = parser.parse_block(("endwith",))
+        parser.eat_empty_tag("endwith")
+        return WithTag(token, args, block)
+
+    def render(self, context: RenderContext, buffer: StringBuffer) -> None:
+        scope: dict[str, object] = {}
+
+        with context.extend(scope):
+            # Later args have access to earlier args.
+            for arg in self.args:
+                scope[arg.name.value] = arg.expr.evaluate(context)
+
+            render_block(self.block, context, buffer)
+
+    async def render_async(self, context: RenderContext, buffer: StringBuffer) -> None:
+        scope: dict[str, object] = {}
+
+        with context.extend(scope):
+            # Later args have access to earlier args.
+            for arg in self.args:
+                scope[arg.name.value] = await arg.expr.evaluate_async(context)
+
+            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 [arg.expr for arg in self.args]
+
+    def block_scope(self) -> list[Name]:
+        return [arg.name for arg in self.args]
+
+    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 []