Глейзер Роман

cs/Markdown/BlockSegmenter.cs

@@ -0,0 +1,31 @@
+using Markdown.Entities;
+using static Markdown.Inlines.InlineSyntax;
+
+namespace Markdown;
+
+public class BlockSegmenter
+{
+    private const string CarriageReturnParagraphSeparator = "\r\n\r\n";
+    private const string ParagraphSeparator = "\n\n";
+
+    public IReadOnlyList<Block> Segment(string text)
+    {
+        var paragraphs = SplitToParagraphs(text);
+        var blocks = new List<Block>();
+
+        foreach (var paragraph in paragraphs)
+        {
+            var blockType = paragraph.StartsWith(Sharp) ? BlockType.Heading : BlockType.Paragraph;
+            var rawText = paragraph.TrimStart('#', ' ');
+            var block = new Block(rawText, blockType);
+            blocks.Add(block);
+        }
+
+        return blocks;
+    }
+
+    private static string[] SplitToParagraphs(string text)
+    {
+        return text.Split([CarriageReturnParagraphSeparator, ParagraphSeparator], StringSplitOptions.RemoveEmptyEntries);
+    }
+}

cs/Markdown/Entities/Block.cs

@@ -0,0 +1,16 @@
+namespace Markdown.Entities;
+
+public class Block(string rawText, BlockType type)
+{
+    public string RawText { get; } = rawText;
+
+    public BlockType Type { get; } = type;
+
+    public IReadOnlyList<Node> Inlines { get; init; } = [];
+}
+
+public enum BlockType
+{
+    Heading,
+    Paragraph
+}

cs/Markdown/Entities/Node.cs

@@ -0,0 +1,15 @@
+namespace Markdown.Entities;
+
+public class Node(string? text, NodeType type)
+{
+    public string? Text { get; } = text;
+
+    public NodeType Type { get; } = type;
+}
+
+public enum NodeType
+{
+    Text,
+    Strong,
+    Em
+}

cs/Markdown/HtmlRenderer.cs

@@ -0,0 +1,122 @@
+namespace Markdown;
+
+using Markdown.Entities;
+using System.Text;
+
+public class HtmlRenderer
+{
+    private const string EmOpen = "<em>";
+    private const string EmClose = "</em>";
+    private const string StrongOpen = "<strong>";
+    private const string StrongClose = "</strong>";
+    private const string HeadingOpen = "<h1>";
+    private const string HeadingClose = "</h1>";
+    private const string ParagraphOpen = "<p>";
+    private const string ParagraphClose = "</p>";
+
+    public string Render(IReadOnlyList<Block> blocks)
+    {
+        var sb = new StringBuilder();
+
+        for (int i = 0; i < blocks.Count; i++)
+        {
+            var block = blocks[i];
+            var inner = RenderInlines(block.Inlines, block.Type);
+
+            switch (block.Type)
+            {
+                case BlockType.Heading:
+                    sb.Append(HeadingOpen).Append(inner).Append(HeadingClose);
+                    break;
+
+                case BlockType.Paragraph:
+                    sb.Append(ParagraphOpen).Append(inner).Append(ParagraphClose);
+                    break;
+            }
+
+            if (i < blocks.Count - 1)
+                sb.AppendLine();
+        }
+
+        return sb.ToString();
+    }
+
+    private static string RenderInlines(IReadOnlyList<Node> inlines, BlockType blockType)
+    {
+        var sb = new StringBuilder();
+
+        for (int i = 0; i < inlines.Count; i++)
+        {
+            var node = inlines[i];
+
+            switch (node.Type)
+            {
+                case NodeType.Text:
+                    if (!string.IsNullOrEmpty(node.Text))
+                        sb.Append(node.Text);
+                    break;
+
+                case NodeType.Em:
+                    RenderEm(sb, node);
+                    break;
+
+                case NodeType.Strong:
+                    if (blockType == BlockType.Heading)
+                        RenderHeadingStrong(sb, inlines, ref i);
+                    else
+                        RenderStrong(sb, node);
+                    break;
+            }
+        }
+
+        return sb.ToString();
+    }
+
+    private static void RenderEm(StringBuilder sb, Node node)
+    {
+        if (!string.IsNullOrEmpty(node.Text))
+            sb.Append(EmOpen).Append(node.Text).Append(EmClose);
+    }
+
+    private static void RenderStrong(StringBuilder sb, Node node)
+    {
+        if (!string.IsNullOrEmpty(node.Text))
+            sb.Append(StrongOpen).Append(node.Text).Append(StrongClose);
+    }
+
+    private static void RenderHeadingStrong(StringBuilder sb, IReadOnlyList<Node> inlines, ref int currentIndex)
+    {
+        sb.Append(StrongOpen);
+
+        var currentNode = inlines[currentIndex];
+        if (!string.IsNullOrEmpty(currentNode.Text))
+            sb.Append(currentNode.Text);
+
+        var nextIndex = currentIndex + 1;
+        while (nextIndex < inlines.Count)
+        {
+            var nextNode = inlines[nextIndex];
+
+            if (nextNode.Type == NodeType.Em)
+            {
+                if (!string.IsNullOrEmpty(nextNode.Text))
+                    sb.Append(EmOpen).Append(nextNode.Text).Append(EmClose);
+
+                nextIndex++;
+                continue;
+            }
+
+            if (nextNode.Type == NodeType.Strong)
+            {
+                if (!string.IsNullOrEmpty(nextNode.Text))
+                    sb.Append(nextNode.Text);
+
+                nextIndex++;
+                continue;
+            }
+        }
+
+        sb.Append(StrongClose);
+        currentIndex = nextIndex - 1;
+    }
+}

