Fin.

cmd/root.go

@@ -3,7 +3,6 @@ package cmd
 import (
 	"os"
 
-	"github.com/mikefarah/yq/v4/pkg/yqlib"
 	"github.com/spf13/cobra"
 	logging "gopkg.in/op/go-logging.v1"
 )
@@ -38,8 +37,6 @@ 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,2 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<cat legs="4">BiBi</cat>
+  <?xml version="1.0" encoding="UTF-8"?>
+  <cat>3f</cat>
+  <dog>meow:as</dog>
+  <dog3>true</dog3>

pkg/yqlib/decode_xml_test.go

@@ -0,0 +1,110 @@
+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,13 +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 | 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:
@@ -274,64 +271,6 @@ 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,10 +14,8 @@ 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 |
+| XML | from_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,10 +1,8 @@
 # XML
 
-Encode and decode to and from XML. Whitespace is not conserved for round trips - but the order of the fields are.
+At the moment, `yq` only supports decoding `xml` (into one of the other supported output formats).
 
-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.
+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.
 
 All values in XML are assumed to be strings - but you can use `from_yaml` to parse them into their correct types:
 
@@ -12,12 +10,3 @@ 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,10 +1,8 @@
 # XML
 
-Encode and decode to and from XML. Whitespace is not conserved for round trips - but the order of the fields are.
+At the moment, `yq` only supports decoding `xml` (into one of the other supported output formats).
 
-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.
+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.
 
 All values in XML are assumed to be strings - but you can use `from_yaml` to parse them into their correct types:
 
@@ -13,15 +11,6 @@ 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
@@ -30,7 +19,7 @@ Given a sample.xml file of:
 ```
 then
 ```bash
-yq e -p=xml '.' sample.xml
+yq e sample.xml
 ```
 will output
 ```yaml
@@ -48,7 +37,7 @@ Given a sample.xml file of:
 ```
 then
 ```bash
-yq e -p=xml '.' sample.xml
+yq e sample.xml
 ```
 will output
 ```yaml
@@ -69,7 +58,7 @@ Given a sample.xml file of:
 ```
 then
 ```bash
-yq e -p=xml '.' sample.xml
+yq e sample.xml
 ```
 will output
 ```yaml
@@ -88,7 +77,7 @@ Given a sample.xml file of:
 ```
 then
 ```bash
-yq e -p=xml '.' sample.xml
+yq e sample.xml
 ```
 will output
 ```yaml
@@ -97,73 +86,3 @@ 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

@@ -1,146 +0,0 @@
-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,9 +322,6 @@ 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))
 
@@ -349,10 +346,6 @@ 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}))
@@ -366,9 +359,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(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(`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(`strload`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: true}))
 	lexer.Add([]byte(`load_str`), opTokenWithPrefs(loadOpType, nil, loadPrefs{loadAsString: true}))

pkg/yqlib/lib.go

@@ -13,13 +13,6 @@ 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(XmlPreferences.AttributePrefix, XmlPreferences.ContentName)
+		decoder = NewXmlDecoder("+a", "+content")
 	}
 
 	var results = list.New()

pkg/yqlib/operator_encoder_decoder_test.go

@@ -168,30 +168,6 @@ 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,7 +25,6 @@ const (
 	PropsOutputFormat
 	CsvOutputFormat
 	TsvOutputFormat
-	XmlOutputFormat
 )
 
 func OutputFormatFromString(format string) (PrinterOutputFormat, error) {
@@ -40,10 +39,8 @@ 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|xml]", format)
+		return 0, fmt.Errorf("unknown format '%v' please use [yaml|json|props|csv|tsv]", format)
 	}
 }
 
@@ -107,8 +104,6 @@ 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

@@ -1,192 +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}
-}
-
-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)
-}