Allow caller to overwrite styling (#3)

* Allow caller to overwrite styling

* Allow the caller to remove the wrapping around Headers

Author: boxofyellow

ConsoleMarkdownRenderer.Example/Program.cs

@@ -39,6 +39,10 @@ class ExampleSettings : CommandSettings
         [DefaultValue(false)]
         public bool IncludeDebug { get; init; }
 
+        [CommandOption("-r|--remove-header-wrap")]
+        [DefaultValue(false)]
+        public bool RemoveHeaderWrap { get; init; }
+
         [CommandOption("-w|--web")]
         [DefaultValue(false)]
         public bool UseWeb { get; init; }
@@ -63,10 +67,16 @@ public override int Execute([NotNull] CommandContext context, [NotNull] ExampleS
                 uri = new Uri(Path.GetFullPath(path));
             }
 
+            DisplayOptions options = new()
+            {
+                IncludeDebug = settings.IncludeDebug,
+                WrapHeader = !settings.RemoveHeaderWrap,
+            };
+
             Displayer.DisplayMarkdown(
                 uri,
-                !settings.IgnoreLinks,
-                settings.IncludeDebug);
+                options,
+                allowFollowingLinks: !settings.IgnoreLinks);
             return 0;
         }
     }

ConsoleMarkdownRenderer.Example/usage.md

@@ -7,5 +7,6 @@ The little application will display the contents of markdown file, and accepts t
 | `-p`/`--path` | The path to where the markdown content can be found, it can be relative (or absolute) file path, or any valid Uri. If not proved this default the contents of `data/example.md` unless the `--web` is provided, in will use the default content from the web |
 | `-i`/`--ignore--links` | Used to suppress the list of links found within the document. |
 | `-d`/`--include-debug` | Include debug information |
+| `-r`/`--remove-header-wrap` | Remove the `#` that wrap headers |
 | `-w`/`--web` | When specified (and `--path` is not) content from [the source repo](https://github.com/boxofyellow/ConsoleMarkdownRenderer) will be displayed |
 

ConsoleMarkdownRenderer.Tests/RendererTests.cs

@@ -58,7 +58,7 @@ public void RendererTests_TextValidation()
             }
 
             var pipeline = Displayer.DefaultPipeline;
-            var renderer = new ConsoleRenderer(includeDebug: true);
+            var renderer = new ConsoleRenderer(new DisplayOptions() { IncludeDebug = true });
 
             foreach (var markdown in markdowns)
             {
@@ -76,9 +76,13 @@ public void RendererTests_TextValidation()
             }
         }
 
-        [TestMethod]
-        public void RendererTests_CodeInlineTest() 
-            => AssertMarkdownYieldsFormat("codeInline", "in line code", new Style(foreground: Color.Yellow, background: Color.Blue));
+        [DataTestMethod]
+        [DataRow(false)]
+        [DataRow(true)]
+        public void RendererTests_CodeInlineTest(bool useCrazy)
+        {
+            AssertMarkdownYieldsFormat("codeInline", "in line code", new Style(foreground: Color.Yellow, background: Color.Blue), useCrazy);
+        }
 
         [DataTestMethod]
         [DataRow("bold"          , Decoration.Bold)]
@@ -87,25 +91,40 @@ public void RendererTests_CodeInlineTest()
         [DataRow("subscript"     , Decoration.SlowBlink)]
         [DataRow("superscript"   , Decoration.RapidBlink)]
         [DataRow("inserted"      , Decoration.Underline)]
-        public void RendererTests_EmphasisInlineTest(string text, Decoration decoration) 
-            => AssertMarkdownYieldsFormat("emphasisInline", text, new Style(decoration: decoration));
+        public void RendererTests_EmphasisInlineTest(string text, Decoration decoration)
+        {
+            AssertMarkdownYieldsFormat("emphasisInline", text, new Style(decoration: decoration), useCrazy: false);
+            AssertMarkdownYieldsFormat("emphasisInline", text, new Style(decoration: decoration), useCrazy: true);
+        }
 
