Merge branch 'develop'

entelect · Jun 2, 2015 · 56a7271 · 56a7271
2 parents 9c33c91 + 058c960
commit 56a7271
Show file tree

Hide file tree

Showing 6 changed files with 187 additions and 70 deletions.
diff --git a/README.md b/README.md
@@ -8,7 +8,7 @@ Core .net libraries used by [Entelect](http://www.entelect.co.za)
 
 Install via [NuGet](https://www.nuget.org/packages/Entelect/)
 
-Read the [Documentation](http://sereph.github.io/Entelect/)
+Read the [Documentation](http://entelect.github.io/Entelect/)
 
 ##How To Contribute
 

diff --git a/src/Entelect/Enums/EnumExtensions.cs b/src/Entelect/Enums/EnumExtensions.cs
@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 namespace Entelect.Extensions
 {
     /// <summary>
@@ -30,8 +28,10 @@ public static string ToSpacedString(this Enum source)
         /// <exception cref="System.ArgumentException">T must be an enumerated type</exception>
         public static T Parse<T>(string value) where T : struct, IConvertible
         {
-            if (!typeof(T).IsEnum)
+            if(!typeof(T).IsEnum)
+            {
                 throw new ArgumentException("T must be an enumerated type");
+            }
             return ParseEnum<T>(value, default(T), true);
         }
 
@@ -47,10 +47,16 @@ public static T Parse<T>(string value) where T : struct, IConvertible
         /// <exception cref="System.ArgumentException">T must be an enumerated type</exception>
         public static T Parse<T>(string value, T defaultValue) where T : struct, IConvertible
         {
-            if (!typeof(T).IsEnum)
+            if(!typeof(T).IsEnum)
+            {
                 throw new ArgumentException("T must be an enumerated type");
-            if (string.IsNullOrWhiteSpace(value))
+            }
+
+            if(string.IsNullOrWhiteSpace(value))
+            {
                 return defaultValue;
+            }
+
             return ParseEnum(value, defaultValue, false);
 
         }
@@ -69,11 +75,17 @@ private static T ParseEnum<T>(string value, T defaultValue, bool throwExceptionI
         {
             foreach (T item in Enum.GetValues(typeof(T)))
             {
-                if (item.ToString().Equals(value.RemoveAllWhitespace(), StringComparison.OrdinalIgnoreCase))
+                if(item.ToString().Equals(value.RemoveAllWhitespace(), StringComparison.OrdinalIgnoreCase))
+                {
                     return item;
+                }
+
             }
-            if (!throwExceptionIfNotFound)
+            if(!throwExceptionIfNotFound)
+            {
                 return defaultValue;
+            }
+
             throw new ArgumentException(string.Format("value {0} could not be converted to an enum of type {1}", value,
                                                       defaultValue.GetType().FullName));
         }

diff --git a/src/Entelect/Strings/StringExtensions.cs b/src/Entelect/Strings/StringExtensions.cs
@@ -92,5 +92,27 @@ public static string RemoveAllWhitespace(this string input)
         {
             return new string(input.ToCharArray().Where(c => !Char.IsWhiteSpace(c)).ToArray());
         }
+
+        /// <summary>
+        /// Indicates whether the spesified string is null or Empty.
+        /// Wraps System.String.IsNullOrEmpty
+        /// </summary>
+        /// <param name="input">The string to test</param>
+        /// <returns>False if input contains characters</returns>
+        public static bool IsNullOrEmpty(this string input)
+        {
+            return string.IsNullOrEmpty(input);
+        }
+
+        /// <summary>
+        /// Indicates whether the spesified string is null or Empty or only whitespace.
+        /// Wraps System.String.IsNullOrWhiteSpace
+        /// </summary>
+        /// <param name="input">The string to test</param>
+        /// <returns>False if input contains characters that are not whitespace characters</returns>
+        public static bool IsNullOrWhiteSpace(this string input)
+        {
+            return string.IsNullOrWhiteSpace(input);
+        }
     }
 }
diff --git a/src/Entelect/Types/TypeExtensions.cs b/src/Entelect/Types/TypeExtensions.cs
@@ -13,108 +13,117 @@ public class TypeExtensions
         /// Adapted from http://stackoverflow.com/questions/721870/c-sharp-how-can-i-get-type-from-a-string-representation
         /// </summary>
         /// <param name="typeName"></param>
-        /// <returns></returns>
+        /// <returns>Null if type is not recognized</returns>
         /// <exception cref="ArgumentNullException"></exception>
         public static Type GetTypeFromTypeName(string typeName)
         {
             if (typeName == null)
+            {
                 throw new ArgumentNullException("typeName");
+            }
+
+            var isArray = typeName.IndexOf("[]", StringComparison.OrdinalIgnoreCase) != -1;
+            var isNullable = typeName.IndexOf("?", StringComparison.OrdinalIgnoreCase) != -1;
+
+            var formattedTypeName = FormatTypeName(typeName, isArray, isNullable);
 
-            bool isArray = false, isNullable = false;
+            var systemTypeName = ExtractSystemTypeNames(formattedTypeName);
+
+            var extractedTypeName = ExtractType(systemTypeName, isArray, isNullable, formattedTypeName);
+
+            return Type.GetType(extractedTypeName);
+        }
+
+        private static string ExtractType(string systemTypeName, bool isArray, bool isNullable, string formattedTypeName)
+        {
+            var extractedTypeName = systemTypeName;
+            if (extractedTypeName != null)
+            {
+                if(isArray)
+                {
+                    extractedTypeName = extractedTypeName + "[]";
+                }
+
+                if(isNullable)
+                {
+                    extractedTypeName = String.Concat("System.Nullable`1[", extractedTypeName, "]");
+                }
+            }
+            else
+            {
+                extractedTypeName = formattedTypeName;
+            }
+            return extractedTypeName;
+        }
 
-            if (typeName.IndexOf("[]", StringComparison.OrdinalIgnoreCase) != -1)
+        private static string FormatTypeName(string typeName, bool isArray, bool isNullable)
+        {
+            var name = typeName;
+            if(isArray)
             {
-                isArray = true;
-                typeName = typeName.Remove(typeName.IndexOf("[]", StringComparison.OrdinalIgnoreCase), 2);
+                name = name.Remove(name.IndexOf("[]", StringComparison.OrdinalIgnoreCase), 2);
             }
 
-            if (typeName.IndexOf("?", StringComparison.OrdinalIgnoreCase) != -1)
+            if(isNullable)
             {
-                isNullable = true;
-                typeName = typeName.Remove(typeName.IndexOf("?", StringComparison.OrdinalIgnoreCase), 1);
+                name = name.Remove(name.IndexOf("?", StringComparison.OrdinalIgnoreCase), 1);
             }
 
-            typeName = typeName.ToLower();
-            typeName = typeName.ReplaceIgnoreCase("system.", "");
-            string parsedTypeName = null;
-            switch (typeName)
+            name = name.ToLower();
+            name = name.ReplaceIgnoreCase("system.", "");
+            return name;
+        }
+
+        private static string ExtractSystemTypeNames(string typeName)
+        {
+            switch(typeName)
             {
                 case "bool":
                 case "boolean":
-                    parsedTypeName = "System.Boolean";
-                    break;
+                    return "System.Boolean";
                 case "byte":
-                    parsedTypeName = "System.Byte";
-                    break;
+                    return "System.Byte";
                 case "char":
-                    parsedTypeName = "System.Char";
-                    break;
+                    return "System.Char";
                 case "datetime":
-                    parsedTypeName = "System.DateTime";
-                    break;
+                    return "System.DateTime";
                 case "datetimeoffset":
-                    parsedTypeName = "System.DateTimeOffset";
-                    break;
+                    return "System.DateTimeOffset";
                 case "decimal":
-                    parsedTypeName = "System.Decimal";
-                    break;
+                    return "System.Decimal";
                 case "double":
-                    parsedTypeName = "System.Double";
-                    break;
+                    return "System.Double";
                 case "float":
-                    parsedTypeName = "System.Single";
-                    break;
+                    return "System.Single";
                 case "int16":
                 case "short":
-                    parsedTypeName = "System.Int16";
-                    break;
+                    return "System.Int16";
                 case "int32":
                 case "int":
-                    parsedTypeName = "System.Int32";
-                    break;
+                    return "System.Int32";
                 case "int64":
                 case "long":
-                    parsedTypeName = "System.Int64";
-                    break;
+                    return "System.Int64";
                 case "object":
-                    parsedTypeName = "System.Object";
-                    break;
+                    return "System.Object";
                 case "sbyte":
-                    parsedTypeName = "System.SByte";
-                    break;
+                    return "System.SByte";
                 case "string":
-                    parsedTypeName = "System.String";
-                    break;
+                    return "System.String";
                 case "timespan":
-                    parsedTypeName = "System.TimeSpan";
-                    break;
+                    return "System.TimeSpan";
                 case "uint16":
                 case "ushort":
-                    parsedTypeName = "System.UInt16";
-                    break;
+                    return "System.UInt16";
                 case "uint32":
                 case "uint":
-                    parsedTypeName = "System.UInt32";
-                    break;
+                    return "System.UInt32";
                 case "uint64":
                 case "ulong":
-                    parsedTypeName = "System.UInt64";
-                    break;
+                    return "System.UInt64";
+                default:
+                    return null;
             }
-
-            if (parsedTypeName != null)
-            {
-                if (isArray)
-                    parsedTypeName = parsedTypeName + "[]";
-
-                if (isNullable)
-                    parsedTypeName = String.Concat("System.Nullable`1[", parsedTypeName, "]");
-            }
-            else
-                parsedTypeName = typeName;
-
-            // Expected to throw an exception in case the type has not been recognized.
-            return Type.GetType(parsedTypeName);
         }
     }
 }
diff --git a/test/Entelect.Tests/Strings/StringExtensionsTests.cs b/test/Entelect.Tests/Strings/StringExtensionsTests.cs
@@ -71,5 +71,27 @@ public void RemoveAllWhitespace(string input, string expected)
             input = input.RemoveAllWhitespace();
             StringAssert.AreEqualIgnoringCase(expected, input);
         }
+
+        [Test]
+        [TestCase(null, true)]
+        [TestCase("", true)]
+        [TestCase(" ", false)]
+        [TestCase(" Aa aAa aA ", false)]
+        public void IsNullOrEmpty(string input, bool expected)
+        {
+            var result = input.IsNullOrEmpty();
+            Assert.AreEqual(expected, result);
+        }
+
+        [Test]
+        [TestCase(null, true)]
+        [TestCase("", true)]
+        [TestCase(" ", true)]
+        [TestCase(" Aa aAa aA ", false)]
+        public void IsNullOrWhiteSpace(string input, bool expected)
+        {
+            var result = input.IsNullOrWhiteSpace();
+            Assert.AreEqual(expected, result);
+        }
     }
 }
