yq/pkg/yqlib/encoder_xml.go

246 lines
6.0 KiB
Go
Raw Normal View History

2021-12-21 04:56:08 +00:00
package yqlib
import (
"encoding/xml"
"fmt"
"io"
2021-12-21 05:08:37 +00:00
"strings"
2021-12-21 04:56:08 +00:00
yaml "gopkg.in/yaml.v3"
)
var XmlPreferences = xmlPreferences{AttributePrefix: "+", ContentName: "+content"}
2021-12-21 04:56:08 +00:00
type xmlEncoder struct {
2021-12-21 05:08:37 +00:00
attributePrefix string
2021-12-21 05:19:27 +00:00
contentName string
indentString string
2021-12-21 04:56:08 +00:00
}
func NewXmlEncoder(indent int, attributePrefix string, contentName string) Encoder {
2021-12-21 04:56:08 +00:00
var indentString = ""
for index := 0; index < indent; index++ {
indentString = indentString + " "
}
return &xmlEncoder{attributePrefix, contentName, indentString}
}
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
2021-12-21 04:56:08 +00:00
}
func (e *xmlEncoder) Encode(writer io.Writer, node *yaml.Node) error {
encoder := xml.NewEncoder(writer)
encoder.Indent("", e.indentString)
2021-12-21 04:56:08 +00:00
switch node.Kind {
case yaml.MappingNode:
err := e.encodeTopLevelMap(encoder, node)
2021-12-21 05:52:54 +00:00
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))
2021-12-21 05:52:54 +00:00
if err != nil {
return err
}
2021-12-21 04:56:08 +00:00
case yaml.ScalarNode:
var charData xml.CharData = []byte(node.Value)
err := encoder.EncodeToken(charData)
2021-12-21 05:52:54 +00:00
if err != nil {
return err
}
return encoder.Flush()
default:
return fmt.Errorf("unsupported type %v", node.Tag)
2021-12-21 04:56:08 +00:00
}
var charData xml.CharData = []byte("\n")
return encoder.EncodeToken(charData)
2021-12-21 04:56:08 +00:00
}
func (e *xmlEncoder) encodeTopLevelMap(encoder *xml.Encoder, node *yaml.Node) error {
err := e.encodeComment(encoder, headAndLineComment(node))
if err != nil {
return err
}
2021-12-21 05:08:37 +00:00
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}}
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))
2021-12-21 04:56:08 +00:00
if err != nil {
return err
}
2021-12-21 05:08:37 +00:00
}
return e.encodeComment(encoder, footComment(node))
}
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))
2021-12-21 05:08:37 +00:00
}
func (e *xmlEncoder) doEncode(encoder *xml.Encoder, node *yaml.Node, start xml.StartElement) error {
2021-12-21 05:08:37 +00:00
switch node.Kind {
case yaml.MappingNode:
return e.encodeMap(encoder, node, start)
2021-12-21 04:56:08 +00:00
case yaml.SequenceNode:
return e.encodeArray(encoder, node, start)
2021-12-21 04:56:08 +00:00
case yaml.ScalarNode:
err := e.encodeStart(encoder, node, start)
2021-12-21 04:56:08 +00:00
if err != nil {
return err
}
var charData xml.CharData = []byte(node.Value)
err = encoder.EncodeToken(charData)
2021-12-21 04:56:08 +00:00
if err != nil {
return err
}
if err = e.encodeComment(encoder, lineComment(node)); err != nil {
return err
}
return e.encodeEnd(encoder, node, start)
2021-12-21 04:56:08 +00:00
}
return fmt.Errorf("unsupported type %v", node.Tag)
}
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)
2021-12-21 04:56:08 +00:00
if err != nil {
return err
}
}
return nil
}
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")
2021-12-21 05:08:37 +00:00
//first find all the attributes and put them on the start token
2021-12-21 04:56:08 +00:00
for i := 0; i < len(node.Content); i += 2 {
key := node.Content[i]
value := node.Content[i+1]
2021-12-21 05:19:27 +00:00
if strings.HasPrefix(key.Value, e.attributePrefix) && key.Value != e.contentName {
2021-12-21 05:08:37 +00:00
if value.Kind == yaml.ScalarNode {
attributeName := strings.Replace(key.Value, e.attributePrefix, "", 1)
start.Attr = append(start.Attr, xml.Attr{Name: xml.Name{Local: attributeName}, Value: value.Value})
} else {
return fmt.Errorf("cannot use %v as attribute, only scalars are supported", value.Tag)
}
2021-12-21 04:56:08 +00:00
}
}
2021-12-21 05:08:37 +00:00
err := e.encodeStart(encoder, node, start)
2021-12-21 05:08:37 +00:00
if err != nil {
return err
}
//now we encode non attribute tokens
for i := 0; i < len(node.Content); i += 2 {
key := node.Content[i]
value := node.Content[i+1]
err := e.encodeComment(encoder, headAndLineComment(key))
if err != nil {
return err
}
2021-12-21 05:19:27 +00:00
if !strings.HasPrefix(key.Value, e.attributePrefix) && key.Value != e.contentName {
2021-12-21 05:08:37 +00:00
start := xml.StartElement{Name: xml.Name{Local: key.Value}}
err := e.doEncode(encoder, value, start)
2021-12-21 05:08:37 +00:00
if err != nil {
return err
}
2021-12-21 05:19:27 +00:00
} else if key.Value == e.contentName {
// directly encode the contents
err = e.encodeComment(encoder, headAndLineComment(value))
if err != nil {
return err
}
2021-12-21 05:19:27 +00:00
var charData xml.CharData = []byte(value.Value)
err = encoder.EncodeToken(charData)
2021-12-21 05:19:27 +00:00
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
2021-12-21 05:08:37 +00:00
}
}
return e.encodeEnd(encoder, node, start)
2021-12-21 04:56:08 +00:00
}