mirror of
https://github.com/mikefarah/yq.git
synced 2026-06-29 16:41:45 +00:00
be5d5da882
When UnwrapScalar is enabled (the default for yaml output), the yaml encoder writes node.Value verbatim as a bare line. Any string whose content is itself a valid YAML mapping, sequence, or alias then round trips as that container instead of as a string. For example, the input document `"this: should really work"` previously re-emitted as the bare line `this: should really work`, which the next reader parses as a one key map, destroying the original scalar. The same problem surfaces whenever a multiline string literal happens to contain `key: value` lines, which is the form the bug report uses for its second reproducer. Guard the fast-path by re-parsing node.Value with yaml.v4: if the bare form decodes to a non-scalar, fall through to the regular encoder so it can apply the quoting style required by the YAML spec. The check is limited to `!!str` nodes and to structural reinterpretations, so tag expressions such as `!!int` and plain strings that re-read as integers, booleans, or nulls are unaffected. An unparseable value (e.g. one containing NUL) stays on the fast-path so downstream NUL-aware writers still see the raw bytes. Updates the base64 "decode yaml document" scenario whose expected output was `a: apple\n` bare; it is now emitted as a block literal, which round-trips back to the same string. Reproducer: ``` printf '"this: should really work"\n' | yq -p yaml -o yaml ``` Before this fix the second run of yq parses the output as a map; after, it remains the original string. Fixes #2608
106 lines
2.9 KiB
Go
106 lines
2.9 KiB
Go
package yqlib
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"strings"
|
|
|
|
"go.yaml.in/yaml/v4"
|
|
)
|
|
|
|
type yamlEncoder struct {
|
|
prefs YamlPreferences
|
|
}
|
|
|
|
func NewYamlEncoder(prefs YamlPreferences) Encoder {
|
|
return &yamlEncoder{prefs}
|
|
}
|
|
|
|
func (ye *yamlEncoder) CanHandleAliases() bool {
|
|
return true
|
|
}
|
|
|
|
func (ye *yamlEncoder) PrintDocumentSeparator(writer io.Writer) error {
|
|
return PrintYAMLDocumentSeparator(writer, ye.prefs.PrintDocSeparators)
|
|
}
|
|
|
|
func (ye *yamlEncoder) PrintLeadingContent(writer io.Writer, content string) error {
|
|
return PrintYAMLLeadingContent(writer, content, ye.prefs.PrintDocSeparators, ye.prefs.ColorsEnabled)
|
|
}
|
|
|
|
func (ye *yamlEncoder) Encode(writer io.Writer, node *CandidateNode) error {
|
|
log.Debugf("encoderYaml - going to print %v", NodeToString(node))
|
|
// Detect line ending style from LeadingContent
|
|
lineEnding := "\n"
|
|
if strings.Contains(node.LeadingContent, "\r\n") {
|
|
lineEnding = "\r\n"
|
|
}
|
|
if node.Kind == ScalarNode && ye.prefs.UnwrapScalar && !bareStringNeedsQuoting(node) {
|
|
valueToPrint := node.Value
|
|
if node.LeadingContent == "" || valueToPrint != "" {
|
|
valueToPrint = valueToPrint + lineEnding
|
|
}
|
|
return writeString(writer, valueToPrint)
|
|
}
|
|
|
|
destination := writer
|
|
tempBuffer := bytes.NewBuffer(nil)
|
|
if ye.prefs.ColorsEnabled {
|
|
destination = tempBuffer
|
|
}
|
|
|
|
var encoder = yaml.NewEncoder(destination)
|
|
|
|
encoder.SetIndent(ye.prefs.Indent)
|
|
if ye.prefs.CompactSequenceIndent {
|
|
encoder.CompactSeqIndent()
|
|
}
|
|
|
|
target, err := node.MarshalYAML()
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
trailingContent := target.FootComment
|
|
target.FootComment = ""
|
|
|
|
if err := encoder.Encode(target); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := ye.PrintLeadingContent(destination, trailingContent); err != nil {
|
|
return err
|
|
}
|
|
|
|
if ye.prefs.ColorsEnabled {
|
|
return colorizeAndPrint(tempBuffer.Bytes(), writer)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// bareStringNeedsQuoting reports whether a top-level string scalar would be
|
|
// structurally reinterpreted if emitted as an unquoted bare value. The
|
|
// unwrap-scalar fast-path writes node.Value verbatim, which silently turns a
|
|
// string like "this: should really work" into a mapping on the next read, or
|
|
// "- item" into a sequence. When this returns true the caller falls through
|
|
// to the full yaml encoder, which applies the quoting style required by the
|
|
// YAML spec. Scalar-to-scalar reinterpretations (e.g. "123" parsing as an int
|
|
// tag) are not covered here: they preserve the node shape and are handled by
|
|
// callers that care about explicit tag preservation.
|
|
func bareStringNeedsQuoting(node *CandidateNode) bool {
|
|
if node.Tag != "!!str" {
|
|
return false
|
|
}
|
|
var parsed yaml.Node
|
|
if err := yaml.Unmarshal([]byte(node.Value), &parsed); err != nil {
|
|
// Unparseable bare form (e.g. control characters): leave it on the
|
|
// fast-path so callers that check for those characters still see them.
|
|
return false
|
|
}
|
|
if parsed.Kind != yaml.DocumentNode || len(parsed.Content) != 1 {
|
|
return false
|
|
}
|
|
return parsed.Content[0].Kind != yaml.ScalarNode
|
|
}
|