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

liquid/golden/comment_tag.py

@@ -1,119 +0,0 @@
-"""Golden tests cases for testing liquid's `comment` tag."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="don't render comments",
-        template=r"{% comment %}foo{% endcomment %}",
-        expect="",
-    ),
-    Case(
-        description="respect whitespace control in comments",
-        template="\n{%- comment %}foo{% endcomment -%}\t \r",
-        expect="",
-    ),
-    Case(
-        description="don't render comments with tags",
-        template=(
-            r"{% comment %}"
-            r"{% if true %}"
-            r"{{ title }}"
-            r"{% endif %}"
-            r"{% endcomment %}"
-        ),
-        expect="",
-    ),
-    Case(
-        description="comment inside liquid tag",
-        template="\n".join(
-            [
-                r"{% liquid",
-                r"    if 1 != 1",
-                r"    comment",
-                r"    else",
-                r"    echo 123",
-                r"    endcomment",
-                r"    endif",
-                r"%}",
-            ]
-        ),
-        expect="",
-    ),
-    Case(
-        description="commented tags are not parsed",
-        template=(
-            r"{% comment %}"
-            r"    {% if true %}"
-            r"    {% if ... %}"
-            r"    {%- for ? -%}"
-            r"    {% while true %}"
-            r"    {%"
-            r"    unless if"
-            r"    %}"
-            r"    {% endcase %}"
-            r"{% endcomment %}"
-        ),
-        expect="",
-    ),
-    Case(
-        description="malformed tags are not parsed",
-        template=r"{% comment %}{% assign foo = '1'{% endcomment %}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="incomplete tags are not parsed",
-        template=r"{% comment %}{% {{ {%- endcomment %}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="nested comment blocks",
-        template=(
-            r"{% comment %}"
-            r"    {% comment %}"
-            r"    {% comment %}{%    endcomment     %}"
-            r"    {% endcomment %}"
-            r"{% endcomment %}"
-        ),
-        expect="",
-        future=True,
-    ),
-    Case(
-        description="nested comment blocks, with nested tags",
-        template=(
-            r"{% comment %}"
-            r"    {% comment %}"
-            r"    {% comment %}{% if true %}hello{%endif%}{%    endcomment     %}"
-            r"    {% endcomment %}"
-            r"{% endcomment %}"
-        ),
-        expect="",
-        future=True,
-    ),
-    Case(
-        description="unclosed nested comment blocks",
-        template=(
-            r"{% comment %}"
-            r"    {% comment %}"
-            r"    {% comment %}"
-            r"    {% endcomment %}"
-            r"{% endcomment %}"
-        ),
-        expect="",
-        error=True,
-        future=True,
-    ),
-    Case(
-        description="raw inside comment block",
-        template=(
-            r"{% comment %}"
-            r"    {% raw %}"
-            r"    {% endcomment %}"
-            r"    {% endraw %}"
-            r"{% endcomment %}"
-        ),
-        expect="",
-    ),
-]

liquid/golden/compact_filter.py

@@ -1,54 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `compact` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="array with a nil",
-        template=r"{{ a | compact | join: '#' }}",
-        expect="b#a#A",
-        globals={"a": ["b", "a", None, "A"]},
-    ),
-    Case(
-        description="empty array",
-        template=r"{{ a | compact | join: '#' }}",
-        expect="",
-        globals={"a": []},
-    ),
-    Case(
-        description="too many arguments",
-        template=r"{{ a | compact: 'foo', 'bar' }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="left value is not an array",
-        template=r"{{ a | compact | first }}",
-        expect="123",
-        globals={"a": 123},
-    ),
-    Case(
-        description="left value is undefined",
-        template=r"{{ nosuchthing | compact }}",
-        expect="",
-    ),
-    Case(
-        description="array of objects with key property",
-        template=(
-            r"{% assign x = a | compact: 'title' %}"
-            r"{% for obj in x %}"
-            r"{% for i in obj %}"
-            r"({{ i[0] }},{{ i[1] }})"
-            r"{% endfor %}"
-            r"{% endfor %}"
-        ),
-        expect="(title,foo)(name,a)(title,bar)(name,c)",
-        globals={
-            "a": [
-                {"title": "foo", "name": "a"},
-                {"title": None, "name": "b"},
-                {"title": "bar", "name": "c"},
-            ]
-        },
-    ),
-]

liquid/golden/concat_filter.py

@@ -1,63 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `concat` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="range literal concat filter left value",
-        template=r"{{ (1..3) | concat: foo | join: '#' }}",
-        expect="1#2#3#5#6#7",
-        globals={"foo": [5, 6, 7]},
-    ),
-    Case(
-        description="two arrays of strings",
-        template=r"{{ a | concat: b | join: '#' }}",
-        expect="a#b#c#d",
-        globals={"a": ["a", "b"], "b": ["c", "d"]},
-    ),
-    Case(
-        description="missing argument is an error",
-        template=r"{{ a | concat | join: '#' }}",
-        expect="a#b",
-        globals={"a": ["a", "b"]},
-        error=True,
-    ),
-    Case(
-        description="non array-like argument is an error",
-        template=r"{{ a | concat: b | join: '#' }}",
-        expect="",
-        globals={"a": ["a", "b"], "b": 5},
-        error=True,
-    ),
-    Case(
-        description="left value is not array-like",
-        template=r"{{ a | concat: b | join: '#' }}",
-        expect="ab#c#d",
-        globals={"a": "ab", "b": ["c", "d"]},
-    ),
-    Case(
-        description="left value contains non string",
-        template=r"{{ a | concat: b | join: '#' }}",
-        expect="a#b#5#c#d",
-        globals={"a": ["a", "b", 5], "b": ["c", "d"]},
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | concat: b | join: '#' }}",
-        expect="c#d",
-        globals={"b": ["c", "d"]},
-    ),
-    Case(
-        description="undefined argument is an error",
-        template=r"{{ a | concat: nosuchthing | join: '#' }}",
-        expect="",
-        globals={"a": ["a", "b"]},
-        error=True,
-    ),
-    Case(
-        description="nested left value gets flattened",
-        template=r"{{ a | concat: b | join: '#' }}",
-        expect="a#x#b#y#z#c#d",
-        globals={"a": [["a", "x"], ["b", ["y", ["z"]]]], "b": ["c", "d"]},
-    ),
-]

liquid/golden/cycle_tag.py

@@ -1,114 +0,0 @@
-"""Golden tests cases for testing liquid's `cycle` tag."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="no identifier",
-        template=(
-            r"{% cycle 'some', 'other' %}"
-            r"{% cycle 'some', 'other' %}"
-            r"{% cycle 'some', 'other' %}"
-        ),
-        expect="someothersome",
-    ),
-    Case(
-        description="with identifier",
-        template=(
-            r"{% cycle 'foo': 'some', 'other' %}"
-            r"{% cycle 'some', 'other' %}"
-            r"{% cycle 'foo': 'some', 'other' %}"
-        ),
-        expect="somesomeother",
-    ),
-    Case(
-        description="different items",
-        template=(
-            r"{% cycle '1', '2', '3' %}"
-            r"{% cycle '1', '2' %}"
-            r"{% cycle '1', '2', '3' %}"
-        ),
-        expect="112",
-    ),
-    Case(
-        description="integers",
-        template=r"{% cycle 1, 2, 3 %}{% cycle 1, 2, 3 %}{% cycle 1, 2, 3 %}",
-        expect="123",
-    ),
-    Case(
-        description="some global variables",
-        template=r"{% cycle a, b, c %}{% cycle a, b, c %}{% cycle a, b, c %}",
-        expect="123",
-        globals={"a": 1, "b": 2, "c": 3},
-        standard=False,
-    ),
-    Case(
-        description="variable name",
-        template=r"{% cycle a: 1, 2, 3 %}{% cycle a: 1, 2, 3 %}{% cycle a: 1, 2, 3 %}",
-        expect="123",
-        globals={"a": "foo"},
-    ),
-    Case(
-        description="multiple undefined variable names",
-        template=r"{% cycle a: 1, 2, 3 %}{% cycle b: 1, 2, 3 %}{% cycle a: 1, 2, 3 %}",
-        expect="123",
-        globals={},
-    ),
-    Case(
-        description="undefined variable names mixed with no name",
-        template=r"{% cycle a: 1, 2, 3 %}{% cycle b: 1, 2, 3 %}{% cycle 1, 2, 3 %}",
-        expect="121",
-        globals={},
-    ),
-    Case(
-        description="changing variable name",
-        template=(
-            r"{% cycle a: 1, 2, 3 %}"
-            r"{% assign a = 'bar' %}"
-            r"{% cycle a: 1, 2, 3 %}"
-            r"{% cycle a: 1, 2, 3 %}"
-        ),
-        expect="112",
-        globals={"a": "foo"},
-    ),
-    Case(
-        description="named with different items",
-        template=(
-            r"{% cycle 'a': 1, 2, 3 %}"
-            r"{% cycle 'a': 7, 8, 9 %}"
-            r"{% cycle 'a': 1, 2, 3 %}"
-        ),
-        expect="183",
-        future=True,
-    ),
-    Case(
-        description="named with different number of arguments",
-        template=(
-            r"{% cycle a: '1', '2' %}"
-            r"{% cycle a: '1', '2', '3' %}"
-            r"{% cycle a: '1' %}"
-        ),
-        expect="12",
-        future=True,
-    ),
-    Case(
-        description="named with shrinking number of arguments",
-        template=(
-            r"{% cycle a: '1', '2', '3' %}"
-            r"{% cycle a: '1', '2' %}"
-            r"{% cycle a: '1' %}"
-        ),
-        expect="121",
-        future=True,
-    ),
-    Case(
-        description="named with growing number of arguments",
-        template=(
-            r"{% cycle a: '1' %}"
-            r"{% cycle a: '1', '2' %}"
-            r"{% cycle a: '1', '2', '3' %}"
-        ),
-        expect="112",
-        future=True,
-    ),
-]

