Added XML encoding/decoding (#1067)

* Added XML encoding/decoding * Minor fixes * Improve yq doc * Lint
2026-08-24 08:22:13 +08:00 · 2022-01-15 11:57:59 +11:00
parent 606ef91cc6
commit ec8ef312ef
30 changed files with 1005 additions and 351 deletions
@@ -9,89 +9,155 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

+var XmlPreferences = xmlPreferences{AttributePrefix: "+", ContentName: "+content"}
+
 type xmlEncoder struct {
-	xmlEncoder      *xml.Encoder
 	attributePrefix string
 	contentName     string
+	indentString    string
 }

-func NewXmlEncoder(writer io.Writer, indent int, attributePrefix string, contentName string) Encoder {
-	encoder := xml.NewEncoder(writer)
+func NewXmlEncoder(indent int, attributePrefix string, contentName string) Encoder {
 	var indentString = ""

 	for index := 0; index < indent; index++ {
 		indentString = indentString + " "
 	}
-	encoder.Indent("", indentString)
-	return &xmlEncoder{encoder, attributePrefix, contentName}
-}
-func (e *xmlEncoder) Encode(node *yaml.Node) error {
-	switch node.Kind {
-	case yaml.MappingNode:
-		err := e.encodeTopLevelMap(node)
-		if err != nil {
-			return err
-		}
-		var charData xml.CharData = []byte("\n")
-		err = e.xmlEncoder.EncodeToken(charData)
-		if err != nil {
-			return err
-		}
-		return e.xmlEncoder.Flush()
-	case yaml.DocumentNode:
-		return e.Encode(unwrapDoc(node))
-	case yaml.ScalarNode:
-		var charData xml.CharData = []byte(node.Value)
-		err := e.xmlEncoder.EncodeToken(charData)
-		if err != nil {
-			return err
-		}
-		return e.xmlEncoder.Flush()
-	}
-	return fmt.Errorf("unsupported type %v", node.Tag)
+	return &xmlEncoder{attributePrefix, contentName, indentString}
 }

-func (e *xmlEncoder) encodeTopLevelMap(node *yaml.Node) error {
+func (e *xmlEncoder) CanHandleAliases() bool {
+	return false
+}
+
+func (e *xmlEncoder) PrintDocumentSeparator(writer io.Writer) error {
+	return nil
+}
+
+func (e *xmlEncoder) PrintLeadingContent(writer io.Writer, content string) error {
+	return nil
+}
+
+func (e *xmlEncoder) Encode(writer io.Writer, node *yaml.Node) error {
+	encoder := xml.NewEncoder(writer)
+	encoder.Indent("", e.indentString)
+
+	switch node.Kind {
+	case yaml.MappingNode:
+		err := e.encodeTopLevelMap(encoder, node)
+		if err != nil {
+			return err
+		}
+	case yaml.DocumentNode:
+		err := e.encodeComment(encoder, headAndLineComment(node))
+		if err != nil {
+			return err
+		}
+		err = e.encodeTopLevelMap(encoder, unwrapDoc(node))
+		if err != nil {
+			return err
+		}
+		err = e.encodeComment(encoder, footComment(node))
+		if err != nil {
+			return err
+		}
+	case yaml.ScalarNode:
+		var charData xml.CharData = []byte(node.Value)
+		err := encoder.EncodeToken(charData)
+		if err != nil {
+			return err
+		}
+		return encoder.Flush()
+	default:
+		return fmt.Errorf("unsupported type %v", node.Tag)
+	}
+	var charData xml.CharData = []byte("\n")
+	return encoder.EncodeToken(charData)
+
+}
+
+func (e *xmlEncoder) encodeTopLevelMap(encoder *xml.Encoder, node *yaml.Node) error {
+	err := e.encodeComment(encoder, headAndLineComment(node))
+	if err != nil {
+		return err
+	}
 	for i := 0; i < len(node.Content); i += 2 {
 		key := node.Content[i]
 		value := node.Content[i+1]

 		start := xml.StartElement{Name: xml.Name{Local: key.Value}}
-		err := e.doEncode(value, start)
+		log.Debugf("comments of key %v", key.Value)
+		err := e.encodeComment(encoder, headAndLineComment(key))
+		if err != nil {
+			return err
+		}
+
+		log.Debugf("recursing")
+
+		err = e.doEncode(encoder, value, start)
+		if err != nil {
+			return err
+		}
+		err = e.encodeComment(encoder, footComment(key))
 		if err != nil {
 			return err
 		}
 	}
-	return nil
+	return e.encodeComment(encoder, footComment(node))
 }

-func (e *xmlEncoder) doEncode(node *yaml.Node, start xml.StartElement) error {
+func (e *xmlEncoder) encodeStart(encoder *xml.Encoder, node *yaml.Node, start xml.StartElement) error {
+	err := encoder.EncodeToken(start)
+	if err != nil {
+		return err
+	}
+	return e.encodeComment(encoder, headComment(node))
+}
+
+func (e *xmlEncoder) encodeEnd(encoder *xml.Encoder, node *yaml.Node, start xml.StartElement) error {
+	err := encoder.EncodeToken(start.End())
+	if err != nil {
+		return err
+	}
+	return e.encodeComment(encoder, footComment(node))
+}
+
+func (e *xmlEncoder) doEncode(encoder *xml.Encoder, node *yaml.Node, start xml.StartElement) error {
 	switch node.Kind {
 	case yaml.MappingNode:
-		return e.encodeMap(node, start)
+		return e.encodeMap(encoder, node, start)
 	case yaml.SequenceNode:
-		return e.encodeArray(node, start)
+		return e.encodeArray(encoder, node, start)
 	case yaml.ScalarNode:
-		err := e.xmlEncoder.EncodeToken(start)
+		err := e.encodeStart(encoder, node, start)
 		if err != nil {
 			return err
 		}

 		var charData xml.CharData = []byte(node.Value)
-		err = e.xmlEncoder.EncodeToken(charData)
-
+		err = encoder.EncodeToken(charData)
 		if err != nil {
 			return err
 		}
-		return e.xmlEncoder.EncodeToken(start.End())
+
+		if err = e.encodeComment(encoder, lineComment(node)); err != nil {
+			return err
+		}
+
+		return e.encodeEnd(encoder, node, start)
 	}
 	return fmt.Errorf("unsupported type %v", node.Tag)
 }

-func (e *xmlEncoder) encodeArray(node *yaml.Node, start xml.StartElement) error {
-	for i := 0; i < len(node.Content); i++ {
-		value := node.Content[i]
-		err := e.doEncode(value, start.Copy())
+func (e *xmlEncoder) encodeComment(encoder *xml.Encoder, commentStr string) error {
+	if commentStr != "" {
+		log.Debugf("encoding comment %v", commentStr)
+		if !strings.HasSuffix(commentStr, " ") {
+			commentStr = commentStr + " "
+		}
+
+		var comment xml.Comment = []byte(commentStr)
+		err := encoder.EncodeToken(comment)
 		if err != nil {
 			return err
 		}
@@ -99,7 +165,23 @@ func (e *xmlEncoder) encodeArray(node *yaml.Node, start xml.StartElement) error
 	return nil
 }

-func (e *xmlEncoder) encodeMap(node *yaml.Node, start xml.StartElement) error {
+func (e *xmlEncoder) encodeArray(encoder *xml.Encoder, node *yaml.Node, start xml.StartElement) error {
+
+	if err := e.encodeComment(encoder, headAndLineComment(node)); err != nil {
+		return err
+	}
+
+	for i := 0; i < len(node.Content); i++ {
+		value := node.Content[i]
+		if err := e.doEncode(encoder, value, start.Copy()); err != nil {
+			return err
+		}
+	}
+	return e.encodeComment(encoder, footComment(node))
+}
+
+func (e *xmlEncoder) encodeMap(encoder *xml.Encoder, node *yaml.Node, start xml.StartElement) error {
+	log.Debug("its a map")

 	//first find all the attributes and put them on the start token
 	for i := 0; i < len(node.Content); i += 2 {
@@ -116,7 +198,7 @@ func (e *xmlEncoder) encodeMap(node *yaml.Node, start xml.StartElement) error {
 		}
 	}

-	err := e.xmlEncoder.EncodeToken(start)
+	err := e.encodeStart(encoder, node, start)
 	if err != nil {
 		return err
 	}
@@ -126,21 +208,38 @@ func (e *xmlEncoder) encodeMap(node *yaml.Node, start xml.StartElement) error {
 		key := node.Content[i]
 		value := node.Content[i+1]

+		err := e.encodeComment(encoder, headAndLineComment(key))
+		if err != nil {
+			return err
+		}
+
 		if !strings.HasPrefix(key.Value, e.attributePrefix) && key.Value != e.contentName {
 			start := xml.StartElement{Name: xml.Name{Local: key.Value}}
-			err := e.doEncode(value, start)
+			err := e.doEncode(encoder, value, start)
 			if err != nil {
 				return err
 			}
 		} else if key.Value == e.contentName {
 			// directly encode the contents
+			err = e.encodeComment(encoder, headAndLineComment(value))
+			if err != nil {
+				return err
+			}
 			var charData xml.CharData = []byte(value.Value)
-			err = e.xmlEncoder.EncodeToken(charData)
+			err = encoder.EncodeToken(charData)
+			if err != nil {
+				return err
+			}
+			err = e.encodeComment(encoder, footComment(value))
 			if err != nil {
 				return err
 			}
 		}
+		err = e.encodeComment(encoder, footComment(key))
+		if err != nil {
+			return err
+		}
 	}

-	return e.xmlEncoder.EncodeToken(start.End())
+	return e.encodeEnd(encoder, node, start)
 }