Merge pull request #94 from tonerdo/filter-assemblies

Add ability to exclude assemblies by expression

Author: tonerdo

README.md

@@ -87,18 +87,34 @@ You can ignore a method or an entire class from code coverage by creating and ap
 Coverlet just uses the type name, so the attributes can be created under any namespace of your choosing.
 
 #### Source Files  
-You can also ignore specific source files from code coverage using the `Exclude` property
+You can also ignore specific source files from code coverage using the `ExcludeByFile` property
  - Use single or multiple paths (separate by comma)
  - Use absolute or relative paths (relative to the project directory)
  - Use file path or directory path with globbing (e.g `dir1/*.cs`)
 
 ```bash
-dotnet test /p:CollectCoverage=true /p:Exclude=\"../dir1/class1.cs,../dir2/*.cs,../dir3/**/*.cs,\"
+dotnet test /p:CollectCoverage=true /p:ExcludeByFile=\"../dir1/class1.cs,../dir2/*.cs,../dir3/**/*.cs,\"
 ```
 
+#### Filters 
+Coverlet gives the ability to have fine grained control over what gets excluded using "filter expressions".
+
+Syntax: `/p:Exclude=[Assembly-Filter]Type-Filter`
+
+Examples
+ - `/p:Exclude="[*]*"` => Excludes all types in all assemblies (nothing is instrumented)
+ - `/p:Exclude="[coverlet.*]Coverlet.Core.Coverage"` => Excludes the Coverage class in the `Coverlet.Core` namespace belonging to any assembly that matches `coverlet.*` (e.g `coverlet.core`)
+ - `/p:Exclude="[*]Coverlet.Core.Instrumentation.*"` => Excludes all types belonging to `Coverlet.Core.Instrumentation` namespace in any assembly
+
+```bash
+dotnet test /p:CollectCoverage=true /p:Exclude="[coverlet.*]Coverlet.Core.Coverage"
+```
+
+You can specify multiple fiter expressions by separting them with a comma (`,`).
+
 ## Roadmap
 
-* Filter modules to be instrumented
+* Merging outputs (multiple test projects, one coverage result)
 * Support for more output formats (e.g. JaCoCo)
 * Console runner (removes the need for requiring a NuGet package)
 

src/coverlet.core/Coverage.cs

@@ -13,24 +13,30 @@ public class Coverage
     {
         private string _module;
         private string _identifier;
-        private IEnumerable<string> _excludeRules;
+        private string[] _filters;
+        private string[] _rules;
         private List<InstrumenterResult> _results;
 
-        public Coverage(string module, string identifier, IEnumerable<string> excludeRules = null)
+        public Coverage(string module, string identifier, string[] filters, string[] rules)
         {
             _module = module;
             _identifier = identifier;
-            _excludeRules = excludeRules;
+            _filters = filters;
+            _rules = rules;
             _results = new List<InstrumenterResult>();
         }
 
         public void PrepareModules()
         {
-            string[] modules = InstrumentationHelper.GetDependencies(_module);
-            var excludedFiles =  InstrumentationHelper.GetExcludedFiles(_excludeRules);
+            string[] modules = InstrumentationHelper.GetCoverableModules(_module);
+            string[] excludedFiles =  InstrumentationHelper.GetExcludedFiles(_rules);
+
             foreach (var module in modules)
             {
-                var instrumenter = new Instrumenter(module, _identifier, excludedFiles);
+                if (InstrumentationHelper.IsModuleExcluded(module, _filters))
+                    continue;
+
+                var instrumenter = new Instrumenter(module, _identifier, _filters, excludedFiles);
                 if (instrumenter.CanInstrument())
                 {
                     InstrumentationHelper.BackupOriginalModule(module, _identifier);
@@ -205,4 +211,4 @@ private void CalculateCoverage()
             }
         }
     }
-}
+}

src/coverlet.core/Helpers/InstrumentationHelper.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Reflection.PortableExecutable;
+using System.Text.RegularExpressions;
 
 using Microsoft.Extensions.FileSystemGlobbing;
 using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
