Попов Захар

cs/Markdown/Converters/IConverter.cs

@@ -0,0 +1,9 @@
+using Markdown.Tokens;
+
+namespace Markdown.Converters
+{
+    internal interface IConverter
+    {
+        IList<Token> Convert(IList<Token> tokensToConvert);
+    }
+}

cs/Markdown/Converters/MdToHTMLConverters/ConverterMdToHTML.cs

@@ -0,0 +1,22 @@
+using Markdown.Tags;
+using Markdown.Tokens;
+using Markdown.Tags.HTMLTags;
+
+namespace Markdown.Converters.MdToHTMLConverters
+{
+    internal class ConverterMdToHTML : IConverter
+    {
+        private readonly Dictionary<string, ITag> _mdTagNamesToHTMLTags
+            = new Dictionary<string, ITag>()
+        {
+            {"_", new HTMLTag("em") },
+            {"__", new HTMLTag("strong") },
+            {"# ", new HTMLTag("h1") },
+        };
+
+        public IList<Token> Convert(IList<Token> tokensToConvert)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

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,22 @@
+using Markdown.Converters;
+using Markdown.Parsers;
+using Markdown.Writers;
+
+namespace Markdown
+{
+    internal class Md(IParser parser, IConverter converter, IWriter writer)
+    {
+        private readonly IParser _parser = parser;
+        private readonly IConverter _converter = converter;
+        private readonly IWriter _writer = writer;
+
+        public string Render(string text)
+        {
+            var mdTokens = _parser.ParseToTokens(text);
+
+            var HTMLTokens = _converter.Convert(mdTokens);
+
+            return _writer.Write(HTMLTokens);
+        }
+    }
+}

cs/Markdown/Parsers/IParser.cs

@@ -0,0 +1,9 @@
+using Markdown.Tokens;
+
+namespace Markdown.Parsers
+{
+    internal interface IParser
+    {
+        IList<Token> ParseToTokens(string textToParse);
+    }
+}

cs/Markdown/Parsers/MdParsers/ParserMD.cs

@@ -0,0 +1,21 @@
+using Markdown.Tags;
+using Markdown.Tags.MdTags;
+using Markdown.Tokens;
+
+namespace Markdown.Parsers.MdParsers
+{
+    internal class ParserMD : IParser
+    {
+        private readonly Dictionary<string, ITag> _mdTags = new Dictionary<string, ITag>()
+        {
+            {"_", new PairedMdTag("_") },
+            {"__", new PairedMdTag("__") },
+            {"# ", new SingleMdTag("# ") }
+        };
+
+        public IList<Token> ParseToTokens(string textToParse)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

cs/Markdown/Program.cs

@@ -0,0 +1,82 @@
+using Markdown.Converters.MdToHTMLConverters;
+using Markdown.Parsers.MdParsers;
+using Markdown.Tags;
+using Markdown.Tags.HTMLTags;
+using Markdown.Tags.MdTags;
+using Markdown.Tokens;
+using Markdown.Writers;
+
+namespace Markdown
+{
+    internal class Program
+    {
+        static void Main(string[] args)
+        {
+            var simpleText = "Hello, Andrey";
+            var simpleTokenMD = new SimpleStringToken(simpleText);
+            var simpleTokenHTML = new SimpleStringToken("Hello, Andrey");
+            ShowEaxmple(simpleText, simpleTokenMD, simpleTokenHTML);
+
+
+            var markdownText = "_Hello, Andrey_";
+            var markdownTokenMD = new MarkdownStringToken(new PairedMdTag("_"), "Hello, Andrey");
+            var markdownTokenHTML = new MarkdownStringToken(new HTMLTag("em"), "Hello, Andrey");
+            ShowEaxmple(markdownText, markdownTokenMD, markdownTokenHTML);
+
+
+            var complexText = "__с _разными_ символами__";
+            var complexInnerTokensMD = new List<Token>()
+            {
+                new SimpleStringToken("c "),
+                new MarkdownStringToken(new PairedMdTag("_"),"разными"),
+                new SimpleStringToken(" символами")
+            };
+            var complexInnerTokensHTML = new List<Token>()
+            {
+                new SimpleStringToken("c "),
+                new MarkdownStringToken(new HTMLTag("em"),"разными"),
+                new SimpleStringToken(" символами")
+            };
+            var complexTokenMD = new ComplexSringToken(new PairedMdTag("__"), complexInnerTokensMD);
+            var complexTokenHTML = new ComplexSringToken(new HTMLTag("strong"), complexInnerTokensHTML);
+            ShowEaxmple(complexText, complexTokenMD, complexTokenHTML);
+
+
+            var complexHeaderText = "# Заголовок __с _разными_ символами__";
+            var complexHeaderInnerTokensMD = new List<Token>()
+            {
+                new SimpleStringToken("Заголовок "),
+                new ComplexSringToken(new PairedMdTag("__"), complexInnerTokensMD)
+            };
+            var complexHeaderInnerTokensHTML = new List<Token>()
+            {
+                new SimpleStringToken("Заголовок "),
+                new ComplexSringToken(new HTMLTag("strong"), complexInnerTokensHTML)
+            };
+            var complexHeaderTokenMD = new ComplexSringToken(new SingleMdTag("# "), complexHeaderInnerTokensMD);
+            var complexHeaderTokenHTML = new ComplexSringToken(new HTMLTag("h1"), complexHeaderInnerTokensHTML);
+            ShowEaxmple(complexHeaderText, complexHeaderTokenMD, complexHeaderTokenHTML);
+
+            Console.ReadLine();
+
+            var exampleText = "# Заголовок __с _разными_ символами__";
+            var parser = new ParserMD();
+            var converter = new ConverterMdToHTML();
+            var writer = new WriterHTML();
+            var md = new Md(parser, converter, writer);
+            var htmlCode = md.Render(exampleText);
+        }
+
+        private static void ShowEaxmple(
+            string rawText,
+            Token tokenMD,
+            Token tokenHTML)
+        {
+            Console.WriteLine("Пример:");
+            Console.WriteLine($"Переданный текст: {rawText}");
+            Console.WriteLine($"Востановленный из токена MD текст: {tokenMD}");
+            Console.WriteLine($"Востановленный из токена HTML текст: {tokenHTML}");
+            Console.WriteLine();
+        }
+    }
+}

cs/Markdown/Tags/HTMLTags/HTMLTag.cs

@@ -0,0 +1,9 @@
+namespace Markdown.Tags.HTMLTags
+{
+    internal class HTMLTag(string tagName) : Tag(tagName), ITag
+    {
+        public string OpeningTagName => $"<{TagName}>";
+
+        public string ClosingTagName => $"</{TagName}>";
+    }
+}

cs/Markdown/Tags/ITag.cs

@@ -0,0 +1,8 @@
+namespace Markdown.Tags
+{
+    internal interface ITag
+    {
+        string OpeningTagName { get; }
+        string ClosingTagName { get; }
+    }
+}

cs/Markdown/Tags/MdTags/PairedMdTag.cs

@@ -0,0 +1,9 @@
+namespace Markdown.Tags.MdTags
+{
+    internal class PairedMdTag(string tagName) : Tag(tagName), ITag
+    {
+        public string OpeningTagName => TagName;
+
+        public string ClosingTagName => TagName;
+    }
+}

cs/Markdown/Tags/MdTags/SingleMdTag.cs

@@ -0,0 +1,9 @@
+namespace Markdown.Tags.MdTags
+{
+    internal class SingleMdTag(string tagName) : Tag(tagName), ITag
+    {
+        public string OpeningTagName => TagName;
+
+        public string ClosingTagName => string.Empty;
+    }
+}

cs/Markdown/Tags/Tag.cs

@@ -0,0 +1,16 @@
+namespace Markdown.Tags
+{
+    internal abstract class Tag
+    {
+        protected Tag(string tagName)
+        {
+            if (string.IsNullOrWhiteSpace(tagName))
+            {
+                throw new ArgumentException(
+                    "Имя тега не может быть null или пустой строкой");
+            }
+            TagName = tagName;
+        }
+        public string TagName { get; }
+    }
+}

cs/Markdown/Tokens/ComplexSringToken.cs

@@ -0,0 +1,50 @@
+using Markdown.Tags;
+using System.Text;
+
+namespace Markdown.Tokens
+{
+    internal class ComplexSringToken : Token
+    {
+        public ITag Tag { get => _tag!; }
+        public Token[] InnerTokens { get => _innerTokens!.ToArray(); }
+
+        public ComplexSringToken(ITag tag, IList<Token> innerTokens)
+            : base(tag: tag, innerTokens: innerTokens)
+        {
+            if (tag is null)
+            {
+                throw new ArgumentException("Передаваемый токен не может быть null");
+            }
+
+            if (innerTokens is null)
+            {
+                throw new ArgumentException("Передаваемые внутренние токены не могут быть null");
+            }
+
+            if (innerTokens.Count == 0)
+            {
+                throw new ArgumentException(
+                    "Передаваемые внутренние токены не могут быть пустыми");
+            }
+        }
+
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+
+            sb.Append(Tag.OpeningTagName);
+            foreach (var token in InnerTokens)
+            {
+                if (token is SimpleStringToken || token is MarkdownStringToken)
+                {
+                    sb.Append(token.ToString());
+                    continue;
+                }
+                sb.Append(token.ToString());
+            }
+            sb.Append(Tag.ClosingTagName);
+
+            return sb.ToString();
+        }
+    }
+}

cs/Markdown/Tokens/MarkdownStringToken.cs

@@ -0,0 +1,28 @@
+using Markdown.Tags;
+
+namespace Markdown.Tokens
+{
+    internal class MarkdownStringToken : Token
+    {
+        public ITag Tag { get => _tag!; }
+
+        public string Content { get => _content!; }
+
+        public MarkdownStringToken(ITag tag, string content) : base(tag: tag, content: content)
+        {
+            if (tag is null)
+            {
+                throw new ArgumentException("Передаваемый токен не может быть null");
+            }
+
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                throw new ArgumentException(
+                    "Содержимое токена не может быть null или пустой строкой");
+            }
+        }
+
+        public override string ToString()
+            => $"{Tag.OpeningTagName}{Content}{Tag.ClosingTagName}";
+    }
+}

cs/Markdown/Tokens/SimpleStringToken.cs

@@ -0,0 +1,18 @@
+namespace Markdown.Tokens
+{
+    internal class SimpleStringToken : Token
+    {
+        public string Content { get => _content!; }
+
+        public SimpleStringToken(string content) : base(content: content)
+        {
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                throw new ArgumentException(
+                    "Содержимое токена не может быть null или пустой строкой");
+            }
+        }
+
+        public override string ToString() => Content;
+    }
+}

cs/Markdown/Tokens/Token.cs

@@ -0,0 +1,15 @@
+using Markdown.Tags;
+
+namespace Markdown.Tokens
+{
+    internal abstract class Token(
+        ITag? tag = null,
+        string? content = null,
+        IList<Token>? innerTokens = null)
+    {
+        protected readonly ITag? _tag = tag;
+        protected readonly string? _content = content;
+        protected readonly IList<Token>? _innerTokens = innerTokens;
+    }
+}
+

cs/Markdown/Writers/IWriter.cs

@@ -0,0 +1,9 @@
+using Markdown.Tokens;
+
+namespace Markdown.Writers
+{
+    internal interface IWriter
+    {
+        string Write(IList<Token> tokensToWrite);
+    }
+}

cs/Markdown/Writers/WriterHTML.cs

@@ -0,0 +1,12 @@
+using Markdown.Tokens;
+
+namespace Markdown.Writers
+{
+    internal class WriterHTML : IWriter
+    {
+        public string Write(IList<Token> tokensToWrite)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}