python-liquid 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

liquid/golden/doc_tag.py

@@ -1,61 +0,0 @@
-"""Golden tests cases for testing liquid's `doc` tag."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="don't render docs",
-        template=r"{% doc %}don't render me{% enddoc %}",
-        expect="",
-    ),
-    Case(
-        description="doc arguments is an error",
-        template=r"{% doc hello %}don't render me{% enddoc %}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="doc tag block must be closed",
-        template=r"{% doc %}don't render me",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="doc text is not parsed",
-        template=(
-            r"{% doc %}"
-            r"    {% if true %}"
-            r"    {% if ... %}"
-            r"    {%- for ? -%}"
-            r"    {% while true %}"
-            r"    {%"
-            r"    unless if"
-            r"    %}"
-            r"    {% endcase %}"
-            r"    {% raw %}"
-            r"{% enddoc %}"
-        ),
-        expect="",
-    ),
-    Case(
-        description="nested docs are not allowed",
-        template=r"{% doc hello %}Hello{% doc %}{% enddoc %}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="docs containing unclosed tags are ok",
-        template=r"{% doc %}{% assign x = y {% enddoc %}",
-        expect="",
-    ),
-    Case(
-        description="docs containing unclosed output are ok",
-        template=r"{% doc %}{{ foo {% enddoc %}",
-        expect="",
-    ),
-    Case(
-        description="whitespace control",
-        template="foo\n {%- doc %}I'm a doc comment{% enddoc -%}  \tbar",
-        expect="foobar",
-    ),
-]

liquid/golden/downcase_filter.py

@@ -1,27 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `downcase` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="make lower case",
-        template=r'{{ "HELLO" | downcase }}',
-        expect="hello",
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | downcase }}",
-        expect="5",
-    ),
-    Case(
-        description="unexpected argument",
-        template=r'{{ "HELLO" | downcase: 5 }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | downcase }}",
-        expect="",
-    ),
-]

liquid/golden/echo_tag.py

@@ -1,116 +0,0 @@
-"""Golden tests cases for testing liquid's `echo` tag."""
-
-import datetime
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="render a string literal",
-        template=r"{% echo 'hello' %}",
-        expect="hello",
-    ),
-    Case(
-        description="render an integer literal",
-        template=r"{% echo 123 %}",
-        expect="123",
-    ),
-    Case(
-        description="render a float literal",
-        template=r"{% echo 1.23 %}",
-        expect="1.23",
-    ),
-    Case(
-        description="render a variable from the global namespace",
-        template=r"{% echo product.title %}",
-        expect="foo",
-        globals={"product": {"title": "foo"}},
-    ),
-    Case(
-        description="render a variable from the local namespace",
-        template=r"{% assign name = 'Brian' %}{% echo name %}",
-        expect="Brian",
-    ),
-    Case(
-        description="render an undefined variable",
-        template=r"{% echo age %}",
-        expect="",
-    ),
-    Case(
-        description="render an undefined property",
-        template=r"{% echo product.age %}",
-        expect="",
-        globals={"product": {"title": "foo"}},
-    ),
-    Case(
-        description="access an array item by index",
-        template=r"{% echo product.tags[1] %}",
-        expect="garden",
-        globals={"product": {"tags": ["sports", "garden"]}},
-    ),
-    Case(
-        description="access an array item by negative index",
-        template=r"{% echo product.tags[-2] %}",
-        expect="sports",
-        globals={"product": {"tags": ["sports", "garden"]}},
-    ),
-    Case(
-        description="access array item by index stored in a local variable",
-        template=r"{% assign i = 1 %}{% echo product.tags[i] %}",
-        expect="garden",
-        globals={"product": {"tags": ["sports", "garden"]}},
-    ),
-    Case(
-        description="render a global identifier with a filter",
-        template=r"{% echo product.title | upcase %}",
-        expect="FOO",
-        globals={"product": {"title": "foo"}},
-    ),
-    Case(
-        description="dump an array from the global context",
-        template=r"{% echo product.tags %}",
-        expect="sportsgarden",
-        globals={"product": {"tags": ["sports", "garden"]}},
-    ),
-    Case(
-        description="assign a variable the value of an existing variable",
-        template=(
-            r"{% capture some %}hello{% endcapture %}"
-            r"{% assign other = some %}"
-            r"{% assign some = 'foo' %}"
-            r"{% echo some %}-{% echo other %}"
-        ),
-        expect="foo-hello",
-    ),
-    Case(
-        description="traverse variables with bracketed identifiers",
-        template=r"{% echo site.data.menu[include.menu][include.locale] %}",
-        expect="it works!",
-        globals={
-            "site": {"data": {"menu": {"foo": {"bar": "it works!"}}}},
-            "include": {"menu": "foo", "locale": "bar"},
-        },
-    ),
-    Case(
-        description="render the special built in variable 'now'",
-        template=r"{% echo now | date: '%d/%m/%Y' %}",
-        expect=datetime.datetime.now().strftime(r"%d/%m/%Y"),
-        standard=False,
-    ),
-    Case(
-        description="render the special built in variable 'today'",
-        template=r"{% echo today | date: '%d/%m/%Y' %}",
-        expect=datetime.date.today().strftime(r"%d/%m/%Y"),
-        standard=False,
-    ),
-    Case(
-        description="access an undefined variable by index",
-        template=r"{% echo nosuchthing[0] %}",
-        expect="",
-    ),
-    Case(
-        description="nothing to echo",
-        template=r"{% echo %}",
-        expect="",
-    ),
-]

