python-liquid 2.2.1__tar.gz → 2.3.0__tar.gz

{python_liquid-2.2.1 → python_liquid-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-liquid
-Version: 2.2.1
+Version: 2.3.0
 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.1 → python_liquid-2.3.0}/liquid/__init__.py

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

{python_liquid-2.2.1 → python_liquid-2.3.0}/liquid/builtin/expressions/loop.py

@@ -123,29 +123,23 @@ class LoopExpression(Expression):
     ) -> tuple[Iterator[object], int]:
         offset_key = f"{self.identifier}-{self.iterable}"
 
-        if limit is None and offset is None:
-            context.stopindex(key=offset_key, index=length)
-            if self.reversed:
-                return reversed(list(it)), length
-            return it, length
-
         if offset == "continue":
-            offset = context.stopindex(key=offset_key)
-            length = max(length - offset, 0)
-        elif offset is not None:
-            assert isinstance(offset, int), f"found {offset!r}"
-            length = max(length - offset, 0)
+            start = context.stopindex(offset_key)
+        else:
+            start = int(offset or 0)
+
+        stop = None if limit is None else limit + start
 
-        if limit is not None:
-            length = min(length, limit)
+        start_ = min(max(start, 0), length)
+        stop_ = min(stop or length, length)
+        length_ = max(stop_ - start_, 0)
 
-        stop = offset + length if offset else length
-        context.stopindex(key=offset_key, index=stop)
-        it = islice(it, offset, stop)
+        context.stopindex(key=offset_key, index=stop_)
+        it = islice(it, start_, stop_)
 
         if self.reversed:
-            return reversed(list(it)), length
-        return it, length
+            return reversed(list(it)), length_
+        return it, length_
 
     def evaluate(self, context: RenderContext) -> tuple[Iterator[object], int]:
         it, length = self._to_iter(self.iterable.evaluate(context), context)

{python_liquid-2.2.1 → python_liquid-2.3.0}/liquid/builtin/expressions/primitive.py

@@ -39,6 +39,12 @@ if TYPE_CHECKING:
     from liquid import TokenStream
 
 
+# MAX_RANGE = (2**53) - 1
+# MIN_RANGE = -(2**53) + 1
+MAX_RANGE = 1024
+MIN_RANGE = -1024
+
+
 class Nil(Expression):
     __slots__ = ()
 
@@ -249,7 +255,9 @@ class RangeLiteral(Expression):
         if start > stop:
             return range(0)
 
-        return range(start, stop + 1)
+        return range(
+            clamp(start, MIN_RANGE, MAX_RANGE), clamp(stop + 1, MIN_RANGE, MAX_RANGE)
+        )
 
     def evaluate(self, context: RenderContext) -> range:
         return self._make_range(
@@ -415,3 +423,8 @@ def parse_string_or_path(
 def is_empty(obj: object) -> bool:
     """Return True if _obj_ is considered empty."""
     return isinstance(obj, (list, dict, str)) and not obj
+
+
+def clamp(n: int, min_value: int, max_value: int) -> int:
+    """Clamp _n_ between _min_value_ and _max_value_."""
+    return max(min_value, min(n, max_value))

{python_liquid-2.2.1 → python_liquid-2.3.0}/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)
 
@@ -66,7 +76,11 @@ class FileSystemLoader(BaseLoader):
         for base in self.search_path:
             source_path = base.joinpath(template_path)
 
-            if not source_path.exists() or not source_path.is_file():
+            try:
+                if not source_path.exists() or not source_path.is_file():
+                    continue
+            except OSError:
+                # "File name too long", for example
                 continue
 
             if self.reject_symlinks:

{python_liquid-2.2.1 → python_liquid-2.3.0}/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.1 → python_liquid-2.3.0}/liquid/builtin/tags/liquid_tag.py

@@ -127,7 +127,8 @@ class LiquidTag(Tag):
                     self._tokenize(
                         token_.value,
                         token=token_,
-                    )
+                    ),
+                    block_depth_carry=stream.block_depth,
                 ),
                 end=(),
             )

{python_liquid-2.2.1 → python_liquid-2.3.0}/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.1 → python_liquid-2.3.0}/liquid/environment.py

