Add support for dec refs for values of dictionaries that are input wi…

…th non-`li` keys.

CHANGELOG.md

@@ -7,7 +7,7 @@ All notable changes to this project will be documented in this file.
 * SetupDependsOnAttribute, which allows you to define ConfigErrors/PostLoad dependencies between Dec classes. This is a prototype and will probably change in the future.
 * A general-purpose stable dag evaluator, which is exposed mostly because it's often convenient.
 * Recorder.InputContext, which gives contextual diagnostic information useful for reporting Recorder issues.
-* The ability to reference class objects contained within Decs. Right now the path generation works only for members, lists, and arrays; this will probably be improved later.
+* The ability to reference class objects contained within Decs. Right now the path generation works only for members, lists, arrays, and values of dictionaries that are input with non-`li` keys; this will probably be improved later.
 * Debug-log functions to Context and Recorder, making it easier to report issues.
 
 ### Breaking

src/Path.cs

@@ -146,6 +146,28 @@ public override bool IsValidForWriting()
         }
     }
 
+    public class PathDictionaryValue : Path
+    {
+        private Path parent;
+        private string key;
+
+        public PathDictionaryValue(Path parent, string key)
+        {
+            this.parent = parent;
+            this.key = key;
+        }
+
+        public override string Serialize()
+        {
+            return $"{parent.Serialize()}[{key}]";
+        }
+
+        public override bool IsValidForWriting()
+        {
+            return parent.IsValidForWriting();
+        }
+    }
+
     // the ones after this point are grossly incomplete
 
     public class PathDictionaryKey : Path
@@ -169,18 +191,18 @@ public override bool IsValidForWriting()
         }
     }
 
-    public class PathDictionaryValue : Path
+    public class PathDictionaryValueUnpathable : Path
     {
         private Path parent;
 
-        public PathDictionaryValue(Path parent)
+        public PathDictionaryValueUnpathable(Path parent)
         {
             this.parent = parent;
         }
 
         public override string Serialize()
         {
-            return $"{parent.Serialize()}[nyi]";
+            return $"{parent.Serialize()}[UNSERIALIZABLE]";
         }
 
         public override bool IsValidForWriting()

src/ReaderXml.cs

@@ -232,7 +232,7 @@ public override void ParseDictionary(IDictionary dict, Type referencedKeyType, T
 
                     writtenFields?.Add(key);
 
-                    var valuePath = new PathDictionaryValue(path);
+                    var valuePath = new PathDictionaryValueUnpathable(path);
                     dict[key] = Serialization.ParseElement(new List<ReaderNodeParseable>() { new ReaderNodeXml(valueNode, fileIdentifier,valuePath, UserSettings) }, referencedValueType, originalValue, readerGlobals, recorderChildContext);
                 }
                 else
@@ -285,7 +285,17 @@ public override void ParseDictionary(IDictionary dict, Type referencedKeyType, T
 
                     writtenFields?.Add(key);
 
-                    var valuePath = new PathDictionaryValue(path);
+                    Path valuePath;
+                    if (fieldElement.Name.LocalName.Contains('[') || fieldElement.Name.LocalName.Contains(']'))
+                    {
+                        // I'm not actually sure this is possible
+                        valuePath = new PathDictionaryValueUnpathable(path);
+                    }
+                    else
+                    {
+                        valuePath = new PathDictionaryValue(path, fieldElement.Name.LocalName);
+                    }
+
                     dict[key] = Serialization.ParseElement(new List<ReaderNodeParseable>() { new ReaderNodeXml(fieldElement, fileIdentifier, valuePath, UserSettings) }, valueType, originalValue, readerGlobals, recorderChildContext);
                 }
             }

src/WriterValidation.cs

@@ -295,7 +295,7 @@ public override void WriteDictionary(IDictionary value)
                 Serialization.ComposeElement(keyNode, iterator.Key, keyType);
 
                 writer.AppendLine($"if ({accessor}.ContainsKey({keyNode.SerializedString})) {{");
