Якшибаев Данил

MarkdownSpec.md

@@ -70,4 +70,42 @@ __Непарные_ символы в рамках одного абзаца н
 
 превратится в:
 
-\<h1>Заголовок \<strong>с \<em>разными\</em> символами\</strong>\</h1>
+\<h1>Заголовок \<strong>с \<em>разными\</em> символами\</strong>\</h1>
+
+
+
+# Ссылки
+
+Ссылка представлена строго в виде: \[текст ссылки](URL). Выделяется тегом \<a href="url">text\</a>
+Текст ссылки не должен начинаться с пробела и в скбоках с URL не должно быть пробелов, иначе это не считается выделением
+
+Таким образом
+
+Ссылка с текстом: \[репозиторий gogy](https://github.com/gogy4?tab=repositories) 
+
+превратится в:
+\<a href=\"https://github.com/gogy4?tab=repositories\">репозиторий gogy\</a>
+
+В тексте ссылки могут присутствовать и другие символы разметки с правилами:
+
+Нельзя выделять весь текст ссылки в другие символы, например: 
+\[\_\_Полужирная ссылка\_\_](google.com) так и останется
+
+Аналогично и с курсивом:
+\[\_Курсивная ссылка\_](google.com) так и останется
+
+Другие символы разметки можно использовать только на учатски, а не на весь текст, например ссылка:
+\[Ссылка с \_курсивным\_ текстом](google.com) 
+
+первратится в:
+\<a href="google.com:>Ссылка с \<em>курсивным\</em> текстом\</a>
+
+Аналогично с полужирным текстом:
+\[Ссылка с \_\_полужирным\_\_ текстом](google.com) 
+
+превратится в:
+\<a href="google.com:>Ссылка с \<strong>полужирным\</strong> текстом\</a>
+
+Чтобы экранировать текст с ссылкой, достаточно поставить знак экранирования перед [
+
+\\\[Ссылка с текстом](google.com)

cs/Markdown/Dto/CharContext.cs

@@ -0,0 +1,3 @@
+namespace Markdown.Dto;
+
+public record CharContext(char? Next, bool CanOpen, bool CanClose);

cs/Markdown/Dto/Tag.cs

@@ -0,0 +1,46 @@
+using System.Text;
+
+namespace Markdown.Dto
+{
+    public class Tag
+    {
+        public Token Token { get; }
+        public StringBuilder Content { get; }
+        public bool IsOpen { get;  }
+
+        public bool ContainsSpace { get; private set; }
+        public bool HasOnlyDigits { get; private set; } = true;
+
+        public Tag(Token token, StringBuilder content, bool isOpen)
+        {
+            Token = token;
+            Content = content;
+            IsOpen = isOpen;
+            UpdateFlags(content.ToString());
+        }
+
+        public void Append(string text)
+        {
+            Content.Append(text);
+            UpdateFlags(text);
+        }
+
+        private void UpdateFlags(string text)
+        {
+            if (!ContainsSpace && text.Contains(' '))
+            {
+                ContainsSpace = true;
+            }
+
+            if (!HasOnlyDigits)
+            {
+                return;
+            }
+            foreach (var ch in text.Skip(Token.Value.Length).Where(ch => !char.IsDigit(ch)))
+            {
+                HasOnlyDigits = false;
+                break;
+            }
+        }
+    }
+}

cs/Markdown/Dto/Token.cs

@@ -0,0 +1,54 @@
+namespace Markdown.Dto
+{
+    public class Token
+    {
+        public string Value { get; private set; }
+        public TokenType Type { get; private set; }
+        public TokenRole Role { get; private set; }
+        public TokenPosition Position { get; private set; }
+
+        public Token(string value, TokenType type, TokenRole role, TokenPosition position)
+        {
+            Value = value;
+            Type = type;
+            Role = role;
+            Position = position;
+        }
+
+        public Token(string value, TokenType type, bool canOpen, bool canClose)
+        {
+            Value = value;
+            Type = type;
+            DetermineRole(canOpen, canClose);
+            DeterminePosition(canOpen, canClose);
+        }
+
+        private void DetermineRole(bool canOpen, bool canClose)
+        {
+            Determine(canOpen, canClose, v => Role = v, 
+                TokenRole.Both, TokenRole.Open, TokenRole.Close);
+        }
+
+        private void DeterminePosition(bool canOpen, bool canClose)
+        {
+            Determine(canOpen, canClose, v => Position = v, 
+                TokenPosition.Inside, TokenPosition.Begin, TokenPosition.End);
+        }
+
+        private void Determine<T>(bool canOpen, bool canClose, Action<T> setter, T both, T open, T close)
+        {
+            if (canOpen == canClose)
+            {
+                setter(both);
+            }
+            else if (canOpen)
+            {
+                setter(open);
+            }
+            else
+            {
+                setter(close);
+            }
+        }
+    }
+}

cs/Markdown/Dto/TokenPosition.cs

@@ -0,0 +1,9 @@
+namespace Markdown.Dto;
+
+public enum TokenPosition
+{
+    None = 0,
+    Begin,
+    Inside,
+    End,
+}

cs/Markdown/Dto/TokenRole.cs

@@ -0,0 +1,9 @@
+namespace Markdown.Dto;
+
+public enum TokenRole
+{
+    None = 0,
+    Open,
+    Close,
+    Both,
+}

cs/Markdown/Dto/TokenType.cs

@@ -0,0 +1,12 @@
+namespace Markdown.Dto;
+
+public enum TokenType
+{
+    Text = 0,
+    Italic,
+    Strong,
+    Escape,
+    Header,
+    Link,
+    End
+}

cs/Markdown/Extensions/StringExtensions.cs

@@ -0,0 +1,30 @@
+namespace Markdown.Extensions;
+
+public static class StringExtensions
+{
+    public static IEnumerable<string> EnumerateLines(this string? markdown)
+    {
+        if (markdown is null)
+        {
+            yield break;
+        }
+
+        var start = 0;
+
+        for (var i = 0; i < markdown.Length; i++)
+        {
+            if (markdown[i] != '\n')
+            {
+                continue;
+            }
+
+            yield return markdown[start..i];
+            start = i + 1;
+        }
+
+        if (start <= markdown.Length)
+        {
+            yield return markdown[start..];
+        }
+    }
+}

cs/Markdown/Markdown.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="FluentAssertions" Version="8.8.0" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+      <PackageReference Include="NUnit" Version="4.4.0" />
+      <PackageReference Include="NUnit3TestAdapter" Version="5.2.0" />
+    </ItemGroup>
+
+</Project>

cs/Markdown/RenderServices/Abstractions/IRender.cs

@@ -0,0 +1,6 @@
+namespace Markdown;
+
+public interface IRender
+{
+    public string RenderText(string markdown);
+}

cs/Markdown/RenderServices/Implementations/MarkdownRender.cs

@@ -0,0 +1,33 @@
+using System.Text;
+using Markdown.Dto;
+using Markdown.Extensions;
+using Markdown.TagUtils.Abstractions;
+using Markdown.TagUtils.Implementations;
+using Markdown.TokensUtils;
+using Markdown.TokensUtils.Abstractions;
+using Markdown.TokensUtils.Implementations;
+
+namespace Markdown
+{
+    public class MarkdownRender(ITokenizer tokenizer, ITagProcessor tagProcessor) : IRender
+    {
+        public string RenderText(string markdown)
+        {
+            var markDownLines = markdown.EnumerateLines();
+            var result = new StringBuilder();
+            foreach (var line in markDownLines)
+            {
+                if (result.Length > 0) result.Append('\n');
+                result.Append(RenderLine(line));
+            }
+
+            return result.ToString();
+        }
+
+        private string RenderLine(string line)
+        {
+            var tokens = tokenizer.Tokenize(line).ToList();
+            return tagProcessor.Process(tokens);
+        }
+    }
+}

cs/Markdown/TagUtils/Abstractions/BaseTagStrategy.cs

@@ -0,0 +1,53 @@
+using System.Text;
+using Markdown.Dto;
+using Markdown.TagUtils.Abstractions;
+
+public abstract class BaseTagStrategy(ITagContext context)
+{
+    protected void ProcessTag(Token token, bool isStrong, Func<Tag, Token, bool> isInvalidCloseContext)
+    {
+        var tagsStack = context.Tags;
+        var parent = tagsStack.Count > 0 ? tagsStack.Peek() : null;
+        var canClose = isStrong ? token.Role is TokenRole.Close : token.Role is TokenRole.Close or TokenRole.Both;
+        var canOpen = isStrong
+            ? token.Role is TokenRole.Open or TokenRole.Both ||
+              (token.Role == TokenRole.Close && tagsStack.Count > 0 && tagsStack.Peek().IsOpen)
+            : token.Role is TokenRole.Open or TokenRole.Both;
+
+        if (canClose && tagsStack.Count > 0 && !isInvalidCloseContext(parent, token))
+        {
+            if (isStrong)
+            {
+                var popParent = tagsStack.Pop();
+                var grandParent = tagsStack.Count > 0 ? tagsStack.Peek() : null;
+                var shouldNotClose = grandParent is not null && grandParent.Token.Type == TokenType.Italic &&
+                                     grandParent.IsOpen;
+
+                if (shouldNotClose)
+                {
+                    var newContent = popParent.Content.Append(popParent.Token.Value);
+                    context.Append(newContent.ToString());
+                }
+                else
+                {
+                    tagsStack.Push(popParent);
+                    context.CloseTop();
+                }
+            }
+            else
+            {
+                context.CloseTop();
+            }
+        }
+        else if (canOpen)
+        {
+            context.Open(new Tag(token, new StringBuilder(token.Value), true));
+        }
+        else
+        {
+            context.Append(token.Value);
+        }
+    }
+
+    public abstract void Process(Token token);
+}

cs/Markdown/TagUtils/Abstractions/ITagContext.cs

@@ -0,0 +1,14 @@
+using System.Text;
+using Markdown.Dto;
+
+namespace Markdown.TagUtils.Abstractions;
+
+public interface ITagContext : IDisposable
+{
+    public void Append(string content);
+    public void CloseTop(bool isFinal = false);
+    public void Open(Tag tag);
+    public Stack<Tag> Tags { get; }
+    public StringBuilder Content { get; }
+    public bool SkipNextAsMarkup { get; set; }
+}

cs/Markdown/TagUtils/Abstractions/ITagProcessor.cs

@@ -0,0 +1,9 @@
+using System.Text;
+using Markdown.Dto;
+
+namespace Markdown.TagUtils.Abstractions;
+
+public interface ITagProcessor
+{
+    public string Process(IEnumerable<Token> tokens);
+}