Смышляев Дмитрий

cs/Markdown/Generator/HTMLGenerator.cs

@@ -0,0 +1,13 @@
+using Markdown.Parser.Nodes;
+
+namespace Markdown.Generator;
+
+public class HTMLGenerator
+{
+
+    public string GenerateHTML(Node astRoot)
+    {
+        /* Do magic with ast root */
+        return "<h1>Hello world</h1>";
+    }
+}

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/Parser/Nodes/Node.cs

@@ -0,0 +1,6 @@
+namespace Markdown.Parser.Nodes;
+
+public class Node
+{
+
+}

cs/Markdown/Parser/Rules/BodyRule.cs

@@ -0,0 +1,12 @@
+using Markdown.Parser.Nodes;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules;
+
+public class BodyRule : IParsingRule
+{
+    public Node Match(List<Token> tokens)
+    {
+        throw new NotImplementedException();
+    }
+}

cs/Markdown/Parser/Rules/BoldRule.cs

@@ -0,0 +1,12 @@
+using Markdown.Parser.Nodes;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules;
+
+public class BoldRule : IParsingRule
+{
+    public Node Match(List<Token> tokens)
+    {
+        throw new NotImplementedException();
+    }
+}

cs/Markdown/Parser/Rules/HeadlineRule.cs

@@ -0,0 +1,12 @@
+using Markdown.Parser.Nodes;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules;
+
+public class HeadlineRule : IParsingRule
+{
+    public Node Match(List<Token> tokens)
+    {
+        throw new NotImplementedException();
+    }
+}

cs/Markdown/Parser/Rules/IParsingRule.cs

@@ -0,0 +1,9 @@
+using Markdown.Parser.Nodes;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules;
+
+public interface IParsingRule
+{
+    public Node Match(List<Token> tokens);
+}

cs/Markdown/Parser/Rules/ItalicRule.cs

@@ -0,0 +1,12 @@
+using Markdown.Parser.Nodes;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules;
+
+public class ItalicRule : IParsingRule
+{
+    public Node Match(List<Token> tokens)
+    {
+        throw new NotImplementedException();
+    }
+}

cs/Markdown/Parser/TokenParser.cs

@@ -0,0 +1,13 @@
+using Markdown.Parser.Nodes;
+using Markdown.Parser.Rules;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser;
+
+public class TokenParser
+{
+    public Node Parse(List<Token> tokens)
+    {
+        return new BodyRule().Match(tokens);
+    }
+}

cs/Markdown/Program.cs

@@ -0,0 +1,20 @@
+// See https://aka.ms/new-console-template for more information
+
+using Markdown.Generator;
+using Markdown.Parser;
+using Markdown.Tokenizer;
+
+namespace Markdown;
+
+internal class Program
+{
+    public static void Main(string[] args)
+    {
+        var markdown = "This _is_ a __sample__ markdown _file_.\n";
+
+        var tokens = new MarkdownTokenizer().Tokenize(markdown);
+        var astRoot = new TokenParser().Parse(tokens);
+
+        Console.WriteLine(new HTMLGenerator().GenerateHTML(astRoot));
+    }
+}

cs/Markdown/Tokenizer/MarkdownTokenizer.cs

@@ -0,0 +1,26 @@
+using Markdown.Tokenizer.Scanners;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Tokenizer;
+
+public class MarkdownTokenizer
+{
+    private readonly ITokenScanner[] scanners = [
+        new SpecScanner(), new NumberScanner(), new TextScanner()
+    ];
+
+    public List<Token> Tokenize(string markdown)
+    {
+        var begin = 0;
+        var tokenList = new List<Token>();
+
+        while (begin < markdown.Length)
+        {
+            var token = scanners
+                .Select(sc => sc.Scan(markdown, begin))
+                .First(token => token is not null);
+            begin += token!.Length; tokenList.Add(token);
+        }
+        return tokenList;
+    }
+}

cs/Markdown/Tokenizer/Scanners/ITokenScanner.cs

@@ -0,0 +1,8 @@
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Tokenizer.Scanners;
+
+public interface ITokenScanner
+{
+    public Token? Scan(string markdown, int begin = 0);
+}

cs/Markdown/Tokenizer/Scanners/NumberScanner.cs

@@ -0,0 +1,17 @@
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Tokenizer.Scanners;
+
+public class NumberScanner : ITokenScanner
+{
+    public Token? Scan(string markdown, int begin = 0)
+    {
+        var numberIterator = markdown
+            .Skip(begin)
+            .TakeWhile(CanScan);
+        var numberLen = numberIterator.Count();
+        return numberLen == 0 ? null : new Token(TokenType.NUMBER, begin, numberLen, markdown);
+    }
+
+    public static bool CanScan(char symbol) => char.IsDigit(symbol);
+}

cs/Markdown/Tokenizer/Scanners/SpecScanner.cs

@@ -0,0 +1,26 @@
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Tokenizer.Scanners;
+
+public class SpecScanner : ITokenScanner
+{
+    public Token? Scan(string markdown, int begin = 0)
+    {
+        var tokenType = GetTokenType(markdown[begin]);
+        if (tokenType is null) return null;
+
+        var notNullType = (TokenType)tokenType;
+        return new Token(notNullType, begin, 1, markdown);
+    }
+
+    public static bool CanScan(char symbol) 
+        => GetTokenType(symbol) != null;
+
+    private static TokenType? GetTokenType(char symbol) => symbol switch
+    {
+        ' ' => TokenType.SPACE,
+        '\n' => TokenType.NEW_LINE,
+        '_' => TokenType.UNDERSCORE,
+        _ => null
+    };
+}

