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

liquid/golden/replace_first_filter.py

@@ -1,59 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `replace_first` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="replace substrings",
-        template=(
-            r'{{ "Take my protein pills and put my helmet on" '
-            r'| replace_first: "my", "your" }}'
-        ),
-        expect="Take your protein pills and put my helmet on",
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | replace_first: 'rain', 'foo' }}",
-        expect="5",
-    ),
-    Case(
-        description="argument not a string",
-        template=r'{{ "hello5" | replace_first: 5, "your" }}',
-        expect="helloyour",
-    ),
-    Case(
-        description="missing argument",
-        template=r'{{ "hello" | replace_first: "ll" }}',
-        expect="heo",
-    ),
-    Case(
-        description="missing arguments",
-        template=r'{{ "hello" | replace_first }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="too many arguments",
-        template=r'{{ "hello" | replace_first: "how", "are", "you" }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r'{{ nosuchthing | replace_first: "my", "your" }}',
-        expect="",
-    ),
-    Case(
-        description="undefined first argument",
-        template=r'{{ "Take my protein" | replace_first: nosuchthing, "#" }}',
-        expect="#Take my protein",
-    ),
-    Case(
-        description="undefined second argument",
-        template=(
-            r'{{ "Take my protein pills and put my helmet on" '
-            r'| replace_first: "my", nosuchthing }}'
-        ),
-        expect="Take  protein pills and put my helmet on",
-    ),
-]

liquid/golden/replace_last_filter.py

@@ -1,60 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `replace_last` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="replace substrings",
-        template=(
-            r'{{ "Take my protein pills and put my helmet on" '
-            r'| replace_last: "my", "your" }}'
-        ),
-        expect="Take my protein pills and put your helmet on",
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | replace_last: 'rain', 'foo' }}",
-        expect="5",
-    ),
-    Case(
-        description="argument not a string",
-        template=r'{{ "hello5" | replace_last: 5, "your" }}',
-        expect="helloyour",
-    ),
-    Case(
-        description="missing argument",
-        template=r'{{ "hello" | replace_last: "ll" }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="missing arguments",
-        template=r'{{ "hello" | replace_last }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="too many arguments",
-        template=r'{{ "hello" | replace_last: "how", "are", "you" }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r'{{ nosuchthing | replace_last: "my", "your" }}',
-        expect="",
-    ),
-    Case(
-        description="undefined first argument",
-        template=r'{{ "Take my protein" | replace_last: nosuchthing, "#" }}',
-        expect="Take my protein#",
-    ),
-    Case(
-        description="undefined second argument",
-        template=(
-            r'{{ "Take my protein pills and put my helmet on" '
-            r'| replace_last: "my", nosuchthing }}'
-        ),
-        expect="Take my protein pills and put  helmet on",
-    ),
-]

liquid/golden/reverse_filter.py

@@ -1,42 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `reverse` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="array of strings",
-        template=r"{{ a | reverse | join: '#' }}",
-        expect="A#B#a#b",
-        globals={"a": ["b", "a", "B", "A"]},
-    ),
-    Case(
-        description="array of things",
-        template=r"{{ a | reverse | join: '#' }}",
-        expect=r"{}#1#b#a",
-        globals={"a": ["a", "b", 1, [], {}]},
-    ),
-    Case(
-        description="empty array",
-        template=r"{{ a | reverse | join: '#' }}",
-        expect="",
-        globals={"a": []},
-    ),
-    Case(
-        description="unexpected argument",
-        template=r"{{ a | reverse: 0 | join: '#' }}",
-        expect="",
-        globals={"a": []},
-        error=True,
-    ),
-    Case(
-        description="left value not an array",
-        template=r"{{ a | reverse | join: '#' }}",
-        expect="123",
-        globals={"a": 123},
-    ),
-    Case(
-        description="left value is undefined",
-        template=r"{{ nosuchthing | reverse | join: '#' }}",
-        expect="",
-    ),
-]

liquid/golden/round_filter.py

