fix: materialize blog page assets

Author: Arlodotexe

src/Commands/Blog/PostPage/PageAssetMaterializer.cs

@@ -0,0 +1,45 @@
+using OwlCore.Storage;
+using WindowsAppCommunity.Blog.Assets;
+
+namespace WindowsAppCommunity.CommandLine.Blog.PostPage;
+
+internal static class PageAssetMaterializer
+{
+    public static async Task<HashSet<string>> GetFileIdsAsync(IStorable source)
+    {
+        if (source is IFile file)
+            return [file.Id];
+
+        if (source is IFolder folder)
+            return [.. await new DepthFirstRecursiveFolder(folder).GetFilesAsync().Select(x => x.Id).ToListAsync()];
+
+        return [];
+    }
+
+    public static async Task CopyAssetsAsync(IModifiableFolder pageOutputFolder, IEnumerable<PageAsset> assets)
+    {
+        foreach (var asset in assets)
+        {
+            if (Path.GetExtension(asset.ResolvedFile.Name).Equals(".md", StringComparison.OrdinalIgnoreCase))
+                continue;
+
+            var rewrittenPath = NormalizePath(asset.RewrittenPath);
+            var directoryPath = NormalizePath(Path.GetDirectoryName(rewrittenPath));
+            var assetOutputFolder = pageOutputFolder;
+
+            if (!string.IsNullOrWhiteSpace(directoryPath) && directoryPath != ".")
+            {
+                assetOutputFolder = (IModifiableFolder)await pageOutputFolder
+                    .CreateFoldersAlongRelativePathAsync(directoryPath, overwrite: false)
+                    .LastAsync();
+            }
+
+            await assetOutputFolder.CreateCopyOfAsync(asset.ResolvedFile, overwrite: true);
+        }
+    }
+
+    private static string NormalizePath(string? path)
+    {
+        return path?.Replace('\\', '/') ?? string.Empty;
+    }
+}

src/Commands/Blog/PostPage/PageCommand.cs

