python-liquid 2.2.0__tar.gz → 2.2.2__tar.gz

{python_liquid-2.2.0 → python_liquid-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-liquid
-Version: 2.2.0
+Version: 2.2.2
 Summary: A Python engine for the Liquid template language.
 Project-URL: Change Log, https://github.com/jg-rp/liquid/blob/main/CHANGES.md
 Project-URL: Documentation, https://jg-rp.github.io/liquid/

{python_liquid-2.2.0 → python_liquid-2.2.2}/liquid/__init__.py

@@ -56,7 +56,7 @@ from .tag import Tag
 
 from . import future
 
-__version__ = "2.2.0"
+__version__ = "2.2.2"
 
 __all__ = (
     "AwareBoundTemplate",

{python_liquid-2.2.0 → python_liquid-2.2.2}/liquid/builtin/loaders/file_system_loader.py

@@ -29,6 +29,9 @@ class FileSystemLoader(BaseLoader):
         ext: A default file extension. Should include a leading period.
         reject_symlinks: When `True`, reject paths to symlinks that resolve to files
             outside the search path. Defaults to `False`.
+
+    Raise:
+        ValueError if `ext` is not a valid suffix.
     """
 
     def __init__(
@@ -48,6 +51,10 @@ class FileSystemLoader(BaseLoader):
         self.ext = ext
         self.reject_symlinks = reject_symlinks
 
+        # Raise a ValueError early if `ext` is invalid.
+        if ext:
+            Path("x").with_suffix(ext)
+
     def resolve_path(self, template_name: str) -> Path:
         """Return a path to the template identified by _template_name_.
 
@@ -57,6 +64,9 @@ class FileSystemLoader(BaseLoader):
         """
         template_path = Path(template_name)
 
+        if not template_path.name:
+            raise TemplateNotFoundError(template_name)
+
         if self.ext and not template_path.suffix:
             template_path = template_path.with_suffix(self.ext)
 

{python_liquid-2.2.0 → python_liquid-2.2.2}/liquid/builtin/tags/case_tag.py

@@ -145,7 +145,7 @@ class CaseTag(Tag):
 
         # Eat whitespace or junk between `case` and when/else/endcase
         while (
-            stream.current.kind != TOKEN_TAG
+            stream.current.kind not in (TOKEN_TAG, TOKEN_EOF)
             and stream.current.value not in ENDWHENBLOCK
         ):
             next(stream)

{python_liquid-2.2.0 → python_liquid-2.2.2}/liquid/builtin/tags/cycle_tag.py

@@ -11,6 +11,7 @@ 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
@@ -124,4 +125,8 @@ class CycleTag(Tag):
             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])

{python_liquid-2.2.0 → python_liquid-2.2.2}/liquid/context.py

@@ -175,7 +175,12 @@ class RenderContext:
         """
         it = iter(path)
         root = next(it)
-        assert isinstance(root, str)
+
+        if not isinstance(root, str):
+            if default == UNDEFINED:
+                hint = f"{root} is undefined"
+                return self.env.undefined(str(root), hint=hint, token=token)
+            return default
 
         try:
             obj = self.scope[root]
@@ -316,7 +321,7 @@ class RenderContext:
         """Return the index of the next item in the cycle."""
         namespace: dict[object, int] = self.tag_namespace["cycles"]
         idx = namespace.setdefault(key, 0)
-        namespace[key] = (idx + 1) % length
+        namespace[key] = (idx + 1) % (length or 1)  # Just in case.
         return idx
 
     def ifchanged(self, val: str) -> bool:

{python_liquid-2.2.0 → python_liquid-2.2.2}/liquid/extra/tags/_with.py

@@ -35,16 +35,20 @@ class WithNode(Node):
         self.block = block
         self.blank = self.block.blank
 
-    def render_to_output(self, context: RenderContext, buffer: TextIO) -> int:
-        namespace = dict(arg.evaluate(context) for arg in self.args)
-
-        with context.extend(namespace):
+    def render_to_output(
+        self,
+        context: RenderContext,
+        buffer: TextIO,
+    ) -> int:
+        with context.extend({a.name: a.value.evaluate(context) for a in self.args}):
             return self.block.render(context, buffer)
 
     async def render_to_output_async(
-        self, context: RenderContext, buffer: TextIO
+        self,
+        context: RenderContext,
+        buffer: TextIO,
     ) -> int:
-        namespace = dict([await arg.evaluate_async(context) for arg in self.args])
+        namespace = {a.name: await a.value.evaluate_async(context) for a in self.args}
         with context.extend(namespace):
             return await self.block.render_async(context, buffer)
 
@@ -54,21 +58,16 @@ class WithNode(Node):
         *,
         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 from (arg.value for arg in self.args)
 
     def block_scope(self) -> Iterable[Identifier]:
-        """Return variables this node adds to the node's block scope."""
         yield from (Identifier(p.name, token=p.token) for p in self.args)
 
 
 class WithTag(Tag):
-    """The extra _with_ tag."""
-
     name = TAG_WITH
     end = TAG_ENDWITH
     node_class = WithNode
@@ -76,8 +75,6 @@ class WithTag(Tag):
     def parse(self, stream: TokenStream) -> Node:
         token = stream.eat(TOKEN_TAG)
         args = KeywordArgument.parse(self.env, stream.into_inner(tag=token))
-
-        # Parse the block
         block = get_parser(self.env).parse_block(stream, (TAG_ENDWITH, TOKEN_EOF))
         stream.expect(TOKEN_TAG, value=TAG_ENDWITH)
         return self.node_class(token, args=args, block=block)

{python_liquid-2.2.0 → python_liquid-2.2.2}/liquid/stream.py

@@ -16,7 +16,7 @@ from .token import reverse_operators
 class TokenStream:
     """Step through a sequence of tokens."""
 
-    eof = Token(TOKEN_EOF, "", -1, "")
+    eof = Token(TOKEN_EOF, TOKEN_EOF, -1, "")
 
     def __init__(
         self,

{python_liquid-2.2.0 → python_liquid-2.2.2}/pyproject.toml

@@ -46,6 +46,7 @@ packages = ["liquid"]
 
 [tool.hatch.envs.default]
 dependencies = [
+  "hypothesis",
   "pytest",
   "pytest-cov",
   "pytest-mock",