feat: add support for multiple multi-line string properties with block scalar handling (#13)

Author: glucaci

src/Yamlify/Writer/Utf8YamlWriter.cs

@@ -434,6 +434,27 @@ public void WriteString(string? value)
     public void WriteString(ReadOnlySpan<char> value)
     {
         WriteScalarPrelude();
+
+        // Handle block scalar case specially
+        if (!_inFlowContext && ContainsNewline(value) &&
+            (_options.DefaultScalarStyle is ScalarStyle.Any or ScalarStyle.Literal))
+        {
+            WriteLiteralScalarValue(value);
+            SetNotFirstInContainer();
+            
+            // For block scalars:
+            // - If string ends with newline (clip/keep), we already wrote the newline
+            //   as part of the content, so don't set _needsNewLine
+            // - If string doesn't end with newline (strip), we need a newline before
+            //   the next property
+            bool endsWithNewline = value.Length > 0 && value[^1] == '\n';
+            if (!endsWithNewline)
+            {
+                _needsNewLine = true;
+            }
+            return;
+        }
+
         WriteScalarValue(value);
         WriteScalarPostlude();
     }
@@ -678,17 +699,9 @@ private void WriteScalarValue(ReadOnlySpan<char> value)
             return;
         }
 
-        // Check if we should use literal block style for multi-line strings
-        // Use literal block style when:
-        // 1. Not in flow context (block scalars not allowed in flow)
-        // 2. String contains actual newlines (\n)
-        // 3. DefaultScalarStyle is Any (auto-detect) or Literal
-        if (!_inFlowContext && ContainsNewline(value) &&
-            (_options.DefaultScalarStyle is ScalarStyle.Any or ScalarStyle.Literal))
-        {
-            WriteLiteralScalarValue(value);
-            return;
-        }
+        // Note: Block scalar handling has been moved to WriteString to properly
+        // skip the postlude (which sets _needsNewLine = true). Block scalars
+        // already end with a newline, so we don't want an additional one.
 
         // Determine if quoting is needed
         bool needsQuoting = NeedsQuoting(value);

test/Yamlify.Tests/Serialization/PrimitiveSerializationTests.cs

@@ -16,6 +16,17 @@ public class AllPrimitivesClass
     public string? StringValue { get; set; }
 }
 
+/// <summary>
+/// Class for testing multiple multi-line string properties.
+/// </summary>
+public class MultiStringClass
+{
+    public string? FirstText { get; set; }
+    public string? SecondText { get; set; }
+    public string? ThirdText { get; set; }
+    public int Value { get; set; }
+}
+
 /// <summary>
 /// Class for testing special float values.
 /// </summary>
@@ -493,6 +504,42 @@ public void RoundtripMultilineString_PreservesContent()
         Assert.Equal(original.Name, deserialized.Name);
     }
 
+    [Fact]
+    public void SerializeMultipleBlockScalars_NoExtraBlankLines()
+    {
+        // Arrange - Object with multiple multi-line string properties
+        var original = new MultiStringClass
+        {
+            FirstText = "First line\nSecond line\n",
+            SecondText = "Another first line\nAnother second line\n",
+            ThirdText = "Third property line 1\nThird property line 2\n",
+            Value = 42
+        };
+
+        // Act
+        var yaml = YamlSerializer.Serialize(original, TestSerializerContext.Default.MultiStringClass);
+
+        // Assert - Should use | (clip) chomping for strings ending with newline
+        Assert.Contains("first-text: |", yaml);
+        Assert.Contains("second-text: |", yaml);
+        Assert.Contains("third-text: |", yaml);
+
+        // Verify no extra blank lines between properties
+        // Each block scalar content ends with a newline, then the next property should start
+        // immediately on the next line without an extra blank line
+        Assert.DoesNotContain("\n\nsecond-text:", yaml);
+        Assert.DoesNotContain("\n\nthird-text:", yaml);
+        Assert.DoesNotContain("\n\nvalue:", yaml);
+
+        // Verify roundtrip
+        var deserialized = YamlSerializer.Deserialize(yaml, TestSerializerContext.Default.MultiStringClass);
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.FirstText, deserialized.FirstText);
+        Assert.Equal(original.SecondText, deserialized.SecondText);
+        Assert.Equal(original.ThirdText, deserialized.ThirdText);
+        Assert.Equal(original.Value, deserialized.Value);
+    }
+
     [Fact]
     public void DeserializeMultilinePlainScalar_FoldsToSingleLine()
     {

test/Yamlify.Tests/Serialization/TestSerializerContext.cs

@@ -20,6 +20,7 @@ namespace Yamlify.Tests.Serialization;
 [YamlSerializable(typeof(Level3))]
 // Primitives
 [YamlSerializable(typeof(AllPrimitivesClass))]
+[YamlSerializable(typeof(MultiStringClass))]
 [YamlSerializable(typeof(SpecialNumbersClass))]
 // Enums
 [YamlSerializable(typeof(EnumClass))]