Can encode in XML!

cmd/root.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"os"
 
+	"github.com/mikefarah/yq/v4/pkg/yqlib"
 	"github.com/spf13/cobra"
 	logging "gopkg.in/op/go-logging.v1"
 )
@@ -37,6 +38,8 @@ See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.`,
 			}
 
 			logging.SetBackend(backend)
+			yqlib.XmlPreferences.AttributePrefix = xmlAttributePrefix
+			yqlib.XmlPreferences.ContentName = xmlContentName
 		},
 	}
 

examples/mike.xml

@@ -1,4 +1,2 @@
-  <?xml version="1.0" encoding="UTF-8"?>
-  <cat>3f</cat>
-  <dog>meow:as</dog>
-  <dog3>true</dog3>
+<?xml version="1.0" encoding="UTF-8"?>
+<cat legs="4">BiBi</cat>

pkg/yqlib/decode_xml_test.go

@@ -1,110 +0,0 @@
-package yqlib
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/mikefarah/yq/v4/test"
-	yaml "gopkg.in/yaml.v3"
-)
-
-func decodeXml(t *testing.T, xml string) *CandidateNode {
-	decoder := NewXmlDecoder("+", "+content")
-
-	decoder.Init(strings.NewReader(xml))
-
-	node := &yaml.Node{}
-	err := decoder.Decode(node)
-	if err != nil {
-		t.Error(err, "fail to decode", xml)
-	}
-	return &CandidateNode{Node: node}
-}
-
-type xmlScenario struct {
-	inputXml       string
-	expected       string
-	description    string
-	subdescription string
-	skipDoc        bool
-}
-
-var xmlScenarios = []xmlScenario{
-	{
-		description: "Parse xml: simple",
-		inputXml:    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<cat>meow</cat>",
-		expected:    "D0, P[], (doc)::cat: meow\n",
-	},
-	{
-		description:    "Parse xml: array",
-		subdescription: "Consecutive nodes with identical xml names are assumed to be arrays.",
-		inputXml:       "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<animal>1</animal>\n<animal>2</animal>",
-		expected:       "D0, P[], (doc)::animal:\n    - \"1\"\n    - \"2\"\n",
-	},
-	{
-		description:    "Parse xml: attributes",
-		subdescription: "Attributes are converted to fields, with the attribute prefix.",
-		inputXml:       "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<cat legs=\"4\">\n  <legs>7</legs>\n</cat>",
-		expected:       "D0, P[], (doc)::cat:\n    +legs: \"4\"\n    legs: \"7\"\n",
-	},
-	{
-		description:    "Parse xml: attributes with content",
-		subdescription: "Content is added as a field, using the content name",
-		inputXml:       "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<cat legs=\"4\">meow</cat>",
-		expected:       "D0, P[], (doc)::cat:\n    +content: meow\n    +legs: \"4\"\n",
-	},
-}
-
-func testXmlScenario(t *testing.T, s *xmlScenario) {
-	var actual = resultToString(t, decodeXml(t, s.inputXml))
-	test.AssertResult(t, s.expected, actual)
-}
-
-func documentXmlScenario(t *testing.T, w *bufio.Writer, i interface{}) {
-	s := i.(xmlScenario)
-
-	if s.skipDoc {
-		return
-	}
-	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
-
-	if s.subdescription != "" {
-		writeOrPanic(w, s.subdescription)
-		writeOrPanic(w, "\n\n")
-	}
-
-	writeOrPanic(w, "Given a sample.xml file of:\n")
-	writeOrPanic(w, fmt.Sprintf("```xml\n%v\n```\n", s.inputXml))
-
-	writeOrPanic(w, "then\n")
-	writeOrPanic(w, "```bash\nyq e sample.xml\n```\n")
-	writeOrPanic(w, "will output\n")
-
-	var output bytes.Buffer
-	printer := NewPrinterWithSingleWriter(bufio.NewWriter(&output), YamlOutputFormat, true, false, 2, true)
-
-	node := decodeXml(t, s.inputXml)
-
-	err := printer.PrintResults(node.AsList())
-	if err != nil {
-		t.Error(err)
-		return
-	}
-
-	writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", output.String()))
-
-}
-
-func TestXmlScenarios(t *testing.T) {
-	for _, tt := range xmlScenarios {
-		testXmlScenario(t, &tt)
-	}
-	genericScenarios := make([]interface{}, len(xmlScenarios))
-	for i, s := range xmlScenarios {
-		genericScenarios[i] = s
-	}
-	documentScenarios(t, "usage", "xml", genericScenarios, documentXmlScenario)
-}

pkg/yqlib/doc/operators/encode-decode.md

@@ -14,10 +14,13 @@ These operators are useful to process yaml documents that have stringified embed
 | Properties |  | to_props/@props |
 | CSV |  | to_csv/@csv |
 | TSV |  | to_tsv/@tsv |
+| XML | from_xml | to_xml(i)/@xml |
 
 
 CSV and TSV format both accept either a single array or scalars (representing a single row), or an array of array of scalars (representing multiple rows). 
 
+XML uses the `--xml-attribute-prefix` and `xml-content-name` flags to identify attributes and content fields.
+
 
 ## Encode value as json string
 Given a sample.yml file of:
@@ -271,6 +274,64 @@ cat	thing1,thing2	true	3.40
 dog	thing3	false	12
 ```
 