diff --git a/test/Entelect.Tests/Types/TypeExtensionsTests.cs b/test/Entelect.Tests/Types/TypeExtensionsTests.cs
@@ -10,10 +10,62 @@ public class TypeExtensionsTests
         [Test]
         [TestCase("string", typeof(String))]
         [TestCase("system.string", typeof(String))]
+        [TestCase("bool", typeof(bool))]
+        [TestCase("boolean", typeof(bool))]
+        [TestCase("byte", typeof(byte))]
+        [TestCase("char", typeof(char))]
+        [TestCase("datetime", typeof(System.DateTime))]
+        [TestCase("datetimeoffset", typeof(DateTimeOffset))]
+        [TestCase("decimal", typeof(Decimal))]
+        [TestCase("double", typeof(Double))]
+        [TestCase("float", typeof(Single))]
+        [TestCase("int16", typeof(Int16))]
+        [TestCase("short", typeof(Int16))]
+        [TestCase("int32", typeof(Int32))]
+        [TestCase("int", typeof(Int32))]
+        [TestCase("int64", typeof(Int64))]
+        [TestCase("long", typeof(Int64))]
+        [TestCase("object", typeof(Object))]
+        [TestCase("sbyte", typeof(SByte))]
+        [TestCase("timespan", typeof(TimeSpan))]
+        [TestCase("uint16", typeof(UInt16))]
+        [TestCase("ushort", typeof(UInt16))]
+        [TestCase("uint32", typeof(UInt32))]
+        [TestCase("uint", typeof(UInt32))]
+        [TestCase("uint64", typeof(UInt64))]
+        [TestCase("ulong", typeof(UInt64))]
         public void GetTypeFromTypeName(string typeString, Type expectedType)
         {
             var type = TypeExtensions.GetTypeFromTypeName(typeString);
             Assert.AreEqual(expectedType, type);
         }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void GivenNullTypeString_WhenGetTypeFromTypeName_ThrowException()
+        {
+            TypeExtensions.GetTypeFromTypeName(null);
+        }
+
+        [Test]
+        public void GivenTypeNameAsArray_WhenGetTypeFromTypeName_ReturnArrayOfType()
+        {
+            var type = TypeExtensions.GetTypeFromTypeName("string[]");
+            Assert.AreEqual(typeof(String[]), type);
+        }
+
+        [Test]
+        public void GivenNullableTypeName_WhenGetTypeFromTypeName_ReturnNullableType()
+        {
+            var type = TypeExtensions.GetTypeFromTypeName("Int?");
+            Assert.AreEqual(typeof(Int32?), type);
+        }
+
+        [Test]
+        public void GivenUnKnowntype_WhenGetTypeFromTypeName_ReturnNull()
+        {
+            var type = TypeExtensions.GetTypeFromTypeName("SomeType");
+            Assert.IsNull(type);
+        }
     }
 }