@@ -1,87 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `round` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="float round down",
-        template=r"{{ 5.1 | round }}",
-        expect="5",
-    ),
-    Case(
-        description="float round up",
-        template=r"{{ 5.6 | round }}",
-        expect="6",
-    ),
-    Case(
-        description="float as a string",
-        template=r'{{ "5.6" | round }}',
-        expect="6",
-    ),
-    Case(
-        description="string argument",
-        template=r'{{ 5.666 | round: "1" }}',
-        expect="5.7",
-    ),
-    Case(
-        description="decimal places",
-        template=r'{{ "5.666666" | round: 2 }}',
-        expect="5.67",
-    ),
-    Case(
-        description="integer",
-        template=r"{{ 5 | round }}",
-        expect="5",
-    ),
-    Case(
-        description="too many args",
-        template=r"{{ 5 | round: 1, 2 }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | round: 2 }}",
-        expect="0",
-    ),
-    Case(
-        description="undefined argument",
-        template=r"{{ 5.666 | round: nosuchthing }}",
-        expect="6",
-    ),
-    Case(
-        description="argument is a string",
-        template=r"{{ 5.666 | round: 'foo' }}",
-        expect="6",
-    ),
-    Case(
-        description="argument is a string representation of an integer",
-        template=r"{{ 5.666 | round: '1' }}",
-        expect="5.7",
-    ),
-    Case(
-        description="argument is a string representation of zero",
-        template=r"{{ 5.666 | round: '1' }}",
-        expect="5.7",
-    ),
-    # Case(
-    #     description="argument is a string representation of a negative integer",
-    #     template=r"{{ 5.666 | round: '-1' }}",
-    #     expect="10",
-    # ),
-    Case(
-        description="argument is a negative",
-        template=r"{{ 5.666 | round: -2 }}",
-        expect="0",
-    ),
-    Case(
-        description="argument is a float",
-        template=r"{{ 5.666 | round: 1.2 }}",
-        expect="5.7",
-    ),
-    Case(
-        description="argument is a zero",
-        template=r"{{ 5.666 | round: 0 }}",
-        expect="6",
-    ),
-]

liquid/golden/rstrip_filter.py

@@ -1,37 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `rstrip` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="left padded",
-        template='{{ " \t\r\n  hello" | rstrip }}',
-        expect=" \t\r\n  hello",
-    ),
-    Case(
-        description="right padded",
-        template='{{ "hello \t\r\n  " | rstrip }}',
-        expect="hello",
-    ),
-    Case(
-        description="left and right padded",
-        template='{{ " \t\r\n  hello  \t\r\n " | rstrip }}',
-        expect=" \t\r\n  hello",
-    ),
-    Case(
-        description="not a string",
-        template="{{ 5 | rstrip }}",
-        expect="5",
-    ),
-    Case(
-        description="unexpected argument",
-        template='{{ "hello" | rstrip: 5 }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template="{{ nosuchthing | rstrip }}",
-        expect="",
-    ),
-]

liquid/golden/size_filter.py

@@ -1,42 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `size` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="size of an array",
-        template=r"{{ a | size }}",
-        globals={"a": ["a", "b", "c"]},
-        expect="3",
-    ),
-    Case(
-        description="size of a string",
-        template=r"{{ a | size }}",
-        globals={"a": "abc"},
-        expect="3",
-    ),
-    Case(
-        description="size of an empty array",
-        template=r"{{ a | size }}",
-        globals={"a": []},
-        expect="0",
-    ),
-    Case(
-        description="size of a hash",
-        template=r"{{ a | size }}",
-        globals={"a": {"a": 1, "b": 2}},
-        expect="2",
-    ),
-    Case(
-        description="unexpected argument",
-        template=r"{{ a | size: 'foo' }}",
-        globals={"a": [1, 2, 3]},
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | size }}",
-        expect="0",
-    ),
-]

liquid/golden/slice_filter.py

