feat: padding empty lines before values

ExerciseBook · ExerciseBook · commit d6b623c129a5 · 2025-01-07T12:19:11.000+08:00
diff --git a/Tomlet.Tests/CommentSerializationTests.cs b/Tomlet.Tests/CommentSerializationTests.cs
@@ -1,13 +1,19 @@
 using System;
+using System.Collections.Generic;
 using Tomlet.Models;
 using Tomlet.Tests.CommentProvider;
 using Tomlet.Tests.TestModelClasses;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace Tomlet.Tests;
 
 public class CommentSerializationTests
 {
+    public CommentSerializationTests(ITestOutputHelper testOutputHelper)
+    {
+    }
+
     [Fact]
     public void CommentsOnSimpleKeyValuePairsWork()
     {
@@ -146,4 +152,59 @@ public void CommentProviderTest()
             doc.GetValue("InlineComment").Comments.InlineComment);
         Assert.Equal("PlainPrecedingComment", doc.GetValue("InlineComment").Comments.PrecedingComment);
     }
+    
+    [Fact]
+    public void PaddingLinesTest()
+    {
+        var data = new PaddingTestModel()
+        {
+            A = "str a",
+            B = 1,
+            C = new PaddingTestModel.NestedModel()
+            {
+                E = "str",
+                F = 2,
+            },
+            D = new List<PaddingTestModel.NestedModel>()
+            {
+                new()
+                {
+                    E = "str0",
+                    F = 0,
+                },
+                new()
+                {
+                    E = "str1",
+                    F = 1,
+                },
+            }
+        };
+
+        var expected = @"
+A = ""str a""
+B = 1
+
+# Nested Object
+[C]
+# Preceding Comment
+E = ""str"" # Preceding Comment
+# Preceding Comment
+F = 2 # Preceding Comment
+
+
+# Nested Array
+[[D]]
+# Preceding Comment
+E = ""str0"" # Preceding Comment
+# Preceding Comment
+F = 0 # Preceding Comment
+
+[[D]]
+# Preceding Comment
+E = ""str1"" # Preceding Comment
+# Preceding Comment
+F = 1 # Preceding Comment
+".Trim();
+        Assert.Equal(expected.ReplaceLineEndings(), TomletMain.TomlStringFrom(data).ReplaceLineEndings().Trim());
+    }
 }
diff --git a/Tomlet.Tests/TestModelClasses/CommentProviderTestModel.cs b/Tomlet.Tests/TestModelClasses/CommentProviderTestModel.cs
@@ -8,7 +8,7 @@ public class CommentProviderTestModel
     [TomlPrecedingCommentProvider(typeof(TestPrecedingCommentProvider), new object[] { "PrecedingComment" })]
     [TomlInlineComment("PlainInlineComment")]
     public string PrecedingComment { get; set; }
-    
+
     [TomlInlineCommentProvider(typeof(TestInlineCommentProvider), new object[] { "InlineComment" })]
     [TomlPrecedingComment("PlainPrecedingComment")]
     public string InlineComment { get; set; }
diff --git a/Tomlet.Tests/TestModelClasses/PaddingTestModel.cs b/Tomlet.Tests/TestModelClasses/PaddingTestModel.cs
@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using Tomlet.Attributes;
+
+namespace Tomlet.Tests.TestModelClasses;
+
+public class PaddingTestModel
+{
+    public string A { get; set; }
+
+    public int B { get; set; }
+    
+    [TomlPaddingLines(1)]
+    [TomlDoNotInlineObject]
+    [TomlPrecedingComment("Nested Object")]
+    public NestedModel C { get; set; }
+
+    [TomlPaddingLines(1)]
+    [TomlDoNotInlineObject]
+    [TomlPrecedingComment("Nested Array")]
+    public List<NestedModel> D { get; set; }
+    
+    public class NestedModel
+    {
+        [TomlPrecedingComment("Preceding Comment")]
+        [TomlInlineComment("Preceding Comment")]
+        public string E { get; set; }
+        
+        [TomlPrecedingComment("Preceding Comment")]
+        [TomlInlineComment("Preceding Comment")]
+        public int F { get; set; }
+    }
+}
diff --git a/Tomlet/Attributes/TomlPaddingLinesAttribute.cs b/Tomlet/Attributes/TomlPaddingLinesAttribute.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace Tomlet.Attributes;
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Field | AttributeTargets.Property)]
+public class TomlPaddingLinesAttribute: Attribute
+{
+    public int PaddingLines { get; }
+
+    public TomlPaddingLinesAttribute(int paddingLines)
+    {
+        PaddingLines = paddingLines;
+    }
+}
diff --git a/Tomlet/Models/TomlArray.cs b/Tomlet/Models/TomlArray.cs
@@ -105,7 +105,10 @@ public string SerializeTableArray(string key)
                     //if we have a preceding comment on the array itself, we add a blank line
                     //prior to the preceding comment on the first table.
                     builder.Append('\n');