@@ -12,10 +13,10 @@ namespace Coverlet.Core.Helpers
 {
     internal static class InstrumentationHelper
     {
-        public static string[] GetDependencies(string module)
+        public static string[] GetCoverableModules(string module)
         {
             IEnumerable<string> modules = Directory.GetFiles(Path.GetDirectoryName(module), "*.dll");
-            modules = modules.Where(a => IsAssembly(a) && Path.GetFileName(a) != Path.GetFileName(module));
+            modules = modules.Where(m => IsAssembly(m) && Path.GetFileName(m) != Path.GetFileName(module));
             return modules.ToArray();
         }
 
@@ -65,7 +66,8 @@ public static void RestoreOriginalModule(string module, string identifier)
             // See: https://github.com/tonerdo/coverlet/issues/25
             var retryStrategy = CreateRetryStrategy();
 
-            RetryHelper.Retry(() => {
+            RetryHelper.Retry(() =>
+            {
                 File.Copy(backupPath, module, true);
                 File.Delete(backupPath);
             }, retryStrategy, 10);
@@ -76,34 +78,86 @@ public static void DeleteHitsFile(string path)
             // Retry hitting the hits file - retry up to 10 times, since the file could be locked
             // See: https://github.com/tonerdo/coverlet/issues/25
             var retryStrategy = CreateRetryStrategy();
-
             RetryHelper.Retry(() => File.Delete(path), retryStrategy, 10);
         }
 
-        public static IEnumerable<string> GetExcludedFiles(IEnumerable<string> excludeRules,
-                                                           string parentDir = null)
+        public static bool IsModuleExcluded(string module, string[] filters)
+        {
+            if (filters == null)
+                return false;
+
+            bool isMatch = false;
+            module = Path.GetFileNameWithoutExtension(module);
+
+            foreach (var filter in filters)
+            {
+                if (!IsValidFilterExpression(filter))
+                    continue;
+
+                string modulePattern = filter.Substring(1, filter.IndexOf(']') - 1);
+                string typePattern = filter.Substring(filter.IndexOf(']') + 1);
+
+                modulePattern = WildcardToRegex(modulePattern);
+
+                var regex = new Regex(modulePattern);
+                isMatch = regex.IsMatch(module) && typePattern == "*";
+            }
+
+            return isMatch;
+        }
+
+        public static bool IsTypeExcluded(string module, string type, string[] filters)
+        {
+            if (filters == null)
+                return false;
+
+            bool isMatch = false;
+            module = Path.GetFileNameWithoutExtension(module);
+
+            foreach (var filter in filters)
+            {
+                if (!IsValidFilterExpression(filter))
+                    continue;
+
+                string typePattern = filter.Substring(filter.IndexOf(']') + 1);
+                string modulePattern = filter.Substring(1, filter.IndexOf(']') - 1);
+
+                typePattern = WildcardToRegex(typePattern);
+                modulePattern = WildcardToRegex(modulePattern);
+
+                isMatch = new Regex(typePattern).IsMatch(type) && new Regex(modulePattern).IsMatch(module);
+            }
+
+            return isMatch;
+        }
+
+        public static string[] GetExcludedFiles(string[] rules)
         {
             const string RELATIVE_KEY = nameof(RELATIVE_KEY);
-            parentDir = string.IsNullOrWhiteSpace(parentDir)? Directory.GetCurrentDirectory() : parentDir;
+            string parentDir = Directory.GetCurrentDirectory();
 
-            if (excludeRules == null || !excludeRules.Any()) return Enumerable.Empty<string>();
+            if (rules == null || !rules.Any()) return Array.Empty<string>();
 
-            var matcherDict = new Dictionary<string, Matcher>(){ {RELATIVE_KEY, new Matcher()}};
-            foreach (var excludeRule in excludeRules)
+            var matcherDict = new Dictionary<string, Matcher>() { { RELATIVE_KEY, new Matcher() } };
+            foreach (var excludeRule in rules)
             {
-                if (Path.IsPathRooted(excludeRule)) {
+                if (Path.IsPathRooted(excludeRule))
+                {
                     var root = Path.GetPathRoot(excludeRule);
-                    if (!matcherDict.ContainsKey(root)) {
+                    if (!matcherDict.ContainsKey(root))
+                    {
                         matcherDict.Add(root, new Matcher());
                     }
                     matcherDict[root].AddInclude(excludeRule.Substring(root.Length));
-                } else {
+                }
+                else
+                {
                     matcherDict[RELATIVE_KEY].AddInclude(excludeRule);
                 }
             }
 
             var files = new List<string>();
-            foreach(var entry in matcherDict)
+            foreach (var entry in matcherDict)
             {
                 var root = entry.Key;
                 var matcher = entry.Value;
@@ -114,20 +168,7 @@ public static IEnumerable<string> GetExcludedFiles(IEnumerable<string> excludeRu
                 files.AddRange(currentFiles);
             }
 
-            return files.Distinct();
-        }
-
-        private static bool IsAssembly(string filePath)
-        {
-            try
-            {
-                AssemblyName.GetAssemblyName(filePath);
-                return true;
-            }
-            catch
-            {
-                return false;
-            }
+            return files.Distinct().ToArray();
         }
 
         private static string GetBackupPath(string module, string identifier)
@@ -149,6 +190,55 @@ TimeSpan retryStrategy()
 
             return retryStrategy;
         }
+
+        private static bool IsValidFilterExpression(string filter)
+        {
+            if (!filter.StartsWith("["))
+                return false;
+
+            if (!filter.Contains("]"))
+                return false;
+
+            if (filter.Count(f => f == '[') > 1)
+                return false;
+
+            if (filter.Count(f => f == ']') > 1)
+                return false;
+
+            if (filter.IndexOf(']') < filter.IndexOf('['))
+                return false;
+
+            if (filter.IndexOf(']') - filter.IndexOf('[') == 1)
+                return false;
+
+            if (filter.EndsWith("]"))
+                return false;
+
+            if (new Regex(@"[^\w*]").IsMatch(filter.Replace(".", "").Replace("[", "").Replace("]", "")))
+                return false;
+
+            return true;
+        }
+
+        private static string WildcardToRegex(string pattern)
+        {
+            return "^" + Regex.Escape(pattern).
+            Replace("\\*", ".*").
+            Replace("\\?", ".") + "$";
+        }
+
+        private static bool IsAssembly(string filePath)
+        {
+            try
+            {
+                AssemblyName.GetAssemblyName(filePath);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
     }
 }
 

src/coverlet.core/Instrumentation/Instrumenter.cs

@@ -18,15 +18,17 @@ internal class Instrumenter
     {
         private readonly string _module;
         private readonly string _identifier;
-        private readonly IEnumerable<string> _excludedFiles;
+        private readonly string[] _filters;
+        private readonly string[] _excludedFiles;
         private readonly static Lazy<MethodInfo> _markExecutedMethodLoader = new Lazy<MethodInfo>(GetMarkExecutedMethod);
         private InstrumenterResult _result;
 
-        public Instrumenter(string module, string identifier, IEnumerable<string> excludedFiles = null)
+        public Instrumenter(string module, string identifier, string[] filters, string[] excludedFiles)
         {
             _module = module;
             _identifier = identifier;
-            _excludedFiles = excludedFiles ?? Enumerable.Empty<string>();
+            _filters = filters;
+            _excludedFiles = excludedFiles ?? Array.Empty<string>();
         }
 
         public bool CanInstrument() => InstrumentationHelper.HasPdb(_module);
@@ -72,7 +74,8 @@ private void InstrumentModule()
 
         private void InstrumentType(TypeDefinition type)
         {
-            if (type.CustomAttributes.Any(IsExcludeAttribute))
+            if (type.CustomAttributes.Any(IsExcludeAttribute)
+                || InstrumentationHelper.IsTypeExcluded(_module, type.FullName, _filters))
                 return;
 
             foreach (var method in type.Methods)