@@ -1,119 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `slice` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="zero",
-        template=r'{{ "hello" | slice: 0 }}',
-        expect="h",
-    ),
-    Case(
-        description="one",
-        template=r'{{ "hello" | slice: 1 }}',
-        expect="e",
-    ),
-    Case(
-        description="one length three",
-        template=r'{{ "hello" | slice: 1, 3 }}',
-        expect="ell",
-    ),
-    Case(
-        description="out of range",
-        template=r'{{ "hello" | slice: 99 }}',
-        expect="",
-    ),
-    Case(
-        description="not a string",
-        template=r"{{ 5 | slice: 1 }}",
-        expect="",
-    ),
-    Case(
-        description="first argument is a string",
-        template=r'{{ "hello" | slice: "2" }}',
-        expect="l",
-    ),
-    Case(
-        description="first argument not an integer",
-        template=r'{{ "hello" | slice: "foo" }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="second argument not an integer",
-        template=r'{{ "hello" | slice: 5, "foo" }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="second argument is a string",
-        template=r'{{ "hello" | slice: 3, "2" }}',
-        expect="lo",
-    ),
-    Case(
-        description="missing arguments",
-        template=r'{{ "hello" | slice }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="too many arguments",
-        template=r'{{ "hello" | slice: 1, 2, 3 }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined left value",
-        template=r"{{ nosuchthing | slice: 1, 3 }}",
-        expect="",
-    ),
-    Case(
-        description="undefined first argument",
-        template=r'{{ "hello" | slice: nosuchthing, 3 }}',
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="undefined second argument",
-        template=r'{{ "hello" | slice: 1, nosuchthing }}',
-        expect="e",
-    ),
-    Case(
-        description="slice an array of numbers",
-        template=r"{{ a | slice: 2, 3 | join: '#' }}",
-        expect="3#4#5",
-        globals={"a": [1, 2, 3, 4, 5]},
-    ),
-    Case(
-        description="first argument is a float",
-        template=r"{{ 'Liquid' | slice: 2.2 }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="second argument is a float",
-        template=r"{{ 'Liquid' | slice: 1, 2.2 }}",
-        expect="",
-        error=True,
-    ),
-    Case(
-        description="negative first argument",
-        template=r"{{ 'Liquid' | slice: -2 }}",
-        expect="i",
-    ),
-    Case(
-        description="negative first argument and positive length",
-        template=r"{{ 'Liquid' | slice: -2, 2 }}",
-        expect="id",
-    ),
-    Case(
-        description="negative first argument and negative length",
-        template=r"{{ 'Liquid' | slice: -2, -1 }}",
-        expect="",
-    ),
-    Case(
-        description="negative first argument and length out of range",
-        template=r"{{ 'Liquid' | slice: -2, 99 }}",
-        expect="id",
-    ),
-]

liquid/golden/sort_filter.py

@@ -1,86 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `sort` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="array of strings",
-        template=r"{{ a | sort | join: '#' }}",
-        expect="A#B#C#a#b",
-        globals={"a": ["b", "a", "C", "B", "A"]},
-    ),
-    Case(
-        description="array of objects",
-        template=(
-            r"{% assign x = a | sort: 'title' %}"
-            r"{% for obj in x %}"
-            r"{% for i in obj %}"
-            r"({{ i[0] }},{{ i[1] }})"
-            r"{% endfor %}"
-            r"{% endfor %}"
-        ),
-        expect="(title,Baz)(title,bar)(title,foo)",
-        globals={"a": [{"title": "foo"}, {"title": "Baz"}, {"title": "bar"}]},
-    ),
-    Case(
-        description="array of objects with missing key",
-        template=(
-            r"{% assign x = a | sort: 'title' %}"
-            r"{% for obj in x %}"
-            r"{% for i in obj %}"
-            r"({{ i[0] }},{{ i[1] }})"
-            r"{% endfor %}"
-            r"{% endfor %}"
-        ),
-        expect="(title,bar)(title,foo)(heading,Baz)",
-        globals={"a": [{"title": "foo"}, {"heading": "Baz"}, {"title": "bar"}]},
-    ),
-    Case(
-        description="empty array",
-        template=r"{{ a | sort | join: '#' }}",
-        expect="",
-        globals={"a": []},
-    ),
-    Case(
-        description="too many arguments",
-        template=r"{{ a | sort: 'title', 'foo' | join: '#' }}",
-        expect="",
-        globals={"a": ["b", "a"]},
-        error=True,
-    ),
-    Case(
-        description="left value is not an array",
-        template=r"{{ a | sort | join: '#' }}",
-        expect="123",
-        globals={"a": 123},
-    ),
-    Case(
-        description="left value is undefined",
-        template=r"{{ nosuchthing | sort | join: '#' }}",
-        expect="",
-    ),
-    Case(
-        description="argument is undefined",
-        template=r"{{ a | sort: nosuchthing | join: '#' }}",
-        expect="a#b",
-        globals={"a": ["b", "a"]},
-    ),
-    Case(
-        description="sort a string",
-        template=r"{{ 'BzAa4' | sort | join: '#' }}",
-        expect="BzAa4",
-    ),
-    Case(
-        description="array of integers",
-        template=r"{{ a | sort | join: '#' }}",
-        expect="1#3#30#1000",
-        globals={"a": [1, 1000, 3, 30]},
-    ),
-    Case(
-        description="incompatible types",
-        template=r"{{ a | sort }}",
-        expect="",
-        globals={"a": [[], {}, 1, "4"]},
-        error=True,
-    ),
-]