-        [TestMethod]
-        public void RendererTests_MarkedTest() 
-            => AssertMarkdownYieldsFormat("emphasisInline", "marked", new Style(foreground: Color.Black, background: Color.Yellow));
+        [DataTestMethod]
+        [DataRow(false)]
+        [DataRow(true)]
+        public void RendererTests_MarkedTest(bool useCrazy)
+        {
+            AssertMarkdownYieldsFormat("emphasisInline", "marked", new Style(foreground: Color.Black, background: Color.Yellow), useCrazy);
+        }
 
-        [TestMethod]
-        public void RendererTests_HeaderTest() 
+        [DataTestMethod]
+        [DataRow(false)]
+        [DataRow(true)]
+        public void RendererTests_HeaderTest(bool useCrazy)
             => AssertMarkdownYieldsFormat(
                 "headingBlock",
-                "# Level One # ## Level Two ## ### Level Three ###",
-                new Style(decoration: Decoration.Bold | Decoration.Invert | Decoration.Underline));
+                text: useCrazy 
+                    ? "Level One Level Two Level Three"
+                    : "# Level One # ## Level Two ## ### Level Three ###",
+                new Style(decoration: Decoration.Bold | Decoration.Invert | Decoration.Underline),
+                useCrazy);
 
         [DataTestMethod]
         [DataRow("htmlBlock", "<table> <tr> <td>1</td> <td>2</td> </tr> <tr> <td>3</td> <td>4</td> </tr> </table>")]
         [DataRow("htmlInline", "<span>html</span>")]
-        public void RendererTests_HtmlTest(string name, string text) 
-            => AssertMarkdownYieldsFormat(name, text, new Style(foreground: Color.Black, background: Color.Green));
+        public void RendererTests_HtmlTest(string name, string text)
+        {
+            AssertMarkdownYieldsFormat(name, text, new Style(foreground: Color.Black, background: Color.Green), useCrazy: false);
+            AssertMarkdownYieldsFormat(name, text, new Style(foreground: Color.Black, background: Color.Green), useCrazy: true);
+        }
 
         [TestMethod]
         public void RendererTests_LinkTest()
@@ -123,7 +142,7 @@ public void RendererTests_LinkTest()
                 new ("9", "https://www.nine.com/nine.jpg", true),
             };
 
-            var renderer = new ConsoleRenderer(includeDebug: true);
+            var renderer = new ConsoleRenderer(new DisplayOptions() { IncludeDebug = true});
 
             ConsoleUnderTest.Write(Renderer(GetResourceContent("linkInline", "md"), renderer));
 
@@ -140,17 +159,22 @@ public void RendererTests_LinkTest()
         [DataRow("quote 2." , Decoration.Italic)]
         [DataRow("should even" , Decoration.Italic | Decoration.Bold)]
         public void RendererTests_QuoteBlockTest(string text, Decoration decoration) 
-            => AssertMarkdownYieldsFormat("quoteBlock", text, new Style(decoration: decoration));
+        {
+            AssertMarkdownYieldsFormat("quoteBlock", text, new Style(decoration: decoration), useCrazy: false);
+            AssertMarkdownYieldsFormat("quoteBlock", text, new Style(decoration: decoration), useCrazy: true);
+        }
 
-        private void AssertMarkdownYieldsFormat(string name, string text, Style style)
+        private void AssertMarkdownYieldsFormat(string name, string text, Style style, bool useCrazy)
         {
+            Style format = useCrazy ? c_crazyFormat : style;
+            DisplayOptions options = useCrazy ? m_crazyOptions : new DisplayOptions();
             var markdown = GetResourceContent(name, "md");
 
-            var renderHook = new TestRenderHook(text, style);
+            var renderHook = new TestRenderHook(text, format);
             ConsoleUnderTest.Pipeline.Attach(renderHook);
 
             Logger.LogMessage($"Rendering {name}");
-            ConsoleUnderTest.Write(Renderer(markdown));
+            ConsoleUnderTest.Write(Renderer(markdown, options: options));
 
             renderHook.AssertFormattedTextFound();
         }
