test comment formatting and newline handling

Author: zachariahcox

KustoSchemaTools.Tests/DemoData/DemoDeployment/DemoDatabase/functions/COMMENT_END.yml

@@ -0,0 +1,6 @@
+folder: test
+docString: Function with comment at end
+body: |-
+  sourceTable
+  | limit 100
+  | where IsNotEmpty(EventId) // this is a comment at the end

KustoSchemaTools.Tests/YamlDatabaseParserTests.cs

@@ -27,7 +27,6 @@ public async Task GetDatabase()
 
             Assert.NotNull(db);
             Assert.Equal(2, db.Tables.Count);
-            Assert.Equal(4, db.Functions.Count);
             Assert.Equal(6, db.Functions["UP"].Body.RowLength());
             Assert.Equal("DemoDatabase", db.Name);
 
@@ -140,9 +139,39 @@ void AssertMaterializedView(
                 Assert.NotNull(mv_with_cleanup);
                 Assert.NotNull(mv_without_cleanup);
                 Assert.Equal(should_match, mv_without_cleanup.Query == mv_with_cleanup.Query);
+
+                Assert.DoesNotContain("Preformatted", mv_with_cleanup.Query);
+                Assert.DoesNotContain("Preformatted", mv_without_cleanup.Query);
             }
             AssertMaterializedView("mv", false);
             AssertMaterializedView("mv_preformatted", true);
         }
+
+        [Fact]
+        public async Task VerifyFunctionWithCommentAtEnd()
+        {
+            // This test verifies that functions with comments at the end without a newline
+            // are handled correctly when scripts are generated
+
+            // Arrange - First load the database
+            var factory = new YamlDatabaseHandlerFactory<Model.Database>()
+                .WithPlugin(new TablePlugin())
+                .WithPlugin(new FunctionPlugin())
+                .WithPlugin(new DatabaseCleanup());
+            var loader = factory.Create(Path.Combine(BasePath, Deployment), Database);
+
+            // Act - Load the database
+            var db = await loader.LoadAsync();
+            var commentEndFunction = db.Functions["COMMENT_END"];
+            Assert.NotNull(commentEndFunction);
+
+            // Generate the script container for the function
+            var scriptContainers = commentEndFunction.CreateScripts("COMMENT_END", false);
+            Assert.Single(scriptContainers);
+
+            var script = scriptContainers[0].Script.Text;
+            var expected = ".create-or-alter function with(SkipValidation=```False```, View=```False```, Folder=```test```, DocString=```Function with comment at end```) COMMENT_END () { sourceTable\n| limit 100\n| where IsNotEmpty(EventId) // this is a comment at the end\n }";
+            Assert.Equal(expected, script);
+        }
     }
-}
+}

KustoSchemaTools/Model/Function.cs

@@ -4,6 +4,7 @@
 using KustoSchemaTools.Parser;
 using System.Text;
 using YamlDotNet.Serialization;
+using System.Xml.Schema;
 
 namespace KustoSchemaTools.Model
 {
@@ -16,14 +17,14 @@ public class Function : IKustoBaseEntity
         public string Parameters { get; set; } = "";
         [YamlMember(ScalarStyle = YamlDotNet.Core.ScalarStyle.Literal)]
         public bool Preformatted { get; set; } = false;
-
         public string Body { get; set; }
 
         public List<DatabaseScriptContainer> CreateScripts(string name, bool isNew)
         {
             // load the non-query parts of the yaml model
+            var excludedProperties = new HashSet<string>(["Body", "Parameters", "Preformatted"]);
             var properties = GetType().GetProperties()
-                .Where(p => p.GetValue(this) != null && p.Name != "Body" && p.Name != "Parameters")
+                .Where(p => p.GetValue(this) != null && !excludedProperties.Contains(p.Name))
                 .Select(p => $"{p.Name}=```{p.GetValue(this)}```");
             var propertiesString = string.Join(", ", properties);
 
@@ -75,7 +76,37 @@ public List<DatabaseScriptContainer> CreateScripts(string name, bool isNew)
                 parameters = replacedFunction[9..^15];
             }
 
-            return new List<DatabaseScriptContainer> { new DatabaseScriptContainer("CreateOrAlterFunction", 40, $".create-or-alter function with({propertiesString}) {name} ({parameters}) {{ {Body} }}") };
+            // Normalize the body to ensure it ends with exactly one newline character
+            // and remove trailing whitespace from each line
+            string normalizedBody = Body;
+            
+            if (string.IsNullOrEmpty(normalizedBody))
+            {
+                // Empty body case
+                normalizedBody = string.Empty;
+            }
+            else
+            {
+                // Split the body into lines, trim each line, and rejoin
+                string[] lines = normalizedBody.Replace("\r\n", "\n").Replace("\r", "\n").Split('\n');
+                
+                // Process all lines except the last one
+                for (int i = 0; i < lines.Length - 1; i++)
+                {
+                    lines[i] = lines[i].TrimEnd();
+                }
+                
+                // Handle the last line separately - no need to trim trailing newlines since we split on them
+                if (lines.Length > 0)
+                {
+                    lines[lines.Length - 1] = lines[lines.Length - 1].TrimEnd();
+                }
+                
+                // Rejoin the lines and add exactly one newline character at the end
+                normalizedBody = string.Join(Environment.NewLine, lines) + Environment.NewLine;
+            }
+
+            return new List<DatabaseScriptContainer> { new DatabaseScriptContainer("CreateOrAlterFunction", 40, $".create-or-alter function with({propertiesString}) {name} ({parameters}) {{ {normalizedBody} }}") };
         }
     }
 

KustoSchemaTools/Model/MaterializedView.cs

@@ -29,7 +29,16 @@ public List<DatabaseScriptContainer> CreateScripts(string name, bool isNew)
         {
             var asyncSetup = isNew && Backfill == true;
 
-            var excludedProperties = new HashSet<string>(["Query", "Source", "Kind", "RetentionAndCachePolicy", "RowLevelSecurity", "Policies"]);
+            var excludedProperties = new HashSet<string>([
+                "Query",
+                "Source",
+                "Kind",
+                "RetentionAndCachePolicy",
+                "RowLevelSecurity",
+                "Policies",
+                "Preformatted"
+                ]);
+                
             if (!asyncSetup)
             {
                 excludedProperties.Add("EffectiveDateTime");