@@ -18,6 +18,7 @@ from . import builtin
 from .analyze_tags import InnerTagMap
 from .analyze_tags import TagAnalysis
 from .builtin import DictLoader
+from .exceptions import BlockNestingError
 from .exceptions import LiquidError
 from .exceptions import LiquidSyntaxError
 from .exceptions import TemplateInheritanceError
@@ -79,6 +80,10 @@ class Environment:
             template loaded from this environment.
     """
 
+    block_nesting_limit: ClassVar[int] = 30
+    """The maximum markup block nesting depth allowed before a `BlockNestingError`
+    exception is raised."""
+
     context_depth_limit: ClassVar[int] = 30
     """The maximum number of times a render context can be extended or wrapped before
     raising a `ContextDepthError`."""
@@ -275,7 +280,7 @@ class Environment:
         """
         try:
             nodes = self._parse(source)
-        except (LiquidSyntaxError, TemplateInheritanceError) as err:
+        except (LiquidSyntaxError, TemplateInheritanceError, BlockNestingError) as err:
             err.template_name = path
             raise err
         except Exception as err:  # noqa: BLE001

{python_liquid-2.2.1 → python_liquid-2.3.0}/liquid/exceptions.py

@@ -191,6 +191,10 @@ class ResourceLimitError(LiquidError):
     """Base class for exceptions relating to resource limits."""
 
 
+class BlockNestingError(ResourceLimitError):
+    """The exception raised when block nesting limit is reached."""
+
+
 class ContextDepthError(ResourceLimitError):
     """Exception raised when the maximum context depth is reached.
 

{python_liquid-2.2.1 → python_liquid-2.3.0}/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.1 → python_liquid-2.3.0}/liquid/parser.py

@@ -9,6 +9,7 @@ from typing import Iterator
 
 from .ast import BlockNode
 from .ast import Node
+from .exceptions import BlockNestingError
 from .exceptions import LiquidError
 from .token import TOKEN_COMMENT
 from .token import TOKEN_CONTENT
@@ -69,6 +70,10 @@ class Parser:
         output = tags[TOKEN_OUTPUT]
 
         nodes: list[Node] = []
+        stream.block_depth += 1
+
+        if stream.block_depth > self.env.block_nesting_limit:
+            raise BlockNestingError("block nesting limit reached", token=None)
 
         while stream.current.kind != TOKEN_EOF:
             if stream.current.kind == TOKEN_TAG and stream.current.value in end:
@@ -92,6 +97,7 @@ class Parser:
 
             next(stream)
 
+        stream.block_depth -= 1
         return BlockNode(stream.current, nodes)
 
 

{python_liquid-2.2.1 → python_liquid-2.3.0}/liquid/stream.py

@@ -18,12 +18,10 @@ class TokenStream:
 
     eof = Token(TOKEN_EOF, TOKEN_EOF, -1, "")
 
-    def __init__(
-        self,
-        tokens: Iterator[Token],
-    ):
+    def __init__(self, tokens: Iterator[Token], block_depth_carry: int = 0):
         self.tokens = list(tokens)
         self.pos = 0
+        self.block_depth = block_depth_carry
 
     def __next__(self) -> Token:
         return self.next_token()

{python_liquid-2.2.1 → python_liquid-2.3.0}/pyproject.toml

@@ -46,6 +46,7 @@ packages = ["liquid"]
 
 [tool.hatch.envs.default]
 dependencies = [
+  "hypothesis",
   "pytest",
   "pytest-cov",
   "pytest-mock",
@@ -159,6 +160,7 @@ convention = "google"
 "liquid/builtin/loaders/__init__.py" = ["D104", "I001"]
 "liquid/builtin/tags/__init__.py" = ["D104", "I001"]
 "tests/*" = ["D100", "D101", "D104", "D103", "D102", "D209", "D205", "SIM117"]
+"tests/test_compliance.py" = ["E501"]
 "performance/*" = ["D103", "PLR2004", "T201", "D100"]
 "liquid/builtin/expressions/primitive.py" = ["D101", "D102"]
 "liquid/builtin/expressions/path.py" = ["D101", "D102"]