@@ -164,10 +188,13 @@ private string GetResourceContent(string name, string extension)
             return reader.ReadToEnd();
         }
 
-        private static IRenderable Renderer(string text, ConsoleRenderer? renderer = default, MarkdownPipeline? pipeline = default)
+        private static IRenderable Renderer(string text, ConsoleRenderer? renderer = default, MarkdownPipeline? pipeline = default, DisplayOptions? options = default)
         {
             var document = Markdown.Parse(text, pipeline ?? Displayer.DefaultPipeline);
-            renderer ??= new ConsoleRenderer(includeDebug: true);
+            options ??= new();
+            options = options.Clone();
+            options.IncludeDebug = true;
+            renderer ??= new ConsoleRenderer(options);
             renderer.Clear();
             renderer.Render(document);
             Assert.IsNotNull(renderer.Root);
@@ -222,6 +249,27 @@ private static Dictionary<string, int> Counts(string text)
             private int m_count;
         }
 
+        private const string c_crazyFormat = "red on purple";
+        private readonly static DisplayOptions m_crazyOptions = new DisplayOptions
+        {
+            Bold = c_crazyFormat,
+            CodeBlock = c_crazyFormat,
+            CodeInLine = c_crazyFormat,
+            Header = c_crazyFormat,
+            HtmlBlock = c_crazyFormat,
+            HtmlInline = c_crazyFormat,
+            Inserted = c_crazyFormat,
+            Italic = c_crazyFormat,
+            Marked = c_crazyFormat,
+            QuotedBlock = c_crazyFormat,
+            Strikethrough = c_crazyFormat,
+            Subscript = c_crazyFormat,
+            Superscript = c_crazyFormat,
+            UnknownDelimiterChar = c_crazyFormat,
+            UnknownDelimiterContent = c_crazyFormat,
+            WrapHeader = false,
+        };
+
         private const string c_resources = "resources";
     }
 }

DisplayOptions.cs

