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

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,7 @@
+namespace Markdown.Parser.Nodes;
+
+public class Node(NodeType nodeType, int consumed)
+{
+    public int Consumed { get; } = consumed;
+    public NodeType NodeType { get; } = nodeType;
+}

cs/Markdown/Parser/Nodes/NodeType.cs

@@ -0,0 +1,8 @@
+namespace Markdown.Parser.Nodes;
+
+public enum NodeType
+{
+    ITALIC,
+    BOLD,
+    TEXT
+}

cs/Markdown/Parser/Nodes/TagNode.cs

@@ -0,0 +1,10 @@
+namespace Markdown.Parser.Nodes;
+
+public class TagNode(NodeType nodeType, List<Node> children, int consumed) : Node(nodeType, consumed)
+{
+    public List<Node> Children { get; } = children;
+
+    public TagNode(NodeType nodeType, Node child, int consumed) 
+        :this(nodeType, [child], consumed)
+    { }
+}

cs/Markdown/Parser/Nodes/TextNode.cs

@@ -0,0 +1,15 @@
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Nodes;
+
+public class TextNode(int start, int consumed, List<Token> source) : Node(NodeType.TEXT, consumed)
+{
+    private readonly Lazy<Token> firstToken = new(source.Skip(start).First);
+    private readonly Lazy<Token> lastToken = new(source.Skip(start).Take(consumed).Last);
+    private readonly Lazy<List<Token>> tokens = new(source.Skip(start).Take(consumed).ToList);
+
+    public Token Last => lastToken.Value;
+    public Token First => firstToken.Value;
+    public List<Token> Tokens => tokens.Value;
+    public string Text => Tokens.ToText();
+}

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, int begin = 0)
+    {
+        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, int begin = 0)
+    {
+        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, int begin = 0)
+    {
+        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, int begin = 0);
+}

cs/Markdown/Parser/Rules/ItalicRule.cs

@@ -0,0 +1,46 @@
+using Markdown.Parser.Nodes;
+using Markdown.Parser.Rules.Tools;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules;
+
+public class ItalicRule : IParsingRule
+{
+    private readonly List<IParsingRule> defaultPattern =
+    [
+        new PatternRule(TokenType.UNDERSCORE),
+        new TextRule(),
+        new PatternRule(TokenType.UNDERSCORE),
+    ];
+
+    private readonly List<IParsingRule> innerTagPattern = 
+    [
+        new PatternRule(TokenType.UNDERSCORE),
+        new PatternRule(TokenType.WORD),
+        new PatternRule(TokenType.UNDERSCORE),
+    ];
+
+    public Node? Match(List<Token> tokens, int begin = 0)
+    {
+        var pattern = ChoosePattern(tokens, begin);
+        var match = tokens.MatchPattern(pattern, begin);
+
+        if (match.Count != pattern.Count) return null;
+        if (match.Second() is not TextNode textNode) return null;
+
+        var endWithWord = textNode.Last.TokenType == TokenType.WORD;
+        var startWithWord = textNode.First.TokenType == TokenType.WORD;
+
+        return startWithWord && endWithWord ? BuildNode(textNode) : null;
+    }
+
+    private List<IParsingRule> ChoosePattern(List<Token> tokens, int begin = 0)
+    {
+        if (begin != 0 && tokens[begin - 1].TokenType == TokenType.WORD)
+            return innerTagPattern;
+        return defaultPattern;
+    }
+
+    private static TagNode BuildNode(TextNode textNode) 
+        => new(NodeType.ITALIC, textNode, textNode.Consumed + 2);
+}

cs/Markdown/Parser/Rules/PatternRule.cs

@@ -0,0 +1,22 @@
+using Markdown.Parser.Nodes;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules;
+
+public class PatternRule(List<TokenType> pattern) : IParsingRule
+{
+    public PatternRule(TokenType tokenType) 
+        : this([tokenType]) 
+    { }
+
+    public Node? Match(List<Token> tokens, int begin = 0)
+    {
+        if (pattern.Count == 0) return null;
+        if (tokens.Count - begin < pattern.Count) return null;
+
+        var isMatched = tokens
+            .Skip(begin).Take(pattern.Count).Zip(pattern)
+            .All(pair => pair.First.TokenType == pair.Second);
+        return !isMatched ? null : new TextNode(begin, pattern.Count, tokens);
+    }
+}

cs/Markdown/Parser/Rules/TextRule.cs

@@ -0,0 +1,16 @@
+using Markdown.Parser.Nodes;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules;
+
+public class TextRule : IParsingRule
+{
+    public Node? Match(List<Token> tokens, int begin = 0)
+    {
+        var textLength = tokens.Skip(begin).TakeWhile(IsText).Count();
+        return textLength == 0 ? null : new TextNode(begin, textLength, tokens);
+    }
+
+    private static bool IsText(Token token)
+        => token.TokenType is TokenType.WORD or TokenType.SPACE;
+}

cs/Markdown/Parser/Rules/Tools/ListMatchExtensions.cs

@@ -0,0 +1,39 @@
+using Markdown.Parser.Nodes;
+using Markdown.Tokenizer.Tokens;
+
+namespace Markdown.Parser.Rules.Tools;
+
+public static class ListMatchExtensions
+{
+    public static List<Node> MatchPattern(this List<Token> tokens, List<IParsingRule> pattern, int begin = 0)
+    {
+        List<Node> nodes = [];
+
+        foreach (var patternRule in pattern)
+        {
+            var node = patternRule.Match(tokens, begin);
+            if (node is null) return [];
+            nodes.Add(node); begin += node.Consumed; 
+        }
+        return nodes;
+    }
+
+    public static List<Node> KleenStarMatch(this List<Token> tokens, IParsingRule pattern, int begin = 0)
+    {
+        List<Node> nodes = [];
+        while (true)
+        {
+            var node = pattern.Match(tokens, begin);
+            if (node is null) return nodes;
+            begin += node.Consumed; nodes.Add(node);
+        }
+    }
+
+    public static Node? FirstMatch(this List<Token> tokens, List<IParsingRule> patterns, int begin = 0)
+    {
+        var match = patterns
+            .Select(rule => rule.Match(tokens, begin))
+            .FirstOrDefault(node => node is not null, null);
+        return match;
+    }
+}

cs/Markdown/Parser/Rules/Tools/ListOrderExtensions.cs

@@ -0,0 +1,10 @@
+namespace Markdown.Parser.Rules.Tools;
+
+public static class ListOrderExtensions
+{
+    public static T? Second<T>(this List<T> list) 
+        => list.Count < 2 ? default : list[1];
+
+    public static T? Third<T>(this List<T> list)
+        => list.Count < 3 ? default : list[2];
+}

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 WordScanner()
+    ];
+
+    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);
+}