Implement sparse/keyed array support

decode_test.go

@@ -79,6 +79,7 @@ func TestIllegalLaxDecode(t *testing.T) {
 
 func TestIllegalDecode(t *testing.T) {
 	i := int64(0)
+	m := make(map[string]string)
 	b := false
 	plists := []struct {
 		pl string
@@ -94,6 +95,8 @@ func TestIllegalDecode(t *testing.T) {
 		{"<dict><key>a</key><integer>0</integer></dict>", &b},
 		{"<array><true/><true/><true/></array>", &[1]int{1}},
 		{"<data>SGVsbG8=</data>", &[3]byte{}},
+		{"<array><string>a</string><key>123</key></array>", &m},
+		{"<array><key>123</key><string>a</string><string>b</string></array>", &m},
 	}
 
 	for _, plist := range plists {
@@ -107,6 +110,22 @@ func TestIllegalDecode(t *testing.T) {
 	}
 }
 
+func TestSparseArrayDecode(t *testing.T) {
+	buf := bytes.NewReader([]byte("<array><key>100</key><string>a</string><key>200</key><string>b</string></array>"))
+	decoder := NewDecoder(buf)
+	var val map[string]string
+	err := decoder.Decode(&val)
+	if err != nil {
+		t.Error(err)
+	}
+	if want, got := "a", val["100"]; want != got {
+		t.Errorf("Expected %q at key 100, got %q", want, got)
+	}
+	if want, got := "b", val["200"]; want != got {
+		t.Errorf("Expected %q at key 200, got %q", want, got)
+	}
+}
+
 func TestDecode(t *testing.T) {
 	for _, test := range tests {
 		subtest(t, test.Name, func(t *testing.T) {

xml_parser.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"runtime"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -181,7 +182,15 @@ func (p *xmlPlistParser) parseXMLElement(element xml.StartElement) cfValue {
 		return dict.maybeUID(false)
 	case "array":
 		p.ntags++
-		values := make([]cfValue, 0, 10)
+		var key *int
+		// Maintain a list of keys: either seen explicitly, or implicitly from
+		// ordering in an array without keys.
+		keys := make([]int, 0, 32)
+		// Two flags to make note of what kind of array we have encountered so
+		// far. Mixed type is currently not allowed.
+		sawExplicitKey := false
+		sawImplicitValue := false
+		values := make([]cfValue, 0, 32)
 		for {
 			token, err := p.xmlDecoder.Token()
 			if err != nil {
@@ -193,9 +202,45 @@ func (p *xmlPlistParser) parseXMLElement(element xml.StartElement) cfValue {
 			}
 
 			if el, ok := token.(xml.StartElement); ok {
-				values = append(values, p.parseXMLElement(el))
+				if el.Name.Local == "key" {
+					sawExplicitKey = true
+					if sawImplicitValue {
+						panic(errors.New("mixed type array"))
+					}
+					if key != nil {
+						panic(errors.New("double key in array"))
+					}
+					var k int
+					p.xmlDecoder.DecodeElement(&k, &el)
+					key = &k
+				} else {
+					if key != nil {
+						keys = append(keys, *key)
+						key = nil
+					} else {
+						sawImplicitValue = true
+						if sawExplicitKey {
+							panic(errors.New("mixed type array"))
+						}
+						keys = append(keys, len(values))
+					}
+					values = append(values, p.parseXMLElement(el))
+				}
+			}
+		}
+		// If the array keys are non-continuous, return a dictionary.
+		for i := 0; i < len(keys); i++ {
+			if keys[i] != i {
+				// ... but first convert the keys into strings.
+				keys2 := make([]string, len(keys))
+				for j, k := range keys {
+					keys2[j] = strconv.Itoa(k)
+				}
+				dict := &cfDictionary{keys: keys2, values: values}
+				return dict.maybeUID(false)
 			}
 		}
+		// If the array is indeed continuous, return it as an array.
 		return &cfArray{values}
 	}
 	err := fmt.Errorf("encountered unknown element %s", element.Name.Local)