Рыбин Леонид

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,30 @@
+using System.Text;
+using Markdown.Token;
+
+namespace Markdown;
+
+public static class Md
+{
+    public static string Render(string text)
+    {
+        var parser = new TagParser();
+        return GenerateHtml(text, parser.GetTokens(text));
+    }
+
+    private static string GenerateHtml(string text, List<IToken> tokens)
+    {
+        var currentTokens = tokens.OrderBy(t => t.Position).ToList();
+        int position = 0;
+        var sb = new StringBuilder();
+        foreach (var token in currentTokens)
+        {
+            sb.Append(text[position..token.Position]);
+            sb.Append(token.ConvertedText);
+            position = token.Position + token.SourceText.Length > text.Length ? text.Length : token.Position + token.SourceText.Length;
+        }
+
+        sb.Append(text[position..text.Length]);
+
+        return sb.ToString();
+    }
+}

cs/Markdown/Program.cs

@@ -0,0 +1,3 @@
+using Markdown;
+
+Console.WriteLine(Md.Render("some text"));

cs/Markdown/Rules/BoldRule.cs

@@ -0,0 +1,94 @@
+using Markdown.Tags;
+
+namespace Markdown.Rules;
+
+public class BoldRule : IRule
+{
+    private readonly ITag tag = new BoldTag();
+    private List<Token.Token> tokens = new();
+    private bool isItalicInStart;
+    private bool isItalicInMiddle;
+    private bool isTagClosed;
+    private readonly int[] italicStartsInBoldState = [10, 12];
+    private readonly int boldStartsInItalicState = 9;
+    private int currentState;
+
+    public TagKind MoveByRule(char ch, int position)
+    {
+        var symbol = SymbolStatusParser.ParseSymbolStatus(ch);
+
+        if (!tag.UsedSymbols.Contains(symbol))
+        {
+            symbol = SymbolStatus.anotherSymbol;
+        }
+
+        currentState = tag.States[currentState][symbol];
+
+        if (currentState == 0)
+        {
+            ClearTokens();
+        }
+
+        if (currentState == tag.InputStateNumber)
+        {
+            tokens.Add(new Token.Token(tag.MdView, tag.Head, position - (tag.MdView.Length - 1)));
+        }
+        else if (currentState == tag.OutputStateNumber)
+        {
+            if (symbol == SymbolStatus.eof)
+            {
+                tokens.Add(new Token.Token(tag.MdView, tag.Tail, position - (tag.MdView.Length - 1)));
+            }
+            else
+            {
+                tokens.Add(new Token.Token(tag.MdView, tag.Tail, position - tag.MdView.Length));
+            }
+
+            isTagClosed = true;
+        }
+        else if (currentState == boldStartsInItalicState)
+        {
+            if (isItalicInMiddle)
+            {
+                isItalicInStart = false;
+                isItalicInMiddle = false;
+                isTagClosed = false;
+                currentState = 0;
+                tokens.Clear();
+            }
+            else
+            {
+                isItalicInStart = !isItalicInStart;
+            }
+        }
+        else if (italicStartsInBoldState.Contains(currentState))
+        {
+            if (isItalicInStart)
+            {
+                isItalicInStart = false;
+                isItalicInMiddle = false;
+                isTagClosed = false;
+                currentState = 0;
+                tokens.Clear();
+            }
+            else
+            {
+                isItalicInMiddle = !isItalicInMiddle;
+            }
+
+        }
+
+        if (isTagClosed && (!isItalicInMiddle && !isItalicInStart || symbol == SymbolStatus.eof))
+        {
+            isTagClosed = false;
+            currentState = 0;
+            return TagKind.Close;
+        }
+
+        return TagKind.None;
+    }
+
+    public List<Token.Token> GetTokens() { return tokens; }
+
+    public void ClearTokens() { tokens.Clear(); }
+}

cs/Markdown/Rules/EscapeRule.cs

@@ -0,0 +1,40 @@
+using Markdown.Tags;
+
+namespace Markdown.Rules;
+
+public class EscapeRule : IRule
+{
+    private readonly ITag tag = new EscapeTag();
+    private List<Token.Token> tokens = new();
+    private int currentState;
+
+    public TagKind MoveByRule(char ch, int position)
+    {
+        var symbol = SymbolStatusParser.ParseSymbolStatus(ch);
+
+        if (!tag.UsedSymbols.Contains(symbol))
+        {
+            symbol = SymbolStatus.anotherSymbol;
+        }
+
+        currentState = tag.States[currentState][symbol];
+
+        if (currentState == tag.InputStateNumber)
+        {
+            tokens.Add(new Token.Token(tag.MdView, tag.Head, position - (tag.MdView.Length - 1)));
+            return TagKind.Open;
+        }
+        else if (currentState == tag.OutputStateNumber)
+        {
+            tokens.Add(new Token.Token(ch.ToString(), ch.ToString(), position - (tag.MdView.Length - 1)));
+            currentState = 0;
+            return TagKind.Close;
+        }
+
+        return TagKind.None;
+    }
+
+    public List<Token.Token> GetTokens() { return tokens; }
+
+    public void ClearTokens() { tokens.Clear(); }
+}

cs/Markdown/Rules/H1Rule.cs

