Fix emoji table alignment regression (#943)

Author: xoofx

src/Markdig.Tests/TestCustomEmojis.cs

@@ -137,4 +137,54 @@ public void TestEmojiInPipeTable(string input, string expected)
         var actual = Markdown.ToHtml(input, pipeline);
         Assert.AreEqual(expected, actual);
     }
-}
+
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void TestEmojiDoesNotBreakPipeTableAlignment(bool useEmojiFirst)
+    {
+        const string input = "| Left | Center | Right |\n| ---- |:------:| -----:|\n| a | b | c |";
+        const string expected = "<table>\n<thead>\n<tr>\n<th>Left</th>\n<th style=\"text-align: center;\">Center</th>\n<th style=\"text-align: right;\">Right</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>a</td>\n<td style=\"text-align: center;\">b</td>\n<td style=\"text-align: right;\">c</td>\n</tr>\n</tbody>\n</table>\n";
+
+        var pipelineBuilder = new MarkdownPipelineBuilder();
+        if (useEmojiFirst)
+        {
+            pipelineBuilder.UseEmojiAndSmiley().UsePipeTables();
+        }
+        else
+        {
+            pipelineBuilder.UsePipeTables().UseEmojiAndSmiley();
+        }
+
+        var pipeline = pipelineBuilder.Build();
+        var actual = Markdown.ToHtml(input, pipeline);
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    public void TestEmojiDoesNotBreakGridTableAlignment()
+    {
+        const string input = "+-----+:---:+-----+\n|  A  | :x: |  C  |\n+-----+-----+-----+";
+        const string expected = "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td>A</td>\n<td style=\"text-align: center;\">❌</td>\n<td>C</td>\n</tr>\n</tbody>\n</table>\n";
+
+        var pipeline = new MarkdownPipelineBuilder()
+            .UseGridTables()
+            .UseEmojiAndSmiley()
+            .Build();
+
+        var actual = Markdown.ToHtml(input, pipeline);
+        Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    public void TestPipeTableExtensionDoesNotSuppressNeutralFaceInParagraph()
+    {
+        var pipeline = new MarkdownPipelineBuilder()
+            .UsePipeTables()
+            .UseEmojiAndSmiley()
+            .Build();
+
+        var actual = Markdown.ToHtml("text :|", pipeline);
+        Assert.AreEqual("<p>text 😐</p>\n", actual);
+    }
+}

src/Markdig/Extensions/Emoji/EmojiExtension.cs

@@ -2,6 +2,7 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
+using Markdig.Parsers.Inlines;
 using Markdig.Renderers;
 
 namespace Markdig.Extensions.Emoji;
@@ -32,8 +33,9 @@ public void Setup(MarkdownPipelineBuilder pipeline)
     {
         if (!pipeline.InlineParsers.Contains<EmojiParser>())
         {
-            // Insert the parser before any other parsers
-            pipeline.InlineParsers.Insert(0, new EmojiParser(EmojiMapping));
+            // Insert before emphasis so emoji shortcodes are parsed early, while preserving
+            // precedence for structural parsers registered earlier in the pipeline.
+            pipeline.InlineParsers.InsertBefore<EmphasisInlineParser>(new EmojiParser(EmojiMapping));
         }
     }
 

src/Markdig/Extensions/Tables/PipeTableExtension.cs

@@ -2,6 +2,7 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
+using Markdig.Extensions.Emoji;
 using Markdig.Parsers.Inlines;
 using Markdig.Renderers;
 
@@ -46,7 +47,11 @@ public void Setup(MarkdownPipelineBuilder pipeline)
             // delimiter inside a cell, e.g. the subscript `~` in `**~$1.50**`, can leave pipe delimiters nested
             // in an emphasis delimiter tree and make the table parser see phantom cells. PipeTableParser re-runs
             // inline post-processors inside each extracted cell after the table structure has been fixed.
-            pipeline.InlineParsers.InsertBefore<EmphasisInlineParser>(new PipeTableParser(lineBreakParser!, Options));
+            var pipeTableParser = new PipeTableParser(lineBreakParser!, Options);
+            if (!pipeline.InlineParsers.InsertBefore<EmojiParser>(pipeTableParser))
+            {
+                pipeline.InlineParsers.InsertBefore<EmphasisInlineParser>(pipeTableParser);
+            }
         }
     }
 

src/Markdig/Extensions/Tables/PipeTableParser.cs

