Finished refactoring ModelManager, now there is no circular dependency with JsonApiFormatter, and the interface boundary is much more clear.

SphtKr · SphtKr · commit 547de42da822 · 2015-01-28T13:31:15.000+01:00
diff --git a/JSONAPI.Tests/Core/ModelManagerTests.cs b/JSONAPI.Tests/Core/ModelManagerTests.cs
@@ -3,13 +3,15 @@
 using JSONAPI.Core;
 using JSONAPI.Tests.Models;
 using System.Reflection;
+using System.Collections.Generic;
+using System.Collections;
 
 namespace JSONAPI.Tests.Core
 {
     [TestClass]
     public class ModelManagerTests
     {
-        private class InvalidModel
+        private class InvalidModel // No Id discernable!
         {
             public string Data { get; set; }
         }
@@ -97,5 +99,54 @@ public void GetPropertyForJsonKeyTest()
             Assert.AreSame(authorType.GetProperty("Posts"), postsProp);
 
         }
+
+        [TestMethod]
+        public void IsSerializedAsManyTest()
+        {
+            // Arrange
+            var mm = new ModelManager();
+
+            // Act
+            bool isArray = mm.IsSerializedAsMany(typeof(Post[]));
+            bool isGenericEnumerable = mm.IsSerializedAsMany(typeof(IEnumerable<Post>));
+            bool isString = mm.IsSerializedAsMany(typeof(string));
+            bool isAuthor = mm.IsSerializedAsMany(typeof(Author));
+            bool isNonGenericEnumerable = mm.IsSerializedAsMany(typeof(IEnumerable));
+
+            // Assert
+            Assert.IsTrue(isArray);
+            Assert.IsTrue(isGenericEnumerable);
+            Assert.IsFalse(isString);
+            Assert.IsFalse(isAuthor);
+            Assert.IsFalse(isNonGenericEnumerable);
+        }
+
+        [TestMethod]
+        public void GetElementTypeTest()
+        {
+            // Arrange
+            var mm = new ModelManager();
+
+            // Act
+            Type postTypeFromArray = mm.GetElementType(typeof(Post[]));
+            Type postTypeFromEnumerable = mm.GetElementType(typeof(IEnumerable<Post>));
+
+            // Assert
+            Assert.AreSame(typeof(Post), postTypeFromArray);
+            Assert.AreSame(typeof(Post), postTypeFromEnumerable);
+        }
+
+        [TestMethod]
+        public void GetElementTypeInvalidArgumentTest()
+        {
+            // Arrange
+            var mm = new ModelManager();
+
+            // Act
+            Type x = mm.GetElementType(typeof(Author));
+
+            // Assert
+            Assert.IsNull(x, "Return value of GetElementType should be null for a non-Many type argument!");
+        }
     }
 }