-                    
+
+                if (first && value.Comments.PrecedingPaddingLines > 0)
+                    builder.Append('\n', value.Comments.PrecedingPaddingLines);
+
                 builder.Append(value.Comments.FormatPrecedingComment())
                     .Append('\n');
             }
diff --git a/Tomlet/Models/TomlCommentData.cs b/Tomlet/Models/TomlCommentData.cs
@@ -6,6 +6,8 @@ namespace Tomlet.Models;
 
 public class TomlCommentData
 {
+    public int PrecedingPaddingLines { get; set; } = 0;
+
     private string? _inlineComment;
 
     public string? PrecedingComment { get; set; }
@@ -20,35 +22,35 @@ public string? InlineComment
                 _inlineComment = null;
                 return;
             }
-            
+
             if (value.Contains("\n") || value.Contains("\r"))
                 throw new TomlNewlineInInlineCommentException();
-            
+
             _inlineComment = value;
         }
     }
-    
+
     public bool ThereAreNoComments => InlineComment == null && PrecedingComment == null;
 
     internal string FormatPrecedingComment(int indentCount = 0)
     {
-        if(PrecedingComment == null)
+        if (PrecedingComment == null)
             throw new Exception("Preceding comment is null");
 
         var builder = new StringBuilder();
-        
+
         var lines = PrecedingComment.Split('\n');
         var first = true;
         foreach (var line in lines)
         {
             if (!first)
                 builder.Append('\n');
             first = false;
-            
+
             var correctIndent = new string('\t', indentCount);
             builder.Append(correctIndent).Append("# ").Append(line);
         }
-        
+
         return builder.ToString();
     }
 }
diff --git a/Tomlet/Models/TomlTable.cs b/Tomlet/Models/TomlTable.cs
@@ -100,6 +100,9 @@ private void WriteValueToStringBuilder(string? keyName, string subKey, StringBui
 
         var hadBlankLine = builder.Length < 2 || builder[builder.Length - 2] == '\n';
 
+        if (value.Comments.PrecedingPaddingLines > 0)
+            builder.Append('\n', value.Comments.PrecedingPaddingLines);
+
         //Handle any preceding comment - this will ALWAYS go before any sort of value
         if (value.Comments.PrecedingComment != null)
             builder.Append(value.Comments.FormatPrecedingComment())
diff --git a/Tomlet/TomlCompositeSerializer.cs b/Tomlet/TomlCompositeSerializer.cs
@@ -39,7 +39,8 @@ public static TomlSerializationMethods.Serialize<object> For(Type type, TomlSeri
                 {
                     inline = GenericExtensions.GetCustomAttribute<TomlInlineCommentProviderAttribute>(f), 
                     preceding = GenericExtensions.GetCustomAttribute<TomlPrecedingCommentProviderAttribute>(f), 
-                    noInline = GenericExtensions.GetCustomAttribute<TomlDoNotInlineObjectAttribute>(f)
+                    noInline = GenericExtensions.GetCustomAttribute<TomlDoNotInlineObjectAttribute>(f),
+                    paddingLines = GenericExtensions.GetCustomAttribute<TomlPaddingLinesAttribute>(f),
                 });
             var props = type.GetProperties(memberFlags)
                 .ToArray();
@@ -49,7 +50,8 @@ public static TomlSerializationMethods.Serialize<object> For(Type type, TomlSeri
                     inline = GenericExtensions.GetCustomAttribute<TomlInlineCommentProviderAttribute>(p), 
                     preceding = GenericExtensions.GetCustomAttribute<TomlPrecedingCommentProviderAttribute>(p), 
                     prop = GenericExtensions.GetCustomAttribute<TomlPropertyAttribute>(p), 
-                    noInline = GenericExtensions.GetCustomAttribute<TomlDoNotInlineObjectAttribute>(p)
+                    noInline = GenericExtensions.GetCustomAttribute<TomlDoNotInlineObjectAttribute>(p),
+                    paddingLines = GenericExtensions.GetCustomAttribute<TomlPaddingLinesAttribute>(p),
                 });
 
             var isForcedNoInline = GenericExtensions.GetCustomAttribute<TomlDoNotInlineObjectAttribute>(type) != null;
