Include i18n and i10n tags and filters

docs/environment.md

@@ -88,6 +88,10 @@ class MyLiquidEnvironment(Environment):
         return dict(self.globals)
 ```
 
+## Extra tags and filters
+
+TODO:
+
 ## Tolerance
 
 Templates are parsed and rendered in strict mode by default. Where syntax and render-time type errors raise an exception as soon as possible. You can change the error tolerance mode with the `tolerance` argument to [`Environment`](api/environment.md).

liquid/__init__.py

@@ -1,5 +1,8 @@
 from pathlib import Path
 from typing import Iterable
+from typing import Iterator
+from typing import Optional
+from typing import TextIO
 from typing import Union
 
 from markupsafe import Markup
@@ -44,6 +47,9 @@
 from .analyze_tags import TagAnalysis
 from .analyze_tags import DEFAULT_INNER_TAG_MAP
 
+from .messages import MessageTuple
+from .messages import Translations
+from .messages import extract_from_template
 
 from .stream import TokenStream
 from .tag import Tag
@@ -54,18 +60,22 @@
 
 __all__ = (
     "AwareBoundTemplate",
+    "BlockNode",
     "BoundTemplate",
     "CachingChoiceLoader",
+    "CachingDictLoader",
     "CachingFileSystemLoader",
+    "CachingLoaderMixin",
     "ChoiceLoader",
-    "RenderContext",
+    "ConditionalBlockNode",
     "DebugUndefined",
     "DEFAULT_INNER_TAG_MAP",
     "DictLoader",
     "Environment",
     "escape",
     "Expression",
-    "CachingDictLoader",
+    "extract_from_template",
+    "FalsyStrictUndefined",
     "FileSystemLoader",
     "future",
     "FutureAwareBoundTemplate",
@@ -74,26 +84,25 @@
     "is_undefined",
     "make_choice_loader",
     "make_file_system_loader",
-    "CachingLoaderMixin",
     "Markup",
+    "MessageTuple",
     "Mode",
+    "Node",
     "PackageLoader",
+    "parse",
+    "render_async",
+    "render",
+    "RenderContext",
     "soft_str",
     "StrictDefaultUndefined",
     "StrictUndefined",
+    "Tag",
     "TagAnalysis",
     "Template",
     "Token",
-    "Undefined",
     "TokenStream",
-    "parse",
-    "render",
-    "render_async",
-    "Node",
-    "BlockNode",
-    "ConditionalBlockNode",
-    "Tag",
-    "FalsyStrictUndefined",
+    "Translations",
+    "Undefined",
 )
 
 DEFAULT_ENVIRONMENT = Environment()
@@ -202,3 +211,36 @@ def make_choice_loader(
         )
 
     return ChoiceLoader(loaders=loaders)
+
+
+def extract_liquid(
+    fileobj: TextIO,
+    keywords: list[str],
+    comment_tags: Optional[list[str]] = None,
+    options: Optional[dict[object, object]] = None,  # noqa: ARG001
+) -> Iterator[MessageTuple]:
+    """A babel compatible translation message extraction method for Liquid templates.
+
+    See https://babel.pocoo.org/en/latest/messages.html
+
+    Keywords are the names of Liquid filters or tags operating on translatable
+    strings. For a filter to contribute to message extraction, it must also
+    appear as a child of a `FilteredExpression` and be a `TranslatableFilter`.
+    Similarly, tags must produce a node that is a `TranslatableTag`.
+
+    Where a Liquid comment contains a prefix in `comment_tags`, the comment
+    will be attached to the translatable filter or tag immediately following
+    the comment. Python Liquid's non-standard shorthand comments are not
+    supported.
+
+    Options are arguments passed to the `liquid.Template` constructor with the
+    contents of `fileobj` as the template's source. Use `extract_from_template`
+    to extract messages from an existing template bound to an existing
+    environment.
+    """
+    template = Environment(extra=True).parse(fileobj.read())
+    return extract_from_template(
+        template=template,
+        keywords=keywords,
+        comment_tags=comment_tags,
+    )

liquid/builtin/expressions/__init__.py

@@ -3,6 +3,7 @@
 from .arguments import Parameter
 from .arguments import PositionalArgument
 from .arguments import parse_arguments
+from .filtered import Filter
 from .filtered import FilteredExpression
 from .filtered import TernaryFilteredExpression
 from .logical import BooleanExpression
@@ -42,4 +43,5 @@
     "tokenize",
     "parse_name",
     "Parameter",
+    "Filter",
 )

liquid/builtin/expressions/path.py

@@ -77,6 +77,9 @@ def location(self) -> Location:
         """
         return tuple([s.location() if isinstance(s, Path) else s for s in self.path])
 
+    def head(self) -> int | str | Path:
+        return self.path[0]
+
     def evaluate(self, context: RenderContext) -> object:
         return context.get(
             [p.evaluate(context) if isinstance(p, Path) else p for p in self.path],

liquid/builtin/tags/comment_tag.py

@@ -55,6 +55,11 @@ class CommentTag(Tag):
 
     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 = []
 

liquid/exceptions.py

@@ -209,6 +209,22 @@ class LocalNamespaceLimitError(ResourceLimitError):
     """Exception raised when a local namespace limit has been exceeded."""
 
 
+class TranslationError(Error):
+    """Base exception for translation errors."""
+
+
+class TranslationSyntaxError(LiquidSyntaxError):
+    """Exception raised when a syntax error is found within a translation block."""
+
+
+class TranslationValueError(TranslationError):
+    """Exception raised when message interpolation fails with a ValueError."""
+
+
+class TranslationKeyError(TranslationError):
+    """Exception raised when message interpolation fails with a KeyError."""
+
+
 # LiquidValueError inheriting from LiquidSyntaxError does not make complete sense.
 # The alternative is to have multiple to_int functions that raise more appropriate
 # exceptions depending on whether we are parsing or rendering when attempting to

liquid/extra/__init__.py

@@ -3,6 +3,15 @@
 from typing import TYPE_CHECKING
 
 from .filters import JSON
+from .filters import Currency
+from .filters import DateTime
+from .filters import GetText
+from .filters import NGetText
+from .filters import NPGetText
+from .filters import Number
+from .filters import PGetText
+from .filters import Translate
+from .filters import Unit
 from .filters import index
 from .filters import script_tag
 from .filters import sort_numeric
@@ -11,6 +20,7 @@
 from .tags import CallTag
 from .tags import ExtendsTag
 from .tags import MacroTag
+from .tags import TranslateTag
 from .tags import WithTag
 
 if TYPE_CHECKING:
@@ -31,6 +41,13 @@
     "sort_numeric",
     "stylesheet_tag",
     "WithTag",
+    "Unit",
+    "Number",
+    "GetText",
+    "PGetText",
+    "PGetText",
+    "Currency",
+    "DateTime",
 )
 
 
@@ -41,6 +58,7 @@ def add_tags(env: Environment) -> None:
     env.add_tag(MacroTag)
     env.add_tag(CallTag)
     env.add_tag(WithTag)
+    env.add_tag(TranslateTag)
 
 
 def add_filters(env: Environment) -> None:
@@ -51,6 +69,23 @@ def add_filters(env: Environment) -> None:
     env.add_filter("sort_numeric", sort_numeric)
     env.add_filter("stylesheet_tag", stylesheet_tag)
 
+    env.filters[GetText.name] = GetText(autoescape_message=env.autoescape)
+    env.filters[NGetText.name] = NGetText(autoescape_message=env.autoescape)
+    env.filters[NPGetText.name] = NPGetText(autoescape_message=env.autoescape)
+    env.filters[PGetText.name] = PGetText(autoescape_message=env.autoescape)
+    env.filters[Translate.name] = Translate(autoescape_message=env.autoescape)
+    env.filters["currency"] = Currency()
+    env.filters["money"] = Currency()
+    env.filters["money_with_currency"] = Currency(default_format="¤#,##0.00 ¤¤")
+    env.filters["money_without_currency"] = Currency(default_format="#,##0.00")
+    env.filters["money_without_trailing_zeros"] = Currency(
+        default_format="¤#,###",
+        currency_digits=False,
+    )
+    env.filters["datetime"] = DateTime()
+    env.filters["decimal"] = Number()
+    env.filters["unit"] = Unit()
+
 
 def add_tags_and_filters(env: Environment) -> None:  # pragma: no cover
     """Register all extra tags and filters with an environment."""

liquid/extra/filters/__init__.py

@@ -1,13 +1,33 @@
 from ._json import JSON  # noqa: D104
 from .array import index
 from .array import sort_numeric
+from .babel import Currency
+from .babel import DateTime
+from .babel import Number
+from .babel import Unit
 from .html import script_tag
 from .html import stylesheet_tag
+from .translate import BaseTranslateFilter
+from .translate import GetText
+from .translate import NGetText
+from .translate import NPGetText
+from .translate import PGetText
+from .translate import Translate
 
 __all__ = (
     "index",
     "JSON",
     "script_tag",
     "sort_numeric",
     "stylesheet_tag",
+    "Currency",
+    "DateTime",
+    "Number",
+    "Unit",
+    "BaseTranslateFilter",
+    "GetText",
+    "NGetText",
+    "NPGetText",
+    "PGetText",
+    "Translate",
 )