Address PR review: extend IHeaderStyle, simplify renderer, FontPath, README tidy

Co-authored-by: boxofyellow <54955040+boxofyellow@users.noreply.github.com>

Author: Copilot

ConsoleMarkdownRenderer.Tests/FigletTextStyleTests.cs

@@ -75,5 +75,59 @@ public void TextStyle_Justification_IsNullViaIHeaderStyle()
             IHeaderStyle plain = new TextStyle(decoration: TextDecoration.Bold, foreground: TextColor.Red);
             Assert.IsNull(plain.Justification);
         }
+
+        [TestMethod]
+        public void TextStyle_FontPath_IsNullViaIHeaderStyle()
+        {
+            // FontPath is explicitly implemented on TextStyle and must always return null --
+            // custom FIGlet fonts are only meaningful for FigletTextStyle.
+            IHeaderStyle plain = new TextStyle();
+            Assert.IsNull(plain.FontPath);
+        }
+
+        [TestMethod]
+        public void TextStyle_ExposesForegroundBackgroundDecorationViaIHeaderStyle()
+        {
+            // Foreground/Background/Decoration on TextStyle are implicit interface members --
+            // they round-trip through the IHeaderStyle interface unchanged.
+            IHeaderStyle plain = new TextStyle(
+                decoration: TextDecoration.Italic,
+                foreground: TextColor.Red,
+                background: TextColor.Blue);
+
+            Assert.AreEqual(TextDecoration.Italic, plain.Decoration);
+            Assert.AreEqual(TextColor.Red,         plain.Foreground);
+            Assert.AreEqual(TextColor.Blue,        plain.Background);
+        }
+
+        [TestMethod]
+        public void FigletTextStyle_BackgroundAndDecoration_HardCodedViaIHeaderStyle()
+        {
+            // FigletText does not support a background color or text decoration so those
+            // members on the IHeaderStyle interface are hard-coded.
+            IHeaderStyle figlet = new FigletTextStyle(foreground: TextColor.Green);
+
+            Assert.AreEqual(TextColor.Green,        figlet.Foreground);
+            Assert.IsNull(figlet.Background);
+            Assert.AreEqual(TextDecoration.None,    figlet.Decoration);
+        }
+
+        [TestMethod]
+        public void FigletTextStyle_FontPath_Preserved()
+        {
+            var style = new FigletTextStyle(fontPath: "/some/path/font.flf");
+
+            Assert.AreEqual("/some/path/font.flf", style.FontPath);
+            Assert.AreEqual("/some/path/font.flf", ((IHeaderStyle)style).FontPath);
+        }
+
+        [TestMethod]
+        public void FigletTextStyle_Equality_DifferentFontPath()
+        {
+            var a = new FigletTextStyle(fontPath: "/a.flf");
+            var b = new FigletTextStyle(fontPath: "/b.flf");
+
+            Assert.AreNotEqual(a, b);
+        }
     }
 }

ConsoleMarkdownRenderer.Tests/RendererTests.cs

@@ -162,14 +162,14 @@ public void RendererTests_MarkedTest(bool useCrazy)
         [DataRow(false)]
         [DataRow(true)]
         public void RendererTests_HeaderTest(bool useCrazy)
-            // The default DisplayOptions configures H1 as a centered FigletTextStyle, so H1's
-            // literal text ("Level One") is replaced by FIGlet ASCII art and is not asserted
-            // here. H2 and H3 still fall through to the default Header style.
+            // The default DisplayOptions configures H1 as a FigletTextStyle, so H1's literal
+            // text ("Level One") is replaced by FIGlet ASCII art and is not asserted here.
+            // H2 and H3 still fall through to the default Header style.
             => AssertMarkdownYieldsFormat(
                 "headingBlock",
                 text: useCrazy 
-                    ? "Level Two Level Three"
-                    : "## Level Two ## ### Level Three ###",
+                    ? "Level Two with  here Level Three with bold word"
+                    : "## Level Two with code here ## ### Level Three with bold word ###",
                 new Style(decoration: Decoration.Bold | Decoration.Invert | Decoration.Underline),
                 useCrazy);
 
