Минеев Максим

.gitignore

@@ -239,3 +239,4 @@ _Pvt_Extensions
 **/.idea
 **/.vscode
 **/node_modules
+/cs/Markdown/Markdown.csproj.DotSettings

cs/Markdown/AstNodes/BoldMarkdownNode.cs

@@ -0,0 +1,9 @@
+using Markdown.Enums;
+
+namespace Markdown.AstNodes;
+
+public class BoldMarkdownNode : MarkdownNode, IMarkdownNodeWithChildren
+{
+    public override MarkdownNodeName Type => MarkdownNodeName.Bold;
+    public List<MarkdownNode> Children { get; } = [];
+}

cs/Markdown/AstNodes/HeadingMarkdownNode.cs

@@ -0,0 +1,9 @@
+using Markdown.Enums;
+
+namespace Markdown.AstNodes;
+
+public class HeadingMarkdownNode : MarkdownNode, IMarkdownNodeWithChildren
+{
+    public override MarkdownNodeName Type => MarkdownNodeName.Heading;
+    public List<MarkdownNode> Children { get; } = [];
+}

cs/Markdown/AstNodes/IMarkdownNodeWithChildren.cs

@@ -0,0 +1,6 @@
+namespace Markdown.AstNodes;
+
+public interface IMarkdownNodeWithChildren
+{
+    public List<MarkdownNode> Children { get; }
+}

cs/Markdown/AstNodes/ItalicMarkdownNode.cs

@@ -0,0 +1,9 @@
+using Markdown.Enums;
+
+namespace Markdown.AstNodes;
+
+public class ItalicMarkdownNode : MarkdownNode, IMarkdownNodeWithChildren
+{
+    public override MarkdownNodeName Type => MarkdownNodeName.Italic;
+    public List<MarkdownNode> Children { get; } = [];
+}

cs/Markdown/AstNodes/MarkdownNode.cs

@@ -0,0 +1,17 @@
+using Markdown.Enums;
+
+namespace Markdown.AstNodes;
+
+public abstract class MarkdownNode
+{
+    public abstract MarkdownNodeName Type { get; }
+
+    public override bool Equals(object? obj)
+    {
+        if (this is IMarkdownNodeWithChildren node && obj is IMarkdownNodeWithChildren other)
+            return this.GetType() == other.GetType() && node.Children.SequenceEqual(other.Children);
+        if (this is TextMarkdownNode valueNode && obj is TextMarkdownNode otherValueNode)
+            return valueNode.Content.Equals(otherValueNode.Content);
+        return false;
+    }
+}

cs/Markdown/AstNodes/RootMarkdownNode.cs

@@ -0,0 +1,9 @@
+using Markdown.Enums;
+
+namespace Markdown.AstNodes;
+
+public class RootMarkdownNode : MarkdownNode, IMarkdownNodeWithChildren
+{
+    public override MarkdownNodeName Type => MarkdownNodeName.Root;
+    public List<MarkdownNode> Children { get; } = [];
+}

cs/Markdown/AstNodes/TextMarkdownNode.cs

@@ -0,0 +1,9 @@
+using Markdown.Enums;
+
+namespace Markdown.AstNodes;
+
+public class TextMarkdownNode(string content) : MarkdownNode
+{
+    public override MarkdownNodeName Type => MarkdownNodeName.Text;
+    public string Content => content;
+}

cs/Markdown/Enums/MarkdownNodeName.cs

@@ -0,0 +1,10 @@
+namespace Markdown.Enums;
+
+public enum MarkdownNodeName
+{
+    Bold,
+    Italic,
+    Heading,
+    Text,
+    Root,
+}

cs/Markdown/Enums/MarkdownTokenName.cs

@@ -0,0 +1,12 @@
+namespace Markdown.Enums;
+
+public enum MarkdownTokenName
+{
+    Italic,
+    Bold,
+    Heading,
+    Text,
+    NewLine,
+    Space,
+    Number,
+}

cs/Markdown/Interfaces/ILexer.cs

