Add literal style support for OpenApiYamlWriter

Author: foriequal0

src/Microsoft.OpenApi/Writers/OpenApiWriterBase.cs

@@ -24,7 +24,7 @@ public abstract class OpenApiWriterBase : IOpenApiWriter
         /// <summary>
         /// The indentation string to prepand to each line for each indentation level.
         /// </summary>
-        private const string IndentationString = "  ";
+        protected const string IndentationString = "  ";
 
         /// <summary>
         /// Scope of the Open API element - object, array, property.

src/Microsoft.OpenApi/Writers/OpenApiYamlWriter.cs

@@ -20,6 +20,8 @@ public OpenApiYamlWriter(TextWriter textWriter, OpenApiWriterSettings settings =
 
         }
 
+        public bool UseLiteralStyle { get; set; }
+
         /// <summary>
         /// Base Indentation Level.
         /// This denotes how many indentations are needed for the property in the base object.
@@ -156,11 +158,76 @@ public override void WritePropertyName(string name)
         /// <param name="value">The string value.</param>
         public override void WriteValue(string value)
         {
-            WriteValueSeparator();
+            if (!UseLiteralStyle || value.IndexOfAny(new [] { '\n', '\r' }) == -1)
+            {
+                WriteValueSeparator();
 
-            value = value.GetYamlCompatibleString();
+                value = value.GetYamlCompatibleString();
 
-            Writer.Write(value);
+                Writer.Write(value);
+            }
+            else
+            {
+                if (CurrentScope() != null)
+                {
+                    WriteValueSeparator();
+                }
+
+                Writer.Write("|");
+                
+                // Write chomping indicator when it ends with line break.
+                if (value.LastIndexOfAny(new []{'\n', '\r'}) == value.Length - 1)
+                {
+                    Writer.Write("+");
+                }
+                
+                // Write indentation indicator when it starts with spaces
+                if (value.StartsWith(" "))
+                {
+                    Writer.Write(IndentationString.Length);
+                }
+                
+                Writer.WriteLine();
+
+                IncreaseIndentation();
+
+                var start = 0;
+                while (start < value.Length && value.IndexOfAny(new [] {'\n', '\r'}, start) is var lineBreak)
+                {
+                    if (lineBreak == -1)
+                    {
+                        break;
+                    }
+
+                    // To preserves line break characters.
+                    var end = lineBreak;
+                    if (lineBreak + 1 < value.Length && value[lineBreak] == '\r' && value[lineBreak + 1] == '\n')
+                    { 
+                        // The line ends with "\r\n". YAML 1.2 specifies only three line breaks. "\r\n" | "\r" | "\n"
+                        end++;
+                    }
+                    
+                    if (lineBreak - start != 0)
+                    {
+                        // Indentation for empty lines aren't needed.
+                        WriteIndentation();
+                    }
+
+                    var line = value.Substring(start, end - start + 1);
+                    Writer.Write(line);
+
+                    start = end + 1;
+                }
+
+                // Last line
+                if (start < value.Length)
+                {
+                    WriteIndentation(); 
+                    Writer.Write(value.Substring(start));
+                }
+
+                DecreaseIndentation();
+            }
         }
 
         /// <summary>

test/Microsoft.OpenApi.Tests/Writers/OpenApiWriterSpecialCharacterTests.cs

@@ -75,5 +75,63 @@ public void WriteStringWithSpecialCharactersAsYamlWorks(string input, string exp
             // Assert
             actual.Should().Be(expected);
         }
+        
+        [Theory]
+        [InlineData("multiline\r\nstring", "test: |\n  multiline\r\n  string")]
+        [InlineData("multiline\nstring", "test: |\n  multiline\n  string")]
+        [InlineData("multiline\rstring", "test: |\n  multiline\r  string")]
+        [InlineData("multiline\n\rstring", "test: |\n  multiline\n\r  string")]
+        [InlineData("ends with\r\nline break\r\n", "test: |+\n  ends with\r\n  line break\r\n")]
+        [InlineData("ends with\nline break\n", "test: |+\n  ends with\n  line break\n")]
+        [InlineData("ends with\rline break\r", "test: |+\n  ends with\r  line break\r")]
+        [InlineData("ends with\n\rline break\n\r", "test: |+\n  ends with\n\r  line break\n\r")]
+        [InlineData("  starts with\nspaces", "test: |2\n    starts with\n  spaces")]
+        [InlineData("  starts with\nspaces, and ends with line break\n", "test: |+2\n    starts with\n  spaces, and ends with line break\n")]
+        [InlineData("contains\n\n\nempty lines", "test: |\n  contains\n\n\n  empty lines")]
+        [InlineData("no line breaks fallback ", "test: 'no line breaks fallback '")]
+        public void WriteStringWithNewlineCharactersInObjectAsYamlWorks(string input, string expected)
+        {
+            // Arrange
+            var outputStringWriter = new StringWriter(CultureInfo.InvariantCulture);
+            var writer = new OpenApiYamlWriter(outputStringWriter) { UseLiteralStyle = true, };
+
+            // Act
+            writer.WriteStartObject();
+            writer.WritePropertyName("test");
+            writer.WriteValue(input);
+            writer.WriteEndObject();
+            var actual = outputStringWriter.GetStringBuilder().ToString();
+
+            // Assert
+            actual.Should().Be(expected);
+        }
+        
+        [Theory]
+        [InlineData("multiline\r\nstring", "- |\n  multiline\r\n  string")]
+        [InlineData("multiline\nstring", "- |\n  multiline\n  string")]
+        [InlineData("multiline\rstring", "- |\n  multiline\r  string")]
+        [InlineData("multiline\n\rstring", "- |\n  multiline\n\r  string")]
+        [InlineData("ends with\r\nline break\r\n", "- |+\n  ends with\r\n  line break\r\n")]
+        [InlineData("ends with\nline break\n", "- |+\n  ends with\n  line break\n")]
+        [InlineData("ends with\rline break\r", "- |+\n  ends with\r  line break\r")]
+        [InlineData("ends with\n\rline break\n\r", "- |+\n  ends with\n\r  line break\n\r")]
+        [InlineData("  starts with\nspaces", "- |2\n    starts with\n  spaces")]
+        [InlineData("  starts with\nspaces, and ends with line break\n", "- |+2\n    starts with\n  spaces, and ends with line break\n")]
+        [InlineData("contains\n\n\nempty lines", "- |\n  contains\n\n\n  empty lines")]
+        [InlineData("no line breaks fallback ", "- 'no line breaks fallback '")]
+        public void WriteStringWithNewlineCharactersInArrayAsYamlWorks(string input, string expected)
+        {
+            // Arrange
+            var outputStringWriter = new StringWriter(CultureInfo.InvariantCulture);
+            var writer = new OpenApiYamlWriter(outputStringWriter) { UseLiteralStyle = true, };
+
+            // Act
+            writer.WriteStartArray();
+            writer.WriteValue(input);
+            var actual = outputStringWriter.GetStringBuilder().ToString();
+
+            // Assert
+            actual.Should().Be(expected);
+        }
     }
 }