+## Encode value as xml string
+Given a sample.yml file of:
+```yaml
+a:
+  cool:
+    foo: bar
+    +id: hi
+```
+then
+```bash
+yq eval '.a | to_xml' sample.yml
+```
+will output
+```yaml
+<cool id="hi">
+  <foo>bar</foo>
+</cool>
+
+```
+
+## Encode value as xml string on a single line
+Given a sample.yml file of:
+```yaml
+a:
+  cool:
+    foo: bar
+    +id: hi
+```
+then
+```bash
+yq eval '.a | @xml' sample.yml
+```
+will output
+```yaml
+<cool id="hi"><foo>bar</foo></cool>
+
+```
+
+## Encode value as xml string with custom indentation
+Given a sample.yml file of:
+```yaml
+a:
+  cool:
+    foo: bar
+    +id: hi
+```
+then
+```bash
+yq eval '{"cat": .a | to_xml(1)}' sample.yml
+```
+will output
+```yaml
+cat: |
+  <cool id="hi">
+   <foo>bar</foo>
+  </cool>
+```
+
 ## Decode a xml encoded string
 Given a sample.yml file of:
 ```yaml

pkg/yqlib/doc/operators/headers/encode-decode.md

@@ -14,8 +14,10 @@ These operators are useful to process yaml documents that have stringified embed
 | Properties |  | to_props/@props |
 | CSV |  | to_csv/@csv |
 | TSV |  | to_tsv/@tsv |
-| XML | from_xml |  |
+| XML | from_xml | to_xml(i)/@xml |
 
 
 CSV and TSV format both accept either a single array or scalars (representing a single row), or an array of array of scalars (representing multiple rows). 
 
+XML uses the `--xml-attribute-prefix` and `xml-content-name` flags to identify attributes and content fields.
+

pkg/yqlib/doc/usage/headers/xml.md

@@ -1,8 +1,10 @@
 # XML
 
-At the moment, `yq` only supports decoding `xml` (into one of the other supported output formats).
+Encode and decode to and from XML. Whitespace is not conserved for round trips - but the order of the fields are.
 
-As yaml does not have the concept of attributes, these are converted to regular fields with a prefix to prevent clobbering. Consecutive xml nodes with the same name are assumed to be arrays.
+As yaml does not have the concept of attributes, xml attributes are converted to regular fields with a prefix to prevent clobbering. This defaults to "+", use the `--xml-attribute-prefix` to change.
+
+Consecutive xml nodes with the same name are assumed to be arrays.
 
 All values in XML are assumed to be strings - but you can use `from_yaml` to parse them into their correct types:
 
@@ -10,3 +12,12 @@ All values in XML are assumed to be strings - but you can use `from_yaml` to par
 ```
 yq e -p=xml '.myNumberField |= from_yaml' my.xml
 ```
+
+
+XML nodes that have attributes then plain content, e.g:
+
+```xml
+<cat name="tiger">meow</cat>
+```
+
+The content of the node will be set as a field in the map with the key "+content". Use the `--xml-content-name` flag to change this.

pkg/yqlib/doc/usage/xml.md

@@ -1,8 +1,10 @@
 # XML
 
-At the moment, `yq` only supports decoding `xml` (into one of the other supported output formats).
+Encode and decode to and from XML. Whitespace is not conserved for round trips - but the order of the fields are.
 
-As yaml does not have the concept of attributes, these are converted to regular fields with a prefix to prevent clobbering. Consecutive xml nodes with the same name are assumed to be arrays.
+As yaml does not have the concept of attributes, xml attributes are converted to regular fields with a prefix to prevent clobbering. This defaults to "+", use the `--xml-attribute-prefix` to change.
+
+Consecutive xml nodes with the same name are assumed to be arrays.
 
 All values in XML are assumed to be strings - but you can use `from_yaml` to parse them into their correct types:
 
@@ -11,6 +13,15 @@ All values in XML are assumed to be strings - but you can use `from_yaml` to par
 yq e -p=xml '.myNumberField |= from_yaml' my.xml
 ```
 