@@ -0,0 +1,47 @@
+using Markdown.Tags;
+
+namespace Markdown.Rules;
+
+public class H1Rule : IRule
+{
+    private readonly ITag tag = new H1Tag();
+    private List<Token.Token> tokens = new();
+    private int currentState;
+
+    public TagKind MoveByRule(char ch, int position)
+    {
+        var symbol = SymbolStatusParser.ParseSymbolStatus(ch);
+
+        if (!tag.UsedSymbols.Contains(symbol))
+        {
+            symbol = SymbolStatus.anotherSymbol;
+        }
+
+        currentState = tag.States[currentState][symbol];
+
+        if (currentState == tag.InputStateNumber)
+        {
+            tokens.Add(new Token.Token(tag.MdView, tag.Head, position - (tag.MdView.Length - 1)));
+        }
+        else if (currentState == tag.OutputStateNumber)
+        {
+            if (symbol == SymbolStatus.eof)
+            {
+                tokens.Add(new Token.Token("", tag.Tail, position + 1));
+            }
+            else
+            {
+                tokens.Add(new Token.Token("", tag.Tail, position));
+            }
+
+            currentState = 0;
+            return TagKind.Close;
+        }
+
+        return TagKind.None;
+    }
+
+    public List<Token.Token> GetTokens() { return tokens; }
+
+    public void ClearTokens() { tokens.Clear(); }
+}

cs/Markdown/Rules/IRule.cs

@@ -0,0 +1,12 @@
+using Markdown.Tags;
+
+namespace Markdown.Rules;
+
+public interface IRule
+{
+    public TagKind MoveByRule(char ch, int position);
+
+    public List<Token.Token> GetTokens();
+
+    public void ClearTokens();
+}

cs/Markdown/Rules/ItalicRule.cs

@@ -0,0 +1,95 @@
+using Markdown.Tags;
+
+namespace Markdown.Rules;
+
+public class ItalicRule : IRule
+{
+    private readonly ITag tag = new ItalicTextTag();
+    private List<Token.Token> tokens = new();
+    private bool isBoldInMiddle;
+    private bool isBoldInStart;
+    private bool isTagClosed;
+    private readonly int anotherStartState = 18;
+    private readonly int italicStartsInBoldState = 7;
+    private readonly int boldStartsInItalicState = 10;
+    private int currentState;
+
+    public TagKind MoveByRule(char ch, int position)
+    {
+
+        var symbol = SymbolStatusParser.ParseSymbolStatus(ch);
+
+        if (!tag.UsedSymbols.Contains(symbol))
+        {
+            symbol = SymbolStatus.anotherSymbol;
+        }
+
+        currentState = tag.States[currentState][symbol];
+
+        if (currentState == 0)
+        {
+            ClearTokens();
+        }
+
+        if (currentState == tag.InputStateNumber || currentState == anotherStartState)
+        {
+            tokens.Add(new Token.Token(tag.MdView, tag.Head, position - tag.MdView.Length));
+        }
+        else if (currentState == tag.OutputStateNumber)
+        {
+            if (symbol == SymbolStatus.eof)
+            {
+                tokens.Add(new Token.Token(tag.MdView, tag.Tail, position));
+            }
+            else
+            {
+                tokens.Add(new Token.Token(tag.MdView, tag.Tail, position - tag.MdView.Length));
+            }
+            isTagClosed = true;
+        }
+        else if (currentState == boldStartsInItalicState)
+        {
+            if (isBoldInMiddle)
+            {
+                isBoldInMiddle = false;
+                isBoldInStart = false;
+                isTagClosed = false;
+                currentState = 0;
+                tokens.Clear();
+            }
+            else
+            {
+                isBoldInStart = !isBoldInStart;
+            }
+        }
+        else if (currentState == italicStartsInBoldState)
+        {
+            if (isBoldInStart)
+            {
+                isBoldInMiddle = false;
+                isBoldInStart = false;
+                isTagClosed = false;
+                currentState = 0;
+                tokens.Clear();
+
+            }
+            else
+            {
+                isBoldInMiddle = !isBoldInMiddle;
+            }
+        }
+
+        if (isTagClosed && (!isBoldInMiddle || symbol == SymbolStatus.eof))
+        {
+            isTagClosed = false;
+            currentState = 0;
+            return TagKind.Close;
+        }
+
+        return TagKind.None;
+    }
+
+    public List<Token.Token> GetTokens() { return tokens; }
+
+    public void ClearTokens() { tokens.Clear(); }
+}

cs/Markdown/SymbolStatus.cs

@@ -0,0 +1,15 @@
+namespace Markdown;
+
+public enum SymbolStatus
+{
+    text,
+    digit,
+    underscore,
+    backslash,
+    eof,
+    newline,
+    space,
+    sharp,
+    anotherSymbol,
+    none
+}

cs/Markdown/SymbolStatusParser.cs

@@ -0,0 +1,25 @@
+namespace Markdown;
+
+public static class SymbolStatusParser
+{
+    public static SymbolStatus ParseSymbolStatus(char symbol)
+    {
+        if (char.IsLetter(symbol))
+            return SymbolStatus.text;
+        if (char.IsDigit(symbol))
+            return SymbolStatus.digit;
+        if (symbol == ' ')
+            return SymbolStatus.space;
+        if (symbol == '_')
+            return SymbolStatus.underscore;
+        if (symbol == '\\')
+            return SymbolStatus.backslash;
+        if (symbol == '\n')
+            return SymbolStatus.newline;
+        if (symbol == '\0')
+            return SymbolStatus.eof;
+        if (symbol == '#')
+            return SymbolStatus.sharp;
+        return SymbolStatus.none;
+    }
+}