Upstream xoofx/markdig state of the touched files before a9eea55dcf

src/Markdig/Extensions/DefinitionLists/DefinitionListParser.cs

@@ -0,0 +1,208 @@
+// Copyright (c) Alexandre Mutel. All rights reserved.
+// 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;
+using Markdig.Syntax;
+
+namespace Markdig.Extensions.DefinitionLists;
+
+/// <summary>
+/// The block parser for a <see cref="DefinitionList"/>.
+/// </summary>
+/// <seealso cref="BlockParser" />
+public class DefinitionListParser : BlockParser
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DefinitionListParser"/> class.
+    /// </summary>
+    public DefinitionListParser()
+    {
+        OpeningCharacters = [':', '~'];
+    }
+
+    /// <summary>
+    /// Attempts to open a block at the current parser position.
+    /// </summary>
+    public override BlockState TryOpen(BlockProcessor processor)
+    {
+        var paragraphBlock = processor.LastBlock as ParagraphBlock;
+        if (processor.IsCodeIndent || paragraphBlock is null || paragraphBlock.LastLine - processor.LineIndex > 1)
+        {
+            return BlockState.None;
+        }
+
+        var startPosition = processor.Start;
+
+        var column = processor.ColumnBeforeIndent;
+        processor.NextChar();
+        processor.ParseIndent();
+        var delta = processor.Column - column;
+
+        // We expect to have a least
+        if (delta < 4)
+        {
+            // Return back to original position
+            processor.GoToColumn(column);
+            return BlockState.None;
+        }
+
+        if (delta > 4)
+        {
+            processor.GoToColumn(column + 4);
+        }
+
+        var previousParent = paragraphBlock.Parent!;
+        var currentDefinitionList = GetCurrentDefinitionList(paragraphBlock, previousParent);
+
+        processor.Discard(paragraphBlock);
+
+        // If the paragraph block was not part of the opened blocks, we need to remove it manually from its parent container
+        if (paragraphBlock.Parent != null)
+        {
+            paragraphBlock.Parent.Remove(paragraphBlock);
+        }
+
+        if (currentDefinitionList is null)
+        {
+            currentDefinitionList = new DefinitionList(this)
+            {
+                Span = new SourceSpan(paragraphBlock.Span.Start, processor.Line.End),
+                Column = paragraphBlock.Column,
+                Line = paragraphBlock.Line,
+            };
+            previousParent.Add(currentDefinitionList);
+        }
+
+        var definitionItem = new DefinitionItem(this)
+        {
+            Line = processor.LineIndex,
+            Column = column,
+            Span = new SourceSpan(paragraphBlock.Span.Start, processor.Line.End),
+            OpeningCharacter = processor.CurrentChar,
+        };
+
+        for (int i = 0; i < paragraphBlock.Lines.Count; i++)
+        {
+            var line = paragraphBlock.Lines.Lines[i];
+            var term = new DefinitionTerm(this)
+            {
+                Column =  paragraphBlock.Column,
+                Line = line.Line,
+                Span = new SourceSpan(paragraphBlock.Span.Start, paragraphBlock.Span.End),
+                IsOpen = false
+            };
+            term.AppendLine(ref line.Slice, line.Column, line.Line, line.Position, processor.TrackTrivia);
+            definitionItem.Add(term);
+        }
+        currentDefinitionList.Add(definitionItem);
+        processor.Open(definitionItem);
+
+        // Update the end position
+        currentDefinitionList.UpdateSpanEnd(processor.Line.End);
+
+        return BlockState.Continue;
+    }
+
+    private static DefinitionList? GetCurrentDefinitionList(ParagraphBlock paragraphBlock, ContainerBlock previousParent)
+    {
+        var index = previousParent.IndexOf(paragraphBlock) - 1;
+        if (index < 0) return null;
+        switch (previousParent[index])
+        {
+            case DefinitionList definitionList:
+                return definitionList;
+
+            case BlankLineBlock:
+                if (index > 0 && previousParent[index - 1] is DefinitionList definitionList2)
+                {
+                    previousParent.RemoveAt(index);
+                    return definitionList2;
+                }
+                break;
+        }
+        return null;
+    }
+
+    /// <summary>
+    /// Attempts to continue parsing the specified block.
+    /// </summary>
+    public override BlockState TryContinue(BlockProcessor processor, Block block)
+    {
+        var definitionItem = (DefinitionItem)block;
+        if (processor.IsCodeIndent)
+        {
+            processor.GoToCodeIndent();
+            return BlockState.Continue;
+        }
+
+        var list = (DefinitionList)definitionItem.Parent!;
+        var lastBlankLine = definitionItem.LastChild as BlankLineBlock;
+
+        // Check if we have another definition list
+        if (Array.IndexOf(OpeningCharacters!, processor.CurrentChar) >= 0)
+        {
+            var startPosition = processor.Start;
+            var column = processor.ColumnBeforeIndent;
+            processor.NextChar();
+            processor.ParseIndent();
+            var delta = processor.Column - column;
+
+            // We expect to have a least
+            if (delta < 4)
+            {
+                // Remove the blankline before breaking this definition item
+                if (lastBlankLine != null)
+                {
+                    definitionItem.RemoveAt(definitionItem.Count - 1);
+                }
+
+                list.Span.End = list.LastChild!.Span.End;
+                return BlockState.None;
+            }
+
+            if (delta > 4)
+            {
+                processor.GoToColumn(column + 4);
+            }
+
+            processor.Close(definitionItem);
+            var nextDefinitionItem = new DefinitionItem(this)
+            {
+                Span = new SourceSpan(startPosition, processor.Line.End),
+                Line = processor.LineIndex,
+                Column = processor.Column,
+                OpeningCharacter = processor.CurrentChar,
+            };
+            list.Add(nextDefinitionItem);
+            processor.Open(nextDefinitionItem);
+
+            return BlockState.Continue;
+        }
+
+        var isBreakable = definitionItem.LastChild?.IsBreakable ?? true;
+        if (processor.IsBlankLine)
+        {
+            if (lastBlankLine is null && isBreakable)
+            {
+                definitionItem.Add(new BlankLineBlock());
+            }
+            return isBreakable ? BlockState.ContinueDiscard : BlockState.Continue;
+        }
+
+        var paragraphBlock = definitionItem.LastChild as ParagraphBlock;
+        if (lastBlankLine is null && paragraphBlock != null)
+        {
+            return BlockState.Continue;
+        }
+
+        // Remove the blankline before breaking this definition item
+        if (lastBlankLine != null)
+        {
+            definitionItem.RemoveAt(definitionItem.Count - 1);
+        }
+
+        list.Span.End = list.LastChild!.Span.End;
+        return BlockState.Break;
+    }
+}