package yqlib import ( "bufio" "bytes" "fmt" "strings" "testing" "github.com/mikefarah/yq/v4/test" yaml "gopkg.in/yaml.v3" ) func decodeXml(t *testing.T, s formatScenario) *CandidateNode { decoder := NewXmlDecoder("+", "+content") decoder.Init(strings.NewReader(s.input)) node := &yaml.Node{} err := decoder.Decode(node) if err != nil { t.Error(err, "fail to decode", s.input) } expression := s.expression if expression == "" { expression = "." } exp, err := NewExpressionParser().ParseExpression(expression) if err != nil { t.Error(err) return nil } candidateNode := CandidateNode{Node: node} context, err := NewDataTreeNavigator().GetMatchingNodes(Context{MatchingNodes: candidateNode.AsList()}, exp) if err != nil { t.Error(err) return nil } return context.MatchingNodes.Front().Value.(*CandidateNode) } func processXmlScenario(s formatScenario) string { var output bytes.Buffer writer := bufio.NewWriter(&output) var encoder = NewXmlEncoder(2, "+", "+content") var decoder = NewYamlDecoder() if s.scenarioType == "roundtrip" { decoder = NewXmlDecoder("+", "+content") } inputs, err := readDocuments(strings.NewReader(s.input), "sample.yml", 0, decoder) if err != nil { panic(err) } node := inputs.Front().Value.(*CandidateNode).Node err = encoder.Encode(writer, node) if err != nil { panic(err) } writer.Flush() return output.String() } type formatScenario struct { input string indent int expression string expected string description string subdescription string skipDoc bool scenarioType string } var inputXmlWithComments = ` 3 z ` var inputXmlWithCommentsWithSubChild = ` 3 ` var expectedDecodeYamlWithSubChild = `D0, P[], (doc)::# before cat cat: # in cat before x: "3" # multi # line comment # for x # before y y: # in y before d: # in d before z: +sweet: cool # in d after # in y after # in_cat_after # after cat ` var inputXmlWithCommentsWithArray = ` 3 ` var expectedDecodeYamlWithArray = `D0, P[], (doc)::# before cat cat: # in cat before x: "3" # multi # line comment # for x # before y y: # in y before d: - # in d before z: +sweet: cool # in d after - # in d2 before z: +sweet: cool2 # in d2 after # in y after # in_cat_after # after cat ` var expectedDecodeYamlWithComments = `D0, P[], (doc)::# before cat cat: # in cat before x: "3" # multi # line comment # for x # before y y: # in y before # in d before d: z # in d after # in y after # in_cat_after # after cat ` var expectedRoundtripXmlWithComments = ` 3 z ` var yamlWithComments = `# above_cat cat: # inline_cat # above_array array: # inline_array - val1 # inline_val1 # above_val2 - val2 # inline_val2 # below_cat ` var expectedXmlWithComments = ` val1 val2 ` var xmlScenarios = []formatScenario{ { description: "Parse xml: simple", subdescription: "Notice how all the values are strings, see the next example on how you can fix that.", input: "\n\n meow\n 4\n true\n", expected: "D0, P[], (doc)::cat:\n says: meow\n legs: \"4\"\n cute: \"true\"\n", }, { description: "Parse xml: number", subdescription: "All values are assumed to be strings when parsing XML, but you can use the `from_yaml` operator on all the strings values to autoparse into the correct type.", input: "\n\n meow\n 4\n true\n", expression: " (.. | select(tag == \"!!str\")) |= from_yaml", expected: "D0, P[], ()::cat:\n says: meow\n legs: 4\n cute: true\n", }, { description: "Parse xml: array", subdescription: "Consecutive nodes with identical xml names are assumed to be arrays.", input: "\ncat\ngoat", expected: "D0, P[], (doc)::animal:\n - cat\n - goat\n", }, { description: "Parse xml: attributes", subdescription: "Attributes are converted to fields, with the default attribute prefix '+'. Use '--xml-attribute-prefix` to set your own.", input: "\n\n 7\n", 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 default content name of `+content`. Use `--xml-content-name` to set your own.", input: "\nmeow", expected: "D0, P[], (doc)::cat:\n +content: meow\n +legs: \"4\"\n", }, { description: "Parse xml: with comments", subdescription: "A best attempt is made to preserve comments.", input: inputXmlWithComments, expected: expectedDecodeYamlWithComments, scenarioType: "decode", }, { description: "Parse xml: with comments subchild", skipDoc: true, input: inputXmlWithCommentsWithSubChild, expected: expectedDecodeYamlWithSubChild, scenarioType: "decode", }, { description: "Parse xml: with comments array", skipDoc: true, input: inputXmlWithCommentsWithArray, expected: expectedDecodeYamlWithArray, scenarioType: "decode", }, { description: "Encode xml: simple", input: "cat: purrs", expected: "purrs\n", scenarioType: "encode", }, { description: "Encode xml: array", input: "pets:\n cat:\n - purrs\n - meows", expected: "\n purrs\n meows\n\n", scenarioType: "encode", }, { 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: "\n true\n\n", scenarioType: "encode", }, { skipDoc: true, input: "cat:\n ++name: tiger\n meows: true\n", expected: "\n true\n\n", scenarioType: "encode", }, { 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: "cool\n", scenarioType: "encode", }, { description: "Encode xml: comments", subdescription: "A best attempt is made to copy comments to xml.", input: yamlWithComments, expected: expectedXmlWithComments, scenarioType: "encode", }, { description: "Round trip: with comments", subdescription: "A best effort is made, but comment positions and white space are not preserved perfectly.", input: inputXmlWithComments, expected: expectedRoundtripXmlWithComments, scenarioType: "roundtrip", }, } func testXmlScenario(t *testing.T, s formatScenario) { if s.scenarioType == "encode" || s.scenarioType == "roundtrip" { test.AssertResultWithContext(t, s.expected, processXmlScenario(s), s.description) } else { var actual = resultToString(t, decodeXml(t, s)) test.AssertResultWithContext(t, s.expected, actual, s.description) } } func documentXmlScenario(t *testing.T, w *bufio.Writer, i interface{}) { s := i.(formatScenario) if s.skipDoc { return } if s.scenarioType == "encode" { documentXmlEncodeScenario(w, s) } else if s.scenarioType == "roundtrip" { documentXmlRoundTripScenario(w, s) } else { documentXmlDecodeScenario(t, w, s) } } func documentXmlDecodeScenario(t *testing.T, w *bufio.Writer, s formatScenario) { 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") expression := s.expression if expression == "" { expression = "." } writeOrPanic(w, fmt.Sprintf("```bash\nyq e -p=xml '%v' sample.xml\n```\n", expression)) writeOrPanic(w, "will output\n") var output bytes.Buffer printer := NewSimpleYamlPrinter(bufio.NewWriter(&output), YamlOutputFormat, true, false, 2, true) node := decodeXml(t, s) 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 formatScenario) { 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", processXmlScenario(s))) } func documentXmlRoundTripScenario(w *bufio.Writer, s formatScenario) { 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 -o=xml '.' sample.xml\n```\n") writeOrPanic(w, "will output\n") writeOrPanic(w, fmt.Sprintf("```xml\n%v```\n\n", processXmlScenario(s))) } 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) }