liquid/golden/sort_natural_filter.py

@@ -1,105 +0,0 @@
-"""Golden tests cases for testing liquid's built-in `sort_natural` filter."""
-
-from liquid.golden.case import Case
-
-cases = [
-    Case(
-        description="array of strings",
-        template=r"{{ a | sort_natural | join: '#' }}",
-        expect="a#A#b#B#C",
-        globals={"a": ["b", "a", "C", "B", "A"]},
-    ),
-    Case(
-        description="array of strings with a nul",
-        template=(
-            r"{% assign x = a | sort_natural %}"
-            r"{% for i in x %}"
-            r"{{ i }}"
-            r"{% unless forloop.last %}#{% endunless %}"
-            r"{% endfor %}"
-        ),
-        expect="a#A#b#B#C#",
-        globals={"a": ["b", "a", None, "C", "B", "A"]},
-    ),
-    Case(
-        description="array of objects with a key",
-        template=(
-            r"{% assign x = a | sort_natural: 'title' %}"
-            r"{% for obj in x %}"
-            r"{% for i in obj %}"
-            r"({{ i[0] }},{{ i[1] }})"
-            r"{% endfor %}"
-            r"{% endfor %}"
-        ),
-        expect="(title,bar)(title,Baz)(title,foo)",
-        globals={"a": [{"title": "foo"}, {"title": "bar"}, {"title": "Baz"}]},
-    ),
-    Case(
-        description="array of objects with a key gets stringified",
-        template=(
-            r"{% assign x = a | sort_natural: 'title' %}"
-            r"{% for obj in x %}"
-            r"{% for i in obj %}"
-            r"({{ i[0] }},{{ i[1] }})"
-            r"{% endfor %}"
-            r"{% endfor %}"
-        ),
-        expect="(title,1111)(title,87)(title,9)",
-        globals={"a": [{"title": 9}, {"title": 1111}, {"title": 87}]},
-    ),
-    Case(
-        description="array of objects with a missing key",
-        template=(
-            r"{% assign x = a | sort_natural: 'title' %}"
-            r"{% for obj in x %}"
-            r"{% for i in obj %}"
-            r"({{ i[0] }},{{ i[1] }})"
-            r"{% endfor %}"
-            r"{% endfor %}"
-        ),
-        expect="(title,bar)(title,foo)(heading,Baz)",
-        globals={"a": [{"title": "foo"}, {"title": "bar"}, {"heading": "Baz"}]},
-    ),
-    Case(
-        description="argument is undefined",
-        template=(
-            r"{% assign x = a | sort_natural: nosuchthing %}"
-            r"{% for obj in x %}"
-            r"{% for i in obj %}"
-            r"({{ i[0] }},{{ i[1] }})"
-            r"{% endfor %}"
-            r"{% endfor %}"
-        ),
-        expect="(title,bar)(title,Baz)(title,foo)",
-        globals={"a": [{"title": "foo"}, {"title": "bar"}, {"title": "Baz"}]},
-    ),
-    Case(
-        description="empty array",
-        template=(
-            r"{% assign x = a | sort_natural %}"
-            r"{% for i in x %}"
-            r"{{ i }}"
-            r"{% unless forloop.last %}#{% endunless %}"
-            r"{% endfor %}"
-        ),
-        expect="",
-        globals={"a": []},
-    ),
-    Case(
-        description="left value is not an array",
-        template=r"{{ a | sort_natural }}",
-        expect="123",
-        globals={"a": 123},
-    ),
-    Case(
-        description="left value is undefined",
-        template=r"{{ nosuchthing | sort_natural }}",
-        expect="",
-    ),
-    Case(
-        description="incompatible types",
-        template=r"{{ a | sort_natural }}",
-        expect="14{}",
-        globals={"a": [{}, 1, "4"]},
-    ),
-]