diff --git a/JSONAPI/Core/IModelManager.cs b/JSONAPI/Core/IModelManager.cs
@@ -11,9 +11,42 @@ public interface IModelManager
     {
         IPluralizationService PluralizationService { get; }
 
+        /// <summary>
+        /// Returns the property that is treated as the unique identifier in a given class.
+        /// This is used most importantly by JsonApiFormatter to determine what value to
+        /// write when serializing a "Many" relationship as an array of Ids. It is also
+        /// used to make dummy related objects (with only the Id property set) when
+        /// deserializing a JSON payload that specifies a related object only by Id.
+        /// 
+        /// Rules for determining this may vary by implementation.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns>The property determined to represent the Id.</returns>
         PropertyInfo GetIdProperty(Type type);
+
+        /// <summary>
+        /// Returns the key that will be used to represent a collection of objects of a
+        /// given type, for example in the top-level of a JSON API document or within
+        /// the "linked" objects section of a payload.
+        /// </summary>
+        /// <param name="type">The serializable Type</param>
+        /// <returns>The string denoting the given type in JSON documents.</returns>
         string GetJsonKeyForType(Type type);
+
+        /// <summary>
+        /// Returns the key that will be used to represent the given property in serialized
+        /// JSON. Inverse of GetPropertyForJsonKey.
+        /// </summary>
+        /// <param name="propInfo">The serializable property</param>
+        /// <returns>The string denoting the given property within a JSON document.</returns>
         string GetJsonKeyForProperty(PropertyInfo propInfo); //TODO: Do we need to have a type parameter here, in case the property is inherited?
+
+        /// <summary>
+        /// Returns the property corresponding to a given JSON Key. Inverse of GetJsonKeyForType.
+        /// </summary>
+        /// <param name="type">The Type to find the property on</param>
+        /// <param name="jsonKey">The JSON key representing a property</param>
+        /// <returns></returns>
         PropertyInfo GetPropertyForJsonKey(Type type, string jsonKey);
 
         /// <summary>
@@ -25,7 +58,21 @@ public interface IModelManager
         //TODO: This needs to include JsonIgnore'd properties, so that they can be found and explicitly included at runtime...confusing? Add another method that excludes these?
         PropertyInfo[] GetProperties(Type type);
 
-        //[Obsolete]
-        //IDictionary<string, PropertyInfo> GetPropertyMap(Type type);
+        /// <summary>
+        /// Determines whether or not the given type will be treated as a "Many" relationship. 
+        /// </summary>
+        /// <param name="type">The serializable Type</param>
+        /// <returns>True for Array and IEnumerable&lt;T&gt; types, false otherwise.</returns>
+        bool IsSerializedAsMany(Type type);
+
+        /// <summary>
+        /// Analogue for System.Type.GetElementType, but works for arrays or IEnumerable&lt;T&gt;,
+        /// and provides a capture point to cache potentially expensive reflection operations that
+        /// have to occur repeatedly in JsonApiFormatter.
+        /// </summary>
+        /// <param name="manyType">A type which must be either an Array type or implement IEnumerable&lt;T&gt;.</param>
+        /// <returns>The element type of an Array, or the first generic parameter of an IEnumerable&lt;T&gt;.</returns>
+        Type GetElementType(Type manyType);
+
     }
 }
diff --git a/JSONAPI/Core/ModelManager.cs b/JSONAPI/Core/ModelManager.cs
@@ -113,10 +113,6 @@ public PropertyInfo GetPropertyForJsonKey(Type type, string jsonKey)
 
         #endregion
 
-        //TODO: This has been "moved" here so we can cache the results and improve performance...but
-        // it raises the question of whether the various methods called within here should belong
-        // to JsonApiFormatter at all...should they move here also? Should the IPluralizationService
-        // instance belong to ModelManager instead?
         public string GetJsonKeyForType(Type type)
         {
             string key = null;
@@ -127,8 +123,8 @@ public string GetJsonKeyForType(Type type)
             {
                 if (keyCache.TryGetValue(type, out key)) return key;
 
-                if (JsonApiFormatter.IsMany(type))
-                    type = JsonApiFormatter.GetSingleType(type);
+                if (IsSerializedAsMany(type))
+                    type = GetElementType(type);
 
                 var attrs = type.CustomAttributes.Where(x => x.AttributeType == typeof(Newtonsoft.Json.JsonObjectAttribute)).ToList();
 
@@ -159,5 +155,26 @@ protected static string FormatPropertyName(string propertyName)
             string result = propertyName.Substring(0, 1).ToLower() + propertyName.Substring(1);
             return result;
         }
+
+        public bool IsSerializedAsMany(Type type)
+        {
+            bool isMany = 
+                type.IsArray ||
+                (type.GetInterfaces().Contains(typeof(System.Collections.IEnumerable)) && type.IsGenericType);
+
+            return isMany;
+        }
+
+        public Type GetElementType(Type manyType)
+        {
+            Type etype = null;
+            if (manyType.IsGenericType)
+                etype = manyType.GetGenericArguments()[0];
+            else
+                etype = manyType.GetElementType();
+
+            return etype;
+        }
+
     }
 }
