Add support for recursive liquid tags

Matches to liquid_c and liquid v5.5.0. Also, fix rounding with invalid precision
parameters to better match ruby's version of liquid.

Liquex currently converts {{ 0 | round 'invalid' }} to '0.0'. Ruby rounds this to '0'.

Ref: Shopify/liquid#1731

Author: markglenn

.devcontainer/Dockerfile

@@ -1,6 +1,6 @@
 FROM elixir:1.14
 
-ENV LIQUID_VERSION 5.4.0
+ENV LIQUID_VERSION 5.5.0
 
 # Install ruby. Since we are only using this to install Liquid,
 # we don't really care which version

lib/liquex/cache.ex

@@ -11,5 +11,5 @@ defmodule Liquex.Cache do
   Fetch a value from cache. If the value doesn't exist, run the given function
   and store the results within the cache.
   """
-  @callback fetch(key, (-> value())) :: value()
+  @callback fetch(key, (() -> value())) :: value()
 end

lib/liquex/filter.ex

@@ -561,12 +561,10 @@ defmodule Liquex.Filter do
   """
   @spec round(binary | number | nil, binary | number | nil, any) :: number
   def round(value, precision \\ 0, context),
-    do: do_round(to_number(value), to_number(precision, false), context)
+    do: do_round(to_number(value), to_number(precision), context)
 
   defp do_round(value, _, _) when is_integer(value), do: value
-  defp do_round(value, precision, _) when precision == 0, do: Float.round(value) |> trunc()
-  defp do_round(value, precision, _) when precision < 0, do: Float.round(value)
-  defp do_round(value, nil, _), do: Float.round(value)
+  defp do_round(value, precision, _) when precision <= 0, do: Float.round(value) |> trunc()
 
   defp do_round(value, precision, _) do
     # Special case negative and invalid precisions
@@ -844,12 +842,10 @@ defmodule Liquex.Filter do
   """
   def where(list, key, _), do: Liquex.Collection.where(list, key)
 
-  defp to_number(value, allow_conversion_to_zero \\ true)
-  defp to_number(value, _) when is_number(value), do: value
-  defp to_number(nil, true), do: 0
-  defp to_number(nil, false), do: nil
+  defp to_number(nil), do: 0
+  defp to_number(value) when is_number(value), do: value
 
-  defp to_number(value, allow_conversion_to_zero) when is_binary(value) do
+  defp to_number(value) when is_binary(value) do
     case Integer.parse(value) do
       # Integer value
       {int_val, ""} ->
@@ -864,7 +860,7 @@ defmodule Liquex.Filter do
 
       # Unknown, so use Ruby's style of "Convert to 0 instead"
       _ ->
-        if allow_conversion_to_zero == true, do: 0, else: nil
+        0
     end
   end
 end

lib/liquex/tag/inline_comment_tag.ex

@@ -1,11 +1,24 @@
 defmodule Liquex.Tag.InlineCommentTag do
   @moduledoc """
+  A tag that allows for inline comments using the # character.
+
+  ## liquid
+      Nothing in the comments will be rendered.
+      {% # This is a comment and won't be rendered %}
+
+      {% liquid # This is also a comment and won't be rendered %}
+
+
+  ### Output
+      Nothing in the comments will be rendered.
+
+
   """
 
   @behaviour Liquex.Tag
 
-  alias Liquex.Parser.Tag
   alias Liquex.Parser.Literal
+  alias Liquex.Parser.Tag
 
   import NimbleParsec
 

lib/liquex/tag/liquid_tag.ex

@@ -36,12 +36,30 @@ defmodule Liquex.Tag.LiquidTag do
   @spec parse :: NimbleParsec.t()
   def parse do
     Tag.open_tag()
+    |> liquid_contents()
+    |> ignore(Literal.whitespace())
+    |> ignore(Tag.close_tag())
+  end
+
+  @impl true
+  @spec parse_liquid_tag :: NimbleParsec.t()
+  def parse_liquid_tag do
+    # Yo dawg! I heard you like liquid tags, so I put a liquid tag in your
+    # liquid tag so you can tag while you tag.
+
+    # This was added in reference to pull request 1731
+    # https://github.com/Shopify/liquid/pull/1731
+
+    liquid_contents()
+    |> ignore(Tag.end_liquid_line())
+  end
+
+  defp liquid_contents(combinator \\ empty()) do
+    combinator
     |> string("liquid")
     |> Literal.whitespace(1)
     |> ignore()
     |> tag(parsec(:liquid_tag_contents), :contents)
-    |> ignore(Literal.whitespace())
-    |> ignore(Tag.close_tag())
   end
 
   @impl true

test/liquex/tag/liquid_tag_test.exs

@@ -0,0 +1,67 @@
+defmodule Liquex.Tag.LiquidTagTest do
+  use ExUnit.Case, async: true
+  import Liquex.TestHelpers
+
+  describe "parse" do
+    test "handles recursive liquid tags" do
+      assert_parse(
+        "{% liquid liquid echo 'hello' %}",
+        [
+          {
+            {:tag, Liquex.Tag.LiquidTag},
+            [
+              contents: [
+                {{:tag, Liquex.Tag.LiquidTag},
+                 [contents: [{{:tag, Liquex.Tag.EchoTag}, [literal: "hello", filters: []]}]]}
+              ]
+            ]
+          }
+        ]
+      )
+    end
+
+    test "handles recursive liquid tags at depth higher than 2" do
+      assert_parse(
+        "{% liquid liquid liquid liquid liquid echo 'hello' %}",
+        [
+          {{:tag, Liquex.Tag.LiquidTag},
+           [
+             contents: [
+               {{:tag, Liquex.Tag.LiquidTag},
+                [
+                  contents: [
+                    {{:tag, Liquex.Tag.LiquidTag},
+                     [
+                       contents: [
+                         {{:tag, Liquex.Tag.LiquidTag},
+                          [
+                            contents: [
+                              {{:tag, Liquex.Tag.LiquidTag},
+                               [
+                                 contents: [
+                                   {{:tag, Liquex.Tag.EchoTag}, [literal: "hello", filters: []]}
+                                 ]
+                               ]}
+                            ]
+                          ]}
+                       ]
+                     ]}
+                  ]
+                ]}
+             ]
+           ]}
+        ]
+      )
+    end
+  end
+
+  describe "render" do
+    # Most of these tests are done in the individual tag tests. This is only
+    # focusing on recursive liquid tags.
+    test "renders tag" do
+      assert render("""
+             {% liquid liquid liquid liquid echo 'hello world' %}
+             """) == "hello world"
+    end
+  end
+end