templates support

Inspectron.Epson.Templates.Tests/Language/CommentTests.cs

@@ -0,0 +1,219 @@
+using Inspectron.Epson.Templates.Language;
+
+namespace Inspectron.Epson.Templates.Tests.Language;
+
+public class CommentTests
+{
+    #region Single-line comments
+
+    [Fact]
+    public void Tokenize_SingleLineComment_ProducesNoTextTokens()
+    {
+        var lexer = new Lexer("@* This is a comment");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
+    }
+
+    [Fact]
+    public void Tokenize_InlineSingleLineComment_ProducesNoTextTokens()
+    {
+        var lexer = new Lexer("@* This is a comment *@");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
+    }
+
+    [Fact]
+    public void Tokenize_IndentedSingleLineComment_IsRecognizedAsComment()
+    {
+        var lexer = new Lexer("    @* indented comment");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
+    }
+
+    [Fact]
+    public void Tokenize_TextBeforeAndAfterCommentLine_IsPreserved()
+    {
+        var lexer = new Lexer("Before\n@* comment\nAfter");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Before");
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "After");
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("comment"));
+    }
+
+    [Fact]
+    public void Tokenize_InlineCommentWithContentAfter_PreservesContentAfter()
+    {
+        var lexer = new Lexer("@* comment *@After");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "After");
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("comment"));
+    }
+
+    #endregion
+
+    #region Multi-line comments
+
+    [Fact]
+    public void Tokenize_MultiLineComment_ProducesNoTextTokens()
+    {
+        var lexer = new Lexer("@*\nThis is multi-line\ncomment text\n*@");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
+    }
+
+    [Fact]
+    public void Tokenize_MultiLineComment_ContentBeforeAndAfterPreserved()
+    {
+        var lexer = new Lexer("Before\n@*\ncomment\n*@\nAfter");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Before");
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "After");
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("comment"));
+    }
+
+    [Fact]
+    public void Tokenize_UnclosedMultiLineComment_ProducesError()
+    {
+        var lexer = new Lexer("@*\nThis comment is never closed");
+        var result = lexer.Tokenize();
+
+        Assert.True(result.HasErrors);
+        Assert.Contains(result.Errors, e => e.Message.Contains("Unclosed multi-line comment"));
+    }
+
+    [Fact]
+    public void Tokenize_MultiLineCommentWithContentAfterCloser_PreservesContent()
+    {
+        var lexer = new Lexer("@*\ncomment\n*@After");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "After");
+    }
+
+    #endregion
+
+    #region Edge cases
+
+    [Fact]
+    public void Tokenize_StarSeparator_StillWorksNotConfusedWithComment()
+    {
+        var lexer = new Lexer("***");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.StarSeparator);
+    }
+
+    [Fact]
+    public void Tokenize_DirectivesInsideComment_AreIgnored()
+    {
+        var lexer = new Lexer("@*\n@if condition\n@foreach item in items\n*@");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.If);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Foreach);
+    }
+
+    [Fact]
+    public void Tokenize_BindingsInsideComment_AreIgnored()
+    {
+        var lexer = new Lexer("@* {PropertyName} *@");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Binding);
+    }
+
+    [Fact]
+    public void Tokenize_CommentWithMultipleStars_HandledCorrectly()
+    {
+        var lexer = new Lexer("@*** This has extra stars ***@");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("stars"));
+    }
+
+    [Fact]
+    public void Tokenize_EmptyMultiLineComment_HandledCorrectly()
+    {
+        var lexer = new Lexer("@*\n*@");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
+    }
+
+    [Fact]
+    public void Tokenize_CommentInComplexTemplate_WorksCorrectly()
+    {
+        var template = @"#bold,center# Title #
+@* This is a header comment *@
+---
+@if HasItems
+@* Loop through items *@
+@foreach item in Items
+{item.Name}
+@end
+@end";
+        var lexer = new Lexer(template);
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.StyleStart);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.DashSeparator);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.If);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Foreach);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("comment"));
+    }
+
+    [Fact]
+    public void Tokenize_MultipleCommentsInTemplate_AllStripped()
+    {
+        var template = @"Line 1
+@* Comment 1 *@
+Line 2
+@* Comment 2
+still comment
+*@
+Line 3";
+        var lexer = new Lexer(template);
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Line 1");
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Line 2");
+        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Line 3");
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("Comment"));
+    }
+
+    [Fact]
+    public void Tokenize_SeparatorInsideMultiLineComment_IsIgnored()
+    {
+        var lexer = new Lexer("@*\n---\n===\n***\n*@");
+        var result = lexer.Tokenize();
+
+        Assert.False(result.HasErrors);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.DashSeparator);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.EqualsSeparator);
+        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.StarSeparator);
+    }
+
+    #endregion
+}