Merge pull request #3 from elliotchance/unserialise-into-map

TestUnmarshalObjectIntoMap

Author: elliotchance

consume.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"reflect"
 	"strconv"
+	"fmt"
 )
 
 // The internal consume functions work as the parser/lexer when reading
@@ -90,7 +91,7 @@ func consumeStringRealPart(data []byte, offset int) (string, int, error) {
 	s := DecodePHPString(data)
 
 	// The +2 is to skip over the final '";'
-	return s[offset : offset+length], offset + length + 2, nil
+	return s[offset: offset+length], offset + length + 2, nil
 }
 
 func consumeNil(data []byte, offset int) (interface{}, int, error) {
@@ -109,24 +110,23 @@ func consumeBool(data []byte, offset int) (bool, int, error) {
 	return data[offset+2] == '1', offset + 4, nil
 }
 
-func consumeObject(data []byte, offset int, v interface{}) (int, error) {
-	if !checkType(data, 'O', offset) {
-		return -1, errors.New("not an object")
-	}
+func consumeObjectAsMap(data []byte, offset int) (
+	map[interface{}]interface{}, int, error) {
+	result := map[interface{}]interface{}{}
 
 	// Read the class name. The class name follows the same format as a
 	// string. We could just ignore the length and hope that no class name
 	// ever had a non-ascii characters in it, but this is safer - and
 	// probably easier.
 	_, offset, err := consumeStringRealPart(data, offset+2)
 	if err != nil {
-		return -1, err
+		return nil, -1, err
 	}
 
 	// Read the number of elements in the object.
 	length, offset, err := consumeIntPart(data, offset)
 	if err != nil {
-		return -1, err
+		return nil, -1, err
 	}
 
 	// Skip over the '{'
@@ -141,69 +141,95 @@ func consumeObject(data []byte, offset int, v interface{}) (int, error) {
 		// about this.
 		key, offset, err = consumeString(data, offset)
 		if err != nil {
-			return -1, err
+			return nil, -1, err
 		}
 
-		// Check the the key exists in the struct, otherwise the value
-		// is discarded.
-		//
-		// We need to uppercase the first letter for compatibility.
-		// The Marshal() function does the opposite of this.
-		field := reflect.ValueOf(v).Elem().
-			FieldByName(upperCaseFirstLetter(key))
-
 		// If the next item is an object we can't simply consume it,
 		// rather we send the reflect.Value back through consumeObject
 		// so the recursion can be handled correctly.
 		if data[offset] == 'O' {
-			var subV interface{}
-
-			if field.IsValid() {
-				subV = field.Addr().Interface()
-			} else {
-				// If the field (key) does not exist on the
-				// struct we pass through a dummy object that no
-				// keys so that all of the values are discarded
-				// but the parser can continue to operate
-				// easily.
-				subV = &dummyObject{}
-			}
+			var subMap interface{}
 
-			offset, err = consumeObject(data, offset, subV)
+			subMap, offset, err = consumeObjectAsMap(data, offset)
 			if err != nil {
-				return -1, err
+				return nil, -1, err
 			}
+
+			result[key] = subMap
 		} else {
 			value, offset, err = consumeNext(data, offset)
 			if err != nil {
-				return -1, err
+				return nil, -1, err
 			}
 
-			if field.IsValid() {
-				setField(field, reflect.ValueOf(value))
-			}
+			result[key] = value
 		}
 	}
 
 	// The +1 is for the final '}'
-	return offset + 1, nil
+	return result, offset + 1, nil
 }
 
-func setField(field, value reflect.Value) {
-	switch field.Type().Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
-		reflect.Int64:
-		field.SetInt(value.Int())
+func setField(obj interface{}, name string, value interface{}) error {
+	structValue := reflect.ValueOf(obj).Elem()
+
+	// We need to uppercase the first letter for compatibility.
+	// The Marshal() function does the opposite of this.
+	structFieldValue := structValue.FieldByName(upperCaseFirstLetter(name))
+
+	if !structFieldValue.IsValid() {
+		return fmt.Errorf("no such field: %s in obj", name)
+	}
+
+	if !structFieldValue.CanSet() {
+		return fmt.Errorf("cannot set %s field value", name)
+	}
+
+	val := reflect.ValueOf(value)
+	switch structFieldValue.Type().Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		structFieldValue.SetInt(val.Int())
 
 	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		field.SetUint(value.Uint())
+		structFieldValue.SetUint(val.Uint())
 
 	case reflect.Float32, reflect.Float64:
-		field.SetFloat(value.Float())
+		structFieldValue.SetFloat(val.Float())
+
+	case reflect.Struct:
+		m := val.Interface().(map[interface{}]interface{})
+		fillStruct(structFieldValue.Addr().Interface(), m)
 
 	default:
-		field.Set(value)
+		structFieldValue.Set(val)
+	}
+
+	return nil
+}
+
+// https://stackoverflow.com/questions/26744873/converting-map-to-struct
+func fillStruct(obj interface{}, m map[interface{}]interface{}) error {
+	for k, v := range m {
+		err := setField(obj, k.(string), v)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func consumeObject(data []byte, offset int, v interface{}) (int, error) {
+	if !checkType(data, 'O', offset) {
+		return -1, errors.New("not an object")
+	}
+
+	m, offset, err := consumeObjectAsMap(data, offset)
+	if err != nil {
+		return -1, err
 	}
+
+	return offset, fillStruct(v, m)
 }
 
 func consumeNext(data []byte, offset int) (interface{}, int, error) {
@@ -212,6 +238,8 @@ func consumeNext(data []byte, offset int) (interface{}, int, error) {
 	}
 
 	switch data[offset] {
+	case 'a':
+		return consumeArray(data, offset)
 	case 'b':
 		return consumeBool(data, offset)
 	case 'd':
@@ -222,8 +250,52 @@ func consumeNext(data []byte, offset int) (interface{}, int, error) {
 		return consumeString(data, offset)
 	case 'N':
 		return consumeNil(data, offset)
+	case 'O':
+		return consumeObjectAsMap(data, offset)
 	}
 
 	return nil, -1, errors.New("can not consume type: " +
 		string(data[offset:]))
 }
+
+func consumeArray(data []byte, offset int) ([]interface{}, int, error) {
+	if !checkType(data, 'a', offset) {
+		return []interface{}{}, -1, errors.New("not an array")
+	}
+
+	rawLength, offset := consumeStringUntilByte(data, ':', offset+2)
+	length, err := strconv.Atoi(rawLength)
+	if err != nil {
+		return []interface{}{}, -1, err
+	}
+
+	// Skip over the ":{"
+	offset += 2
+
+	result := make([]interface{}, length)
+	for i := 0; i < length; i++ {
+		// Even non-associative arrays (arrays that are zero-indexed)
+		// still have their keys serialized. We need to read these
+		// indexes to make sure we are actually decoding a slice and not
+		// a map.
+		var index int64
+		index, offset, err = consumeInt(data, offset)
+		if err != nil {
+			return []interface{}{}, -1, err
+		}
+
+		if index != int64(i) {
+			return []interface{}{}, -1,
+				errors.New("cannot decode map as slice")
+		}
+
+		// Now we consume the value
+		result[i], offset, err = consumeNext(data, offset)
+		if err != nil {
+			return []interface{}{}, -1, err
+		}
+	}
+
+	// The +1 is for the final '}'
+	return result, offset+1, nil
+}

unserialize.go

@@ -8,8 +8,6 @@ import (
 	"strings"
 )
 
-type dummyObject struct{ Qux float64 }
-
 // findByte will return the first position at or after offset of the specified
 // byte. -1 is returned if the byte is not found.
 func findByte(data []byte, lookingFor byte, offset int) int {
@@ -80,49 +78,22 @@ func checkType(data []byte, typeCharacter byte, offset int) bool {
 }
 
 func UnmarshalArray(data []byte) ([]interface{}, error) {
-	if !checkType(data, 'a', 0) {
-		return []interface{}{}, errors.New("not an array")
-	}
-
-	rawLength, offset := consumeStringUntilByte(data, ':', 2)
-	length, err := strconv.Atoi(rawLength)
-	if err != nil {
-		return []interface{}{}, err
-	}
-
-	// Skip over the ":{"
-	offset += 2
+	v, _, err := consumeArray(data, 0)
 
-	result := make([]interface{}, length)
-	for i := 0; i < length; i++ {
-		// Even non-associative arrays (arrays that are zero-indexed)
-		// still have their keys serialized. We need to read these
-		// indexes to make sure we are actually decoding a slice and not
-		// a map.
-		var index int64
-		index, offset, err = consumeInt(data, offset)
-		if err != nil {
-			return []interface{}{}, err
-		}
+	return v, err
+}
 
-		if index != int64(i) {
-			return []interface{}{},
-				errors.New("cannot decode map as slice")
-		}
+func UnmarshalAssociativeArray(data []byte) (map[interface{}]interface{}, error) {
+	// We may be unmarshalling an object into a map.
+	if checkType(data, 'O', 0) {
+		result, _, err := consumeObjectAsMap(data, 0)
 
-		// Now we consume the value
-		result[i], offset, err = consumeNext(data, offset)
-		if err != nil {
-			return []interface{}{}, err
-		}
+		return result, err
 	}
 
-	return result, nil
-}
-
-func UnmarshalAssociativeArray(data []byte) (map[interface{}]interface{}, error) {
 	if !checkType(data, 'a', 0) {
-		return map[interface{}]interface{}{}, errors.New("not an array")
+		return map[interface{}]interface{}{},
+			errors.New("not an array or object")
 	}
 
 	rawLength, offset := consumeStringUntilByte(data, ':', 2)

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": {
+		"not an array or object": {
 			[]byte("N;"),
 			map[interface{}]interface{}{},
-			errors.New("not an array"),
+			errors.New("not an array or object"),
 		},
 	}
 
@@ -447,3 +447,59 @@ func TestUnmarshalObject(t *testing.T) {
 		t.Errorf("Expected %v, got %v", "yay", result.Baz)
 	}
 }
+
+func TestUnmarshalObjectIntoMap(t *testing.T) {
+	data := "O:7:\"struct1\":3:{s:3:\"foo\";i:10;s:3:\"bar\";O:7:\"Struct2\":1:{s:3:\"qux\";d:1.23;}s:3:\"baz\";s:3:\"yay\";}"
+	var result map[interface{}]interface{}
+	err := phpserialize.Unmarshal([]byte(data), &result)
+	expectErrorToNotHaveOccurred(t, err)
+
+	expected := map[interface{}]interface{}{
+		"baz": "yay",
+		"foo": int64(10),
+		"bar": map[interface{}]interface{}{
+			"qux": 1.23,
+		},
+	}
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected:\n  %#+v\nGot:\n  %#+v", expected, result)
+	}
+}
+
+func TestUnmarshalObjectIntoMapContainingArray(t *testing.T) {
+	data := "O:7:\"struct1\":3:{s:3:\"foo\";i:10;s:3:\"bar\";a:3:{i:0;i:7;i:1;i:8;i:2;i:9;}s:3:\"baz\";s:3:\"yay\";}"
+	var result map[interface{}]interface{}
+	err := phpserialize.Unmarshal([]byte(data), &result)
+	expectErrorToNotHaveOccurred(t, err)
+
+	expected := map[interface{}]interface{}{
+		"baz": "yay",
+		"foo": int64(10),
+		"bar": []interface{}{int64(7), int64(8), int64(9)},
+	}
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected:\n  %#+v\nGot:\n  %#+v", expected, result)
+	}
+}
+
+func TestUnmarshalArrayThatContainsObject(t *testing.T) {
+	data := "a:3:{i:0;O:7:\"struct1\":2:{s:3:\"foo\";i:10;s:3:\"baz\";s:3:\"yay\";}i:1;i:8;i:2;i:9;}"
+	var result []interface{}
+	err := phpserialize.Unmarshal([]byte(data), &result)
+	expectErrorToNotHaveOccurred(t, err)
+
+	expected := []interface{}{
+		map[interface{}]interface{}{
+			"baz": "yay",
+			"foo": int64(10),
+		},
+		int64(8),
+		int64(9),
+	}
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected:\n  %#+v\nGot:\n  %#+v", expected, result)
+	}
+}