Fix dotted dict processing dots in second+ level keys (#2745)

Author: rchl

plugin/core/collections.py

@@ -7,6 +7,15 @@
 import sublime
 
 
+def deep_merge(base: dict[str, Any], update: dict[str, Any]) -> None:
+    """Recursively merge update dict with base dict."""
+    for key, value in update.items():
+        if isinstance(value, dict) and key in base and isinstance(base[key], dict):
+            deep_merge(base[key], value)
+        else:
+            base[key] = deepcopy(value)
+
+
 class DottedDict:
 
     __slots__ = ('_d',)
@@ -15,6 +24,9 @@ def __init__(self, d: dict[str, Any] | None = None) -> None:
         """
         Construct a DottedDict, optionally from an existing dictionary.
 
+        The dots within the first-level keys (only) of the passed dict will be interpreted as nesting triggers and the
+        resulting dict will have those transformed into nested keys.
+
         :param      d:    An existing dictionary.
         """
         self._d: dict[str, Any] = {}
@@ -138,13 +150,13 @@ def update(self, d: dict[str, Any]) -> None:
         """
         Overwrite and/or add new key-value pairs to the collection.
 
+        The dots within the first-level keys (only) of the passed dict will be interpreted as nesting triggers and the
+        resulting dict will have those transformed into nested keys.
+
         :param      d:    The overriding dictionary. Can contain nested dictionaries.
         """
         for key, value in d.items():
-            if isinstance(value, dict):
-                self._update_recursive(value, key)
-            else:
-                self.set(key, value)
+            self._merge(key, value)
 
     def get_resolved(self, variables: dict[str, str]) -> dict[str, Any]:
         """
@@ -156,15 +168,29 @@ def get_resolved(self, variables: dict[str, str]) -> dict[str, Any]:
         """
         return sublime.expand_variables(self._d, variables)
 
-    def _update_recursive(self, current: dict[str, Any], prefix: str) -> None:
-        if not current or any(filter(lambda key: isinstance(key, str) and (":" in key or "/" in key), current.keys())):
-            return self.set(prefix, current)
-        for key, value in current.items():
-            path = f"{prefix}.{key}"
-            if isinstance(value, dict):
-                self._update_recursive(value, path)
-            else:
-                self.set(path, value)
+    def _merge(self, path: str, value: Any) -> None:
+        """
+        Update a value in the dictionary (merge if value is a dict).
+
+        :param      path:   The path, e.g. foo.bar.baz
+        :param      value:  The value
+        """
+        current = self._d
+        keys = path.split('.')
+        for i in range(0, len(keys) - 1):
+            key = keys[i]
+            next_current = current.get(key)
+            if not isinstance(next_current, dict):
+                next_current = {}
+                current[key] = next_current
+            current = next_current
+        last_key = keys[-1]
+        if isinstance(value, dict):
+            if not isinstance(current.get(last_key), dict):
+                current[last_key] = {}
+            deep_merge(current[last_key], value)
+        else:
+            current[last_key] = value
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({repr(self._d)})"

tests/test_collections.py

@@ -25,6 +25,25 @@ def test_set_and_get(self) -> None:
         d.set("foo.bar.baz", {"some": "dict"})
         self.verify(d, "foo.bar.baz.some", "dict")
 
+    def test_does_not_expand_at_second_nesting_level(self) -> None:
+        d = DottedDict({"editor.codeActionsOnSave": {"source.fixAll": "explicit"}})
+        self.verify(d, "editor.codeActionsOnSave", {"source.fixAll": "explicit"})
+        self.assertIsNone(d.get("editor.codeActionsOnSave.source"))
+
+    def test_overwrite_int_with_dict(self) -> None:
+        d = DottedDict({'foo.bar': 1})
+        d.set('foo.bar', {
+            "a": "a",
+        })
+        self.verify(d, "foo.bar", {"a": "a"})
+
+    def test_overwrite_dict_with_dict(self) -> None:
+        d = DottedDict({'foo.bar': {'a': 'a'}})
+        d.set('foo.bar', {
+            "b": "b",
+        })
+        self.verify(d, "foo.bar", {"b": "b"})
+
     def test_remove(self) -> None:
         d = DottedDict()
         d.set("foo", "asdf")