liquid/golden/date_filter.py

@@ -1,63 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `date` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="well formed string",
-        template=r"{{ 'March 14, 2016' | date: '%b %d, %y' }}",
-        expect="Mar 14, 16",
-    ),
-    Case(
-        description="too many arguments",
-        template=r"{{ 'March 14, 2016' | date: '%b %d, %y', 'foo' }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | date: '%b %d, %y' }}",
-        expect="",
-    ),
-    Case(
-        description="missing argument",
-        template=r"{{ 'March 14, 2016' | date }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined argument",
-        template=r"{{ 'March 14, 2016' | date: nosuchthing }}",
-        expect="March 14, 2016",
-    ),
-    Case(
-        description="literal percent",
-        template=r"{{ 'March 14, 2016' | date: '%%%b %d, %y' }}",
-        expect="%Mar 14, 16",
-    ),
-    Case(
-        description="timestamp integer",
-        template=r"{{ 1152098955 | date: '%m/%d/%Y' }}",
-        expect="07/05/2006",
-    ),
-    Case(
-        description="timestamp string",
-        template=r"{{ '1152098955' | date: '%m/%d/%Y' }}",
-        expect="07/05/2006",
-    ),
-    # Case(
-    #     description="negative timestamp integer",
-    #     template=r"{{ -1152098955 | date: '%m/%d/%Y' }}",
-    #     expect="06/29/1933",
-    # ),
-    Case(
-        description="negative timestamp string",
-        template=r"{{ '-1152098955' | date: '%m/%d/%Y' }}",
-        expect="-1152098955",
-    ),
-    Case(
-        description="seconds since epoch format directive",
-        template=r"{{ 'March 14, 2016' | date: '%s' }}",
-        expect="1457913600",
-    ),
-]

