From fd8e68091e8c780f893ff3ff330a57b4239d8b7f Mon Sep 17 00:00:00 2001
From: Pieter-Jan Briers <pieterjan.briers+git@gmail.com>
Date: Wed, 25 Mar 2020 21:34:30 +0100
Subject: [PATCH] Fix implementation, add tests.

---
 .../Serialization/YamlObjectSerializer.cs     | 26 ++++-------
 .../YamlObjectSerializer_Test.cs              | 45 +++++++++++++++++++
 2 files changed, 53 insertions(+), 18 deletions(-)

diff --git a/Robust.Shared/Serialization/YamlObjectSerializer.cs b/Robust.Shared/Serialization/YamlObjectSerializer.cs
index 592380bf47..5d93403945 100644
--- a/Robust.Shared/Serialization/YamlObjectSerializer.cs
+++ b/Robust.Shared/Serialization/YamlObjectSerializer.cs
@@ -161,37 +161,27 @@ namespace Robust.Shared.Serialization
 
             if (!(expr.Body is MemberExpression mExpr))
             {
-                throw new NotImplementedException(expr.Body.GetType().FullName);
+                throw new NotSupportedException("Cannot handle expressions of types other than MemberExpression.");
             }
 
-            Func<T> getter;
-            Action<T> setter;
+
+            WriteFunctionDelegate<T> getter;
+            ReadFunctionDelegate<T> setter;
             switch (mExpr.Member)
             {
                 case FieldInfo fi:
                     getter = () => (T) fi.GetValue(o);
-                    setter = (v) => fi.SetValue(o, v);
+                    setter = v => fi.SetValue(o, v);
                     break;
                 case PropertyInfo pi:
                     getter = () => (T) pi.GetValue(o);
-                    setter = (v) => pi.SetValue(o, v);
+                    setter = v => pi.SetValue(o, v);
                     break;
                 default:
-                    throw new NotImplementedException(mExpr.Member.GetType().FullName);
+                    throw new NotSupportedException("Cannot handle member expressions of types other than FieldInfo or PropertyInfo.");
             }
 
-            var value = getter();
-            DataField(ref value, name, defaultValue, alwaysWrite);
-
-            if (Writing)
-            {
-                return;
-            }
-
-            if (!alwaysWrite && IsValueDefault(name, value, defaultValue))
-            {
-                setter(value);
-            }
+            DataReadWriteFunction(name, defaultValue, setter, getter, alwaysWrite);
         }
 
         /// <inheritdoc />
diff --git a/Robust.UnitTesting/Shared/Serialization/YamlObjectSerializer_Test.cs b/Robust.UnitTesting/Shared/Serialization/YamlObjectSerializer_Test.cs
index c7e9c086d1..815f9cb08f 100644
--- a/Robust.UnitTesting/Shared/Serialization/YamlObjectSerializer_Test.cs
+++ b/Robust.UnitTesting/Shared/Serialization/YamlObjectSerializer_Test.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
 using NUnit.Framework;
+using Robust.Shared.Maths;
 using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
 using YamlDotNet.RepresentationModel;
@@ -82,6 +83,43 @@ namespace Robust.UnitTesting.Shared.Serialization
                 Assert.That(data[kvEntry.Key], Is.EqualTo(kvEntry.Value));
         }
 
+        [Test]
+        public void DeserializeExpressionTest()
+        {
+            var dummy = new DummyClass();
+
+            var rootNode = YamlTextToNode("foo: 5\nbar: \"baz\"");
+            var serializer = YamlObjectSerializer.NewReader(rootNode);
+
+            serializer.DataField(dummy, d => d.Foo, "foo", 4);
+            serializer.DataField(dummy, d => d.Bar, "bar", "honk");
+            serializer.DataField(dummy, d => d.Baz, "baz", Color.Black);
+
+            Assert.That(dummy.Foo, Is.EqualTo(5));
+            Assert.That(dummy.Bar, Is.EqualTo("baz"));
+            Assert.That(dummy.Baz, Is.EqualTo(Color.Black));
+        }
+
+        [Test]
+        public void SerializeExpressionTest()
+        {
+            var dummy = new DummyClass
+            {
+                Bar = "honk!",
+                Baz = Color.Black,
+                Foo = 5
+            };
+
+            var mapping = new YamlMappingNode();
+            var serializer = YamlObjectSerializer.NewWriter(mapping);
+
+            serializer.DataField(dummy, d => d.Foo, "foo", 1);
+            serializer.DataField(dummy, d => d.Bar, "bar", "*silence*");
+            serializer.DataField(dummy, d => d.Baz, "baz", Color.Black);
+
+            Assert.That(mapping, Is.EquivalentTo(new YamlMappingNode {{"bar", "honk!"}, {"foo", "5"}}));
+        }
+
         private readonly string SerializedDictYaml = "datadict:\n  val1: 1\n  val2: 2\n...\n";
         private readonly Dictionary<string, int> SerializableDict = new Dictionary<string, int> { { "val1", 1 }, { "val2", 2 } };
 
@@ -125,5 +163,12 @@ namespace Robust.UnitTesting.Shared.Serialization
                 return (YamlMappingNode)firstDoc.RootNode;
             }
         }
+
+        private class DummyClass
+        {
+            public int Foo { get; set; }
+            public string Bar { get; set; }
+            public Color Baz { get; set; } = Color.Orange;
+        }
     }
 }