cs/Markdown/Tokenizer/Scanners/TextScanner.cs

@@ -0,0 +1,18 @@
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Tokenizer.Scanners;
+
+public class TextScanner : ITokenScanner
+{
+    public Token? Scan(string markdown, int begin = 0)
+    {
+        var valueIterator = markdown
+            .Skip(begin)
+            .TakeWhile(CanScan);
+        var valueLen = valueIterator.Count();
+        return valueLen == 0 ? null : new Token(TokenType.TEXT, begin, valueLen, markdown);
+    }
+
+    private static bool CanScan(char symbol)
+        => !SpecScanner.CanScan(symbol) && !NumberScanner.CanScan(symbol);
+}

cs/Markdown/Tokenizer/Tokens/Token.cs

@@ -0,0 +1,20 @@
+namespace Markdown.Tokenizer.Tokens;
+
+public class Token(TokenType tokenType, int begin, int length, string sourceText)
+{
+    private string? value;
+
+    public int Begin { get; } = begin;
+    public int Length { get; } = length;
+    public TokenType TokenType { get; } = tokenType;
+
+    public string GetValue()
+    {
+        return value ??= sourceText.Substring(Begin, Length);
+    }
+
+    public override string ToString()
+    {
+        return $"Token {TokenType} | Value \"{GetValue()}\"";
+    }
+}

cs/Markdown/Tokenizer/Tokens/TokenType.cs

@@ -0,0 +1,10 @@
+namespace Markdown.Tokenizer.Tokens;
+
+public enum TokenType
+{
+    TEXT,
+    UNDERSCORE,
+    SPACE,
+    NEW_LINE,
+    NUMBER,
+}

cs/MarkdownTests/MarkdownTests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+        <PackageReference Include="FluentAssertions" Version="7.0.0-alpha.5" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
+        <PackageReference Include="NUnit" Version="3.14.0"/>
+        <PackageReference Include="NUnit.Analyzers" Version="3.9.0"/>
+        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Using Include="NUnit.Framework"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Markdown\Markdown.csproj" />
+    </ItemGroup>
+
+</Project>

cs/MarkdownTests/Tokenizer/MarkdownTokenizerTest.cs

@@ -0,0 +1,54 @@
+using System.Text;
+using FluentAssertions;
+using Markdown.Tokenizer;
+
+namespace MarkdownTests.Tokenizer;
+
+[TestFixture]
+public class MarkdownTokenizerTest
+{
+    [TestCase("Text with numbers 321")]
+    [TestCase("Some not specific text")]
+    [TestCase("Text with __markdown__ characters")]
+    [TestCase("_A_ __lot__ of _characters_ in _markdown_\n")]
+    public void MarkdownTokenizer_Tokenize_TransformAllTextToTokens(string markdown)
+    {
+        var tokenizer = new MarkdownTokenizer();
+
+        var tokens = tokenizer.Tokenize(markdown);
+
+        var totalLength = tokens.Sum(token => token.Length);
+        totalLength.Should().Be(markdown.Length);
+    }
+
+    [TestCase("Hello world!")]
+    [TestCase("0123456789 - this is all digits")]
+    [TestCase("Some _wonderful __text with_ intersects__")]
+    public void MarkdownTokenizer_Tokenize_AllTokensAreNotIntersect(string markdown)
+    {
+        var tokenizer = new MarkdownTokenizer();
+
+        var tokens = tokenizer.Tokenize(markdown);
+
+        var pairs = Enumerable
+            .Range(0, tokens.Count - 1)
+            .Select(i => tokens[i + 1]).Zip(tokens)
+            .Select(pair => (next : pair.First, prev : pair.Second));
+        pairs.Should().OnlyContain(pair => pair.next.Begin - pair.prev.Begin == pair.prev.Length);
+    }
+
+    [TestCase("Text with numbers 321")]
+    [TestCase("Some not specific text")]
+    [TestCase("Text with __markdown__ characters")]
+    [TestCase("_A_ __lot__ of _characters_ in _markdown_\n")]
+    public void MarkdownTokenizer_Tokenize_TokensPresentInCorrectOrder(string markdown)
+    {
+        var tokenizer = new MarkdownTokenizer();
+
+        var tokens = tokenizer.Tokenize(markdown);
+
+        var resultStringBuilder = tokens
+            .Aggregate(new StringBuilder(), (sb, token) => sb.Append(token.GetValue()));
+        resultStringBuilder.ToString().Should().Be(markdown);
+    }
+}

cs/MarkdownTests/Tokenizer/Scanners/NumberScannerTest.cs

@@ -0,0 +1,31 @@
+using FluentAssertions;
+using Markdown.Tokenizer.Scanners;
+using Markdown.Tokenizer.Tokens;
+
+namespace MarkdownTests.Tokenizer.Scanners;
+
+[TestFixture]
+public class NumberScannerTest
+{
+    [TestCase("1", 0)]
+    [TestCase("12345", 0)]
+    public void NumberScanner_Scan_TokenShouldHaveNumberType(string text, int begin)
+    {
+        var scanner = new NumberScanner();
+
+        var token = scanner.Scan(text, begin);
+
+        token.Should().NotBeNull();
+        token.TokenType.Should().Be(TokenType.NUMBER);
+    }
+
+    [TestCase(" 123", 0)]
+    [TestCase("_\n ", 0)]
+    [TestCase("abcdifgh", 0)]
+    public void NumberScanner_Scan_ShouldScanNullFromText(string text, int begin)
+    {
+        var scanner = new NumberScanner();
+        var token = scanner.Scan(text, begin);
+        token.Should().BeNull();
+    }
+}