Merge pull request wk8#25 from xiegeo/master

allow special character as keys

Author: wk8

json.go

@@ -116,41 +116,37 @@ func (om *OrderedMap[K, V]) UnmarshalJSON(data []byte) error {
 			var key K
 			var value V
 
-			if typedKeyPointer, ok := any(&key).(encoding.TextUnmarshaler); ok {
-				// pointer receiver
-				if err := typedKeyPointer.UnmarshalText(keyData); err != nil {
+			switch tkp := any(&key).(type) {
+			case *string:
+				*tkp = string(keyData)
+			case encoding.TextUnmarshaler:
+				if err := tkp.UnmarshalText(keyData); err != nil {
 					return err
 				}
-			} else {
-				keyAlreadyUnmarshalled := false
-				switch typedKey := any(key).(type) {
-				case string:
-					keyData = quoteString(keyData)
-				case encoding.TextUnmarshaler:
-					// not a pointer receiver
-					if err := typedKey.UnmarshalText(keyData); err != nil {
-						return err
-					}
-					keyAlreadyUnmarshalled = true
-				case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
-				default:
-
-					// this switch takes care of wrapper types around primitive types, such as
-					// type myType string
-					switch reflect.TypeOf(key).Kind() {
-					case reflect.String:
-						keyData = quoteString(keyData)
-					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-						reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-					default:
-						return fmt.Errorf("unsupported key type: %T", typedKey)
-					}
+			case *encoding.TextUnmarshaler:
+				// This is to preserve compatibility with original implementation
+				// that handled none pointer receivers, but I (xiegeo) believes this is unused.
+				if err := (*tkp).UnmarshalText(keyData); err != nil {
+					return err
 				}
-
-				if !keyAlreadyUnmarshalled {
+			case *int, *int8, *int16, *int32, *int64, *uint, *uint8, *uint16, *uint32, *uint64:
+				if err := json.Unmarshal(keyData, tkp); err != nil {
+					return err
+				}
+			default:
+				// this switch takes care of wrapper types around primitive types, such as
+				// type myType string
+				switch reflect.TypeOf(key).Kind() {
+				case reflect.String:
+					convertedkeyData := reflect.ValueOf(keyData).Convert(reflect.TypeOf(key))
+					reflect.ValueOf(&key).Elem().Set(convertedkeyData)
+				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+					reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 					if err := json.Unmarshal(keyData, &key); err != nil {
 						return err
 					}
+				default:
+					return fmt.Errorf("unsupported key type: %T", key)
 				}
 			}
 
@@ -162,11 +158,3 @@ func (om *OrderedMap[K, V]) UnmarshalJSON(data []byte) error {
 			return nil
 		})
 }
-
-func quoteString(data []byte) []byte {
-	withQuotes := make([]byte, len(data)+2) //nolint:gomnd
-	copy(withQuotes[1:], data)
-	withQuotes[0] = '"'
-	withQuotes[len(data)+1] = '"'
-	return withQuotes
-}

json_test.go

@@ -184,6 +184,45 @@ func TestUnmarshallJSON(t *testing.T) {
 	})
 }
 
+const specialCharacters = "\\\\/\"\b\f\n\r\t\x00\uffff\ufffd世界\u007f\u00ff\U0010FFFF"
+
+func TestJSONSpecialCharacters(t *testing.T) {
+	baselineMap := map[string]any{specialCharacters: specialCharacters}
+	baselineData, err := json.Marshal(baselineMap)
+	require.NoError(t, err) // baseline proves this key is supported by official json library
+	t.Logf("specialCharacters: %#v as []rune:%v", specialCharacters, []rune(specialCharacters))
+	t.Logf("baseline json data: %s", baselineData)
+
+	t.Run("marshal "+specialCharacters, func(t *testing.T) {
+		om := New[string, any]()
+		om.Set(specialCharacters, specialCharacters)
+		b, err := json.Marshal(om)
+		require.NoError(t, err)
+		require.Equal(t, baselineData, b)
+
+		type myString string
+		om2 := New[myString, myString]()
+		om2.Set(specialCharacters, specialCharacters)
+		b, err = json.Marshal(om2)
+		require.NoError(t, err)
+		require.Equal(t, baselineData, b)
+	})
+	t.Run("unmarshall "+specialCharacters, func(t *testing.T) {
+		om := New[string, any]()
+		require.NoError(t, json.Unmarshal([]byte(baselineData), &om))
+		assertOrderedPairsEqual(t, om,
+			[]string{specialCharacters},
+			[]any{specialCharacters})
+
+		type myString string
+		om2 := New[myString, myString]()
+		require.NoError(t, json.Unmarshal([]byte(baselineData), &om2))
+		assertOrderedPairsEqual(t, om2,
+			[]myString{specialCharacters},
+			[]myString{specialCharacters})
+	})
+}
+
 // to test structs that have nested map fields
 type nestedMaps struct {
 	X int                                                               `json:"x"`

test_utils.go

@@ -26,8 +26,8 @@ func assertOrderedPairsEqualFromNewest[K comparable, V any](
 	if assert.Equal(t, len(expectedKeys), len(expectedValues)) && assert.Equal(t, len(expectedKeys), orderedMap.Len()) {
 		i := orderedMap.Len() - 1
 		for pair := orderedMap.Newest(); pair != nil; pair = pair.Prev() {
-			assert.Equal(t, expectedKeys[i], pair.Key)
-			assert.Equal(t, expectedValues[i], pair.Value)
+			assert.Equal(t, expectedKeys[i], pair.Key, "from newest index=%d on key", i)
+			assert.Equal(t, expectedValues[i], pair.Value, "from newest index=%d on value", i)
 			i--
 		}
 	}
@@ -41,8 +41,8 @@ func assertOrderedPairsEqualFromOldest[K comparable, V any](
 	if assert.Equal(t, len(expectedKeys), len(expectedValues)) && assert.Equal(t, len(expectedKeys), orderedMap.Len()) {
 		i := 0
 		for pair := orderedMap.Oldest(); pair != nil; pair = pair.Next() {
-			assert.Equal(t, expectedKeys[i], pair.Key)
-			assert.Equal(t, expectedValues[i], pair.Value)
+			assert.Equal(t, expectedKeys[i], pair.Key, "from oldest index=%d on key", i)
+			assert.Equal(t, expectedValues[i], pair.Value, "from oldest index=%d on value", i)
 			i++
 		}
 	}