diff --git a/JSONAPI/Json/JsonApiFormatter.cs b/JSONAPI/Json/JsonApiFormatter.cs
@@ -119,18 +119,18 @@ public override Task WriteToStreamAsync(System.Type type, object value, Stream w
             else
             {
                 Type valtype = GetSingleType(value.GetType());
-                if (IsMany(value.GetType()))
+                if (_modelManager.IsSerializedAsMany(value.GetType()))
                     aggregator.AddPrimary(valtype, (IEnumerable<object>) value);
                 else
                     aggregator.AddPrimary(valtype, value);
 
                 //writer.Formatting = Formatting.Indented;
 
-                var root = GetJsonKeyForType(type, value);
+                var root = _modelManager.GetJsonKeyForType(type);
 
                 writer.WriteStartObject();
                 writer.WritePropertyName(root);
-                if (IsMany(value.GetType()))
+                if (_modelManager.IsSerializedAsMany(value.GetType()))
                     this.SerializeMany(value, writeStream, writer, serializer, aggregator);
                 else
                     this.Serialize(value, writeStream, writer, serializer, aggregator);
@@ -422,7 +422,7 @@ protected void SerializeLinkedResources(Stream writeStream, JsonWriter writer, J
                 foreach (KeyValuePair<Type, KeyValuePair<JsonWriter, StringWriter>> apair in writers)
                 {
                     apair.Value.Key.WriteEnd(); // close off the array
-                    writer.WritePropertyName(GetJsonKeyForType(apair.Key));
+                    writer.WritePropertyName(_modelManager.GetJsonKeyForType(apair.Key));
                     writer.WriteRawValue(apair.Value.Value.ToString()); // write the contents of the type JsonWriter's StringWriter to the main JsonWriter
                 }
 
@@ -445,7 +445,7 @@ private object ReadFromStream(Type type, Stream readStream, HttpContent content,
         {
             object retval = null;
             Type singleType = GetSingleType(type);
-            var pripropname = GetJsonKeyForType(type);
+            var pripropname = _modelManager.GetJsonKeyForType(type);
             var contentHeaders = content == null ? null : content.Headers;
 
             // If content length is 0 then return default value for this type
@@ -522,7 +522,7 @@ private object ReadFromStream(Type type, Stream readStream, HttpContent content,
                  */
                 if (retval != null)
                 {
-                    if (!type.IsAssignableFrom(retval.GetType()) && IsMany(type))
+                    if (!type.IsAssignableFrom(retval.GetType()) && _modelManager.IsSerializedAsMany(type))
                     {
                         IList list = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(singleType));
                         list.Add(retval);
@@ -770,42 +770,11 @@ private object DeserializePrimitive(Type type, JsonReader reader)
 
         #endregion
 
-        //TODO: Remove shell function, call _modelManager.GetJsonKeyForType directly.
-        private string GetJsonKeyForType(Type type, dynamic value = null)
+        private Type GetSingleType(Type type)//dynamic value = null)
         {
-            return _modelManager.GetJsonKeyForType(type);
+            return _modelManager.IsSerializedAsMany(type) ? _modelManager.GetElementType(type) : type;
         }
 
-        //private string GetPropertyName(Type type)
-        //{
-        //    return FormatPropertyName(PluralizationService.Pluralize(type.Name));
-        //}
-
-        internal static bool IsMany(Type type)
-        {
-            return
-                type.IsArray ||
-                (type.GetInterfaces().Contains(typeof(IEnumerable)) && type.IsGenericType);
-        }
-
-        internal static Type GetSingleType(Type type)//dynamic value = null)
-        {
-            if (IsMany(type))
-                if (type.IsGenericType)
-                    return type.GetGenericArguments()[0];
-                else
-                    return type.GetElementType();
-            return type;
-        }
-
-        /*
-        public static string FormatPropertyName(string propertyName)
-        {
-            string result = propertyName.Substring(0, 1).ToLower() + propertyName.Substring(1);
-            return result;
-        }
-        */
-
         protected object GetById(Type type, string id)
         {
             // Only good for creating dummy relationship objects...
@@ -815,13 +784,6 @@ protected object GetById(Type type, string id)
             return retval;
         }
 
-        /*
-        protected PropertyInfo GetIdProperty(Type type)
-        {
-            return type.GetProperty("Id");
-        }
-        */
-
         protected string GetValueForIdProperty(PropertyInfo idprop, object obj)
         {
             if (idprop != null)
