Бабинцев Григорий

cs/Markdown.Tests/Markdown.Tests.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="NUnit" Version="3.12.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Markdown\Markdown.csproj" />
+  </ItemGroup>
+
+</Project>

cs/Markdown.Tests/Markdown.cs

@@ -0,0 +1,16 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Markdown.Builder;
+using Markdown.Checker;
+using Markdown.Config;
+using Markdown.Parser;
+using FluentAssertions;
+
+namespace Markdown.Tests
+{
+
+}

cs/Markdown.Tests/Program.cs

@@ -0,0 +1,2 @@
+// See https://aka.ms/new-console-template for more information
+Console.WriteLine("Hello, World!");

cs/Markdown/Builder/HtmlBuilder.cs

@@ -0,0 +1,80 @@
+using Markdown.Domain.Tags;
+using Markdown.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Markdown.Extensions;
+
+namespace Markdown.Builder
+{
+    public class HtmlBuilder : IHtmlBuilder
+    {
+        private readonly Dictionary<Tag, string> _htmlTagsMarkupDict;
+
+        private int shift;
+
+        public HtmlBuilder(Dictionary<Tag, string> htmlTagsMarkupDict)
+        {
+            _htmlTagsMarkupDict = htmlTagsMarkupDict;
+        }
+
+        public string BuildHtmlFromMarkdown(string markdownText, List<Token> tokens)
+        {
+            var htmlResultText = new StringBuilder(markdownText);
+            var htmlTags = ConvertToHtmlTags(tokens);
+            shift = 0;
+
+            foreach (var tag in htmlTags)
+            {
+                ReplaceMarkdownWithHtml(htmlResultText, tag);
+                shift = htmlResultText.Length - markdownText.Length;
+            }
+
+            return htmlResultText.ToString();
+        }
+
+        private void ReplaceMarkdownWithHtml(StringBuilder htmlResultText, HtmlTag tag)
+        {
+            var mdTagLength = GetMdTagLength(tag);
+
+            htmlResultText.Remove(tag.Index + shift, mdTagLength);
+
+            htmlResultText.Insert(tag.Index + shift, tag.GetMarkup());
+        }
+
+        private int GetMdTagLength(HtmlTag tag)
+        {
+            if (tag.Tag == Tag.Bold)
+            {
+                shift--;
+                return 2;
+            }
+
+            if (tag.IsClosing && (tag.Tag == Tag.Header || tag.Tag == Tag.EscapedSymbol))
+            {
+                shift++;
+                return 0;
+            }
+
+            return 1;
+        }
+
+        private List<HtmlTag> ConvertToHtmlTags(List<Token> tokens)
+        {
+            var htmlTags = new List<HtmlTag>();
+
+            foreach (var token in tokens)
+            {
+                var htmlMarkup = _htmlTagsMarkupDict[token.TagType];
+                var tag = token.TagType;
+
+                htmlTags.Add(new HtmlTag(tag, token.StartIndex, false, htmlMarkup));
+                htmlTags.Add(new HtmlTag(tag, token.EndIndex, true, htmlMarkup));
+            }
+
+            return htmlTags.OrderBy(tag => tag.Index).ToList();
+        }
+    }
+}

cs/Markdown/Checker/TagChecker.cs

@@ -0,0 +1,85 @@
+using Markdown.Domain.Tags;
+using Markdown.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Markdown.Checker
+{
+    public class TagChecker : ITagChecker
+    {
+        private int currentIndex;
+
+        public const char HASH_SYMBOL = '#';
+        public const char UNDERSCORE_SYMBOL = '_';
+        public const char SLASH_SYMBOL = '\\';
+
+        public Tuple<Tag, int> GetTagType(string line, int index)
+        {
+            currentIndex = index;
+            var tag = Tag.None;
+
+            switch (line[index])
+            {
+                case UNDERSCORE_SYMBOL:
+                    tag = GetTagForUnderscore(line);
+                    break;
+                case SLASH_SYMBOL:
+                    tag = GetTagForSlash(line);
+                    break;
+                case HASH_SYMBOL:
+                    if (index == 0)
+                        tag = Tag.Header;
+                    break;
+            }
+
+            return Tuple.Create(tag, currentIndex);
+        }
+
+        private Tag GetTagForSlash(string line)
+        {
+            if (currentIndex < line.Length - 1
+                && (line[currentIndex + 1] == SLASH_SYMBOL
+                || line[currentIndex + 1] == UNDERSCORE_SYMBOL
+                || line[currentIndex + 1] == HASH_SYMBOL))
+            {
+                return Tag.EscapedSymbol;
+            }
+
+            return Tag.None;
+        }
+
+        private Tag GetTagForUnderscore(string line)
+        {
+            if (currentIndex < line.Length - 1 && line[currentIndex + 1] == UNDERSCORE_SYMBOL)
+                return GetTagWithMultipleUnderscores(line);
+
+            return Tag.Italic;
+        }
+
+        private Tag GetTagWithMultipleUnderscores(string line)
+        {
+            if (currentIndex < line.Length - 2 && line[currentIndex + 2] == UNDERSCORE_SYMBOL)
+            {
+                currentIndex = FindEndOfInvalidTag(line);
+                return Tag.None;
+            }
+
+            currentIndex++;
+
+            return Tag.Bold;
+        }
+
+        private int FindEndOfInvalidTag(string line)
+        {
+            var endIndex = currentIndex;
+
+            while (endIndex < line.Length && line[endIndex] == UNDERSCORE_SYMBOL)
+                endIndex++;
+
+            return endIndex;
+        }
+    }
+}

