kyaml: Implement escaping closer to YAML spec

It's unclear if we actually need this.  The round-trip test works
without it.

The spec describes escapes for things like space and forward-slash,
which seem wrong to escape, so I may be misreading it.

Author: thockin

kyaml/kyaml.go

@@ -237,33 +237,37 @@ const kyamlFoldStr = "\\\n"
 func (ky *Encoder) renderString(val string, indent int, flags flagMask, out io.Writer) error {
 	lazyQuote := flags&flagLazyQuote != 0
 	compact := flags&flagCompact != 0
+	multi := strings.Contains(val, "\n")
 
-	// If no newlines, just use standard Go quoting.
-	if compact || !strings.Contains(val, "\n") {
-		if lazyQuote && !needsQuotes(val) {
-			fmt.Fprint(out, val)
-		} else {
-			fmt.Fprint(out, strconv.Quote(val))
-		}
+	if !multi && lazyQuote && !needsQuotes(val) {
+		fmt.Fprint(out, val)
 		return nil
 	}
 
-	// The input has at least one newline. We will use YAML's line folding to
-	// make the output more readable.
+	// What to print when we find a newline in the input.
+	newline := "\\n"
+	if !compact {
+		// We use YAML's line folding to make the output more readable.
+		newline += kyamlFoldStr
+	}
+
 	//
 	// The rest of this is borrowed from Go's strconv.Quote implementation.
-
-	s := val
+	//
 
 	// accumulate into a buffer
 	buf := &bytes.Buffer{}
 
-	// opening quote and fold
-	fmt.Fprint(buf, `"`, kyamlFoldStr)
+	// opening quote
+	fmt.Fprint(buf, `"`)
+	if multi && !compact {
+		fmt.Fprint(buf, kyamlFoldStr)
+	}
 
 	// Iterating a string with invalid UTF8 returns RuneError rather than the
 	// bytes, so we iterate the string and decode the runes. This is a bit
 	// slower, but gives us a better result.
+	s := val
 	for width := 0; len(s) > 0; s = s[width:] {
 		r := rune(s[0])
 		width = 1
@@ -275,15 +279,17 @@ func (ky *Encoder) renderString(val string, indent int, flags flagMask, out io.W
 			fmt.Fprintf(buf, "%02x", s[0])
 			continue
 		}
-		ky.appendEscapedRune(r, indent, buf)
+		ky.appendEscapedRune(r, indent, newline, buf)
 	}
 
 	// closing quote
 	afterNewline := buf.Bytes()[len(buf.Bytes())-1] == '\n'
-	if !afterNewline {
-		fmt.Fprint(buf, kyamlFoldStr)
+	if multi && !compact {
+		if !afterNewline {
+			fmt.Fprint(buf, kyamlFoldStr)
+		}
+		ky.writeIndent(indent, buf)
 	}
-	ky.writeIndent(indent, buf)
 	fmt.Fprint(buf, `"`)
 
 	fmt.Fprint(out, buf.String())
@@ -433,7 +439,7 @@ func parseTimestamp(s string) (time.Time, bool) {
 }
 
 // We use a buffer here so we can peek backwards.
-func (ky *Encoder) appendEscapedRune(r rune, indent int, buf *bytes.Buffer) {
+func (ky *Encoder) appendEscapedRune(r rune, indent int, newline string, buf *bytes.Buffer) {
 	afterNewline := buf.Bytes()[len(buf.Bytes())-1] == '\n'
 
 	if afterNewline {
@@ -469,14 +475,25 @@ func (ky *Encoder) appendEscapedRune(r rune, indent int, buf *bytes.Buffer) {
 	case '\f':
 		buf.WriteString(`\f`)
 	case '\n':
-		buf.WriteString(`\n`)
-		buf.WriteString(kyamlFoldStr)
+		buf.WriteString(newline)
 	case '\r':
 		buf.WriteString(`\r`)
 	case '\t':
 		buf.WriteString(`\t`)
 	case '\v':
 		buf.WriteString(`\v`)
+	case '\x00':
+		buf.WriteString(`\0`)
+	case '\x1b':
+		buf.WriteString(`\e`)
+	case '\x85':
+		buf.WriteString(`\N`)
+	case '\xa0':
+		buf.WriteString(`\_`)
+	case '\u2028':
+		buf.WriteString(`\L`)
+	case '\u2029':
+		buf.WriteString(`\P`)
 	default:
 		const hexits = "0123456789abcdef"
 		switch {

kyaml/kyaml_test.go

@@ -1970,3 +1970,98 @@ func TestIsTypeAmbiguous(t *testing.T) {
 		})
 	}
 }
+
+func TestRenderStringEscapes(t *testing.T) {
+	simpleCases := []struct {
+		name   string
+		input  rune
+		expect string
+	}{{
+		name:   "backslash",
+		input:  '\\',
+		expect: `"\\"`,
+	}, {
+		name:   "dquote",
+		input:  '"',
+		expect: `"\""`,
+	}, {
+		name:   "bell",
+		input:  '\a',
+		expect: `"\a"`,
+	}, {
+		name:   "backspace",
+		input:  '\b',
+		expect: `"\b"`,
+	}, {
+		name:   "ff",
+		input:  '\f',
+		expect: `"\f"`,
+	}, {
+		name:   "nl",
+		input:  '\n',
+		expect: "\"\\\n \\n\\\n\"",
+	}, {
+		name:   "cr",
+		input:  '\r',
+		expect: `"\r"`,
+	}, {
+		name:   "tab",
+		input:  '\t',
+		expect: `"\t"`,
+	}, {
+		name:   "vtab",
+		input:  '\v',
+		expect: `"\v"`,
+	}, {
+		name:   "null",
+		input:  '\x00',
+		expect: `"\0"`,
+	}, {
+		name:   "esc",
+		input:  '\x1b',
+		expect: `"\e"`,
+	}, {
+		name:   "nextline",
+		input:  '\u0085',
+		expect: `"\N"`,
+	}, {
+		name:   "nbsp",
+		input:  '\u00a0',
+		expect: `"\_"`,
+	}, {
+		name:   "linesep",
+		input:  '\u2028',
+		expect: `"\L"`,
+	}, {
+		name:   "parasep",
+		input:  '\u2029',
+		expect: `"\P"`,
+	}, {
+		name:   "x01",
+		input:  '\x01',
+		expect: `"\x01"`,
+	}, {
+		name:   "uffff",
+		input:  '\uffff',
+		expect: `"\uffff"`,
+	}, {
+		name:   "U0010ffff",
+		input:  '\U0010ffff',
+		expect: `"\U0010ffff"`,
+	}}
+
+	for _, tt := range simpleCases {
+		t.Run(tt.name, func(t *testing.T) {
+			ky := &Encoder{}
+			buf := &bytes.Buffer{}
+			err := ky.renderString(string(tt.input), 0, 0, buf)
+			if err != nil {
+				t.Fatalf("renderString(%q) returned error: %v", tt.input, err)
+			}
+			if result := buf.String(); result != tt.expect {
+				t.Errorf("renderString(%q): want %q, got %q", tt.input, tt.expect, result)
+			}
+		})
+	}
+
+}