@@ -0,0 +1,68 @@
+using Spectre.Console;
+
+namespace ConsoleMarkdownRenderer
+{
+    /// <summary>
+    /// Class for controlling the styling and other other display options for the Markdown elements 
+    /// </summary>
+    public class DisplayOptions
+    {
+        public Style Bold { get; set; } = new(decoration: Decoration.Bold);
+        public Style CodeBlock { get; set; } = new(foreground: Color.Yellow, background: Color.Blue);
+        public Style CodeInLine { get; set; } = new(foreground: Color.Yellow, background: Color.Blue);
+        public Style Header { get; set; } = new(decoration: Decoration.Bold | Decoration.Underline | Decoration.Invert);
+        public Style HtmlBlock { get; set; } = new(foreground: Color.Black, background: Color.Green);
+        public Style HtmlInline { get; set; } = new(foreground: Color.Black, background: Color.Green);
+        /// <see cref="Markdig.Extensions.EmphasisExtras.EmphasisExtraOptions.Inserted"/>
+        public Style Inserted { get; set; } = new(decoration: Decoration.Underline);
+        public Style Italic { get; set; } = new(decoration: Decoration.Italic);
+        /// <see cref="Markdig.Extensions.EmphasisExtras.EmphasisExtraOptions.Marked"/>
+        public Style Marked { get; set; } = new(foreground: Color.Black, background: Color.Yellow);
+
+        public Style QuotedBlock { get; set; } = new Style(decoration: Decoration.Italic);
+
+        /// <see cref="Markdig.Extensions.EmphasisExtras.EmphasisExtraOptions.Strikethrough"/>
+        public Style Strikethrough { get; set; } = new(decoration: Decoration.Strikethrough);
+
+        // Hey, I'm sure there might be something better for subscript... but sometimes you have to make due with what you got 
+        // And the blink does not seem to render well
+        /// <see cref="Markdig.Extensions.EmphasisExtras.EmphasisExtraOptions.Subscript"/>
+        public Style Subscript { get; set; } = new(decoration: Decoration.SlowBlink);
+
+        // This another one.  Don't have an exact match for superscript
+        /// <see cref="Markdig.Extensions.EmphasisExtras.EmphasisExtraOptions.Superscript"/>
+        public Style Superscript { get; set; } = new(decoration: Decoration.RapidBlink);
+
+
+        // Yes, these more a style, but it should help identify where things need updating
+        public Style UnknownDelimiterChar { get; set; } = new(decoration: Decoration.Dim);
+        public Style UnknownDelimiterContent { get; set; } = new(decoration: Decoration.Invert);
+
+        // When set to true wrap Headers with '#'s 
+        public bool WrapHeader { get; set; } = true;
+ 
+        // When set to true the content structure is displayed and detail of unsupported markdown is displayed
+        public bool IncludeDebug = false;
+
+        public DisplayOptions Clone() => new()
+        {
+            Bold = this.Bold,
+            CodeBlock = this.CodeBlock,
+            CodeInLine = this.CodeInLine,
+            Header = this.Header,
+            HtmlBlock = this.HtmlBlock,
+            HtmlInline = this.HtmlInline,
+            IncludeDebug = this.IncludeDebug,
+            Inserted = this.Inserted,
+            Italic = this.Italic,
+            Marked = this.Marked,
+            QuotedBlock = this.QuotedBlock,
+            Strikethrough = this.Strikethrough,
+            Subscript = this.Subscript,
+            Superscript = this.Superscript,
+            UnknownDelimiterChar = this.UnknownDelimiterChar,
+            UnknownDelimiterContent = this.UnknownDelimiterContent,
+            WrapHeader = this.WrapHeader,
+        };
+    }
+}

Displayer.cs

@@ -34,9 +34,9 @@ public static class Displayer
         ///  - For everything else it is thrown at the OS to see if it can sort it out.
         /// </summary>
         /// <param name="uri">The uri to pull the content from</param>
+        /// <param name="options">options to control how to display the content</param>
         /// <param name="allowFollowingLinks">when set to true, the list of links will be provided, when false the list is omitted</param>
