Allow freezing cyclic and deeply nested dictionaries

addict/addict.py

@@ -150,10 +150,20 @@ def setdefault(self, key, default=None):
             return default
 
     def freeze(self, shouldFreeze=True):
-        object.__setattr__(self, '__frozen', shouldFreeze)
-        for key, val in self.items():
-            if isinstance(val, Dict):
-                val.freeze(shouldFreeze)
+        pending = [self]
+        seen = set()
+        while pending:
+            current = pending.pop()
+            if id(current) in seen:
+                continue
+            seen.add(id(current))
+            object.__setattr__(current, '__frozen', shouldFreeze)
+            for val in current.values():
+                if isinstance(val, Dict):
+                    if type(val).freeze is Dict.freeze:
+                        pending.append(val)
+                    else:
+                        val.freeze(shouldFreeze)
 
     def unfreeze(self):
         self.freeze(False)

test_addict.py

@@ -520,6 +520,49 @@ def test_parent_key_prop(self):
             self.fail(e)
         self.assertEqual(a, {'y': {'x': 1}})
 
+    def test_freeze_calls_child_override(self):
+        calls = []
+
+        class CustomDict(self.dict_class):
+            def freeze(self, shouldFreeze=True):
+                calls.append(shouldFreeze)
+                super(CustomDict, self).freeze(shouldFreeze)
+
+        d = self.dict_class()
+        d.child = CustomDict()
+        d.freeze()
+        d.unfreeze()
+        self.assertEqual(calls, [True, False])
+
+    def test_freeze_cyclic_dict(self):
+        d = self.dict_class()
+        d.self = d
+        d.child.parent = d
+        d.freeze()
+        with self.assertRaises(KeyError):
+            d.new_key = 1
+        with self.assertRaises(KeyError):
+            d.child.new_key = 1
+        d.unfreeze()
+        d.new_key = 1
+        d.child.new_key = 2
+        self.assertIs(d.self, d)
+        self.assertIs(d.child.parent, d)
+
+    def test_freeze_deep_dict(self):
+        d = self.dict_class()
+        current = d
+        for _ in range(1500):
+            child = self.dict_class()
+            current.child = child
+            current = child
+        d.freeze()
+        with self.assertRaises(KeyError):
+            current.new_key = 1
+        d.unfreeze()
+        current.new_key = 1
+        self.assertEqual(current.new_key, 1)
+
     def test_top_freeze_against_top_key(self):
         "Test that d.freeze() produces KeyError on d.missing."
         d = self.dict_class()