Implementation exclusion of files according to source file paths (including file globbing)

ido-namely · ido-namely · commit 222eef73e8b9 · 2018-04-26T00:29:03.000-04:00
diff --git a/src/coverlet.core/Coverage.cs b/src/coverlet.core/Coverage.cs
@@ -12,12 +12,14 @@ public class Coverage
     {
         private string _module;
         private string _identifier;
+        private IEnumerable<string> _excludedFiles;
         private List<InstrumenterResult> _results;
 
-        public Coverage(string module, string identifier)
+        public Coverage(string module, string identifier, IEnumerable<string> excludedFiles)
         {
             _module = module;
             _identifier = identifier;
+            _excludedFiles = excludedFiles;
             _results = new List<InstrumenterResult>();
         }
 
@@ -26,7 +28,7 @@ public void PrepareModules()
             string[] modules = InstrumentationHelper.GetDependencies(_module);
             foreach (var module in modules)
             {
-                var instrumenter = new Instrumenter(module, _identifier);
+                var instrumenter = new Instrumenter(module, _identifier, _excludedFiles);
                 if (instrumenter.CanInstrument())
                 {
                     InstrumentationHelper.BackupOriginalModule(module, _identifier);
diff --git a/src/coverlet.core/Helpers/InstrumentationHelper.cs b/src/coverlet.core/Helpers/InstrumentationHelper.cs
@@ -3,12 +3,14 @@
 using System.IO;
 using System.Linq;
 using System.Reflection.PortableExecutable;
+using Microsoft.Extensions.FileSystemGlobbing;
 
 using Coverlet.Core.Instrumentation;
+using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
 
 namespace Coverlet.Core.Helpers
 {
-    internal static class InstrumentationHelper
+    public static class InstrumentationHelper
     {
         public static string[] GetDependencies(string module)
         {
@@ -106,5 +108,26 @@ public static void DeleteHitsFile(string path)
 
             RetryHelper.Retry(() => File.Delete(path), retryStrategy, 10);
         }
+        
+        public static string[] GetExcludedFiles(string[] exclusionRules, string parentDir) {
+            if (exclusionRules == null || exclusionRules.Length == 0 ) return null;
+            var matcher = new Matcher();
+            foreach (var exclusionRule in exclusionRules)
+            {
+                matcher.AddInclude(exclusionRule);
+            }
+        
+            DirectoryInfo directoryInfo = new DirectoryInfo(parentDir);
+            
+            var fileMatchResult = matcher.Execute(new DirectoryInfoWrapper(directoryInfo));
+            return fileMatchResult.Files
+                .Select(
+                    f => System.IO.Path.GetFullPath(
+                        System.IO.Path.Combine(directoryInfo.ToString(), f.Path)
+                    )
+                )
+                .ToArray();
+        }
     }
-}
+}
+
diff --git a/src/coverlet.core/Instrumentation/Instrumenter.cs b/src/coverlet.core/Instrumentation/Instrumenter.cs
@@ -8,19 +8,23 @@
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
+using System;
+using System.Xml.Linq;
 
 namespace Coverlet.Core.Instrumentation
 {
     internal class Instrumenter
     {
         private string _module;
         private string _identifier;
+        private IEnumerable<string> _excludedFiles;
         private InstrumenterResult _result;
 
-        public Instrumenter(string module, string identifier)
+        public Instrumenter(string module, string identifier, IEnumerable<string> excludedFiles)
         {
             _module = module;
             _identifier = identifier;
+            _excludedFiles = excludedFiles;
         }
 
         public bool CanInstrument() => InstrumentationHelper.HasPdb(_module);
@@ -61,6 +65,10 @@ private void InstrumentModule()
 
                     foreach (var method in type.Methods)
                     {
+                        var sourceFiles = method.DebugInformation.SequencePoints.Select(s => s.Document.Url).Distinct();
+                        if (sourceFiles.Any(_excludedFiles.Contains)) {
+                            continue;
+                        }
                         if (!method.CustomAttributes.Any(a => a.AttributeType.Name == "ExcludeFromCoverageAttribute" || a.AttributeType.Name == "ExcludeFromCoverage"))
                             InstrumentMethod(method);
                     }
diff --git a/src/coverlet.core/coverlet.core.csproj b/src/coverlet.core/coverlet.core.csproj
@@ -9,6 +9,7 @@
     <PackageReference Include="Jil" Version="2.15.4" />
     <PackageReference Include="Mono.Cecil" Version="0.10.0" />
     <PackageReference Include="System.Reflection.Metadata" Version="1.5.0" />
+    <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="2.0.1" />
   </ItemGroup>
 
 </Project>
diff --git a/src/coverlet.msbuild.tasks/InstrumentationTask.cs b/src/coverlet.msbuild.tasks/InstrumentationTask.cs
@@ -1,35 +1,31 @@
 ﻿using System;
 using Coverlet.Core;
-
+using Coverlet.Core.Helpers;
 using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-
+using Microsoft.Build.Utilities;
+
 namespace Coverlet.MSbuild.Tasks
 {
     public class InstrumentationTask : Task
-    {
-        private string _path;
-        private static Coverage _coverage;
-
-        internal static Coverage Coverage
-        {
-            get { return _coverage; }
-            private set { _coverage = value; }
-        }
+    {        
+        internal static Coverage Coverage { get; private set; }
 
         [Required]
-        public string Path
-        {
-            get { return _path; }
-            set { _path = value; }
-        }
-
+        public string Path { get; set; }
+        
+        [Required]
+        public string[] ExclusionRules { get; set; }
+        
+        public string ExclusionParentDir { get; set; }
+        
         public override bool Execute()
         {
             try
             {
-                _coverage = new Coverage(_path, Guid.NewGuid().ToString());
-                _coverage.PrepareModules();
+                var excludedFiles =  InstrumentationHelper.GetExcludedFiles(
+                    ExclusionRules, ExclusionParentDir);
+                Coverage = new Coverage(Path, Guid.NewGuid().ToString(), excludedFiles);
+                Coverage.PrepareModules();
             }
             catch(Exception ex)
             {
diff --git a/src/coverlet.msbuild/coverlet.msbuild.props b/src/coverlet.msbuild/coverlet.msbuild.props
@@ -6,6 +6,7 @@
     <CoverletOutputDirectory Condition="$(CoverletOutputDirectory) == ''">$(MSBuildProjectDirectory)</CoverletOutputDirectory>
     <CoverletOutputName Condition=" '$(CoverletOutputName)' == '' ">coverage</CoverletOutputName>
     <CoverletOutput>$([MSBuild]::EnsureTrailingSlash('$(CoverletOutputDirectory)'))$(CoverletOutputName)</CoverletOutput>
+    <CoverletExclusionParentDir Condition="$(CoverletExclusionParentDir) == ''">$(MSBuildProjectDirectory)</CoverletExclusionParentDir>
 
     <Threshold Condition="$(Threshold) == ''">0</Threshold>
     <CollectCoverage Condition="$(CollectCoverage) == ''">false</CollectCoverage>
diff --git a/src/coverlet.msbuild/coverlet.msbuild.targets b/src/coverlet.msbuild/coverlet.msbuild.targets
@@ -6,12 +6,16 @@
   <Target Name="InstrumentModulesNoBuild" BeforeTargets="VSTest">
     <Coverlet.MSbuild.Tasks.InstrumentationTask
       Condition="'$(VSTestNoBuild)' == 'true' and $(CollectCoverage) == 'true'"
+      ExclusionRules="$(ExclusionRules)"
+      ExclusionParentDir="$(CoverletExclusionParentDir)"
       Path="$(TargetPath)" />
   </Target>
 
   <Target Name="InstrumentModulesAfterBuild" AfterTargets="BuildProject">
     <Coverlet.MSbuild.Tasks.InstrumentationTask
       Condition="'$(VSTestNoBuild)' != 'true' and $(CollectCoverage) == 'true'"
+      ExclusionRules="$(ExclusionRules)"
+      ExclusionParentDir="$(CoverletExclusionParentDir)"
       Path="$(TargetPath)" />
   </Target>
 
diff --git a/test/coverlet.core.tests/CoverageTests.cs b/test/coverlet.core.tests/CoverageTests.cs
@@ -21,7 +21,7 @@ public void TestCoverage()
 
             File.Copy(module, tempModule, true);
 
-            var coverage = new Coverage(tempModule, identifier);
+            var coverage = new Coverage(tempModule, identifier, null);
             coverage.PrepareModules();
 
             var result = coverage.GetCoverageResult();
diff --git a/test/coverlet.core.tests/Instrumentation/InstrumenterTests.cs b/test/coverlet.core.tests/Instrumentation/InstrumenterTests.cs
@@ -3,6 +3,7 @@
 
 using Xunit;
 using Coverlet.Core.Instrumentation;
+using Coverlet.MSbuild.Tasks;
 
 namespace Coverlet.Core.Instrumentation.Tests
 {
@@ -21,8 +22,7 @@ public void TestInstrument()
             File.Copy(pdb, Path.Combine(directory.FullName, Path.GetFileName(pdb)), true);
 
             module = Path.Combine(directory.FullName, Path.GetFileName(module));
-
-            Instrumenter instrumenter = new Instrumenter(module, identifier);
+            Instrumenter instrumenter = new Instrumenter(module, identifier, null);
             var result = instrumenter.Instrument();
 
             Assert.Equal(Path.GetFileNameWithoutExtension(module), result.Module);
diff --git a/test/coverlet.core.tests/coverlet.core.tests.csproj b/test/coverlet.core.tests/coverlet.core.tests.csproj
@@ -17,6 +17,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\coverlet.core\coverlet.core.csproj" />
+    <ProjectReference Include="..\..\src\coverlet.msbuild.tasks\coverlet.msbuild.tasks.csproj" />
   </ItemGroup>
 
   <Import Project="$(MSBuildThisFileDirectory)\..\..\build\$(Configuration)\coverlet.msbuild.targets" />

Original file line number	Diff line number	Diff line change
`@@ -12,12 +12,14 @@ public class Coverage`
`12`	`12`	`{`
`13`	`13`	`private string _module;`
`14`	`14`	`private string _identifier;`
	`15`	`+ private IEnumerable<string> _excludedFiles;`
`15`	`16`	`private List<InstrumenterResult> _results;`
`16`	`17`
`17`		`- public Coverage(string module, string identifier)`
	`18`	`+ public Coverage(string module, string identifier, IEnumerable<string> excludedFiles)`
`18`	`19`	`{`
`19`	`20`	`_module = module;`
`20`	`21`	`_identifier = identifier;`
	`22`	`+ _excludedFiles = excludedFiles;`
`21`	`23`	`_results = new List<InstrumenterResult>();`
`22`	`24`	`}`
`23`	`25`
`@@ -26,7 +28,7 @@ public void PrepareModules()`
`26`	`28`	`string[] modules = InstrumentationHelper.GetDependencies(_module);`
`27`	`29`	`foreach (var module in modules)`
`28`	`30`	`{`
`29`		`- var instrumenter = new Instrumenter(module, _identifier);`
	`31`	`+ var instrumenter = new Instrumenter(module, _identifier, _excludedFiles);`
`30`	`32`	`if (instrumenter.CanInstrument())`
`31`	`33`	`{`
`32`	`34`	`InstrumentationHelper.BackupOriginalModule(module, _identifier);`
Original file line number	Diff line number	Diff line change
`@@ -8,19 +8,23 @@`
`8`	`8`	`using Mono.Cecil;`
`9`	`9`	`using Mono.Cecil.Cil;`
`10`	`10`	`using Mono.Cecil.Rocks;`
	`11`	`+using System;`
	`12`	`+using System.Xml.Linq;`
`11`	`13`
`12`	`14`	`namespace Coverlet.Core.Instrumentation`
`13`	`15`	`{`
`14`	`16`	`internal class Instrumenter`
`15`	`17`	`{`
`16`	`18`	`private string _module;`
`17`	`19`	`private string _identifier;`
	`20`	`+ private IEnumerable<string> _excludedFiles;`
`18`	`21`	`private InstrumenterResult _result;`
`19`	`22`
`20`		`- public Instrumenter(string module, string identifier)`
	`23`	`+ public Instrumenter(string module, string identifier, IEnumerable<string> excludedFiles)`
`21`	`24`	`{`
`22`	`25`	`_module = module;`
`23`	`26`	`_identifier = identifier;`
	`27`	`+ _excludedFiles = excludedFiles;`
`24`	`28`	`}`
`25`	`29`
`26`	`30`	`public bool CanInstrument() => InstrumentationHelper.HasPdb(_module);`
`@@ -61,6 +65,10 @@ private void InstrumentModule()`
`61`	`65`
`62`	`66`	`foreach (var method in type.Methods)`
`63`	`67`	`{`
	`68`	`+ var sourceFiles = method.DebugInformation.SequencePoints.Select(s => s.Document.Url).Distinct();`
	`69`	`+ if (sourceFiles.Any(_excludedFiles.Contains)) {`
	`70`	`+ continue;`
	`71`	`+ }`
`64`	`72`	`if (!method.CustomAttributes.Any(a => a.AttributeType.Name == "ExcludeFromCoverageAttribute" \|\| a.AttributeType.Name == "ExcludeFromCoverage"))`
`65`	`73`	`InstrumentMethod(method);`
`66`	`74`	`}`