unmarshall array: nested associative. Fixes #7 (#8)

This fixes a bug where a nested array might be associative.

Author: elliotchance

consume.go

@@ -239,7 +239,7 @@ func consumeNext(data []byte, offset int) (interface{}, int, error) {
 
 	switch data[offset] {
 	case 'a':
-		return consumeArray(data, offset)
+		return consumeIndexedOrAssociativeArray(data, offset)
 	case 'b':
 		return consumeBool(data, offset)
 	case 'd':
@@ -258,7 +258,57 @@ func consumeNext(data []byte, offset int) (interface{}, int, error) {
 		string(data[offset:]))
 }
 
-func consumeArray(data []byte, offset int) ([]interface{}, int, error) {
+func consumeIndexedOrAssociativeArray(data []byte, offset int) (interface{}, int, error) {
+	// Sometimes we don't know if the array is going to be indexed or
+	// associative until we have already started to consume it.
+	originalOffset := offset
+
+	// Try to consume it as an indexed array first.
+	arr, offset, err := consumeIndexedArray(data, originalOffset)
+	if err == nil {
+		return arr, offset, err
+	}
+
+	// Fallback to consuming an associative array
+	return consumeAssociativeArray(data, originalOffset)
+}
+
+func consumeAssociativeArray(data []byte, offset int) (map[interface{}]interface{}, int, error) {
+	if !checkType(data, 'a', offset) {
+		return map[interface{}]interface{}{}, -1, errors.New("not an array")
+	}
+
+	// Skip over the "a:"
+	offset += 2
+
+	rawLength, offset := consumeStringUntilByte(data, ':', offset)
+	length, err := strconv.Atoi(rawLength)
+	if err != nil {
+		return map[interface{}]interface{}{}, -1, err
+	}
+
+	// Skip over the ":{"
+	offset += 2
+
+	result := map[interface{}]interface{}{}
+	for i := 0; i < length; i++ {
+		var key interface{}
+
+		key, offset, err = consumeNext(data, offset)
+		if err != nil {
+			return map[interface{}]interface{}{}, -1, err
+		}
+
+		result[key], offset, err = consumeNext(data, offset)
+		if err != nil {
+			return map[interface{}]interface{}{}, -1, err
+		}
+	}
+
+	return result, offset, nil
+}
+
+func consumeIndexedArray(data []byte, offset int) ([]interface{}, int, error) {
 	if !checkType(data, 'a', offset) {
 		return []interface{}{}, -1, errors.New("not an array")
 	}

unserialize.go

@@ -77,8 +77,8 @@ func checkType(data []byte, typeCharacter byte, offset int) bool {
 	return len(data) > offset && data[offset] == typeCharacter
 }
 
-func UnmarshalArray(data []byte) ([]interface{}, error) {
-	v, _, err := consumeArray(data, 0)
+func UnmarshalIndexedArray(data []byte) ([]interface{}, error) {
+	v, _, err := consumeIndexedArray(data, 0)
 
 	return v, err
 }
@@ -91,36 +91,9 @@ func UnmarshalAssociativeArray(data []byte) (map[interface{}]interface{}, error)
 		return result, err
 	}
 
-	if !checkType(data, 'a', 0) {
-		return map[interface{}]interface{}{},
-			errors.New("not an array or object")
-	}
-
-	rawLength, offset := consumeStringUntilByte(data, ':', 2)
-	length, err := strconv.Atoi(rawLength)
-	if err != nil {
-		return map[interface{}]interface{}{}, err
-	}
-
-	// Skip over the ":{"
-	offset += 2
-
-	result := map[interface{}]interface{}{}
-	for i := 0; i < length; i++ {
-		var key interface{}
-
-		key, offset, err = consumeNext(data, offset)
-		if err != nil {
-			return map[interface{}]interface{}{}, err
-		}
-
-		result[key], offset, err = consumeNext(data, offset)
-		if err != nil {
-			return map[interface{}]interface{}{}, err
-		}
-	}
+	result, _, err := consumeAssociativeArray(data, 0)
 
-	return result, nil
+	return result, err
 }
 
 func UnmarshalObject(data []byte, v interface{}) error {
@@ -187,7 +160,7 @@ func Unmarshal(data []byte, v interface{}) error {
 		}
 
 		// Otherwise this must be a slice (array)
-		v, err := UnmarshalArray(data)
+		v, err := UnmarshalIndexedArray(data)
 		if err != nil {
 			return err
 		}

unserialize_test.go

@@ -366,10 +366,10 @@ func TestUnmarshalAssociativeArray(t *testing.T) {
 			map[interface{}]interface{}{int64(1): int64(10), int64(2): "foo"},
 			nil,
 		},
-		"not an array or object": {
+		"not an array": {
 			[]byte("N;"),
 			map[interface{}]interface{}{},
-			errors.New("not an array or object"),
+			errors.New("not an array"),
 		},
 	}
 
@@ -503,3 +503,23 @@ func TestUnmarshalArrayThatContainsObject(t *testing.T) {
 		t.Errorf("Expected:\n  %#+v\nGot:\n  %#+v", expected, result)
 	}
 }
+
+// https://github.com/elliotchance/phpserialize/issues/7
+func TestUnmarshalArrayThatContainsInteger(t *testing.T) {
+	data := `a:3:{s:4:"name";s:2:"tw";s:3:"age";i:123;s:4:"wife";a:1:{s:1:"x";s:1:"y";}}`
+	var result map[interface{}]interface{}
+	err := phpserialize.Unmarshal([]byte(data), &result)
+	expectErrorToNotHaveOccurred(t, err)
+
+	expected := map[interface{}]interface{}{
+		"wife": map[interface{}]interface{}{
+			"x": "y",
+		},
+		"name": "tw",
+		"age":  int64(123),
+	}
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected:\n  %#+v\nGot:\n  %#+v", expected, result)
+	}
+}