Fix XML format, and fix missing metadata when reading/writing to model values

Author: TomWright

model/value_map.go

@@ -45,7 +45,7 @@ func (v *Value) SetMapKey(key string, value *Value) error {
 		if err != nil {
 			return fmt.Errorf("error getting map: %w", err)
 		}
-		m.Set(key, value.value.Interface())
+		m.Set(key, value)
 		return nil
 	case v.isStandardMap():
 		unpacked, err := v.UnpackUntilKind(reflect.Map)
@@ -93,9 +93,16 @@ func (v *Value) GetMapKey(key string) (*Value, error) {
 		if !ok {
 			return nil, MapKeyNotFound{Key: key}
 		}
+		if modelValue, isValue := val.(*Value); isValue {
+			modelValue.setFn = func(newValue *Value) error {
+				m.Set(key, newValue)
+				return nil
+			}
+			return modelValue, nil
+		}
 		res := NewValue(val)
 		res.setFn = func(newValue *Value) error {
-			m.Set(key, newValue.value.Interface())
+			m.Set(key, newValue)
 			return nil
 		}
 		return res, nil

model/value_slice.go

@@ -79,7 +79,12 @@ func (v *Value) GetSliceIndex(i int) (*Value, error) {
 		return nil, SliceIndexOutOfRange{Index: i}
 	}
 
-	res := NewValue(unpacked.value.Index(i))
+	item := unpacked.value.Index(i)
+	if item.Kind() == reflect.Ptr && item.Type() == reflect.TypeFor[*Value]() {
+		return item.Interface().(*Value), nil
+	}
+
+	res := NewValue(item)
 	return res, nil
 }
 
@@ -95,7 +100,7 @@ func (v *Value) SetSliceIndex(i int, val *Value) error {
 	if i < 0 || i >= unpacked.value.Len() {
 		return SliceIndexOutOfRange{Index: i}
 	}
-	unpacked.value.Index(i).Set(val.value)
+	unpacked.value.Index(i).Set(reflect.ValueOf(val))
 	return nil
 }
 

parsing/xml/reader.go

@@ -156,6 +156,8 @@ func (j *xmlReader) parseElement(decoder *xml.Decoder, element xml.StartElement)
 		})
 	}
 
