Added new overloads to Types

Author: khellang

TestStack.ConventionTests/ConventionData/TypeExtensions.cs

@@ -4,6 +4,7 @@
     using System.Collections.Generic;
     using System.Linq;
     using System.Reflection;
+    using System.Runtime.CompilerServices;
     using System.Text;
     using System.Text.RegularExpressions;
 
@@ -24,6 +25,11 @@ public static bool IsStatic(this Type type)
             return type.IsClass && !(type.IsSealed && type.IsAbstract);
         }
 
+        public static bool IsCompilerGenerated(this Type type)
+        {
+            return type.IsDefined(typeof(CompilerGeneratedAttribute), true);
+        }
+
         public static bool HasDefaultConstructor(this Type type)
         {
             return type.GetConstructors(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic |

TestStack.ConventionTests/ConventionData/Types.cs

@@ -2,8 +2,9 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.ComponentModel;
     using System.Linq;
-    using System.Runtime.CompilerServices;
+    using System.Reflection;
 
     /// <summary>
     ///     This is where we set what our convention is all about.
@@ -19,31 +20,190 @@ public Types(string descriptionOfTypes)
 
         public string Description { get; private set; }
 
-        public bool HasData {get { return TypesToVerify.Any(); }}
+        public bool HasData
+        {
+            get { return TypesToVerify.Any(); }
+        }
+
+        /// <summary>
+        /// Gets a filtered list of types from the assembly of the specified
+        /// type, <typeparam name="T" />, using the specified <param name="predicate" />.
+        /// </summary>
+        /// <typeparam name="T">A type residing in the assembly to get types from.</typeparam>
+        /// <param name="predicate">A function to test each type for a condition.</param>
+        public static Types InAssemblyOf<T>(Func<Type, bool> predicate)
+        {
+            return InAssemblyOf(typeof(T), predicate);
+        }
+
+        /// <summary>
+        /// Gets a filtered list of types from the assembly of the specified
+        /// type, <param name="type" />, using the specified <param name="predicate" />.
+        /// </summary>
+        /// <param name="type">A type residing in the assembly to get types from.</param>
+        /// <param name="predicate">A function to test each type for a condition.</param>
+        public static Types InAssemblyOf(Type type, Func<Type, bool> predicate)
+        {
+            return InAssembly(type.Assembly, predicate);
+        }
+
+        /// <summary>
+        /// Gets a filtered list of types from the specified <param name="assembly" /> using the specified <param name="predicate" />.
+        /// </summary>
+        /// <param name="assembly">The assembly to get types from.</param>
+        /// <param name="predicate">A function to test each type for a condition.</param>
+        public static Types InAssembly(Assembly assembly, Func<Type, bool> predicate)
+        {
+            return InAssembly(assembly, GetAssemblyName(assembly), predicate);
+        }
+
+        /// <summary>
+        /// Gets a filtered list of types from the assembly of the specified
+        /// type, <typeparam name="T" />, using the specified <param name="predicate" />.
+        /// </summary>
+        /// <typeparam name="T">A type residing in the assembly to get types from.</typeparam>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="predicate">A function to test each type for a condition.</param>
+        public static Types InAssemblyOf<T>(string descriptionOfTypes, Func<Type, bool> predicate)
+        {
+            return InAssemblyOf(typeof(T), descriptionOfTypes, predicate);
+        }
+
+        /// <summary>
+        /// Gets a filtered list of types from the assembly of the specified
+        /// type, <param name="type" />, using the specified <param name="predicate" />.
+        /// </summary>
+        /// <param name="type">A type residing in the assembly to get types from.</param>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="predicate">A function to test each type for a condition.</param>
+        public static Types InAssemblyOf(Type type, string descriptionOfTypes, Func<Type, bool> predicate)
+        {
+            return InAssembly(type.Assembly, descriptionOfTypes, predicate);
+        }
+
+        /// <summary>
+        /// Gets a filtered list of types from the specified <param name="assembly" /> using the specified <param name="predicate" />.
+        /// </summary>
+        /// <param name="assembly">The assembly to get types from.</param>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="predicate">A function to test each type for a condition.</param>
+        public static Types InAssembly(Assembly assembly, string descriptionOfTypes, Func<Type, bool> predicate)
+        {
+            return InAssemblies(new[] { assembly }, descriptionOfTypes, predicate);
+        }
+
+        /// <summary>
+        /// Gets an optionally filtered list of types from the specified <param name="assemblies" /> using the specified <param name="predicate" />.
+        /// </summary>
+        /// <param name="assemblies">A list of assemblies to get types from.</param>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="predicate">A function to test each type for a condition.</param>
+        public static Types InAssemblies(IEnumerable<Assembly> assemblies, string descriptionOfTypes, Func<Type, bool> predicate)
+        {
+            return InCollection(assemblies.SelectMany(x => x.GetTypes()).Where(predicate), descriptionOfTypes);
+        }
 
+        /// <summary>
+        /// Gets an optionally filtered list of types from the assembly of the specified type, <typeparam name="T" />.
+        /// </summary>
+        /// <typeparam name="T">A type residing in the assembly to get types from.</typeparam>
+        /// <param name="excludeCompilerGeneratedTypes">Compiler generated types will be excluded if set to <c>true</c>.</param>
         public static Types InAssemblyOf<T>(bool excludeCompilerGeneratedTypes = true)
         {
-            var assembly = typeof(T).Assembly;
-            var typesToVerify = assembly.GetTypes();
-            if (excludeCompilerGeneratedTypes)
-            {
-                typesToVerify = typesToVerify
-                    .Where(t => !t.GetCustomAttributes(typeof (CompilerGeneratedAttribute), true).Any())
-                    .ToArray();
-            }
-            return new Types(assembly.GetName().Name)
-            {
-                TypesToVerify = typesToVerify
-            };
+            return InAssemblyOf(typeof(T), excludeCompilerGeneratedTypes);
         }
 
+        /// <summary>
+        /// Gets an optionally filtered list of types from the assembly of the specified type, <param name="type" />.
+        /// </summary>
+        /// <param name="type">A type residing in the assembly to get types from.</param>
+        /// <param name="excludeCompilerGeneratedTypes">Compiler generated types will be excluded if set to <c>true</c>.</param>
+        public static Types InAssemblyOf(Type type, bool excludeCompilerGeneratedTypes = true)
+        {
+            return InAssembly(type.Assembly, excludeCompilerGeneratedTypes);
+        }
+
+        /// <summary>
+        /// Gets an optionally filtered list of types from the specified <param name="assembly" />.
+        /// </summary>
+        /// <param name="assembly">The assembly to get types from.</param>
+        /// <param name="excludeCompilerGeneratedTypes">Compiler generated types will be excluded if set to <c>true</c>.</param>
+        public static Types InAssembly(Assembly assembly, bool excludeCompilerGeneratedTypes = true)
+        {
+            return InAssembly(assembly, GetAssemblyName(assembly), excludeCompilerGeneratedTypes);
+        }
+
+        /// <summary>
+        /// Gets an optionally filtered list of types from the assembly of the specified
+        /// type, <typeparam name="T" />, using the specified <param name="types" /> filter.
+        /// </summary>
+        /// <typeparam name="T">A type residing in the assembly to get types from.</typeparam>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="types">A function to filter or add matched types.</param>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Obsolete("This method is obsolete and should not be used. Use the overload with a predicate instead.")]
         public static Types InAssemblyOf<T>(string descriptionOfTypes, Func<IEnumerable<Type>, IEnumerable<Type>> types)
         {
-            var assembly = typeof (T).Assembly;
-            return new Types(descriptionOfTypes)
-            {
-                TypesToVerify = types(assembly.GetTypes()).ToArray()
-            };
+            return InCollection(types(typeof(T).Assembly.GetTypes()), descriptionOfTypes);
+        }
+
+        /// <summary>
+        /// Gets an optionally filtered list of types from the assembly of the specified type, <typeparam name="T" />.
+        /// </summary>
+        /// <typeparam name="T">A type residing in the assembly to get types from.</typeparam>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="excludeCompilerGeneratedTypes">Compiler generated types will be excluded if set to <c>true</c>.</param>
+        public static Types InAssemblyOf<T>(string descriptionOfTypes, bool excludeCompilerGeneratedTypes = true)
+        {
+            return InAssemblyOf(typeof(T), descriptionOfTypes, excludeCompilerGeneratedTypes);
+        }
+
+        /// <summary>
+        /// Gets an optionally filtered list of types from the assembly of the specified type, <param name="type" />.
+        /// </summary>
+        /// <param name="type">A type residing in the assembly to get types from.</param>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="excludeCompilerGeneratedTypes">Compiler generated types will be excluded if set to <c>true</c>.</param>
+        public static Types InAssemblyOf(Type type, string descriptionOfTypes, bool excludeCompilerGeneratedTypes = true)
+        {
+            return InAssembly(type.Assembly, descriptionOfTypes, excludeCompilerGeneratedTypes);
+        }
+
+        /// <summary>
+        /// Gets an optionally filtered list of types from the specified <param name="assembly" />.
+        /// </summary>
+        /// <param name="assembly">The assembly to get types from.</param>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="excludeCompilerGeneratedTypes">Compiler generated types will be excluded if set to <c>true</c>.</param>
+        public static Types InAssembly(Assembly assembly, string descriptionOfTypes, bool excludeCompilerGeneratedTypes = true)
+        {
+            return InAssemblies(new[] { assembly }, descriptionOfTypes, excludeCompilerGeneratedTypes);
+        }
+
+        /// <summary>
+        /// Gets an optionally filtered list of types from the specified <param name="assemblies" />.
+        /// </summary>
+        /// <param name="assemblies">A list of assemblies to get types from.</param>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        /// <param name="excludeCompilerGeneratedTypes">Compiler generated types will be excluded if set to <c>true</c>.</param>
+        public static Types InAssemblies(IEnumerable<Assembly> assemblies, string descriptionOfTypes, bool excludeCompilerGeneratedTypes = true)
+        {
+            return InAssemblies(assemblies, descriptionOfTypes, type => !(excludeCompilerGeneratedTypes && type.IsCompilerGenerated()));
+        }
+
+        /// <summary>
+        /// Gets a list of types from the specified <param name="types" /> collection.
+        /// </summary>
+        /// <param name="types">The types.</param>
+        /// <param name="descriptionOfTypes">A description of the matched types.</param>
+        public static Types InCollection(IEnumerable<Type> types, string descriptionOfTypes)
+        {
+            return new Types(descriptionOfTypes) { TypesToVerify = types.ToArray() };
+        }
+
+        private static string GetAssemblyName(Assembly assembly)
+        {
+            return assembly.GetName().Name;
         }
     }
 }