cs/Markdown/Inlines/InlineEscapesNormalizer.cs

@@ -0,0 +1,91 @@
+using Markdown.Entities;
+using System.Text;
+using static Markdown.Inlines.InlineSyntax;
+
+namespace Markdown.Inlines;
+
+public static class InlineEscapesNormalizer
+{
+    public static string Normalize(string text)
+    {
+        if (string.IsNullOrEmpty(text))
+            return text;
+
+        var result = new StringBuilder(text.Length);
+
+        for (var index = 0; index < text.Length;)
+        {
+            var current = text[index];
+
+            if (current == Escape)
+            {
+                index = HandleEscape(text, index, result);
+                continue;
+            }
+
+            result.Append(current);
+            index++;
+        }
+
+        return result.ToString();
+    }
+
+    private static int HandleEscape(string text, int index, StringBuilder result)
+    {
+        if (index + 1 >= text.Length)
+        {
+            result.Append(Escape);
+            return index + 1;
+        }
+
+        var nextSymbol = text[index + 1];
+
+        if (nextSymbol == Underscore)
+        {
+            result.Append(PlaceholderUnderscore);
+            return index + 2;
+        }
+
+        if (nextSymbol == Sharp)
+        {
+            result.Append(PlaceholderHash);
+            return index + 2;
+        }
+
+        if (nextSymbol == Escape)
+            return HandleEscapedEscape(text, index, result);
+
+        result.Append(Escape).Append(nextSymbol);
+        return index + 2;
+    }
+
+    private static int HandleEscapedEscape(string text, int index, StringBuilder result)
+    {
+        var afterSymbol = index + 2 < text.Length ? text[index + 2] : EndOfText;
+
+        if (afterSymbol == Underscore || afterSymbol == Sharp)
+            result.Append(PlaceholderBackslash);
+        else
+            result.Append(Escape).Append(Escape);
+
+        return index + 2;
+    }
+
+    public static void RestorePlaceholders(List<Node> nodes)
+    {
+        for (var i = 0; i < nodes.Count; i++)
+        {
+            var text = nodes[i].Text;
+            if (text is null)
+                continue;
+
+            var restored = text
+                .Replace(PlaceholderUnderscore, Underscore)
+                .Replace(PlaceholderBackslash, Escape)
+                .Replace(PlaceholderHash, Sharp);
+
+            if (!ReferenceEquals(restored, text))
+                nodes[i] = new Node(restored, nodes[i].Type);
+        }
+    }
+}

cs/Markdown/Inlines/InlineExtensions.cs

@@ -0,0 +1,40 @@
+using Markdown.Entities;
+using System.Text;
+
+namespace Markdown.Inlines;
+
+public static class InlineExtensions
+{
+    public static void CommitText(this StringBuilder builder, List<Node> nodes)
+    {
+        if (builder.Length == 0) return;
+
+        nodes.Add(new Node(builder.ToString(), NodeType.Text));
+        builder.Clear();
+    }
+
+    public static void MergeTextNodes(this List<Node> nodes)
+    {
+        for (int i = 0; i < nodes.Count - 1;)
+        {
+            if (nodes[i].Type == NodeType.Text && nodes[i + 1].Type == NodeType.Text)
+            {
+                nodes[i] = new Node(nodes[i].Text + nodes[i + 1].Text, NodeType.Text);
+                nodes.RemoveAt(i + 1);
+            }
+            else
+            {
+                i++;
+            }
+        }
+    }
+
+    public static void InsertFromEnd(this StringBuilder target, List<(int index, string text)> inserts)
+    {
+        if (inserts.Count == 0) return;
+
+        inserts.Sort((a, b) => b.index.CompareTo(a.index));
+        foreach (var (index, text) in inserts)
+            target.Insert(index, text);
+    }
+}