@@ -0,0 +1,6 @@
+namespace Markdown;
+
+public interface ILexer
+{
+    List<IToken> Tokenize(string input);
+}

cs/Markdown/Interfaces/IParser.cs

@@ -0,0 +1,8 @@
+using Markdown.AstNodes;
+
+namespace Markdown;
+
+public interface IParser
+{
+    RootMarkdownNode Parse(List<IToken> tokens);
+}

cs/Markdown/Interfaces/IToken.cs

@@ -0,0 +1,13 @@
+using Markdown.Enums;
+
+namespace Markdown;
+
+public interface IToken
+{
+    MarkdownTokenName Name { get; }
+    int Position { get; }
+    int Length { get; }
+    string Value { get; }
+    int GetIndexToNextToken();
+    bool Is(MarkdownTokenName type);
+}

cs/Markdown/Markdown.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+</Project>

cs/Markdown/MarkdownLexer.cs

@@ -0,0 +1,216 @@
+using System.Text;
+using Markdown.Tokens;
+
+namespace Markdown;
+
+public class MarkdownLexer : ILexer
+{
+    private int position;
+    private readonly List<IToken> tokens = [];
+    private const string DoubleGround = "__";
+    private const string Ground = "_";
+    private const string Escape = "\\";
+    private const char GroundChar = '_';
+    private const char SharpChar = '#';
+    private const char EscapeChar = '\\';
+    private const char NewLineChar = '\n';
+    private const char SpaceChar = ' ';
+    private readonly char[] escapedChars = [SharpChar, GroundChar, EscapeChar, NewLineChar];
+
+    public List<IToken> Tokenize(string input)
+    {
+        position = 0;
+        var nestingStack = new Stack<string>();
+
+        while (position < input.Length)
+        {
+            switch (input[position])
+            {
+                case SpaceChar:
+                    ParseSpaceAndAdvance();
+                    break;
+                case NewLineChar:
+                    ParseNewLineAndAdvance(nestingStack);
+                    break;
+                case EscapeChar:
+                    ParseEscapeAndAdvance(input);
+                    break;
+                case GroundChar:
+                    ParseItalicOrBoldAndAdvance(input, nestingStack);
+                    break;
+                case SharpChar:
+                    ParseHeadingAndAdvance(input);
+                    break;
+                default:
+                    ParseTextAndAdvance(input);
+                    break;
+            }
+        }
+
+        return tokens;
+    }
+
+    private void ParseSpaceAndAdvance() => tokens.Add(new SpaceToken(position++));
+
+    private void ParseHeadingAndAdvance(string input)
+    {
+        if (NextIsSpace(input) && IsStartOfParagraph(input)) tokens.Add(new HeadingToken(position++));
+        else tokens.Add(new TextToken(position, "#"));
+        position++;
+    }
+
+    private void ParseTextAndAdvance(string input)
+    {
+        var value = new StringBuilder();
+        var start = position;
+        var endChars = new[] { SharpChar, GroundChar, NewLineChar, EscapeChar, SpaceChar };
+        while (position < input.Length && !endChars.Contains(input[position]) && !CurrentIsDigit(input))
+            value.Append(input[position++]);
+
+        if (value.Length > 0) tokens.Add(new TextToken(start, value.ToString()));
+        if (position < input.Length && CurrentIsDigit(input)) ParseNumberAndAdvance(input);
+    }
+
+
+    private void ParseNumberAndAdvance(string input)
+    {
+        var sb = new StringBuilder();
+        var start = position;
+        while (position < input.Length && (CurrentIsDigit(input) || input[position] == GroundChar))
+            sb.Append(input[position++]);
+        tokens.Add(new NumberToken(start, sb.ToString()));
+    }
+
+    private void ParseItalicOrBoldAndAdvance(string input, Stack<string> stack)
+    {
+        var isDoubleGround = NextIsGround(input);
+        var isTripleGround = NextIsDoubleGround(input);
+        var isSingleGround = !isTripleGround && !isDoubleGround;
+        if (stack.Count == 0) ParseItalicOrBoldAndAdvanceWhenStackEmpty(isSingleGround, isTripleGround, stack);
+        else if (stack.Count == 1)
+            ParseItalicOrBoldAndAdvanceWhenStackHasOne(isSingleGround, isDoubleGround, isTripleGround, stack);
+        else if (stack.Count == 2) ParseItalicOrBoldAndAdvanceWhenStackHasTwo(isSingleGround, isTripleGround, stack);
+    }
+
+    private void ParseItalicOrBoldAndAdvanceWhenStackEmpty(bool isSingleGround, bool isTripleGround,
+        Stack<string> stack)
+    {
+        if (isSingleGround)
+        {
+            ParseItalicAndAdvance();
+            stack.Push(Ground);
+            return;
+        }
+
+        ParseBoldAndAdvance();
+        stack.Push(DoubleGround);
+        if (!isTripleGround) return;
+        ParseItalicAndAdvance();
+        stack.Push(Ground);
+    }
+
+    private void ParseItalicOrBoldAndAdvanceWhenStackHasOne(bool isSingleGround, bool isDoubleGround,
+        bool isTripleGround,
+        Stack<string> stack)
+    {
+        switch (stack.Peek())
+        {
+            case DoubleGround when isSingleGround:
+                ParseItalicAndAdvance();
+                stack.Push(Ground);
+                break;
+            case DoubleGround:
+            {
+                if (isTripleGround) ParseItalicAndAdvance();
+                ParseBoldAndAdvance();
+                stack.Pop();
+                break;
+            }
+            case Ground:
+            {
+                if (isTripleGround)
+                {
+                    ParseBoldAndAdvance();
+                    ParseItalicAndAdvance();
+                }
+                else if (isDoubleGround)
+                {
+                    tokens.Add(new TextToken(position, DoubleGround));
+                    position += 2;
+                }
+                else ParseItalicAndAdvance();
+
+                stack.Pop();
+                break;
+            }
+        }
+    }
+
+    private void ParseItalicOrBoldAndAdvanceWhenStackHasTwo(bool isSingleGround, bool isTripleGround,
+        Stack<string> stack)
+    {
+        if (isSingleGround)
+        {
+            ParseItalicAndAdvance();
+            stack.Pop();
+            return;
+        }
+
+        if (isTripleGround) ParseItalicAndAdvance();
+        ParseBoldAndAdvance();
+
+        stack.Pop();
+        stack.Pop();
+    }
+
+    private void ParseBoldAndAdvance()
+    {
+        tokens.Add(new BoldToken(position));
+        position += 2;
+    }
+
+    private void ParseItalicAndAdvance()
+    {
+        tokens.Add(new ItalicToken(position));
+        position++;
+    }
+
+    private void ParseNewLineAndAdvance(Stack<string> stack)
+    {
+        tokens.Add(new NewLineToken(position));
+        stack.Clear();
+        position++;
+    }
+
+    private void ParseEscapeAndAdvance(string input)
+    {
+        if (position + 1 >= input.Length)
+        {
+            tokens.Add(new TextToken(position++, Escape));
+            return;
+        }
+
+        if (NextIsDoubleGround(input))
+        {
+            tokens.Add(new TextToken(position, DoubleGround));
+            position += 3;
+            return;
+        }
+
+        var next = input[position + 1];
+        tokens.Add(escapedChars.Contains(next)
+            ? new TextToken(position, next.ToString())
+            : new TextToken(position, Escape + next));
+        position += 2;
+    }
+
+    private bool NextIsDoubleGround(string input) =>
+        position + 2 < input.Length && input[position + 1] == GroundChar && input[position + 2] == GroundChar;
+
+    private bool NextIsSpace(string input) => position + 1 < input.Length && input[position + 1] == SpaceChar;
+    private bool NextIsGround(string input) => position + 1 < input.Length && input[position + 1] == GroundChar;
+    private bool CurrentIsDigit(string input) => char.IsDigit(input[position]);
+
+    private bool IsStartOfParagraph(string input) =>
+        position == 0 || position > 0 && input[position - 1] == NewLineChar;
+}