+
+XML nodes that have attributes then plain content, e.g:
+
+```xml
+<cat name="tiger">meow</cat>
+```
+
+The content of the node will be set as a field in the map with the key "+content". Use the `--xml-content-name` flag to change this.
+
 ## Parse xml: simple
 Given a sample.xml file of:
 ```xml
@@ -19,7 +30,7 @@ Given a sample.xml file of:
 ```
 then
 ```bash
-yq e sample.xml
+yq e -p=xml '.' sample.xml
 ```
 will output
 ```yaml
@@ -37,7 +48,7 @@ Given a sample.xml file of:
 ```
 then
 ```bash
-yq e sample.xml
+yq e -p=xml '.' sample.xml
 ```
 will output
 ```yaml
@@ -58,7 +69,7 @@ Given a sample.xml file of:
 ```
 then
 ```bash
-yq e sample.xml
+yq e -p=xml '.' sample.xml
 ```
 will output
 ```yaml
@@ -77,7 +88,7 @@ Given a sample.xml file of:
 ```
 then
 ```bash
-yq e sample.xml
+yq e -p=xml '.' sample.xml
 ```
 will output
 ```yaml
@@ -86,3 +97,73 @@ cat:
   +legs: "4"
 ```
 
+## Encode xml: simple
+Given a sample.yml file of:
+```yaml
+cat: purrs
+```
+then
+```bash
+yq e -o=xml '.' sample.yml
+```
+will output
+```xml
+<cat>purrs</cat>```
+
+## Encode xml: array
+Given a sample.yml file of:
+```yaml
+pets:
+  cat:
+    - purrs
+    - meows
+```
+then
+```bash
+yq e -o=xml '.' sample.yml
+```
+will output
+```xml
+<pets>
+  <cat>purrs</cat>
+  <cat>meows</cat>
+</pets>```
+
+## Encode xml: attributes
+Fields with the matching xml-attribute-prefix are assumed to be attributes.
+
+Given a sample.yml file of:
+```yaml
+cat:
+  +name: tiger
+  meows: true
+
+```
+then
+```bash
+yq e -o=xml '.' sample.yml
+```
+will output
+```xml
+<cat name="tiger">
+  <meows>true</meows>
+</cat>```
+
+## Encode xml: attributes with content
+Fields with the matching xml-content-name is assumed to be content.
+
+Given a sample.yml file of:
+```yaml
+cat:
+  +name: tiger
+  +content: cool
+
+```
+then
+```bash
+yq e -o=xml '.' sample.yml
+```
+will output
+```xml
+<cat name="tiger">cool</cat>```
+

pkg/yqlib/encoder_xml.go