liquid/golden/escape_filter.py

@@ -1,27 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `escape` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="make HTML-safe",
-        template=r'{{ "<p>test</p>" | escape }}',
-        expect="&lt;p&gt;test&lt;/p&gt;",
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | escape }}",
-        expect="5",
-    ),
-    Case(
-        description="unexpected argument",
-        template=r'{{ "HELLO" | escape: 5 }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | escape }}",
-        expect="",
-    ),
-]

liquid/golden/escape_once_filter.py

@@ -1,32 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `escape_once` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="make HTML-safe",
-        template=r'{{ "<p>test</p>" | escape_once }}',
-        expect="<p>test</p>",
-    ),
-    Case(
-        description="make HTML-safe from mixed safe and markup.",
-        template=r'{{ "&lt;p&gt;test&lt;/p&gt;<p>test</p>" | escape_once }}',
-        expect="&lt;p&gt;test&lt;/p&gt;&lt;p&gt;test&lt;/p&gt;",
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | escape_once }}",
-        expect="5",
-    ),
-    Case(
-        description="unexpected argument",
-        template=r'{{ "HELLO" | escape_once: 5 }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | escape_once }}",
-        expect="",
-    ),
-]

liquid/golden/find_filter.py

@@ -1,90 +0,0 @@
-"""Test cases for the standard `find` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="array of strings, default value",
-        template=r"{{ a | find: 'z' }}",
-        expect="z",
-        globals={"a": ["x", "y", "z"]},
-    ),
-    Case(
-        description="array of strings, substring match, default value",
-        template=r"{{ a | find: 'oo' }}",
-        expect="zoo",
-        globals={"a": ["x", "y", "zoo"]},
-    ),
-    Case(
-        description="array of strings, default value, no match",
-        template=r"{{ a | find: 'foo' }}",
-        expect="",
-        globals={"a": ["x", "y", "zoo"]},
-    ),
-    # Case(
-    #     description="array of ints, default value",
-    #     template=r"{{ a | find: 2 }}",
-    #     expect="1",
-    #     globals={"a": [1, 2, 3]},
-    # ),
-    Case(
-        description="mixed array, default value",
-        template=r"{{ a | find: 'z' }}",
-        expect="",
-        globals={"a": ["x", None, "z", False, True]},
-    ),
-    Case(
-        description="string input, default value, match",
-        template=r"{{ a | find: 'z' }}",
-        expect="zoo",
-        globals={"a": "zoo"},
-    ),
-    Case(
-        description="string input, string value, match",
-        template=r"{{ a | find: 'z', 'z' }}",
-        expect="zoo",
-        globals={"a": "zoo"},
-    ),
-    Case(
-        description="string input, string value, no match",
-        template=r"{{ a | find: 'z', 'y' }}",
-        expect="",
-        globals={"a": "zoo"},
-    ),
-    Case(
-        description="hash input, default value, match",
-        template=r"{% assign b = a | find: 'z' %}{{ b.z }}",
-        expect="42",
-        globals={"a": {"z": 42}},
-    ),
-    Case(
-        description="hash input, default value, no match",
-        template=r"{% assign b = a | find: 'foo' %}{{ b }}",
-        expect="",
-        globals={"a": {"z": 42}},
-    ),
-    Case(
-        description="hash input, int value, match",
-        template=r"{% assign b = a | find: 'z', 42 %}{{ b.z }}",
-        expect="42",
-        globals={"a": {"z": 42}},
-    ),
-    Case(
-        description="hash input, explicit nil, match",
-        template=r"{% assign b = a | find: 'z', nil %}{{ b.z }}",
-        expect="",
-        globals={"a": {"z": None}},
-    ),
-    Case(
-        description="array of hashes, int value, match",
-        template=r"{% assign b = a | find: 'z', 42 %}{{ b.foo }}",
-        expect="bar",
-        globals={"a": [{"x": 99}, {"z": 42, "foo": "bar"}]},
-    ),
-    Case(
-        description="array of hashes, with a nil",
-        template=r"{% assign b = a | find: 'z', 42 %}{{ b.foo }}",
-        expect="",
-        globals={"a": [{"x": 99}, None, {"z": 42, "foo": "bar"}]},
-    ),
-]

liquid/golden/find_index_filter.py

@@ -1,96 +0,0 @@
-"""Test cases for the standard `find_index` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="array of strings, default value",
-        template=r"{{ a | find_index: 'z' }}",
-        expect="2",
-        globals={"a": ["x", "y", "z"]},
-    ),
-    Case(
-        description="array of strings, substring match, default value",
-        template=r"{{ a | find_index: 'oo' }}",
-        expect="2",
-        globals={"a": ["x", "y", "zoo"]},
-    ),
-    Case(
-        description="array of strings, default value, no match",
-        template=r"{{ a | find_index: 'foo' }}",
-        expect="",
-        globals={"a": ["x", "y", "zoo"]},
-    ),
-    # Case(
-    #     description="array of ints, default value",
-    #     template=r"{{ a | find_index: 3 }}",
-    #     expect="0",
-    #     globals={"a": [1, 2, 3]},
-    # ),
-    Case(
-        description="mixed array, default value",
-        template=r"{{ a | find_index: 'z' }}",
-        expect="",
-        globals={"a": ["x", None, "z", False, True]},
-    ),
-    Case(
-        description="string input, default value, match",
-        template=r"{{ a | find_index: 'z' }}",
-        expect="0",
-        globals={"a": "zoo"},
-    ),
-    Case(
-        description="string input, string value, match",
-        template=r"{{ a | find_index: 'z', 'z' }}",
-        expect="0",
-        globals={"a": "zoo"},
-    ),
-    Case(
-        description="string input, string value, no match",
-        template=r"{{ a | find_index: 'z', 'y' }}",
-        expect="",
-        globals={"a": "zoo"},
-    ),
-    Case(
-        description="hash input, default value, match",
-        template=r"{{ a | find_index: 'z' }}",
-        expect="0",
-        globals={"a": {"z": 42}},
-    ),
-    Case(
-        description="hash input, default value, no match",
-        template=r"{{ a | find_index: 'foo' }}",
-        expect="",
-        globals={"a": {"z": 42}},
-    ),
-    Case(
-        description="hash input, int value, match",
-        template=r"{{ a | find_index: 'z', 42 }}",
-        expect="0",
-        globals={"a": {"z": 42}},
-    ),
-    Case(
-        description="hash input, explicit nil, match",
-        template=r"{{ a | find_index: 'z', nil }}",
-        expect="",
-        globals={"a": {"z": None}},
-    ),
-    Case(
-        description="array of hashes, explicit nil, match",
-        template=r"{{ a | find_index: 'z', nil }}",
-        expect="",
-        globals={"a": ["foo", "bar", {"z": None}]},
-    ),
-    Case(
-        description="array of hashes, int value, match",
-        template=r"{{ a | find_index: 'z', 42 }}",
-        expect="1",
-        globals={"a": [{"x": 99}, {"z": 42, "foo": "bar"}]},
-    ),
-    Case(
-        description="array of hashes, with a nil",
-        template=r"{% assign b = a | find_index: 'z', 42 %}{{ b.foo }}",
-        expect="",
-        globals={"a": [{"x": 99}, None, {"z": 42, "foo": "bar"}]},
-    ),
-]

