Nested converter support (#662)

src/Verify.Tests/Converters/ExtensionConverterTests.Nested#00.verified.txt

@@ -0,0 +1,4 @@
+[
+  level1Info,
+  level2Info
+]

src/Verify.Tests/Converters/ExtensionConverterTests.Nested#01.verified.txt

@@ -0,0 +1 @@
+text from level1

src/Verify.Tests/Converters/ExtensionConverterTests.Nested#02.verified.txt

@@ -0,0 +1 @@
+text from level2

src/Verify.Tests/Converters/ExtensionConverterTests.Nested#03.verified.txt

@@ -0,0 +1,2 @@
+Foo
+Bar

src/Verify.Tests/Converters/ExtensionConverterTests.cs

@@ -1,6 +1,45 @@
 [UsesVerify]
 public class ExtensionConverterTests
 {
+    [ModuleInitializer]
+    public static void NestedInit()
+    {
+        VerifierSettings.RegisterFileConverter(
+            "level1",
+            (stream, _) =>
+                new(
+                    "level1Info",
+                    new List<Target>
+                    {
+                        new("txt", "text from level1"),
+                        new("level2", stream)
+                    }));
+        VerifierSettings.RegisterFileConverter(
+            "level2",
+            async (stream, _) =>
+                new(
+                    "level2Info",
+                    new List<Target>
+                    {
+                        new("txt", "text from level2"),
+                        new("txt", await stream.ReadString())
+                    }));
+    }
+
+    [Fact]
+    public Task Nested() =>
+        Verify(IoHelpers.OpenRead("sample.level1"));
+
+    [Fact]
+    public Task NestedTarget()
+    {
+        var targets = new[]
+        {
+            new Target("level1", new MemoryStream())
+        };
+        return Verify(targets);
+    }
+
     [ModuleInitializer]
     public static void TextSplitInit() =>
         VerifierSettings.RegisterFileConverter(

src/Verify.Tests/Verify.Tests.csproj

@@ -36,6 +36,9 @@
     <None Update="EmptyFiles\**\*.*">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="sample.level1">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
   <Import Project="$(ProjectDir)..\Verify\buildTransitive\Verify.props" />
   <Import Project="$(ProjectDir)..\Verify\buildTransitive\Verify.targets" />

src/Verify.Tests/sample.level1

@@ -0,0 +1,2 @@
+Foo
+Bar

src/Verify/Splitters/Settings_Extension.cs

@@ -7,6 +7,9 @@ public static partial class VerifierSettings
     internal static bool TryGetExtensionConverter(string extension, [NotNullWhen(true)] out AsyncConversion<Stream>? converter) =>
         extensionConverters.TryGetValue(extension, out converter);
 
+    internal static bool HasExtensionConverter(string extension) =>
+        extensionConverters.ContainsKey(extension);
+
     public static void RegisterFileConverter(
         string fromExtension,
         Conversion<Stream> conversion) =>

src/Verify/Verifier/InnerVerifier_Stream.cs

@@ -41,10 +41,33 @@ public async Task<VerifyResult> VerifyStream(Stream stream, string extension)
                 throw new("Empty data is not allowed.");
             }
 
-            if (VerifierSettings.TryGetExtensionConverter(extension, out var conversion))
+            if (VerifierSettings.HasExtensionConverter(extension))
             {
-                var result = await conversion(stream, settings.Context);
-                return await VerifyInner(result.Info, result.Cleanup, result.Targets);
+                var (infos, convertedTargets, cleanups) = await DoExtensionConversion(
+                    new()
+                    {
+                        new(extension, stream)
+                    });
+                object? info = null;
+                if (infos.Count == 1)
+                {
+                    info = infos[0];
+                }
+                else if (infos.Count > 1)
+                {
+                    info = infos;
+                }
+
+                return await VerifyInner(
+                    info,
+                    async () =>
+                    {
+                        foreach (var cleanup in cleanups)
+                        {
+                            await cleanup();
+                        }
+                    },
+                    convertedTargets);
             }
 
             var targets = await GetTargets(stream, extension);
@@ -68,4 +91,42 @@ static async Task<List<Target>> GetTargets(Stream stream, string extension)
             new(extension, stream)
         };
     }
+
+    async Task<(List<object> infos, List<Target> targets, List<Func<Task>> cleanups)> DoExtensionConversion(List<Target> list)
+    {
+        var infos = new List<object>();
+        var outputTargets = new List<Target>();
+        var cleanups = new List<Func<Task>>();
+
+        var queue = new Queue<Target>(list);
+
+        while (queue.Count > 0)
+        {
+            var target = queue.Dequeue();
+
+            if (!VerifierSettings.TryGetExtensionConverter(target.Extension, out var conversion))
+            {
+                outputTargets.Add(target);
+                continue;
+            }
+
+            var result = await conversion(target.StreamData, settings.Context);
+            if (result.Info != null)
+            {
+                infos.Add(result.Info);
+            }
+
+            if (result.Cleanup != null)
+            {
+                cleanups.Add(result.Cleanup);
+            }
+
+            foreach (var innerTarget in result.Targets)
+            {
+                queue.Enqueue(innerTarget);
+            }
+        }
+
+        return (infos, outputTargets, cleanups);
+    }
 }