Вильданов Савелий

cs/Markdown/Converter.cs

@@ -0,0 +1,18 @@
+using System.Text;
+
+namespace Markdown;
+
+public class Converter
+{
+    public string ConvertWithTokens(List<Token> tokens)
+    {
+        StringBuilder result = new();
+
+        foreach (var token in tokens)
+        {
+            result.Append(token.Context);
+        }
+
+        return result.ToString();
+    }
+}

cs/Markdown/ListOfTokens.cs

@@ -0,0 +1,10 @@
+namespace Markdown;
+
+public class ListOfTokens<T> : List<T>
+{
+    public new void Add(T token)
+    {
+        if (!(token is null))
+            base.Add(token);
+    }
+}

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/Md.cs

@@ -0,0 +1,11 @@
+namespace Markdown;
+
+public class Md
+{
+    public static string Render(string markdown)
+    {
+        TokenGenerator tokenGenerator = new TokenGenerator();
+        Converter converter = new Converter();
+        return converter.ConvertWithTokens(tokenGenerator.SplitParagraphs(markdown));
+    }
+}

cs/Markdown/Parsers/BoldParser.cs

@@ -0,0 +1,118 @@
+using System.Collections;
+using System.Security.Principal;
+using Markdown.TagsType;
+
+namespace Markdown.Parsers;
+
+public class BoldParser : IParser
+{
+    private readonly Stack<Token> tagsStack;
+    private readonly GeneralParser.IsValidTag isValidOpenBoldTag;
+    private readonly GeneralParser.IsValidTag isValidCloseBoldTag;
+    private readonly GeneralParser.AddInsert addBoldTag;
+    public bool IsHaveInsideBoldTag;
+    public static bool IsBoldClosed;
+    private int index;
+
+    public BoldParser()
+    {
+        IsBoldClosed = true;
+        IsHaveInsideBoldTag = false;
+        tagsStack = GeneralParser.tagsStack;
+        addBoldTag = GeneralParser.AddInsideTag;
+        isValidOpenBoldTag = GeneralParser.IsValidOpenTag;
+        isValidCloseBoldTag = GeneralParser.IsValidCloserTag;
+        index = 0;
+    }
+
+    private Token BoldParse(string text, int i)
+    {
+        index = i;
+        index++;
+
+        if (i != 0 && i != text.Length - 2)
+            IsHaveInsideBoldTag = true;
+        if (IsEmptyStringInsideBold(text, i))
+        {
+            index = text.Length;
+            return new Token("____", new TextTag());
+        }
+
+        if (IsBoldClosed)
+        {
+            if (!isValidOpenBoldTag(text, i + 1))
+            {
+                return (new Token("__", new TextTag()));
+            }
+        }
+        else
+        {
+            if (!isValidCloseBoldTag(text, i))
+            {
+                if (isValidOpenBoldTag(text, i))
+                {
+                    if (tagsStack.Count != 0)
+                        tagsStack.Pop();
+                    return addBoldTag(new BoldTag(), true);
+                }
+
+                return new Token("__", new TextTag());
+            }
+        }
+
+        if (tagsStack.Count > 1 &&
+            tagsStack.Any(p => p.Type is {MarkdownTag: "_"}) &&
+            tagsStack.Peek().Type is {MarkdownTag: "__"})
+        {
+            tagsStack.Pop();
+        }
+
+        if (!IsBoldClosed && i == text.Length - 1)
+        {
+            tagsStack.Pop();
+        }
+
+        var boldTag = addBoldTag(new BoldTag(), IsBoldClosed);
+        IsBoldClosed = !IsBoldClosed;
+
+
+        return boldTag;
+    }
+
+    public bool IsNextSymbolBold(string text, int i)
+    {
+        var nextIndex = i + 1;
+        if (nextIndex < text.Length)
+        {
+            if (text[nextIndex] == '_')
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private bool IsEmptyStringInsideBold(string text, int i)
+    {
+        int nextIndex = i + 1;
+        if (nextIndex < text.Length - 2 && IsNextSymbolBold(text, nextIndex))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool TryParse(char symbol, string text, int i)
+    {
+        return symbol == '_' && IsNextSymbolBold(text, i);
+    }
+
+    public Token Parse(string text, ref int i)
+    {
+        var token = BoldParse(text, i);
+        i = index;
+        return token;
+    }
+}

cs/Markdown/Parsers/GeneralParser.cs

@@ -0,0 +1,59 @@
+using Markdown.TagsType;
+
+namespace Markdown.Parsers;
+
+public static class GeneralParser
+{
+    public static Stack<Token> tagsStack = new();
+
+    public delegate Token AddInsert(ITagsType tags, bool isClose);
+
+    public delegate bool IsValidTag(string text, int index);
+
+    public static Token AddInsideTag(ITagsType tag, bool isClose)
+    {
+        var result = GenerateTagToken(tag, isClose);
+        if (!isClose && tagsStack.Count != 0 && tagsStack.Peek().Type?.MarkdownTag == tag.MarkdownTag)
+            ClosePairTag(tagsStack.Pop());
+        return result;
+    }
+
+    public static Token GenerateTagToken(ITagsType tag, bool isClose)
+    {
+        if (isClose)
+        {
+            var temp = new Token(tag.GetHtmlOpenTag, tag);
+            tagsStack.Push(temp);
+            return temp;
+        }
+
+        if (tagsStack.Count != 0 && tagsStack.Peek().Type?.MarkdownTag == tag.MarkdownTag)
+            tag.HasPair = true;
+        return new Token(tag.GetHtmlCloseTag, tag);
+    }
+
+    public static void ClosePairTag(Token token)
+    {
+        if (token.Type != null) token.Type.HasPair = true;
+    }
+
+    public static bool IsValidCloserTag(string text, int index)
+    {
+        if (index == 0)
+            return false;
+        if (index > 0 && text[index - 1] == ' ')
+            return false;
+
+        return true;
+    }
+
+    public static bool IsValidOpenTag(string text, int index)
+    {
+        if (index == text.Length - 1)
+            return false;
+        if (index < text.Length - 1 && text[index + 1] == ' ')
+            return false;
+
+        return true;
+    }
+}

cs/Markdown/Parsers/HeadingParser.cs

@@ -0,0 +1,17 @@
+using Markdown.TagsType;
+
+namespace Markdown.Parsers;
+
+public class HeadingParser : IParser
+{
+    public bool TryParse(char symbol, string text, int index)
+    {
+        return symbol == '#';
+    }
+
+    public Token Parse(string text, ref int index)
+    {
+        var headingTag = new HeadingTag();
+        return new Token(headingTag.GetHtmlOpenTag, headingTag);
+    }
+}

cs/Markdown/Parsers/IParser.cs

@@ -0,0 +1,7 @@
+namespace Markdown.Parsers;
+
+public interface IParser
+{
+    bool TryParse(char symbol, string text, int index);
+    Token Parse(string text, ref int index);
+}

cs/Markdown/Parsers/ItalicParser.cs

@@ -0,0 +1,75 @@
+using Markdown.TagsType;
+
+namespace Markdown.Parsers;
+
+public class ItalicParser : IParser
+{
+    private readonly GeneralParser.IsValidTag isValidOpenItalicTag;
+    private readonly GeneralParser.IsValidTag isValidCloseItalicTag;
+    private readonly GeneralParser.AddInsert addItalicTag;
+    private bool isItalicClosed;
+    private readonly Stack<Token> tagsStack;
+    public bool IsHaveInsideItalicTag;
+
+
+    public ItalicParser()
+    {
+        isItalicClosed = true;
+        tagsStack = GeneralParser.tagsStack;
+        addItalicTag = GeneralParser.AddInsideTag;
+        isValidOpenItalicTag = GeneralParser.IsValidOpenTag;
+        isValidCloseItalicTag = GeneralParser.IsValidCloserTag;
+        IsHaveInsideItalicTag = false;
+    }
+
+    private Token ItalicParse(string text, int i)
+    {
+        if (i != 0 && i != text.Length - 1)
+            IsHaveInsideItalicTag = true;
+        if (isItalicClosed)
+        {
+            if (!isValidOpenItalicTag(text, i))
+            {
+                return new Token("_", new TextTag());
+            }
+        }
+        else
+        {
+            if (!isValidCloseItalicTag(text, i))
+            {
+                if (isValidOpenItalicTag(text, i))
+                {
+                    if (tagsStack.Count != 0)
+                        tagsStack.Pop();
+                    return addItalicTag(new ItalicTag(), true);
+                }
+
+                return new Token("_", new TextTag());
+            }
+        }
+
+        if (tagsStack.Count > 1 && !isItalicClosed && BoldParser.IsBoldClosed)
+        {
+            tagsStack.Pop();
+        }
+
+        var result = addItalicTag(new ItalicTag(), isItalicClosed);
+        isItalicClosed = !isItalicClosed;
+        if (!isItalicClosed && i == text.Length - 1)
+        {
+            tagsStack.Pop();
+        }
+
+        return result;
+    }
+
+    public bool TryParse(char symbol, string text, int i)
+    {
+        return symbol == '_';
+    }
+
+    public Token Parse(string text, ref int index)
+    {
+        return ItalicParse(text, index);
+    }
+}