cs/Markdown/Config/MarkdownConfig.cs

@@ -0,0 +1,30 @@
+using Markdown.Domain.Tags;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Markdown.Config
+{
+    public class MarkdownConfig
+    {
+        public static Dictionary<Tag, string> HtmlTags => new Dictionary<Tag, string>()
+        {
+            { Tag.Bold, "strong" }, { Tag.Italic, "em" },
+            { Tag.Header, "h1" }, { Tag.EscapedSymbol, "" }
+        };
+
+        public static Dictionary<Tag, string> MdTags => new Dictionary<Tag, string>()
+        {
+            { Tag.Bold, "__" }, { Tag.Italic, "_" },
+            { Tag.Header, "# " }, { Tag.EscapedSymbol, ""}
+        };
+
+        public static Dictionary<Tag, Tag> DifferentTags => new Dictionary<Tag, Tag>()
+        {
+            {Tag.Bold, Tag.Italic},
+            {Tag.Italic, Tag.Bold}
+        };
+    }
+}

cs/Markdown/Domain/IHtmlBuilder.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Markdown.Domain
+{
+    public interface IHtmlBuilder
+    {
+        string BuildHtmlFromMarkdown(string markdownText, List<Token> tokens);
+    }
+}

cs/Markdown/Domain/IMarkdownParser.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Markdown.Domain
+{
+    public interface IMarkdownParser
+    {
+        List<Token> ParseMarkdown(string line);
+    }
+}

cs/Markdown/Domain/ITagChecker.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Markdown.Domain.Tags;
+
+namespace Markdown.Domain
+{
+    public interface ITagChecker
+    {
+        Tuple<Tag, int> GetTagType(string line, int index);
+    }
+}

cs/Markdown/Domain/Tags/HtmlTag.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Markdown.Domain.Tags
+{
+    public class HtmlTag
+    {
+        public Tag Tag { get; }
+        public int Index { get; }
+        public bool IsClosing { get; }
+        public string Markup { get; }
+
+        public HtmlTag(Tag tag, int index, bool isClosing, string htmlMarkup)
+        {
+            Tag = tag;
+            Index = index;
+            IsClosing = isClosing;
+            Markup = htmlMarkup;
+        }
+    }
+}

cs/Markdown/Domain/Tags/MdTag.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Markdown.Domain.Tags
+{
+    public class MdTag
+    {
+        public Tag Tag { get; }
+        public int Index { get; }
+
+        public MdTag(Tag tag, int index)
+        {
+            Tag = tag;
+            Index = index;
+        }
+    }
+}

cs/Markdown/Domain/Tags/Tag.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Markdown.Domain.Tags
+{
+    public enum Tag
+    {
+        None,
+        Bold,
+        Italic,
+        Header,
+        EscapedSymbol,
+    }
+}

cs/Markdown/Domain/Token.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Markdown.Domain.Tags;
+
+namespace Markdown.Domain
+{
+    public class Token
+    {
+        public Tag TagType { get; }
+        public int StartIndex { get; }
+        public int EndIndex { get; }
+        public bool IsSingleTag { get; }
+
+        public Token(Tag type, int startIndex, int endIndex, bool isSingleTag = false)
+        {
+            TagType = type;
+            IsSingleTag = isSingleTag;
+            StartIndex = startIndex;
+            EndIndex = endIndex;
+        }
+    }
+}

cs/Markdown/Extensions/HtmlTagExtensions.cs

@@ -0,0 +1,23 @@
+using Markdown.Domain.Tags;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Markdown.Extensions
+{
+    public static class HtmlTagExtensions
+    {
+        public static string GetMarkup(this HtmlTag htmlTag)
+        {
+            if (htmlTag.Tag == Tag.EscapedSymbol)
+                return "";
+
+            var format = htmlTag.IsClosing ? "</{0}>" : "<{0}>";
+
+            return string.Format(format, htmlTag.Markup);
+        }
+    }
+}