python-liquid 2.0.1__tar.gz → 2.0.2__tar.gz

{python_liquid-2.0.1 → python_liquid-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-liquid
-Version: 2.0.1
+Version: 2.0.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/
@@ -104,6 +104,7 @@ $ conda install -c conda-forge python-liquid
 ## Related Projects
 
 - [Python Liquid2](https://github.com/jg-rp/python-liquid2): A new Python engine for Liquid with [extra features](https://jg-rp.github.io/python-liquid2/migration/#new-features).
+- [Ruby Liquid2](https://github.com/jg-rp/ruby-liquid2): Liquid2 templates for Ruby.
 - [LiquidScript](https://github.com/jg-rp/liquidscript): A JavaScript engine for Liquid with a similar high-level API to Python Liquid.
 
 ## Quick Start

{python_liquid-2.0.1 → python_liquid-2.0.2}/README.md

@@ -74,6 +74,7 @@ $ conda install -c conda-forge python-liquid
 ## Related Projects
 
 - [Python Liquid2](https://github.com/jg-rp/python-liquid2): A new Python engine for Liquid with [extra features](https://jg-rp.github.io/python-liquid2/migration/#new-features).
+- [Ruby Liquid2](https://github.com/jg-rp/ruby-liquid2): Liquid2 templates for Ruby.
 - [LiquidScript](https://github.com/jg-rp/liquidscript): A JavaScript engine for Liquid with a similar high-level API to Python Liquid.
 
 ## Quick Start

{python_liquid-2.0.1 → python_liquid-2.0.2}/liquid/__init__.py

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

{python_liquid-2.0.1 → python_liquid-2.0.2}/liquid/builtin/expressions/loop.py

@@ -97,14 +97,11 @@ class LoopExpression(Expression):
         if isinstance(obj, range):
             return iter(obj), len(obj)
         if isinstance(obj, str) and not context.env.string_sequences:
-            return iter([obj]), 1
+            return (iter([]), 0) if not obj else (iter([obj]), 1)
         if isinstance(obj, Sequence):
             return iter(obj), len(obj)
 
-        raise LiquidTypeError(
-            f"expected an iterable at '{self.iterable}', found '{obj}'",
-            token=self.token,
-        )
+        return iter([]), 0
 
     def _to_int(self, obj: object, *, token: Token) -> int:
         try:

{python_liquid-2.0.1 → python_liquid-2.0.2}/liquid/extra/tags/macro_tag.py

@@ -94,6 +94,8 @@ class MacroNode(Node):
 
     def block_scope(self) -> Iterable[Identifier]:
         """Return variables this node adds to the node's block scope."""
+        yield Identifier("args", token=self.token)
+        yield Identifier("kwargs", token=self.token)
         yield from (Identifier(p.name, token=p.token) for p in self.args.values())
 
 

{python_liquid-2.0.1 → python_liquid-2.0.2}/liquid/static_analysis.py

@@ -301,19 +301,25 @@ async def _analyze_async(
 def _extract_filters(
     expression: Expression, template_name: str
 ) -> Iterable[tuple[str, Span]]:
-    if (
-        isinstance(expression, (FilteredExpression, TernaryFilteredExpression))
-        and expression.filters
-    ):
-        yield from (
-            (f.name, Span(template_name, f.token.start_index))
-            for f in expression.filters
-        )
+    if isinstance(expression, TernaryFilteredExpression):
+        yield from _extract_filters(expression.left, template_name)
 
-    if isinstance(expression, TernaryFilteredExpression) and expression.tail_filters:
+        if expression.filters:
+            yield from (
+                (f.name, Span(template_name, f.token.start_index))
+                for f in expression.filters
+            )
+
+        if expression.tail_filters:
+            yield from (
+                (f.name, Span(template_name, f.token.start_index))
+                for f in expression.tail_filters
+            )
+
+    if isinstance(expression, FilteredExpression) and expression.filters:
         yield from (
             (f.name, Span(template_name, f.token.start_index))
-            for f in expression.tail_filters
+            for f in expression.filters
         )
 
     for expr in expression.children():

python_liquid-2.0.1/liquid/golden/__init__.py

@@ -1,173 +0,0 @@
-from . import abs_filter  # noqa: D104
-from . import append_filter
-from . import assign_tag
-from . import at_least_filter
-from . import at_most_filter
-from . import base64_decode_filter
-from . import base64_encode_filter
-from . import base64_url_safe_decode_filter
-from . import base64_url_safe_encode_filter
-from . import capitalize_filter
-from . import capture_tag
-from . import case_tag
-from . import ceil_filter
-from . import comment_tag
-from . import compact_filter
-from . import concat_filter
-from . import cycle_tag
-from . import date_filter
-from . import decrement_tag
-from . import default_filter
-from . import divided_by_filter
-from . import doc_tag
-from . import downcase_filter
-from . import echo_tag
-from . import escape_filter
-from . import escape_once_filter
-from . import find_filter
-from . import find_index_filter
-from . import first_filter
-from . import floor_filter
-from . import for_tag
-from . import has_filter
-from . import identifiers
-from . import if_tag
-from . import ifchanged_tag
-from . import illegal
-from . import include_tag
-from . import increment_tag
-from . import inline_comment_tag
-from . import join_filter
-from . import last_filter
-from . import liquid_tag
-from . import lstrip_filter
-from . import map_filter
-from . import minus_filter
-from . import modulo_filter
-from . import newline_to_br_filter
-from . import not_liquid
-from . import output_statement
-from . import plus_filter
-from . import prepend_filter
-from . import range_objects
-from . import raw_tag
-from . import reject_filter
-from . import remove_filter
-from . import remove_first_filter
-from . import remove_last_filter
-from . import render_tag
-from . import replace_filter
-from . import replace_first_filter
-from . import replace_last_filter
-from . import reverse_filter
-from . import round_filter
-from . import rstrip_filter
-from . import size_filter
-from . import slice_filter
-from . import sort_filter
-from . import sort_natural_filter
-from . import special
-from . import split_filter
-from . import strip_filter
-from . import strip_html_filter
-from . import strip_newlines_filter
-from . import sum_filter
-from . import tablerow_tag
-from . import times_filter
-from . import truncate_filter
-from . import truncatewords_filter
-from . import uniq_filter
-from . import unless_tag
-from . import upcase_filter
-from . import url_decode_filter
-from . import url_encode_filter
-from . import where_filter
-from . import whitespace_control
-
-test_cases = [
-    abs_filter,
-    append_filter,
-    assign_tag,
-    at_least_filter,
-    at_most_filter,
-    base64_decode_filter,
-    base64_encode_filter,
-    base64_url_safe_decode_filter,
-    base64_url_safe_encode_filter,
-    capitalize_filter,
-    capture_tag,
-    case_tag,
-    ceil_filter,
-    comment_tag,
-    compact_filter,
-    concat_filter,
-    cycle_tag,
-    date_filter,
-    decrement_tag,
-    default_filter,
-    divided_by_filter,
-    doc_tag,
-    downcase_filter,
-    echo_tag,
-    escape_filter,
-    escape_once_filter,
-    find_filter,
-    find_index_filter,
-    first_filter,
-    floor_filter,
-    for_tag,
-    has_filter,
-    identifiers,
-    if_tag,
-    ifchanged_tag,
-    illegal,
-    include_tag,
-    increment_tag,
-    inline_comment_tag,
-    join_filter,
-    last_filter,
-    liquid_tag,
-    lstrip_filter,
-    map_filter,
-    minus_filter,
-    modulo_filter,
-    newline_to_br_filter,
-    not_liquid,
-    output_statement,
-    plus_filter,
-    prepend_filter,
-    range_objects,
-    raw_tag,
-    reject_filter,
-    remove_filter,
-    remove_first_filter,
-    remove_last_filter,
-    render_tag,
-    replace_filter,
-    replace_first_filter,
-    replace_last_filter,
-    reverse_filter,
-    round_filter,
-    rstrip_filter,
-    size_filter,
-    slice_filter,
-    sort_filter,
-    sort_natural_filter,
-    special,
-    split_filter,
-    strip_filter,
-    strip_html_filter,
-    strip_newlines_filter,
-    sum_filter,
-    tablerow_tag,
-    times_filter,
-    truncate_filter,
-    truncatewords_filter,
-    uniq_filter,
-    unless_tag,
-    upcase_filter,
-    url_decode_filter,
-    url_encode_filter,
-    where_filter,
-    whitespace_control,
-]

python_liquid-2.0.1/liquid/golden/abs_filter.py

@@ -1,73 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `abs` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="positive integer",
-        template=r"{{ 5 | abs }}",
-        expect="5",
-    ),
-    Case(
-        description="negative integer",
-        template=r"{{ -5 | abs }}",
-        expect="5",
-    ),
-    Case(
-        description="positive float",
-        template=r"{{ 5.4 | abs }}",
-        expect="5.4",
-    ),
-    Case(
-        description="negative float",
-        template=r"{{ -5.4 | abs }}",
-        expect="5.4",
-    ),
-    Case(
-        description="zero",
-        template=r"{{ 0 | abs }}",
-        expect="0",
-    ),
-    Case(
-        description="positive string integer",
-        template=r"{{ '5' | abs }}",
-        expect="5",
-    ),
-    Case(
-        description="negative string integer",
-        template=r"{{ '-5' | abs }}",
-        expect="5",
-    ),
-    Case(
-        description="positive string float",
-        template=r"{{ '5.1' | abs }}",
-        expect="5.1",
-    ),
-    Case(
-        description="negative string float",
-        template=r"{{ '-5.1' | abs }}",
-        expect="5.1",
-    ),
-    Case(
-        description="unexpected argument",
-        template=r"{{ -3 | abs: 1 }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="string not a number",
-        template=r"{{ 'hello' | abs }}",
-        expect="0",
-    ),
-    Case(
-        description="not a string, int or float",
-        template=r"{{ a | abs }}",
-        expect="0",
-        globals={"a": {}},
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | abs }}",
-        expect="0",
-    ),
-]

python_liquid-2.0.1/liquid/golden/append_filter.py

@@ -1,43 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `append` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="concat",
-        template=r'{{ "hello" | append: "there" }}',
-        expect="hellothere",
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | append: 'there' }}",
-        expect="5there",
-    ),
-    Case(
-        description="argument not a string",
-        template=r'{{ "hello" | append: 5 }}',
-        expect="hello5",
-    ),
-    Case(
-        description="missing argument",
-        template=r'{{ "hello" | append }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="too many arguments",
-        template=r'{{ "hello" | append: "how", "are", "you" }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r'{{ nosuchthing | append: "hi" }}',
-        expect="hi",
-    ),
-    Case(
-        description="undefined argument",
-        template=r'{{ "hi" | append: nosuchthing }}',
-        expect="hi",
-    ),
-]