@@ -0,0 +1,146 @@
+package yqlib
+
+import (
+	"encoding/xml"
+	"fmt"
+	"io"
+	"strings"
+
+	yaml "gopkg.in/yaml.v3"
+)
+
+type xmlEncoder struct {
+	xmlEncoder      *xml.Encoder
+	attributePrefix string
+	contentName     string
+}
+
+func NewXmlEncoder(writer io.Writer, indent int, attributePrefix string, contentName string) Encoder {
+	encoder := xml.NewEncoder(writer)
+	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)
+}
+
+func (e *xmlEncoder) encodeTopLevelMap(node *yaml.Node) error {
+	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)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (e *xmlEncoder) doEncode(node *yaml.Node, start xml.StartElement) error {
+	switch node.Kind {
+	case yaml.MappingNode:
+		return e.encodeMap(node, start)
+	case yaml.SequenceNode:
+		return e.encodeArray(node, start)
+	case yaml.ScalarNode:
+		err := e.xmlEncoder.EncodeToken(start)
+		if err != nil {
+			return err
+		}
+
+		var charData xml.CharData = []byte(node.Value)
+		err = e.xmlEncoder.EncodeToken(charData)
+
+		if err != nil {
+			return err
+		}
+		return e.xmlEncoder.EncodeToken(start.End())
+	}
+	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())
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (e *xmlEncoder) encodeMap(node *yaml.Node, start xml.StartElement) error {
+
+	//first find all the attributes and put them on the start token
+	for i := 0; i < len(node.Content); i += 2 {
+		key := node.Content[i]
+		value := node.Content[i+1]
+
+		if strings.HasPrefix(key.Value, e.attributePrefix) && key.Value != e.contentName {
+			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)
+			}
+		}
+	}
+
+	err := e.xmlEncoder.EncodeToken(start)
+	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]
+
+		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)
+			if err != nil {
+				return err
+			}
+		} else if key.Value == e.contentName {
+			// directly encode the contents
+			var charData xml.CharData = []byte(value.Value)
+			err = e.xmlEncoder.EncodeToken(charData)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return e.xmlEncoder.EncodeToken(start.End())
+}

pkg/yqlib/expression_tokeniser.go

@@ -322,6 +322,9 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`toyaml\([0-9]+\)`), encodeWithIndent(YamlOutputFormat))
 	lexer.Add([]byte(`to_yaml\([0-9]+\)`), encodeWithIndent(YamlOutputFormat))
 
+	lexer.Add([]byte(`toxml\([0-9]+\)`), encodeWithIndent(XmlOutputFormat))
+	lexer.Add([]byte(`to_xml\([0-9]+\)`), encodeWithIndent(XmlOutputFormat))
+
 	lexer.Add([]byte(`tojson\([0-9]+\)`), encodeWithIndent(JsonOutputFormat))
 	lexer.Add([]byte(`to_json\([0-9]+\)`), encodeWithIndent(JsonOutputFormat))
 
@@ -346,6 +349,10 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`to_tsv`), opTokenWithPrefs(encodeOpType, nil, encoderPreferences{format: TsvOutputFormat}))
 	lexer.Add([]byte(`@tsv`), opTokenWithPrefs(encodeOpType, nil, encoderPreferences{format: TsvOutputFormat}))
 
+	lexer.Add([]byte(`toxml`), opTokenWithPrefs(encodeOpType, nil, encoderPreferences{format: XmlOutputFormat}))
+	lexer.Add([]byte(`to_xml`), opTokenWithPrefs(encodeOpType, nil, encoderPreferences{format: XmlOutputFormat, indent: 2}))
+	lexer.Add([]byte(`@xml`), opTokenWithPrefs(encodeOpType, nil, encoderPreferences{format: XmlOutputFormat, indent: 0}))
+
 	lexer.Add([]byte(`fromyaml`), opTokenWithPrefs(decodeOpType, nil, decoderPreferences{format: YamlInputFormat}))
 	lexer.Add([]byte(`fromjson`), opTokenWithPrefs(decodeOpType, nil, decoderPreferences{format: YamlInputFormat}))
 	lexer.Add([]byte(`fromxml`), opTokenWithPrefs(decodeOpType, nil, decoderPreferences{format: XmlInputFormat}))