@@ -88,24 +88,31 @@ private async Task<int> ExecuteAsync(string markdownPath, string templatePath, s
         // Resolve output folder (SystemFolder throws if doesn't exist)
         IModifiableFolder outputFolder = new SystemFolder(outputPath);
 
+        var templateFileIds = await PageAssetMaterializer.GetFileIdsAsync(templateSource);
+
         // Create virtual PostPageFolder (lazy generation - no I/O during construction)
         var postPageFolder = new AssetAwareHtmlTemplatedMarkdownPageFolder(markdownFile, templateSource, templateFileName)
         {
             Id = markdownFile.Id.HashMD5Fast(),
-            // Single-file page output includes assets by default
-            // Unlike multi-page output which references assets by default
-            AssetStrategy = new KnownAssetStrategy(),
+            AssetStrategy = new KnownAssetStrategy
+            {
+                IncludedAssetFileIds = templateFileIds,
+                ReferencedAssetFileIds = [markdownFile.Id],
+                UnknownAssetFallbackStrategy = AssetFallbackBehavior.Reference,
+                UnknownAssetFaultStrategy = FaultStrategy.None,
+            },
             Resolver = new RelativePathAssetResolver(),
             LinkDetector = new RegexAssetLinkDetector(),
         };
 
         // Create output folder for this page
-        var pageOutputFolder = await outputFolder.CreateFolderAsync(postPageFolder.Name, overwrite: true);
+        var pageOutputFolder = (IModifiableFolder)await outputFolder.CreateFolderAsync(postPageFolder.Name, overwrite: true);
 
         // Materialize virtual structure by recursively copying all files
-        await foreach (AssetAwareHtmlTemplatedMarkdownFile file in new DepthFirstRecursiveFolder(postPageFolder).GetFilesAsync())
+        await foreach (AssetAwareHtmlTemplatedMarkdownFile file in postPageFolder.GetItemsAsync(StorableType.File))
         {
-            // TODO, see https://discord.com/channels/372137812037730304/1396673230013464636/1441902694196449505
+            await pageOutputFolder.CreateCopyOfAsync(file, overwrite: true);
+            await PageAssetMaterializer.CopyAssetsAsync(pageOutputFolder, file.Assets);
         }
 
         var outputFolderName = Path.GetFileNameWithoutExtension(markdownFile.Name);

src/Commands/Blog/PostPage/PagesCommand.cs

@@ -86,8 +86,8 @@ private async Task<int> ExecuteAsync(
 
             // Create recursive markdown-to-webpage folder (lazy generation - no I/O during construction)
             // Turns `.md` files into folders with an `index.html` holding asset metadata for output copy
-            HashSet<string> templateFileIds = [.. (templateSource is IFile file) ? [file.Id] : await new DepthFirstRecursiveFolder((IFolder)templateSource).GetFilesAsync().Select(x => x.Id).ToListAsync()];
-            HashSet<string> markdownSourceFileIds = [.. await new DepthFirstRecursiveFolder(markdownSourceFolder).GetFilesAsync().Select(x => x.Id).ToListAsync()];
+            var templateFileIds = await PageAssetMaterializer.GetFileIdsAsync(templateSource);
+            var markdownSourceFileIds = await PageAssetMaterializer.GetFileIdsAsync(markdownSourceFolder);
             var pagesFolder = new AssetAwareHtmlTemplatedMarkdownPagesFolder(markdownSourceFolder, templateSource, templateFileName)
             {
                 LinkDetector = new RegexAssetLinkDetector(),
@@ -112,20 +112,8 @@ private async Task<int> ExecuteAsync(
                 await foreach (AssetAwareHtmlTemplatedMarkdownFile indexFile in pageFolder.GetItemsAsync(StorableType.File))
                 {
                     // Create folders relative to THIS page's output folder, then copy
-                    var copiedIndexFile = await pageOutputFolder.CreateCopyOfAsync(indexFile, overwrite: true);
-
-                    // Copy all assets referenced in index.html to the rewritten asset path
-                    // Logger.LogInformation($"Included: {indexFile.Assets.Count}");
-                    foreach (var asset in indexFile.Assets)
-                    {
-                        if (Path.GetExtension(asset.ResolvedFile.Name) == ".md")
-                        {
-                            // 
-                        }
-
-                        var assetOutputFolder = (IModifiableFolder)await pageOutputFolder.CreateFoldersAlongRelativePathAsync(asset.RewrittenPath, overwrite: false).LastAsync();
-                        await assetOutputFolder.CreateCopyOfAsync(asset.ResolvedFile, overwrite: true);
-                    }
+                    await pageOutputFolder.CreateCopyOfAsync(indexFile, overwrite: true);
+                    await PageAssetMaterializer.CopyAssetsAsync(pageOutputFolder, indexFile.Assets);
                 }
             }
 

tests/Blog/AssetAwareHtmlTemplatedMarkdownPagesFolderTests.cs

@@ -24,6 +24,15 @@ public class AssetAwareHtmlTemplatedMarkdownPagesFolderTests
     private IFile _page2File = null!;
     private IFile _logoFile = null!;
 
+    private static KnownAssetStrategy CreateReferenceOnlyStrategy()
+    {
+        return new KnownAssetStrategy
+        {
+            UnknownAssetFallbackStrategy = AssetFallbackBehavior.Reference,
+            UnknownAssetFaultStrategy = FaultStrategy.None,
+        };
+    }
+
     [TestInitialize]
     public async Task Setup()
     {
@@ -94,7 +103,7 @@ await templateWriter.WriteAsync(@"<!DOCTYPE html>
         {
             LinkDetector = new RegexAssetLinkDetector(),
             Resolver = new RelativePathAssetResolver(),
-            AssetStrategy = new ReferenceOnlyAssetStrategy()
+            AssetStrategy = CreateReferenceOnlyStrategy()
         };
     }
 
@@ -176,12 +185,13 @@ public async Task AssetPathResolution_ResolvesValidPaths()
     [TestMethod]
     public async Task AssetStrategy_AppliesReferenceDecisions()
     {
-        var strategy = new ReferenceOnlyAssetStrategy();
+        var strategy = CreateReferenceOnlyStrategy();
         Assert.IsNotNull(_page1File, "page1.md should exist");
         Assert.IsNotNull(_logoFile, "logo.png should exist");
 
         var rewrittenPath = await strategy.DecideAsync(_page1File, _logoFile, "../images/logo.png");
 
+        Assert.IsNotNull(rewrittenPath, "Reference-only strategy should return a rewritten path");
         Assert.IsTrue(rewrittenPath.StartsWith("../"), "Reference-only strategy should return path with ../ prefix");
         Assert.IsTrue(rewrittenPath.Contains("images/logo.png"), "Rewritten path should preserve original structure");
     }

tests/Blog/BlogCommandMaterializationTests.cs

@@ -0,0 +1,104 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.CommandLine;
+using WindowsAppCommunity.CommandLine.Blog.PostPage;
+
+namespace WindowsAppCommunity.CommandLine.Tests.Blog;
+
+[TestClass]
+public class BlogCommandMaterializationTests
+{
+    [TestMethod]
+    public async Task PageCommand_CopiesGeneratedIndexAndTemplateAssets()
+    {
+        var tempRoot = CreateTempRoot();
+
+        try
+        {
+            var markdownPath = Path.Combine(tempRoot, "post.md");
+            var templateFolder = Path.Combine(tempRoot, "template");
+            var outputFolder = Path.Combine(tempRoot, "output");
+
+            Directory.CreateDirectory(Path.Combine(templateFolder, "images"));
+            Directory.CreateDirectory(outputFolder);
+
+            await File.WriteAllTextAsync(markdownPath, "---\ntitle: Test Post\n---\n\n# Hello");
+            await File.WriteAllTextAsync(Path.Combine(templateFolder, "template.html"), "<html><head><link rel=\"stylesheet\" href=\"styles.css\"></head><body><img src=\"images/logo.png\">{{ body }}</body></html>");
+            await File.WriteAllTextAsync(Path.Combine(templateFolder, "styles.css"), "body { color: black; }");
+            await File.WriteAllTextAsync(Path.Combine(templateFolder, "images", "logo.png"), "logo");
+
+            var exitCode = await new PageCommand().InvokeAsync([
+                "--markdown", markdownPath,
+                "--template", templateFolder,
+                "--output", outputFolder]);
+
+            var pageOutputFolder = Path.Combine(outputFolder, "post");
+
+            Assert.AreEqual(0, exitCode);
+            Assert.IsTrue(File.Exists(Path.Combine(pageOutputFolder, "index.html")), "index.html should be generated.");
+            Assert.IsTrue(File.Exists(Path.Combine(pageOutputFolder, "styles.css")), "styles.css should be copied as a file.");
+            Assert.IsFalse(Directory.Exists(Path.Combine(pageOutputFolder, "styles.css")), "styles.css must not be materialized as a folder.");
+            Assert.IsTrue(File.Exists(Path.Combine(pageOutputFolder, "images", "logo.png")), "Nested template image should be copied.");
+            Assert.IsTrue(File.Exists(Path.Combine(templateFolder, "styles.css")), "Template source asset should remain in place.");
+            Assert.AreEqual(0, Directory.GetFiles(pageOutputFolder, "*.md", SearchOption.AllDirectories).Length, "Markdown source should not be copied into page output.");
+        }
+        finally
+        {
+            DeleteTempRoot(tempRoot);
+        }
+    }
+
+    [TestMethod]
+    public async Task PagesCommand_CopiesTemplateAssetsAndReferencedSourceAssetsToRewrittenPaths()
+    {
+        var tempRoot = CreateTempRoot();
+
+        try
+        {
+            var sourceFolder = Path.Combine(tempRoot, "source");
+            var templateFolder = Path.Combine(tempRoot, "template");
+            var outputFolder = Path.Combine(tempRoot, "output");
+
+            Directory.CreateDirectory(Path.Combine(sourceFolder, "images"));
+            Directory.CreateDirectory(Path.Combine(templateFolder, "images"));
+            Directory.CreateDirectory(outputFolder);
+
+            await File.WriteAllTextAsync(Path.Combine(sourceFolder, "page1.md"), "---\ntitle: Page 1\n---\n\n# Page 1\n\n![Content](images/content.png)");
+            await File.WriteAllTextAsync(Path.Combine(sourceFolder, "images", "content.png"), "content");
+            await File.WriteAllTextAsync(Path.Combine(templateFolder, "template.html"), "<html><head><link rel=\"stylesheet\" href=\"styles.css\"></head><body><img src=\"images/template-logo.png\">{{ body }}</body></html>");
+            await File.WriteAllTextAsync(Path.Combine(templateFolder, "styles.css"), "body { color: black; }");
+            await File.WriteAllTextAsync(Path.Combine(templateFolder, "images", "template-logo.png"), "logo");
+
+            var exitCode = await new PagesCommand().InvokeAsync([
+                "--markdown-folder", sourceFolder,
+                "--template", templateFolder,
+                "--output", outputFolder]);
+
+            var pageOutputFolder = Path.Combine(outputFolder, "page1");
+
+            Assert.AreEqual(0, exitCode);
+            Assert.IsTrue(File.Exists(Path.Combine(pageOutputFolder, "index.html")), "Page index.html should be generated.");
+            Assert.IsTrue(File.Exists(Path.Combine(pageOutputFolder, "styles.css")), "Template stylesheet should be copied into each page folder.");
+            Assert.IsFalse(Directory.Exists(Path.Combine(pageOutputFolder, "styles.css")), "styles.css must not be materialized as a folder.");
+            Assert.IsTrue(File.Exists(Path.Combine(pageOutputFolder, "images", "template-logo.png")), "Template image should be copied into each page folder.");
+            Assert.IsTrue(File.Exists(Path.Combine(outputFolder, "images", "content.png")), "Referenced source image should be copied to the rewritten parent-relative path.");
+            Assert.AreEqual(0, Directory.GetFiles(outputFolder, "*.md", SearchOption.AllDirectories).Length, "Markdown source should not be copied into multi-page output.");
+        }
+        finally
+        {
+            DeleteTempRoot(tempRoot);
+        }
+    }
+
+    private static string CreateTempRoot()
+    {
+        var tempRoot = Path.Combine(Path.GetTempPath(), "wac-blog-tests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(tempRoot);
+        return tempRoot;
+    }
+
+    private static void DeleteTempRoot(string tempRoot)
+    {
+        if (Directory.Exists(tempRoot))
+            Directory.Delete(tempRoot, recursive: true);
+    }
+}