liquid/golden/decrement_tag.py

@@ -1,16 +0,0 @@
-"""Golden tests cases for testing liquid's `decrement` tag."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="named counter",
-        template=r"{% decrement foo %}{{ foo }} {% decrement foo %}{{ foo }}",
-        expect="-1-1 -2-2",
-    ),
-    Case(
-        description="increment and decrement named counter",
-        template=r"{% decrement foo %} {% decrement foo %} {% increment foo %}",
-        expect="-1 -2 -2",
-    ),
-]

liquid/golden/default_filter.py

@@ -1,112 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `default` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="nil",
-        template=r"{{ nil | default: 'foo' }}",
-        expect="foo",
-    ),
-    Case(
-        description="false",
-        template=r"{{ False | default: 'foo' }}",
-        expect="foo",
-    ),
-    Case(
-        description="empty string",
-        template=r'{{ "" | default: "foo" }}',
-        expect="foo",
-    ),
-    Case(
-        description="empty array",
-        template=r"{{ a | default: 'foo' }}",
-        expect="foo",
-        globals={"a": []},
-    ),
-    Case(
-        description="empty object",
-        template=r"{{ a | default: 'foo' }}",
-        expect="foo",
-        globals={"a": {}},
-    ),
-    Case(
-        description="not empty string",
-        template=r'{{ "hello" | default: "foo" }}',
-        expect="hello",
-    ),
-    Case(
-        description="not empty list",
-        template=r'{{ a | default: "foo" | join: "#" }}',
-        expect="hello#world",
-        globals={"a": ["hello", "world"]},
-    ),
-    Case(
-        description="not empty object",
-        template=(
-            r"{% assign b = a | default: foo %}"
-            r"{% for item in b %}"
-            r"({{ item[0] }},{{ item[1] }})"
-            r"{% endfor %}"
-        ),
-        expect="(greeting,hello)",
-        globals={"a": {"greeting": "hello"}, "foo": {"greeting": "goodbye"}},
-    ),
-    Case(
-        description="too many arguments",
-        template=r"{{ None | default: 'foo', 'bar', 'baz' }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="missing argument",
-        template=r"{{ false | default }}",
-        expect="",
-    ),
-    Case(
-        description="empty",
-        template=r"{{ empty | default: bar }}",
-        expect="",
-    ),
-    Case(
-        description="allow false",
-        template=r"{{ false | default: 'bar', allow_false:true }}",
-        expect="false",
-    ),
-    Case(
-        description="allow false from context",
-        template=r"{{ false | default: 'bar', allow_false:foo }}",
-        expect="false",
-        globals={"foo": True},
-    ),
-    Case(
-        description="undefined left value",
-        template=r'{{ nosuchthing | default: "bar" }}',
-        expect="bar",
-    ),
-    Case(
-        description="true keyword argument before positional",
-        template=r'{{ false | default: allow_false: true, "bar" }}',
-        expect="false",
-    ),
-    Case(
-        description="false keyword argument before positional",
-        template=r'{{ false | default: allow_false: false, "bar" }}',
-        expect="bar",
-    ),
-    Case(
-        description="zero is not falsy",
-        template=r'{{ 0 | default: "bar" }}',
-        expect="0",
-    ),
-    Case(
-        description="zero is not falsy with allow_false",
-        template=r'{{ 0 | default: "bar", allow_false: true }}',
-        expect="0",
-    ),
-    Case(
-        description="0.0 is not falsy",
-        template=r'{{ 0.0 | default: "bar" }}',
-        expect="0.0",
-    ),
-]

liquid/golden/divided_by_filter.py

@@ -1,101 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `divided_by` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="integer value and integer arg",
-        template=r"{{ 10 | divided_by: 2 }}",
-        expect="5",
-    ),
-    Case(
-        description="integer value and float arg",
-        template=r"{{ 10 | divided_by: 2.0 }}",
-        expect="5.0",
-    ),
-    Case(
-        description="integer division",
-        template=r"{{ 9 | divided_by: 2 }}",
-        expect="4",
-    ),
-    Case(
-        description="float value and integer arg",
-        template=r"{{ 9.0 | divided_by: 2 }}",
-        expect="4.5",
-    ),
-    Case(
-        description="float division",
-        template=r"{{ 20 | divided_by: 7.0 }}",
-        expect="2.857142857142857",
-    ),
-    Case(
-        description="string value and argument",
-        template=r'{{ "10" | divided_by: "2" }}',
-        expect="5",
-    ),
-    Case(
-        description="string not a number",
-        template=r'{{ "foo" | divided_by: "2" }}',
-        expect="0",
-    ),
-    Case(
-        description="arg string not a number",
-        template=r'{{ "10" | divided_by: "foo" }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="too many args",
-        template=r"{{ 5 | divided_by: 1, '5' }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="not a string, int or float",
-        template=r"{{ a | divided_by: 1 }}",
-        expect="0",
-        globals={"a": {}},
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | divided_by: 2 }}",
-        expect="0",
-    ),
-    Case(
-        description="undefined argument",
-        template=r"{{ 10 | divided_by: nosuchthing }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="divied by zero",
-        template=r"{{ 10 | divided_by: 0 }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="zero divided by float",
-        template=r"{{ 0 | divided_by: 1.1 }}",
-        expect="0.0",
-    ),
-    Case(
-        description="zero divided by integer",
-        template=r"{{ 0 | divided_by: 1 }}",
-        expect="0",
-    ),
-    Case(
-        description="issue",
-        template=r"{{ 5 | divided_by: 3 }}",
-        expect="1",
-    ),
-    Case(
-        description="render",
-        template=r"{{ 5.0 }} {{ 5 }}",
-        expect="5.0 5",
-    ),
-    Case(
-        description="left value is an empty string",
-        template=r"{{ '' | divided_by: 2 }}",
-        expect="0",
-    ),
-]