@@ -359,9 +366,9 @@ func initLexer() (*lex.Lexer, error) {
 
 	lexer.Add([]byte(`load`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: false, decoder: NewYamlDecoder()}))
 
-	lexer.Add([]byte(`xmlload`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: false, decoder: NewXmlDecoder("+", "+content")}))
-	lexer.Add([]byte(`load_xml`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: false, decoder: NewXmlDecoder("+", "+content")}))
-	lexer.Add([]byte(`loadxml`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: false, decoder: NewXmlDecoder("+", "+content")}))
+	lexer.Add([]byte(`xmlload`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: false, decoder: NewXmlDecoder(XmlPreferences.AttributePrefix, XmlPreferences.ContentName)}))
+	lexer.Add([]byte(`load_xml`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: false, decoder: NewXmlDecoder(XmlPreferences.AttributePrefix, XmlPreferences.ContentName)}))
+	lexer.Add([]byte(`loadxml`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: false, decoder: NewXmlDecoder(XmlPreferences.AttributePrefix, XmlPreferences.ContentName)}))
 
 	lexer.Add([]byte(`strload`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: true}))
 	lexer.Add([]byte(`load_str`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: true}))

pkg/yqlib/lib.go

@@ -13,6 +13,13 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )
 
+type xmlPreferences struct {
+	AttributePrefix string
+	ContentName     string
+}
+
+var XmlPreferences = xmlPreferences{AttributePrefix: "+", ContentName: "+content"}
+
 var log = logging.MustGetLogger("yq-lib")
 
 // GetLogger returns the yq logger instance.

pkg/yqlib/operator_encoder_decoder.go

@@ -82,7 +82,7 @@ func decodeOperator(d *dataTreeNavigator, context Context, expressionNode *Expre
 	case YamlInputFormat:
 		decoder = NewYamlDecoder()
 	case XmlInputFormat:
-		decoder = NewXmlDecoder("+a", "+content")
+		decoder = NewXmlDecoder(XmlPreferences.AttributePrefix, XmlPreferences.ContentName)
 	}
 
 	var results = list.New()

pkg/yqlib/operator_encoder_decoder_test.go

@@ -168,6 +168,30 @@ var encoderDecoderOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::a: \"foo:\\n  a: frog\"\n",
 		},
 	},