-        /// <param name="includeDebug">when set to true the content structure is displayed and detail of unsupported markdown is displayed</param>
-        public static void DisplayMarkdown(Uri uri, bool allowFollowingLinks = true, bool includeDebug = false)
+        public static void DisplayMarkdown(Uri uri, DisplayOptions? options = default, bool allowFollowingLinks = true)
         {
             using var tempFiles = new TempFileManager();
             string path = string.Empty;
@@ -60,7 +60,7 @@ public static void DisplayMarkdown(Uri uri, bool allowFollowingLinks = true, boo
             if (!string.IsNullOrEmpty(path))
             {
                 var text = File.ReadAllText(path);
-                DisplayMarkdown(text, uri, allowFollowingLinks, tempFiles, includeDebug);
+                DisplayMarkdown(text, uri, options, allowFollowingLinks, tempFiles);
             }
         }
 
@@ -77,12 +77,12 @@ public static void DisplayMarkdown(Uri uri, bool allowFollowingLinks = true, boo
         /// </summary>
         /// <param name="text">the content to display</param>
         /// <param name="baseUri">uri for that content, this base is used to calculate relative links</param>
+        /// <param name="options">options to control how to display the content</param>
         /// <param name="allowFollowingLinks">when set to true, the list of links will be provided, when false the list is omitted</param>
-        /// <param name="includeDebug">when set to true the content structure is displayed and detail of unsupported markdown is displayed</param>
-        public static void DisplayMarkdown(string text, Uri baseUri, bool allowFollowingLinks = true, bool includeDebug = false)
+        public static void DisplayMarkdown(string text, Uri baseUri, DisplayOptions? options = default, bool allowFollowingLinks = true)
         {
             using var tempFiles = new TempFileManager();
-            DisplayMarkdown(text, baseUri, allowFollowingLinks, tempFiles, includeDebug);
+            DisplayMarkdown(text, baseUri, options, allowFollowingLinks, tempFiles);
         }
 
         /// <summary>
@@ -130,7 +130,7 @@ internal static string Download(Uri uri, TempFileManager tempFiles, bool expectI
                 string tempFile = tempFiles.GetTempFile();
                 using var fileStream = File.Create(tempFile);
                 // We we make this method async we should flip this too.
-                response.Content.CopyTo(fileStream, context: null, CancellationToken.None);
+                response.Content.CopyTo(fileStream, context: default, CancellationToken.None);
                 return tempFile;
             }
             catch (Exception ex)
@@ -145,17 +145,19 @@ internal static string Download(Uri uri, TempFileManager tempFiles, bool expectI
         /// </summary>
         /// <param name="text">the content to display</param>
         /// <param name="baseUri">uri for that content, this base is used to calculate relative links</param>
+        /// <param name="options">options to control how to display the content</param>
         /// <param name="allowFollowingLinks">when true the user will be allow to follow links in the document</param>
         /// <param name="tempFiles">a manager for temp files, the caller is expected to clean these up</param>
-        /// <param name="includeDebug"see the public version></param>
-        private static void DisplayMarkdown(string text, Uri baseUri, bool allowFollowingLinks, TempFileManager tempFiles, bool includeDebug)
+        private static void DisplayMarkdown(string text, Uri baseUri, DisplayOptions? options, bool allowFollowingLinks, TempFileManager tempFiles)
         {
             // Two additional options that get included in the list links
             const int done = -1;  // To indicate that the user is done and want to give control back to the caller
             const int back = -2;  // To indicate that the user was to view the previously displayed content 
 
+            options ??= new DisplayOptions();
+
             var pipeline = DefaultPipeline;
-            var renderer = new ConsoleRenderer(includeDebug);
+            var renderer = new ConsoleRenderer(options);
 
             // As the user browses the links, this stack allows us display the previous content at their request
             var stack = new Stack<(string Text, Uri RelativePath)>();
@@ -384,24 +386,24 @@ private static void Open(Uri uri)
         /// <returns>an http client, the call should NOT dispose this</returns>
         private static HttpClient GetClient()
         {
-            lock (m_lockObject)
+            lock (s_lockObject)
             {
-                if (m_client is null)
+                if (s_client is null)
                 {
                     var handler = new SocketsHttpHandler
                     {
                         // Really I don't expect the DNS much for these, but as a library we don't really know how long we will hang around
                         // so **_some_** limit makes sense
                         PooledConnectionLifetime = TimeSpan.FromMinutes(15)
                     };
-                    m_client = new HttpClient(handler);
+                    s_client = new HttpClient(handler);
                 }
             }
-            return m_client;
+            return s_client;
         }
 
-        private static HttpClient? m_client;
-        private static object m_lockObject = new();
+        private static HttpClient? s_client;
+        private static readonly object s_lockObject = new();
 
         /// <summary>
         /// Try to determine if this an iTerm2 console

ObjectRenderers/ConsoleCodeBlockRenderer.cs

@@ -10,7 +10,7 @@ protected override void Write(ConsoleRenderer renderer, CodeBlock obj)
             renderer
                 .NewFrame()
                 .StartInline()
-                .AddInLine("[yellow on blue]")
+                .PushStyle(renderer.Options.CodeBlock)
                 .AddInLine(Environment.NewLine);
 
             for (int i = 0; i < obj.Lines.Lines.Length; i++)
@@ -25,7 +25,7 @@ protected override void Write(ConsoleRenderer renderer, CodeBlock obj)
             }
 
             renderer
-                .AddInLine("[/]")
+                .PopStyle()
                 .EndInline()
                 .CompleteFrame();
         }