Add more options to SimpleJson

Add extension methods for serializing/deserializing so we can
control how fields and properties are named. This allows us to
serialize/deserialize public and private fields and properties
with either Capitalized or lowerCase names

Author: shana

script

@@ -198,7 +198,7 @@ private void LoadConnectionsFromDisk()
                 var json = cachePath.ReadAllText();
                 try
                 {
-                    var conns = SimpleJson.DeserializeObject<Connection[]>(json);
+                    var conns = json.FromJson<Connection[]>();
                     UpdateConnections(conns);
                 }
                 catch (IOException ex)
@@ -219,7 +219,7 @@ private void SaveConnectionsToDisk(bool raiseChangedEvent = true)
             //logger.Trace("WriteCacheToDisk Count:{0} Path:{1}", connectionCache.Count, cachePath.ToString());
             try
             {
-                var json = SimpleJson.SerializeObject(connections.Values.ToArray());
+                var json = connections.Values.ToJson();
                 cachePath.WriteAllText(json);
             }
             catch (IOException ex)

src/GitHub.Api/Authentication/Keychain.cs

@@ -36,7 +36,7 @@
 
 // NOTE: uncomment the following line to disable linq expressions/compiled lambda (better performance) instead of method.invoke().
 // define if you are using .net framework <= 3.0 or < WP7.5
-//#define SIMPLE_JSON_NO_LINQ_EXPRESSION
+#define SIMPLE_JSON_NO_LINQ_EXPRESSION
 
 // NOTE: uncomment the following line if you are compiling under Window Metro style application/library.
 // usually already defined in properties
@@ -66,12 +66,14 @@
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Text;
-using GitHub.Reflection;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using GitHub.Unity.Json;
 
 // ReSharper disable LoopCanBeConvertedToQuery
 // ReSharper disable RedundantExplicitArrayCreation
 // ReSharper disable SuggestUseVarKeywordEvident
-namespace GitHub
+namespace GitHub.Unity.Json
 {
     /// <summary>
     /// Represents the json array.
@@ -482,10 +484,7 @@ public override IEnumerable<string> GetDynamicMemberNames()
         }
 #endif
     }
-}
 