@@ -94,6 +96,7 @@ public static TomlSerializationMethods.Serialize<object> For(Type type, TomlSeri
 
                     tomlValue.Comments.InlineComment = commentAttribs.inline?.GetComment();
                     tomlValue.Comments.PrecedingComment = commentAttribs.preceding?.GetComment();
+                    tomlValue.Comments.PrecedingPaddingLines = commentAttribs.paddingLines?.PaddingLines ?? 0;
                     
                     if(commentAttribs.noInline != null && tomlValue is TomlTable table)
                         table.ForceNoInline = true;
@@ -123,6 +126,7 @@ public static TomlSerializationMethods.Serialize<object> For(Type type, TomlSeri
                     
                     tomlValue.Comments.InlineComment = thisPropAttribs.inline?.GetComment();
                     tomlValue.Comments.PrecedingComment = thisPropAttribs.preceding?.GetComment();
+                    tomlValue.Comments.PrecedingPaddingLines = thisPropAttribs.paddingLines?.PaddingLines ?? 0;
 
                     if (thisPropAttribs.noInline != null && tomlValue is TomlTable table)
                         table.ForceNoInline = true;

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@ namespace Tomlet.Models;`
`6`	`6`
`7`	`7`	`public class TomlCommentData`
`8`	`8`	`{`
	`9`	`+ public int PrecedingPaddingLines { get; set; } = 0;`
	`10`	`+`
`9`	`11`	`private string? _inlineComment;`
`10`	`12`
`11`	`13`	`public string? PrecedingComment { get; set; }`
`@@ -20,35 +22,35 @@ public string? InlineComment`
`20`	`22`	`_inlineComment = null;`
`21`	`23`	`return;`
`22`	`24`	`}`
`23`		`-`
	`25`	`+`
`24`	`26`	`if (value.Contains("\n") \|\| value.Contains("\r"))`
`25`	`27`	`throw new TomlNewlineInInlineCommentException();`
`26`		`-`
	`28`	`+`
`27`	`29`	`_inlineComment = value;`
`28`	`30`	`}`
`29`	`31`	`}`
`30`		`-`
	`32`	`+`
`31`	`33`	`public bool ThereAreNoComments => InlineComment == null && PrecedingComment == null;`
`32`	`34`
`33`	`35`	`internal string FormatPrecedingComment(int indentCount = 0)`
`34`	`36`	`{`
`35`		`- if(PrecedingComment == null)`
	`37`	`+ if (PrecedingComment == null)`
`36`	`38`	`throw new Exception("Preceding comment is null");`
`37`	`39`
`38`	`40`	`var builder = new StringBuilder();`
`39`		`-`
	`41`	`+`
`40`	`42`	`var lines = PrecedingComment.Split('\n');`
`41`	`43`	`var first = true;`
`42`	`44`	`foreach (var line in lines)`
`43`	`45`	`{`
`44`	`46`	`if (!first)`
`45`	`47`	`builder.Append('\n');`
`46`	`48`	`first = false;`
`47`		`-`
	`49`	`+`
`48`	`50`	`var correctIndent = new string('\t', indentCount);`
`49`	`51`	`builder.Append(correctIndent).Append("# ").Append(line);`
`50`	`52`	`}`
`51`		`-`
	`53`	`+`
`52`	`54`	`return builder.ToString();`
`53`	`55`	`}`
`54`	`56`	`}`