-                Serialization.ComposeElement(new WriterNodeValidation(writer, $"{accessor}[{keyNode.SerializedString}]", new PathDictionaryValue(Path)), iterator.Value, valueType);
+                Serialization.ComposeElement(new WriterNodeValidation(writer, $"{accessor}[{keyNode.SerializedString}]", new PathDictionaryValueUnpathable(Path)), iterator.Value, valueType);
                 writer.AppendLine($"}} else {{");
                 writer.AppendLine($"Assert.IsTrue({accessor}.ContainsKey({keyNode.SerializedString}));");   // this is unnecessary - it could just be .Fail() - but this gives you a *much* better error message
                 writer.AppendLine($"}}");

src/WriterXml.cs

@@ -263,7 +263,9 @@ public override void WriteDictionary(IDictionary value)
                 var li = CreateNamedChild("li", RecorderSettings, Path);
 
                 Serialization.ComposeElement(li.CreateNamedChild("key", RecorderSettings.CreateChild(), new PathDictionaryKey(Path)), iterator.Key, keyType);
-                Serialization.ComposeElement(li.CreateNamedChild("value", RecorderSettings.CreateChild(), new PathDictionaryValue(Path)), iterator.Value, valueType);
+
+                // unfortunate consequence: we can't generate sensible Paths when doing this
+                Serialization.ComposeElement(li.CreateNamedChild("value", RecorderSettings.CreateChild(), new PathDictionaryValueUnpathable(Path)), iterator.Value, valueType);
             }
         }
 

test/unit/Path.cs

@@ -170,18 +170,23 @@ public void DictionaryValuePath([ValuesExcept(ParserMode.Validation)] ParserMode
                         <dictValue>
                             <li>
                                 <key>first</key>
-                                <value>PathDec.TestDec.dictValue[nyi]</value>
+                                <value>PathDec.TestDec.dictValue[UNSERIALIZABLE]</value>
                             </li>
+                            <second>PathDec.TestDec.dictValue[second]</second>
                         </dictValue>
                     </PathDec>
                 </Decs>");
             parser.Finish();
 
-            Assert.IsTrue(PathTester.validations == 1);
+            Assert.IsTrue(PathTester.validations == 2);
+
+            // the `second` currently does not serialize properly, so we replace the value there for now
+            // fix this when we add support!
+            Dec.Database<PathDec>.Get("TestDec").dictValue["second"] = new PathTester { text = "PathDec.TestDec.dictValue[UNSERIALIZABLE]" };
 
             DoParserTests(mode);
 
-            Assert.IsTrue(PathTester.validations == (mode == ParserMode.Bare ? 1 : 3));
+            Assert.IsTrue(PathTester.validations == (mode == ParserMode.Bare ? 2 : 6));
         }
 
         [Test]

test/unit/PathDecRef.cs

@@ -14,6 +14,7 @@ private class PathDec : Dec.Dec
             public StubRecordable[] array;
             public StubRecordable[,] arrayMulti;
             public List<StubRecordable> list;
+            public Dictionary<string, StubRecordable> dictionary;
         }
 
         [SetUp]
@@ -44,6 +45,10 @@ public void Setup()
                             <li />
                             <li />
                         </list>
+                        <dictionary>
+                          <horse />
+                          <dog />
+                        </dictionary>
                     </PathDec>
                 </Decs>");
             parser.Finish();
@@ -96,5 +101,17 @@ public void List([ValuesExcept(RecorderMode.Simple)] RecorderMode mode, [Values(
 
             Assert.AreSame(item, newItem);
         }
+
+        [Test]
+        public void Dictionary([ValuesExcept(RecorderMode.Simple)] RecorderMode mode, [Values("horse", "dog")] string key)
+        {
+            var dec = Dec.Database<PathDec>.Get("TestDec");
+
+            var item = dec.dictionary[key];
+
+            var newItem = DoRecorderRoundTrip(item, mode);
+
+            Assert.AreSame(item, newItem);
+        }
     }
 }