liquid/golden/first_filter.py

@@ -1,51 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `first` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="range literal first filter left value",
-        template=r"{{ (1..3) | first }}",
-        expect="1",
-    ),
-    Case(
-        description="array of strings",
-        template=r"{{ arr | first }}",
-        expect="a",
-        globals={"arr": ["a", "b"]},
-    ),
-    Case(
-        description="array of things",
-        template=r"{{ arr | first }}",
-        expect="a",
-        globals={"arr": ["a", "b", 1, [], {}]},
-    ),
-    Case(
-        description="empty left value",
-        template=r"{{ arr | first }}",
-        expect="",
-        globals={"arr": []},
-    ),
-    Case(
-        description="left value is not an array",
-        template=r"{{ arr | first }}",
-        expect="",
-        globals={"arr": 12},
-    ),
-    Case(
-        description="left value is undefined",
-        template=r"{{ nosuchthing | first }}",
-        expect="",
-    ),
-    Case(
-        description="first of a string",
-        template=r"{{ 'hello' | first }}",
-        expect="",
-    ),
-    Case(
-        description="first of a hash",
-        template=r"{% assign x = a | first %}({{ x[0] }},{{ x[1] }})",
-        expect="(b,1)",
-        globals={"a": {"b": 1, "c": 2}},
-    ),
-]

liquid/golden/floor_filter.py

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