@@ -29,7 +29,7 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor
     public PipeTableParser(LineBreakInlineParser lineBreakParser, PipeTableOptions? options = null)
     {
         _lineBreakParser = lineBreakParser ?? throw new ArgumentNullException(nameof(lineBreakParser));
-        OpeningCharacters = ['|', '\n', '\r'];
+        OpeningCharacters = ['|', '\n', '\r', ':'];
         Options = options ?? new PipeTableOptions();
     }
 
@@ -51,6 +51,18 @@ public override bool Match(InlineProcessor processor, ref StringSlice slice)
 
         var c = slice.CurrentChar;
 
+        if (c == ':')
+        {
+            var tableStateForColon = processor.ParserStates[Index] as TableState;
+            if (tableStateForColon is null || !IsHeaderSeparatorColonBeforePipe(slice))
+            {
+                return false;
+            }
+
+            MatchLiteralColon(processor, ref slice);
+            return true;
+        }
+
         // If we have not a delimiter on the first line of a paragraph, don't bother to continue
         // tracking other delimiters on following lines
         var tableState = processor.ParserStates[Index] as TableState;
@@ -116,6 +128,142 @@ public override bool Match(InlineProcessor processor, ref StringSlice slice)
         return true;
     }
 
+    private static bool IsHeaderSeparatorColonBeforePipe(StringSlice slice)
+    {
+        if (slice.PeekChar() != '|')
+        {
+            return false;
+        }
+
+        var text = slice.Text;
+        int currentLineStart = FindLineStart(text, slice.Start);
+        int currentLineEnd = FindLineEnd(text, slice.Start, slice.End);
+
+        if (!IsHeaderSeparatorLine(text, currentLineStart, currentLineEnd))
+        {
+            return false;
+        }
+
+        int previousLineStart = FindPreviousLineStart(text, currentLineStart);
+        return previousLineStart >= 0 && LineHasPipe(text, previousLineStart, currentLineStart - 1);
+    }
+
+    private static void MatchLiteralColon(InlineProcessor processor, ref StringSlice slice)
+    {
+        int position = processor.GetSourcePosition(slice.Start, out int line, out int column);
+        if (processor.Inline is LiteralInline previousLiteral
+            && ReferenceEquals(previousLiteral.Content.Text, slice.Text)
+            && previousLiteral.Content.End + 1 == slice.Start)
+        {
+            previousLiteral.Content.End = slice.Start;
+            previousLiteral.Span.End = position;
+            processor.Inline = previousLiteral;
+        }
+        else
+        {
+            processor.Inline = new LiteralInline
+            {
+                Content = new StringSlice(slice.Text, slice.Start, slice.Start),
+                Span = new SourceSpan(position, position),
+                Line = line,
+                Column = column,
+            };
+        }
+
+        slice.SkipChar();
+    }
+
+    private static int FindLineStart(string text, int position)
+    {
+        for (int i = position - 1; i >= 0; i--)
+        {
+            if (text[i] == '\r' || text[i] == '\n')
+            {
+                return i + 1;
+            }
+        }
+
+        return 0;
+    }
+
+    private static int FindLineEnd(string text, int position, int sliceEnd)
+    {
+        int end = Math.Min(sliceEnd, text.Length - 1);
+        for (int i = position; i <= end; i++)
+        {
+            if (text[i] == '\r' || text[i] == '\n')
+            {
+                return i - 1;
+            }
+        }
+
+        return end;
+    }
+
+    private static int FindPreviousLineStart(string text, int currentLineStart)
+    {
+        int previousLineEnd = currentLineStart - 2;
+        if (previousLineEnd >= 0 && text[previousLineEnd] == '\r')
+        {
+            previousLineEnd--;
+        }
+
+        if (previousLineEnd < 0)
+        {
+            return -1;
+        }
+
+        for (int i = previousLineEnd; i >= 0; i--)
+        {
+            if (text[i] == '\r' || text[i] == '\n')
+            {
+                return i + 1;
+            }
+        }
+
+        return 0;
+    }
+
+    private static bool IsHeaderSeparatorLine(string text, int start, int end)
+    {
+        bool hasPipe = false;
+        bool hasDash = false;
+
+        for (int i = start; i <= end; i++)
+        {
+            switch (text[i])
+            {
+                case '|':
+                    hasPipe = true;
+                    break;
+                case '-':
+                    hasDash = true;
+                    break;
+                case ':':
+                case ' ':
+                case '\t':
+                    break;
+                default:
+                    return false;
+            }
+        }
+
+        return hasPipe && hasDash;
+    }
+
+    private static bool LineHasPipe(string text, int start, int end)
+    {
+        for (int i = start; i <= end; i++)
+        {
+            if (text[i] == '|')
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /// <summary>
     /// Performs the post process operation.
     /// </summary>