python_liquid-2.0.1/liquid/golden/assign_tag.py

@@ -1,45 +0,0 @@
-"""Golden tests cases for testing liquid's `assign` tag."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="assign a filtered literal",
-        template=r"{% assign foo = 'foo' | upcase %}{{ foo }}",
-        expect="FOO",
-    ),
-    Case(
-        description="local variables shadow global variables",
-        template=r"{{ foo }}{% assign foo = 'foo' | upcase %}{{ foo }}",
-        expect="barFOO",
-        globals={"foo": "bar"},
-    ),
-    Case(
-        description="assign a range literal",
-        template=r"{% assign foo = (1..3) %}{{ foo | join: '#' }}",
-        expect="1#2#3",
-    ),
-    Case(
-        description="assign to variable with a hyphen",
-        template=r"{% assign some-thing = 'foo' %}{{ some-thing }}",
-        expect="foo",
-    ),
-    Case(
-        description="assign an existing array",
-        template=r"{% assign foo = bar %}{{ foo[0] }}/{{ foo[1] }}",
-        expect="a/b",
-        globals={"bar": ["a", "b", "c"]},
-    ),
-    Case(
-        description="assign an item from an existing object with quoted notation",
-        template=r"{% assign foo = bar['baz'] %}{{ foo }}",
-        expect="hello",
-        globals={"bar": {"baz": "hello"}},
-    ),
-    Case(
-        description="assign with quoted notation and extra whitespace",
-        template=r"{% assign foo = bar[ 'baz'  ] %}{{ foo }}",
-        expect="hello",
-        globals={"bar": {"baz": "hello"}},
-    ),
-]

python_liquid-2.0.1/liquid/golden/at_least_filter.py

@@ -1,78 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `at_least` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="positive integer < arg",
-        template=r"{{ 5 | at_least: 8 }}",
-        expect="8",
-    ),
-    Case(
-        description="positive integer > arg",
-        template=r"{{ 8 | at_least: 5 }}",
-        expect="8",
-    ),
-    Case(
-        description="negative integer < arg",
-        template=r"{{ -8 | at_least: 5 }}",
-        expect="5",
-    ),
-    Case(
-        description="positive integer == arg",
-        template=r"{{ 5 | at_least: 5 }}",
-        expect="5",
-    ),
-    Case(
-        description="positive float < arg",
-        template=r"{{ 5.4 | at_least: 8.9 }}",
-        expect="8.9",
-    ),
-    Case(
-        description="positive float > arg",
-        template=r"{{ 8.4 | at_least: 5.9 }}",
-        expect="8.4",
-    ),
-    Case(
-        description="positive string > arg",
-        template=r'{{ "9" | at_least: 8 }}',
-        expect="9",
-    ),
-    Case(
-        description="missing arg",
-        template=r"{{ 5 | at_least }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="too many args",
-        template=r"{{ 5 | at_least: 1, 2}}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | at_least: 5 }}",
-        expect="5",
-    ),
-    Case(
-        description="undefined argument",
-        template=r"{{ 5 | at_least: nosuchthing }}",
-        expect="5",
-    ),
-    Case(
-        description="left value not a number",
-        template=r'{{ "abc" | at_least: 2 }}',
-        expect="2",
-    ),
-    Case(
-        description="left value not a number negative argument",
-        template=r'{{ "abc" | at_least: -2 }}',
-        expect="0",
-    ),
-    Case(
-        description="argument string not a number",
-        template=r'{{ -1 | at_least: "abc" }}',
-        expect="0",
-    ),
-]

python_liquid-2.0.1/liquid/golden/at_most_filter.py

@@ -1,68 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `at_most` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="positive integer < arg",
-        template=r"{{ 5 | at_most: 8 }}",
-        expect="5",
-    ),
-    Case(
-        description="positive integer > arg",
-        template=r"{{ 8 | at_most: 5 }}",
-        expect="5",
-    ),
-    Case(
-        description="negative integer < arg",
-        template=r"{{ -8 | at_most: 5 }}",
-        expect="-8",
-    ),
-    Case(
-        description="positive integer == arg",
-        template=r"{{ 5 | at_most: 5 }}",
-        expect="5",
-    ),
-    Case(
-        description="positive float < arg",
-        template=r"{{ 5.4 | at_most: 8.9 }}",
-        expect="5.4",
-    ),
-    Case(
-        description="positive float > arg",
-        template=r"{{ 8.4 | at_most: 5.9 }}",
-        expect="5.9",
-    ),
-    Case(
-        description="positive string > arg",
-        template=r'{{ "9" | at_most: 8 }}',
-        expect="8",
-    ),
-    Case(
-        description="missing arg",
-        template=r"{{ 5 | at_most }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="too many args",
-        template=r"{{ 5 | at_most: 1, 2}}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | at_most: 5 }}",
-        expect="0",
-    ),
-    Case(
-        description="undefined argument",
-        template=r"{{ 5 | at_most: nosuchthing }}",
-        expect="0",
-    ),
-    Case(
-        description="left value not a number",
-        template=r'{{ "abc" | at_most: -2 }}',
-        expect="-2",
-    ),
-]

python_liquid-2.0.1/liquid/golden/base64_decode_filter.py

@@ -1,43 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `base64_decode` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="from string",
-        template=r'{{ "XyMvLg==" | base64_decode }}',
-        expect="_#/.",
-    ),
-    Case(
-        description="from string with URL unsafe",
-        template=r"{{ a | base64_decode }}",
-        expect=(
-            r"abcdefghijklmnopqrstuvwxyz "
-            r"ABCDEFGHIJKLMNOPQRSTUVWXYZ "
-            r"1234567890 !@#$%^&*()-=_+/?.:;[]{}\|"
-        ),
-        globals={
-            "a": (
-                "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVV"
-                "ldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8/Ljo7W117fVx8"
-            )
-        },
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | base64_decode }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="unexpected argument",
-        template=r'{{ "hello" | base64_decode: 5 }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | base64_decode }}",
-        expect="",
-    ),
-]

python_liquid-2.0.1/liquid/golden/base64_encode_filter.py

@@ -1,42 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `base64_encode` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="from string",
-        template=r'{{ "_#/." | base64_encode }}',
-        expect="XyMvLg==",
-    ),
-    Case(
-        description="from string with URL unsafe",
-        template=r"{{ a | base64_encode }}",
-        expect=(
-            "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVV"
-            "ldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8/Ljo7W117fVx8"
-        ),
-        globals={
-            "a": (
-                r"abcdefghijklmnopqrstuvwxyz "
-                r"ABCDEFGHIJKLMNOPQRSTUVWXYZ "
-                r"1234567890 !@#$%^&*()-=_+/?.:;[]{}\|"
-            )
-        },
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | base64_encode }}",
-        expect="NQ==",
-    ),
-    Case(
-        description="unexpected argument",
-        template=r'{{ "hello" | base64_encode: 5 }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | base64_encode }}",
-        expect="",
-    ),
-]