@@ -245,9 +245,9 @@ public void RendererTests_FigletHeaderOnlyAppliesToConfiguredLevel()
             Assert.DoesNotContain("Level One", output,
                 $"H1 should be FIGlet rendered:\n{output}");
             // H2 and H3 should still be rendered as styled markup wrapped in '#'s.
-            Assert.Contains("## Level Two ##", output,
+            Assert.Contains("## Level Two with code here ##", output,
                 $"H2 should remain styled with '##' wrapping:\n{output}");
-            Assert.Contains("### Level Three ###", output,
+            Assert.Contains("### Level Three with bold word ###", output,
                 $"H3 should remain styled with '###' wrapping:\n{output}");
         }
 
@@ -264,9 +264,56 @@ public void RendererTests_FigletDefaultCanBeOverriddenWithTextStyle()
             ConsoleUnderTest.Write(Renderer(GetResourceContent("headingBlock", "md"), options));
 
             var output = ConsoleUnderTest.Output;
-            Assert.Contains("# Level One #",       output, $"H1 should be wrapped with '#':\n{output}");
-            Assert.Contains("## Level Two ##",     output, $"H2 should be wrapped with '##':\n{output}");
-            Assert.Contains("### Level Three ###", output, $"H3 should be wrapped with '###':\n{output}");
+            Assert.Contains("# Level One #",                            output, $"H1 should be wrapped with '#':\n{output}");
+            Assert.Contains("## Level Two with code here ##",           output, $"H2 should be wrapped with '##':\n{output}");
+            Assert.Contains("### Level Three with bold word ###",       output, $"H3 should be wrapped with '###':\n{output}");
+        }
+
+        [TestMethod]
+        public void RendererTests_FigletEmptyHeadingFallsBackToStyledMarkup()
+        {
+            // FigletText cannot render an empty string. When the heading has no text the
+            // renderer should fall through to the styled-markup path so the level marker
+            // (e.g. "# #" with WrapHeader=true) is still emitted.
+            DisplayOptions options = new();
+            // Sanity check: H1 is configured to use FIGlet by default.
+            Assert.IsInstanceOfType<FigletTextStyle>(options.EffectiveHeader(1));
+
+            ConsoleUnderTest.Write(Renderer("#\n", options));
+
+            var output = ConsoleUnderTest.Output;
+            Assert.Contains("#", output,
+                $"Empty H1 should fall back to styled '#'-wrapped markup:\n{output}");
+        }
+
+        [TestMethod]
+        public void RendererTests_FigletFontPathLoadsCustomFont()
+        {
+            // When FontPath is set the renderer should load the custom .flf font and use it
+            // to render the FIGlet text. Compare the output against the default font to make
+            // sure something actually changed.
+            const string markdown = "# Hi\n";
+            var defaultOptions = new DisplayOptions();
+            ConsoleUnderTest.Write(Renderer(markdown, defaultOptions));
+            var defaultOutput = ConsoleUnderTest.Output;
+
+            NewConsole();
+
+            var fontPath = Path.Combine(DataPath, "fonts", "shadow.flf");
+            Assert.IsTrue(File.Exists(fontPath), $"Test font file should exist at {fontPath}");
+
+            var customOptions = new DisplayOptions
+            {
+                Headers = new() { new FigletTextStyle(fontPath: fontPath) },
+            };
+            ConsoleUnderTest.Write(Renderer(markdown, customOptions));
+            var customOutput = ConsoleUnderTest.Output;
+
+            Assert.AreNotEqual(defaultOutput, customOutput,
+                $"FIGlet output should differ when a custom FontPath is supplied.\nDefault:\n{defaultOutput}\nCustom:\n{customOutput}");
+            // FIGlet output should still contain ASCII-art glyph characters.
+            Assert.IsTrue(customOutput.Contains('|') || customOutput.Contains('\\'),
+                $"Expected FIGlet glyph characters in custom-font output:\n{customOutput}");
         }
 
         [TestMethod]