+	var processingInstructions []*xmlProcessingInstruction
+
 	for {
 		t, err := decoder.Token()
 		if errors.Is(err, io.EOF) {
@@ -171,6 +173,7 @@ func (j *xmlReader) parseElement(decoder *xml.Decoder, element xml.StartElement)
 			if err != nil {
 				return nil, err
 			}
+			child.ProcessingInstructions = processingInstructions
 			el.Children = append(el.Children, child)
 		case xml.CharData:
 			if unicode.IsSpace([]rune(string(t))[0]) {
@@ -186,7 +189,7 @@ func (j *xmlReader) parseElement(decoder *xml.Decoder, element xml.StartElement)
 				Target: t.Target,
 				Value:  string(t.Inst),
 			}
-			el.ProcessingInstructions = append(el.ProcessingInstructions, pi)
+			processingInstructions = append(processingInstructions, pi)
 			continue
 		case xml.Directive:
 			continue

parsing/xml/writer.go

@@ -29,13 +29,17 @@ func (j *xmlWriter) Write(value *model.Value) ([]byte, error) {
 	}()
 	writer.Indent("", "  ")
 
-	element, err := j.toElement(value)
+	element, err := j.toElement("root", value)
 	if err != nil {
 		return nil, fmt.Errorf("failed to convert to element: %w", err)
 	}
-
-	if err := writer.Encode(element); err != nil {
-		return nil, err
+	for _, c := range element.Children {
+		if err := writer.Encode(c); err != nil {
+			return nil, err
+		}
+		if err := writer.EncodeToken(xml.CharData("\n")); err != nil {
+			return nil, err
+		}
 	}
 
 	if err := writer.Flush(); err != nil {
@@ -48,7 +52,7 @@ func (j *xmlWriter) Write(value *model.Value) ([]byte, error) {
 	return outBytes, nil
 }
 
-func (j *xmlWriter) toElement(value *model.Value) (*xmlElement, error) {
+func (j *xmlWriter) toElement(key string, value *model.Value) (*xmlElement, error) {
 	readProcessingInstructions := func() []*xmlProcessingInstruction {
 		if piMeta, ok := value.MetadataValue("xml_processing_instructions"); ok && piMeta != nil {
 			if pis, ok := piMeta.([]*xmlProcessingInstruction); ok {
@@ -62,7 +66,7 @@ func (j *xmlWriter) toElement(value *model.Value) (*xmlElement, error) {
 	case model.TypeString:
 		strVal, err := valueToString(value)
 		return &xmlElement{
-			Name:                   "root",
+			Name:                   key,
 			Content:                strVal,
 			ProcessingInstructions: readProcessingInstructions(),
 		}, err
@@ -74,7 +78,7 @@ func (j *xmlWriter) toElement(value *model.Value) (*xmlElement, error) {
 		}
 
 		el := &xmlElement{
-			Name:                   "root",
+			Name:                   key,
 			ProcessingInstructions: readProcessingInstructions(),
 		}
 
@@ -99,27 +103,34 @@ func (j *xmlWriter) toElement(value *model.Value) (*xmlElement, error) {
 				continue
 			}
 
-			childEl, err := j.toElement(kv.Value)
+			childEl, err := j.toElement(kv.Key, kv.Value)
 			if err != nil {
 				return nil, fmt.Errorf("failed to convert child element %q to element: %w", kv.Key, err)
 			}
-			childEl.Name = kv.Key
-			el.Children = append(el.Children, childEl)
+			if childEl.useChildrenOnly {
+				el.Children = append(el.Children, childEl.Children...)
+			} else {
+				el.Children = append(el.Children, childEl)
+			}
 		}
 
 		return el, nil
 	case model.TypeSlice:
 		el := &xmlElement{
 			Name:                   "root",
 			ProcessingInstructions: readProcessingInstructions(),
+			useChildrenOnly:        true,
 		}
 		if err := value.RangeSlice(func(i int, value *model.Value) error {
-			childEl, err := j.toElement(value)
+			childEl, err := j.toElement(key, value)
 			if err != nil {
 				return err
 			}
-			childEl.Name = "item"
-			el.Children = append(el.Children, childEl)
+			if childEl.useChildrenOnly {
+				el.Children = append(el.Children, childEl.Children...)
+			} else {
+				el.Children = append(el.Children, childEl)
+			}
 
 			return nil
 		}); err != nil {
@@ -181,21 +192,20 @@ func (e *xmlElement) MarshalXML(enc *xml.Encoder, start xml.StartElement) error
 		}
 	}
 	start.Name = xml.Name{Local: e.Name}
-	if err := enc.EncodeToken(start); err != nil {
-		return err
-	}
 
 	if len(e.Attrs) > 0 {
 		for _, attr := range e.Attrs {
-			if err := enc.EncodeToken(xml.Attr{
+			start.Attr = append(start.Attr, xml.Attr{
 				Name:  xml.Name{Local: attr.Name},
 				Value: attr.Value,
-			}); err != nil {
-				return err
-			}
+			})
 		}
 	}
 
+	if err := enc.EncodeToken(start); err != nil {
+		return err
+	}
+
 	if len(e.Content) > 0 {
 		if err := enc.EncodeToken(xml.CharData(e.Content)); err != nil {
 			return err

parsing/xml/writer_test.go

@@ -1,6 +1,7 @@
 package xml_test
 
 import (
+	"github.com/tomwright/dasel/v3/model"
 	"testing"
 
 	"github.com/tomwright/dasel/v3/parsing"
@@ -42,21 +43,19 @@ func TestXmlReader_Write(t *testing.T) {
 			t.Fatalf("Unexpected error: %s", err)
 		}
 
-		expected := `<root>
-  <Document>
-    <Sender>Ivanov</Sender>
-    <In_N_Document>
-      <N_Document>1024</N_Document>
-      <Date_Reg>2024-06-21T15:07:29.0451517+03:00</Date_Reg>
-    </In_N_Document>
-    <Out_N_Document>
-      <N_Document>2043</N_Document>
-      <Date_Reg>2024-05-01T00:00:00</Date_Reg>
-    </Out_N_Document>
-    <Content>Skzzkz</Content>
-    <DSP>true</DSP>
-  </Document>
-</root>
+		expected := `<Document>
+  <Sender>Ivanov</Sender>
+  <In_N_Document>
+    <N_Document>1024</N_Document>
+    <Date_Reg>2024-06-21T15:07:29.0451517+03:00</Date_Reg>
+  </In_N_Document>
+  <Out_N_Document>
+    <N_Document>2043</N_Document>
+    <Date_Reg>2024-05-01T00:00:00</Date_Reg>
+  </Out_N_Document>
+  <Content>Skzzkz</Content>
+  <DSP>true</DSP>
+</Document>
 `
 		if string(xmlBytes) != expected {
 			t.Fatalf("Expected:\n%s\nGot:\n%s", expected, string(xmlBytes))
@@ -93,30 +92,62 @@ func TestXmlReader_Write(t *testing.T) {
 			t.Fatalf("Unexpected error: %s", err)
 		}
 
+		doc, err := data.GetMapKey("Document")
+		if err != nil {
+			t.Fatalf("Unexpected error: %s", err)
+		}
+		docProcessingInstructions, ok := doc.MetadataValue("xml_processing_instructions")
+		if !ok || docProcessingInstructions == nil {
+			t.Fatalf("Expected processing instructions on Document element")
+		}
+
 		jsonBytes, err := w.Write(data)
 		if err != nil {
 			t.Fatalf("Unexpected error: %s", err)
 		}
 
 		expected := `<?xml version="1.0" encoding="utf-8" standalone="yes"?>
-<root>
-  <Document>
-    <Sender>Ivanov</Sender>
-    <In_N_Document>
-      <N_Document>1024</N_Document>
-      <Date_Reg>2024-06-21T15:07:29.0451517+03:00</Date_Reg>
-    </In_N_Document>
-    <Out_N_Document>
-      <N_Document>2043</N_Document>
-      <Date_Reg>2024-05-01T00:00:00</Date_Reg>
-    </Out_N_Document>
-    <Content>Skzzkz</Content>
-    <DSP>true</DSP>
-  </Document>
-</root>
+<Document>
+  <Sender>Ivanov</Sender>
+  <In_N_Document>
+    <N_Document>1024</N_Document>
+    <Date_Reg>2024-06-21T15:07:29.0451517+03:00</Date_Reg>
+  </In_N_Document>
+  <Out_N_Document>
+    <N_Document>2043</N_Document>
+    <Date_Reg>2024-05-01T00:00:00</Date_Reg>
+  </Out_N_Document>
+  <Content>Skzzkz</Content>
+  <DSP>true</DSP>
+</Document>
 `
 		if string(jsonBytes) != expected {
 			t.Fatalf("Expected:\n%s\nGot:\n%s", expected, string(jsonBytes))
 		}
 	})
+
+	t.Run("encode attributes", func(t *testing.T) {
+		w, err := xml.XML.NewWriter(parsing.DefaultWriterOptions())
+		if err != nil {
+			t.Fatalf("Unexpected error: %s", err)
+		}
+
+		toEncode := model.NewMapValue()
+		foo := model.NewMapValue()
+		_ = foo.SetMapKey("-fiz", model.NewStringValue("hello"))
+		_ = foo.SetMapKey("bar", model.NewStringValue(""))
+		_ = toEncode.SetMapKey("foo", foo)
+
+		got, err := w.Write(toEncode)
+		if err != nil {
+			t.Fatalf("Unexpected error: %s", err)
+		}
+		exp := []byte(`<foo fiz="hello">
+  <bar></bar>
+</foo>
+`)
+		if string(got) != string(exp) {
+			t.Errorf("Expected:\n%s\nGot:\n%s", string(exp), string(got))
+		}
+	})
 }

parsing/xml/xml.go

@@ -33,4 +33,5 @@ type xmlElement struct {
 	Children               []*xmlElement
 	Content                string
 	ProcessingInstructions []*xmlProcessingInstruction
+	useChildrenOnly        bool
 }

parsing/yaml/yaml_test.go

@@ -183,7 +183,7 @@ list:
 name2: *name
 `,
 		out: `name: Tom
-name2: Tom
+name2: *name
 `,
 	}.run)
 }