+	{
+		description: "Encode value as xml string",
+		document:    `{a: {cool: {foo: "bar", +id: hi}}}`,
+		expression:  `.a | to_xml`,
+		expected: []string{
+			"D0, P[a], (!!str)::<cool id=\"hi\">\n  <foo>bar</foo>\n</cool>\n\n",
+		},
+	},
+	{
+		description: "Encode value as xml string on a single line",
+		document:    `{a: {cool: {foo: "bar", +id: hi}}}`,
+		expression:  `.a | @xml`,
+		expected: []string{
+			"D0, P[a], (!!str)::<cool id=\"hi\"><foo>bar</foo></cool>\n\n",
+		},
+	},
+	{
+		description: "Encode value as xml string with custom indentation",
+		document:    `{a: {cool: {foo: "bar", +id: hi}}}`,
+		expression:  `{"cat": .a | to_xml(1)}`,
+		expected: []string{
+			"D0, P[], (!!map)::cat: |\n    <cool id=\"hi\">\n     <foo>bar</foo>\n    </cool>\n",
+		},
+	},
 	{
 		description: "Decode a xml encoded string",
 		document:    `a: "<foo>bar</foo>"`,

pkg/yqlib/printer.go

@@ -25,6 +25,7 @@ const (
 	PropsOutputFormat
 	CsvOutputFormat
 	TsvOutputFormat
+	XmlOutputFormat
 )
 
 func OutputFormatFromString(format string) (PrinterOutputFormat, error) {
@@ -39,8 +40,10 @@ func OutputFormatFromString(format string) (PrinterOutputFormat, error) {
 		return CsvOutputFormat, nil
 	case "tsv", "t":
 		return TsvOutputFormat, nil
+	case "xml", "x":
+		return XmlOutputFormat, nil
 	default:
-		return 0, fmt.Errorf("unknown format '%v' please use [yaml|json|props|csv|tsv]", format)
+		return 0, fmt.Errorf("unknown format '%v' please use [yaml|json|props|csv|tsv|xml]", format)
 	}
 }
 
@@ -104,6 +107,8 @@ func (p *resultsPrinter) printNode(node *yaml.Node, writer io.Writer) error {
 		encoder = NewCsvEncoder(writer, '\t')
 	case YamlOutputFormat:
 		encoder = NewYamlEncoder(writer, p.indent, p.colorsEnabled)
+	case XmlOutputFormat:
+		encoder = NewXmlEncoder(writer, p.indent, XmlPreferences.AttributePrefix, XmlPreferences.ContentName)
 	}
 
 	return encoder.Encode(node)

pkg/yqlib/xml_test.go

@@ -0,0 +1,192 @@
+package yqlib
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/mikefarah/yq/v4/test"
+	yaml "gopkg.in/yaml.v3"
+)
+
+func decodeXml(t *testing.T, xml string) *CandidateNode {
+	decoder := NewXmlDecoder("+", "+content")
+
+	decoder.Init(strings.NewReader(xml))
+
+	node := &yaml.Node{}
+	err := decoder.Decode(node)
+	if err != nil {
+		t.Error(err, "fail to decode", xml)
+	}
+	return &CandidateNode{Node: node}
+}
+
+func yamlToXml(sampleYaml string, indent int) string {
+	var output bytes.Buffer
+	writer := bufio.NewWriter(&output)
+
+	var encoder = NewXmlEncoder(writer, indent, "+", "+content")
+	inputs, err := readDocuments(strings.NewReader(sampleYaml), "sample.yml", 0, NewYamlDecoder())
+	if err != nil {
+		panic(err)
+	}
+	node := inputs.Front().Value.(*CandidateNode).Node
+	err = encoder.Encode(node)
+	if err != nil {
+		panic(err)
+	}
+	writer.Flush()
+
+	return strings.TrimSuffix(output.String(), "\n")
+}
+
+type xmlScenario struct {
+	input          string
+	expected       string
+	description    string
+	subdescription string
+	skipDoc        bool
+	encodeScenario bool
+}
+
+var xmlScenarios = []xmlScenario{
+	{
+		description: "Parse xml: simple",
+		input:       "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<cat>meow</cat>",
+		expected:    "D0, P[], (doc)::cat: meow\n",
+	},
+	{
+		description:    "Parse xml: array",
+		subdescription: "Consecutive nodes with identical xml names are assumed to be arrays.",
+		input:          "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<animal>1</animal>\n<animal>2</animal>",
+		expected:       "D0, P[], (doc)::animal:\n    - \"1\"\n    - \"2\"\n",
+	},
+	{
+		description:    "Parse xml: attributes",
+		subdescription: "Attributes are converted to fields, with the attribute prefix.",
+		input:          "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<cat legs=\"4\">\n  <legs>7</legs>\n</cat>",
+		expected:       "D0, P[], (doc)::cat:\n    +legs: \"4\"\n    legs: \"7\"\n",
+	},
+	{
+		description:    "Parse xml: attributes with content",
+		subdescription: "Content is added as a field, using the content name",
+		input:          "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<cat legs=\"4\">meow</cat>",
+		expected:       "D0, P[], (doc)::cat:\n    +content: meow\n    +legs: \"4\"\n",
+	},
+	{
+		description:    "Encode xml: simple",
+		input:          "cat: purrs",
+		expected:       "<cat>purrs</cat>",
+		encodeScenario: true,
+	},
+	{
+		description:    "Encode xml: array",
+		input:          "pets:\n  cat:\n    - purrs\n    - meows",
+		expected:       "<pets>\n  <cat>purrs</cat>\n  <cat>meows</cat>\n</pets>",
+		encodeScenario: true,
+	},
+	{
+		description:    "Encode xml: attributes",
+		subdescription: "Fields with the matching xml-attribute-prefix are assumed to be attributes.",
+		input:          "cat:\n  +name: tiger\n  meows: true\n",
+		expected:       "<cat name=\"tiger\">\n  <meows>true</meows>\n</cat>",
+		encodeScenario: true,
+	},
+	{
+		skipDoc:        true,
+		input:          "cat:\n  ++name: tiger\n  meows: true\n",
+		expected:       "<cat +name=\"tiger\">\n  <meows>true</meows>\n</cat>",
+		encodeScenario: true,
+	},
+	{
+		description:    "Encode xml: attributes with content",
+		subdescription: "Fields with the matching xml-content-name is assumed to be content.",
+		input:          "cat:\n  +name: tiger\n  +content: cool\n",
+		expected:       "<cat name=\"tiger\">cool</cat>",
+		encodeScenario: true,
+	},
+}
+
+func testXmlScenario(t *testing.T, s *xmlScenario) {
+	if s.encodeScenario {
+		test.AssertResultWithContext(t, s.expected, yamlToXml(s.input, 2), s.description)
+	} else {
+		var actual = resultToString(t, decodeXml(t, s.input))
+		test.AssertResultWithContext(t, s.expected, actual, s.description)
+	}
+}
+
+func documentXmlScenario(t *testing.T, w *bufio.Writer, i interface{}) {
+	s := i.(xmlScenario)
+
+	if s.skipDoc {
+		return
+	}
+	if s.encodeScenario {
+		documentXmlEncodeScenario(w, s)
+	} else {
+		documentXmlDecodeScenario(t, w, s)
+	}
+
+}
+
+func documentXmlDecodeScenario(t *testing.T, w *bufio.Writer, s xmlScenario) {
+	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
+
+	if s.subdescription != "" {
+		writeOrPanic(w, s.subdescription)
+		writeOrPanic(w, "\n\n")
+	}
+
+	writeOrPanic(w, "Given a sample.xml file of:\n")
+	writeOrPanic(w, fmt.Sprintf("```xml\n%v\n```\n", s.input))
+
+	writeOrPanic(w, "then\n")
+	writeOrPanic(w, "```bash\nyq e -p=xml '.' sample.xml\n```\n")
+	writeOrPanic(w, "will output\n")
+
+	var output bytes.Buffer
+	printer := NewPrinterWithSingleWriter(bufio.NewWriter(&output), YamlOutputFormat, true, false, 2, true)
+
+	node := decodeXml(t, s.input)
+
+	err := printer.PrintResults(node.AsList())
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", output.String()))
+}
+
+func documentXmlEncodeScenario(w *bufio.Writer, s xmlScenario) {
+	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
+
+	if s.subdescription != "" {
+		writeOrPanic(w, s.subdescription)
+		writeOrPanic(w, "\n\n")
+	}
+
+	writeOrPanic(w, "Given a sample.yml file of:\n")
+	writeOrPanic(w, fmt.Sprintf("```yaml\n%v\n```\n", s.input))
+
+	writeOrPanic(w, "then\n")
+	writeOrPanic(w, "```bash\nyq e -o=xml '.' sample.yml\n```\n")
+	writeOrPanic(w, "will output\n")
+
+	writeOrPanic(w, fmt.Sprintf("```xml\n%v```\n\n", yamlToXml(s.input, 2)))
+}
+
+func TestXmlScenarios(t *testing.T) {
+	for _, tt := range xmlScenarios {
+		testXmlScenario(t, &tt)
+	}
+	genericScenarios := make([]interface{}, len(xmlScenarios))
+	for i, s := range xmlScenarios {
+		genericScenarios[i] = s
+	}
+	documentScenarios(t, "usage", "xml", genericScenarios, documentXmlScenario)
+}