-namespace GitHub
-{
     /// <summary>
     /// This class encodes and decodes JSON strings.
     /// Spec. details, see http://www.json.org/
@@ -517,6 +516,7 @@ static class SimpleJson
 
         private static readonly char[] EscapeTable;
         private static readonly char[] EscapeCharacters = new char[] { '"', '\\', '\b', '\f', '\n', '\r', '\t' };
+        private static readonly string EscapeCharactersString = new string(EscapeCharacters);
 
         static SimpleJson()
         {
@@ -620,7 +620,7 @@ public static string EscapeToJavascriptString(string jsonString)
             StringBuilder sb = new StringBuilder();
             char c;
 
-            for (int i = 0; i < jsonString.Length; )
+            for (int i = 0; i < jsonString.Length;)
             {
                 c = jsonString[i++];
 
@@ -1282,14 +1282,14 @@ internal virtual ReflectionUtils.ConstructorDelegate ContructorDelegateFactory(T
                 if (propertyInfo.CanRead)
                 {
                     MethodInfo getMethod = ReflectionUtils.GetGetterMethodInfo(propertyInfo);
-                    if (getMethod.IsStatic || !getMethod.IsPublic)
+                    if (!CanAddProperty(propertyInfo, getMethod))
                         continue;
                     result[MapClrMemberNameToJsonFieldName(propertyInfo.Name)] = ReflectionUtils.GetGetMethod(propertyInfo);
                 }
             }
             foreach (FieldInfo fieldInfo in ReflectionUtils.GetFields(type))
             {
-                if (fieldInfo.IsStatic || !fieldInfo.IsPublic)
+                if (!CanAddField(fieldInfo))
                     continue;
                 result[MapClrMemberNameToJsonFieldName(fieldInfo.Name)] = ReflectionUtils.GetGetMethod(fieldInfo);
             }
@@ -1304,20 +1304,40 @@ internal virtual ReflectionUtils.ConstructorDelegate ContructorDelegateFactory(T
                 if (propertyInfo.CanWrite)
                 {
                     MethodInfo setMethod = ReflectionUtils.GetSetterMethodInfo(propertyInfo);
-                    if (setMethod.IsStatic || !setMethod.IsPublic)
+                    if (!CanAddProperty(propertyInfo, setMethod))
                         continue;
                     result[MapClrMemberNameToJsonFieldName(propertyInfo.Name)] = new KeyValuePair<Type, ReflectionUtils.SetDelegate>(propertyInfo.PropertyType, ReflectionUtils.GetSetMethod(propertyInfo));
                 }
             }
             foreach (FieldInfo fieldInfo in ReflectionUtils.GetFields(type))
             {
-                if (fieldInfo.IsInitOnly || fieldInfo.IsStatic || !fieldInfo.IsPublic)
+                if (fieldInfo.IsInitOnly || !CanAddField(fieldInfo))
                     continue;
                 result[MapClrMemberNameToJsonFieldName(fieldInfo.Name)] = new KeyValuePair<Type, ReflectionUtils.SetDelegate>(fieldInfo.FieldType, ReflectionUtils.GetSetMethod(fieldInfo));
             }
             return result;
         }
 
+        protected virtual bool CanAddField(FieldInfo field)
+        {
+            if (field.IsStatic)
+                return false;
+            if (ReflectionUtils.GetAttribute(field, typeof(NotSerializedAttribute)) != null)
+                return false;
+            if (ReflectionUtils.GetAttribute(field, typeof(CompilerGeneratedAttribute)) != null)
+                return false;
+            return true;
+        }
+
+        protected virtual bool CanAddProperty(PropertyInfo property, MethodInfo method)
+        {
+            if (method.IsStatic)
+                return false;
+            if (ReflectionUtils.GetAttribute(property, typeof(NotSerializedAttribute)) != null)
+                return false;
+            return true;
+        }
+
         public virtual bool TrySerializeNonPrimitiveObject(object input, out object output)
         {
             return TrySerializeKnownTypes(input, out output) || TrySerializeUnknownTypes(input, out output);
@@ -1329,7 +1349,7 @@ public virtual object DeserializeObject(object value, Type type)
             if (type == null) throw new ArgumentNullException("type");
             string str = value as string;
 
-            if (type == typeof (Guid) && string.IsNullOrEmpty(str))
+            if (type == typeof(Guid) && string.IsNullOrEmpty(str))
                 return default(Guid);
 
             if (value == null)
@@ -1349,19 +1369,19 @@ public virtual object DeserializeObject(object value, Type type)
                         return new Guid(str);
                     if (type == typeof(Uri))
                     {
-                        bool isValid =  Uri.IsWellFormedUriString(str, UriKind.RelativeOrAbsolute);
+                        bool isValid = Uri.IsWellFormedUriString(str, UriKind.RelativeOrAbsolute);
 
                         Uri result;
                         if (isValid && Uri.TryCreate(str, UriKind.RelativeOrAbsolute, out result))
                             return result;
 
-                                                return null;
+                        return null;
                     }
 
-                                    if (type == typeof(string))
-                                        return str;
+                    if (type == typeof(string))
+                        return str;
 
-                                    return Convert.ChangeType(str, type, CultureInfo.InvariantCulture);
+                    return Convert.ChangeType(str, type, CultureInfo.InvariantCulture);
                 }
                 else
                 {
@@ -1592,8 +1612,6 @@ private static bool CanAdd(MemberInfo info, out string jsonKey)
 
 #endif
 
-    namespace Reflection
-    {
         // This class is meant to be copied into other libraries. So we want to exclude it from Code Analysis rules
         // that might be in place in the target project.
         [GeneratedCode("reflection-utils", "1.0.0")]
@@ -1648,7 +1666,7 @@ public static Type GetGenericListElementType(Type type)
                 foreach (Type implementedInterface in interfaces)
                 {
                     if (IsTypeGeneric(implementedInterface) &&
-                        implementedInterface.GetGenericTypeDefinition() == typeof (IList<>))
+                        implementedInterface.GetGenericTypeDefinition() == typeof(IList<>))
                     {
                         return GetGenericTypeArguments(implementedInterface)[0];
                     }
@@ -1837,7 +1855,13 @@ public static ConstructorDelegate GetConstructorByReflection(ConstructorInfo con
             public static ConstructorDelegate GetConstructorByReflection(Type type, params Type[] argsType)
             {
                 ConstructorInfo constructorInfo = GetConstructorInfo(type, argsType);
-                return constructorInfo == null ? null : GetConstructorByReflection(constructorInfo);
+                // if it's a value type (i.e., struct), it won't have a default constructor, so use Activator instead
+                return constructorInfo == null ? (type.IsValueType ? GetConstructorForValueType(type) : null) : GetConstructorByReflection(constructorInfo);
+            }
+
+            static ConstructorDelegate GetConstructorForValueType(Type type)
+            {
+                return delegate(object[] args) { return Activator.CreateInstance(type); };
             }
 
 #if !SIMPLE_JSON_NO_LINQ_EXPRESSION
@@ -1864,7 +1888,8 @@ public static ConstructorDelegate GetConstructorByExpression(ConstructorInfo con
             public static ConstructorDelegate GetConstructorByExpression(Type type, params Type[] argsType)
             {
                 ConstructorInfo constructorInfo = GetConstructorInfo(type, argsType);
-                return constructorInfo == null ? null : GetConstructorByExpression(constructorInfo);
+                // if it's a value type (i.e., struct), it won't have a default constructor, so use Activator instead
+                return constructorInfo == null ? (type.IsValueType ? GetConstructorForValueType(type) : null) : GetConstructorByExpression(constructorInfo);
             }
 
 #endif
@@ -1924,6 +1949,9 @@ public static SetDelegate GetSetMethod(PropertyInfo propertyInfo)
 #if SIMPLE_JSON_NO_LINQ_EXPRESSION
                 return GetSetMethodByReflection(propertyInfo);
 #else
+                // if it's a struct, we want to use reflection, as linq expressions modify copies of the object and not the real thing
+                if (propertyInfo.DeclaringType.IsValueType)
+                    return GetSetMethodByReflection(propertyInfo);
                 return GetSetMethodByExpression(propertyInfo);
 #endif
             }
@@ -1933,6 +1961,9 @@ public static SetDelegate GetSetMethod(FieldInfo fieldInfo)
 #if SIMPLE_JSON_NO_LINQ_EXPRESSION
                 return GetSetMethodByReflection(fieldInfo);
 #else
+                // if it's a struct, we want to use reflection, as linq expressions modify copies of the object and not the real thing
+                if (fieldInfo.DeclaringType.IsValueType)
+                    return GetSetMethodByReflection(fieldInfo);
                 return GetSetMethodByExpression(fieldInfo);
 #endif
             }
@@ -2119,6 +2150,107 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
             }
 
         }
+
+}
+
+namespace GitHub.Unity
+{
+    [System.AttributeUsage(System.AttributeTargets.Property |
+                       System.AttributeTargets.Field)]
+    public sealed class NotSerializedAttribute : Attribute
+    {
+    }
+
+    public static class JsonSerializerExtensions
+    {
+        static JsonSerializationStrategy publicLowerCaseStrategy = new JsonSerializationStrategy(true, true);
+        static JsonSerializationStrategy publicUpperCaseStrategy = new JsonSerializationStrategy(false, true);
+        static JsonSerializationStrategy privateLowerCaseStrategy = new JsonSerializationStrategy(true, false);
+        static JsonSerializationStrategy privateUpperCaseStrategy = new JsonSerializationStrategy(false, false);
+        public static string ToJson<T>(this T model, bool lowerCase = false, bool onlyPublic = true)
+        {
+            return SimpleJson.SerializeObject(model, GetStrategy(lowerCase, onlyPublic));
+        }
+
+        public static T FromJson<T>(this string json, bool lowerCase = false, bool onlyPublic = true)
+        {
+            return SimpleJson.DeserializeObject<T>(json, GetStrategy(lowerCase, onlyPublic));
+        }
+
+        public static T FromObject<T>(this object obj, bool lowerCase = false, bool onlyPublic = true)
+        {
+            if (obj == null)
+                return default(T);
+            var ret = GetStrategy(lowerCase, onlyPublic).DeserializeObject(obj, typeof(T));
+            if (ret is T)
+                return (T)ret;
+            return default(T);
+        }
+
+        private static JsonSerializationStrategy GetStrategy(bool lowerCase, bool onlyPublic)
+        {
+            if (lowerCase && onlyPublic)
+                return publicLowerCaseStrategy;
+            if (lowerCase && !onlyPublic)
+                return privateLowerCaseStrategy;
+            if (!lowerCase && onlyPublic)
+                return publicUpperCaseStrategy;
+            return privateUpperCaseStrategy;
+        }
+
+        /// <summary>
+        /// Convert from PascalCase to camelCase.
+        /// </summary>
+        private static string ToJsonPropertyName(string propertyName)
+        {
+            Guard.ArgumentNotNullOrWhiteSpace(propertyName, "propertyName");
+            int i = 0;
+            while (i < propertyName.Length && char.IsUpper(propertyName[i]))
+                i++;
+            return propertyName.Substring(0, i).ToLowerInvariant() + propertyName.Substring(i);
+        }
+
+        class JsonSerializationStrategy : PocoJsonSerializerStrategy
+        {
+            private bool toLowerCase = false;
+            private bool onlyPublic = true;
+
+            public JsonSerializationStrategy(bool toLowerCase, bool onlyPublic)
+            {
+                this.toLowerCase = toLowerCase;
+                this.onlyPublic = onlyPublic;
+            }
+
+            protected override bool CanAddField(FieldInfo field)
+            {
+                var canAdd = base.CanAddField(field);
+                return canAdd && ((onlyPublic && field.IsPublic) || !onlyPublic);
+            }
+
+            protected override bool CanAddProperty(PropertyInfo property, MethodInfo method)
+            {
+                var canAdd = base.CanAddProperty(property, method);
+                if (!canAdd)
+                    return false;
+
+                // we always serialize public things
+                if (method.IsPublic)
+                    return true;
+
+                // if the getter is private and we're only serializing public things, skip this property
+                if (onlyPublic && method.Name.StartsWith("get_"))
+                    return false;
+
+                return true;
+            }
+
+            protected override string MapClrMemberNameToJsonFieldName(string clrPropertyName)
+            {
+                if (!toLowerCase)
+                    return base.MapClrMemberNameToJsonFieldName(clrPropertyName);
+                return ToJsonPropertyName(clrPropertyName);
+            }
+        }
     }
 }
 // ReSharper restore LoopCanBeConvertedToQuery

src/GitHub.Api/Helpers/SimpleJson.cs

@@ -47,7 +47,7 @@ private UsageStore LoadUsage()
                     json = storePath.ReadAllText(Encoding.UTF8);
                     if (json != null)
                     {
-                        result = SimpleJson.DeserializeObject<UsageStore>(json);
+                        result = json.FromJson<UsageStore>();
                     }
                 }
                 catch (Exception ex)
@@ -83,7 +83,7 @@ private void SaveUsage(UsageStore store)
 
             try
             {
-                var json = SimpleJson.SerializeObject(store);
+                var json = store.ToJson();
                 storePath.WriteAllText(json, Encoding.UTF8);
             }
             catch (Exception ex)

src/GitHub.Api/Metrics/UsageTracker.cs

@@ -125,7 +125,7 @@ private void LoadFromCache(string path)
 
             try
             {
-                cacheData = SimpleJson.DeserializeObject<CacheData>(data);
+                cacheData = data.FromJson<CacheData>();
             }
             catch(Exception ex)
             {
@@ -149,7 +149,7 @@ private bool SaveToCache(string path)
 
             try
             {
-                var data = SimpleJson.SerializeObject(cacheData);
+                var data = cacheData.ToJson();
                 writeAllText(path, data);
             }
             catch (Exception ex)

src/GitHub.Api/Platform/Settings.cs

@@ -45,11 +45,13 @@ public static ILogging Instance
             set { instance = value; }
         }
 
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter")]
         public static ILogging GetLogger<T>()
         {
             return GetLogger(typeof(T));
         }
 
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters")]
         public static ILogging GetLogger(Type type)
         {
             return GetLogger(type.Name);