Merge pull request #260 from tonerdo/sourcelink

tonerdo · web-flow · commit b8195882cad0 · 2018-12-10T00:23:45.000+01:00
Add support for Sourcelink
diff --git a/src/coverlet.console/Program.cs b/src/coverlet.console/Program.cs
@@ -36,6 +36,7 @@ static int Main(string[] args)
             CommandOption includeDirectories = app.Option("--include-directory", "Include directories containing additional assemblies to be instrumented.", CommandOptionType.MultipleValue);
             CommandOption excludeAttributes = app.Option("--exclude-by-attribute", "Attributes to exclude from code coverage.", CommandOptionType.MultipleValue);
             CommandOption mergeWith = app.Option("--merge-with", "Path to existing coverage result to merge.", CommandOptionType.SingleValue);
+            CommandOption useSourceLink = app.Option("--use-source-link", "Specifies whether to use SourceLink URIs in place of file system paths.", CommandOptionType.NoValue);
 
             app.OnExecute(() =>
             {
@@ -45,7 +46,7 @@ static int Main(string[] args)
                 if (!target.HasValue())
                     throw new CommandParsingException(app, "Target must be specified.");
 
-                Coverage coverage = new Coverage(module.Value, includeFilters.Values.ToArray(), includeDirectories.Values.ToArray(), excludeFilters.Values.ToArray(), excludedSourceFiles.Values.ToArray(), excludeAttributes.Values.ToArray(), mergeWith.Value());
+                Coverage coverage = new Coverage(module.Value, includeFilters.Values.ToArray(), includeDirectories.Values.ToArray(), excludeFilters.Values.ToArray(), excludedSourceFiles.Values.ToArray(), excludeAttributes.Values.ToArray(), mergeWith.Value(), useSourceLink.HasValue());
                 coverage.PrepareModules();
 
                 Process process = new Process();
diff --git a/src/coverlet.core/Coverage.cs b/src/coverlet.core/Coverage.cs
@@ -8,35 +8,38 @@
 using Coverlet.Core.Symbols;
 
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace Coverlet.Core
 {
     public class Coverage
     {
         private string _module;
         private string _identifier;
-        private string[] _excludeFilters;
         private string[] _includeFilters;
         private string[] _includeDirectories;
+        private string[] _excludeFilters;
         private string[] _excludedSourceFiles;
-        private string _mergeWith;
         private string[] _excludeAttributes;
+        private string _mergeWith;
+        private bool _useSourceLink;
         private List<InstrumenterResult> _results;
 
         public string Identifier
         {
             get { return _identifier; }
         }
 
-        public Coverage(string module, string[] includeFilters, string[] includeDirectories, string[] excludeFilters, string[] excludedSourceFiles, string[] excludeAttributes, string mergeWith)
+        public Coverage(string module, string[] includeFilters, string[] includeDirectories, string[] excludeFilters, string[] excludedSourceFiles, string[] excludeAttributes, string mergeWith, bool useSourceLink)
         {
             _module = module;
-            _excludeFilters = excludeFilters;
             _includeFilters = includeFilters;
             _includeDirectories = includeDirectories ?? Array.Empty<string>();
+            _excludeFilters = excludeFilters;
             _excludedSourceFiles = excludedSourceFiles;
-            _mergeWith = mergeWith;
             _excludeAttributes = excludeAttributes;
+            _mergeWith = mergeWith;
+            _useSourceLink = useSourceLink;
 
             _identifier = Guid.NewGuid().ToString();
             _results = new List<InstrumenterResult>();
@@ -186,6 +189,15 @@ private void CalculateCoverage()
                 }
 
                 List<Document> documents = result.Documents.Values.ToList();
+                if (_useSourceLink && result.SourceLink != null)
+                {
+                    var jObject = JObject.Parse(result.SourceLink)["documents"];
+                    var sourceLinkDocuments = JsonConvert.DeserializeObject<Dictionary<string, string>>(jObject.ToString());
+                    foreach (var document in documents)
+                    {
+                        document.Path = GetSourceLinkUrl(sourceLinkDocuments, document.Path);
+                    }
+                }
 
                 using (var fs = new FileStream(result.HitsFilePath, FileMode.Open))
                 using (var br = new BinaryReader(fs))
@@ -199,9 +211,7 @@ private void CalculateCoverage()
                     for (int i = 0; i < hitCandidatesCount; ++i)
                     {
                         var hitLocation = result.HitCandidates[i];
-
                         var document = documentsList[hitLocation.docIndex];
-
                         int hits = br.ReadInt32();
 
                         if (hitLocation.isBranch)
@@ -248,5 +258,46 @@ private void CalculateCoverage()
                 InstrumentationHelper.DeleteHitsFile(result.HitsFilePath);
             }
         }
+
+        private string GetSourceLinkUrl(Dictionary<string, string> sourceLinkDocuments, string document)
+        {
+            if (sourceLinkDocuments.TryGetValue(document, out string url))
+            {
+                return url;
+            }
+
+            var keyWithBestMatch = string.Empty;
+            var relativePathOfBestMatch = string.Empty;
+
+            foreach (var sourceLinkDocument in sourceLinkDocuments)
+            {
+                string key = sourceLinkDocument.Key;
+                if (Path.GetFileName(key) != "*") continue;
+
+                string relativePath = Path.GetRelativePath(Path.GetDirectoryName(key), Path.GetDirectoryName(document));
+
+                if (relativePath.Contains("..")) continue;
+
+                if (relativePathOfBestMatch.Length == 0)
+                {
+                    keyWithBestMatch = sourceLinkDocument.Key;
+                    relativePathOfBestMatch = relativePath;
+                }
+
+                if (relativePath.Length < relativePathOfBestMatch.Length)
+                {
+                    keyWithBestMatch = sourceLinkDocument.Key;
+                    relativePathOfBestMatch = relativePath;
+                }
+            }
+
+            relativePathOfBestMatch = relativePathOfBestMatch == "." ? string.Empty : relativePathOfBestMatch;
+            
+            string replacement = Path.Combine(relativePathOfBestMatch, Path.GetFileName(document));
+            replacement = replacement.Replace('\\', '/');
+
+            url = sourceLinkDocuments[keyWithBestMatch];
+            return url.Replace("*", replacement);
+        }
     }
 }
diff --git a/src/coverlet.core/Instrumentation/Instrumenter.cs b/src/coverlet.core/Instrumentation/Instrumenter.cs
@@ -79,6 +79,12 @@ private void InstrumentModule()
                     var types = module.GetTypes();
                     AddCustomModuleTrackerToModule(module);
 
+                    var sourceLinkDebugInfo = module.CustomDebugInformations.FirstOrDefault(c => c.Kind == CustomDebugInformationKind.SourceLink);
+                    if (sourceLinkDebugInfo != null)
+                    {
+                        _result.SourceLink = ((SourceLinkDebugInformation)sourceLinkDebugInfo).Content;
+                    }
+
                     foreach (TypeDefinition type in types)
                     {
                         var actualType = type.DeclaringType ?? type;
diff --git a/src/coverlet.core/Instrumentation/InstrumenterResult.cs b/src/coverlet.core/Instrumentation/InstrumenterResult.cs
@@ -43,6 +43,7 @@ public InstrumenterResult()
         public string Module;
         public string HitsFilePath;
         public string ModulePath;
+        public string SourceLink;
         public Dictionary<string, Document> Documents { get; private set; }
         public List<(bool isBranch, int docIndex, int start, int end)> HitCandidates { get; private set; }
     }
diff --git a/src/coverlet.core/Reporters/CoberturaReporter.cs b/src/coverlet.core/Reporters/CoberturaReporter.cs
@@ -31,8 +31,6 @@ public string Report(CoverageResult result)
             coverage.Add(new XAttribute("timestamp", ((int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString()));
 
             XElement sources = new XElement("sources");
-            var basePath = GetBasePath(result.Modules);
-            sources.Add(new XElement("source", basePath));
 
             XElement packages = new XElement("packages");
             foreach (var module in result.Modules)
@@ -50,7 +48,7 @@ public string Report(CoverageResult result)
                     {
                         XElement @class = new XElement("class");
                         @class.Add(new XAttribute("name", cls.Key));
-                        @class.Add(new XAttribute("filename", GetRelativePathFromBase(basePath, document.Key)));
+                        @class.Add(new XAttribute("filename", document.Key));
                         @class.Add(new XAttribute("line-rate", summary.CalculateLineCoverage(cls.Value).Percent.ToString()));
                         @class.Add(new XAttribute("branch-rate", summary.CalculateBranchCoverage(cls.Value).Percent.ToString()));
                         @class.Add(new XAttribute("complexity", summary.CalculateCyclomaticComplexity(cls.Value).ToString()));
@@ -131,34 +129,5 @@ public string Report(CoverageResult result)
 
             return Encoding.UTF8.GetString(stream.ToArray());
         }
-
-        private string GetBasePath(Modules modules)
-        {
-            List<string> sources = new List<string>();
-            string path = string.Empty;
-
-            foreach (var module in modules)
-            {
-                sources.AddRange(
-                    module.Value.Select(d => Path.GetDirectoryName(d.Key)));
-            }
-
-            sources = sources.Distinct().ToList();
-            var segments = sources[0].Split(Path.DirectorySeparatorChar);
-
-            foreach (var segment in segments)
-            {
-                var startsWith = sources.All(s => s.StartsWith(path + segment));
-                if (!startsWith)
-                    break;
-
-                path += segment + Path.DirectorySeparatorChar;
-            }
-
-            return path;
-        }
-
-        private string GetRelativePathFromBase(string basePath, string path)
-            => basePath == string.Empty ? path : path.Replace(basePath, string.Empty);
     }
 }
diff --git a/src/coverlet.core/coverlet.core.csproj b/src/coverlet.core/coverlet.core.csproj
@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <OutputType>Library</OutputType>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
     <AssemblyVersion>4.0.0</AssemblyVersion>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Mono.Cecil" Version="0.10.1" />
     <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
-    <PackageReference Include="System.Reflection.Metadata" Version="1.5.0" />
     <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="2.0.1" />
   </ItemGroup>
 
diff --git a/src/coverlet.msbuild.tasks/InstrumentationTask.cs b/src/coverlet.msbuild.tasks/InstrumentationTask.cs
@@ -9,12 +9,13 @@ public class InstrumentationTask : Task
     {
         private static Coverage _coverage;
         private string _path;
-        private string _exclude;
         private string _include;
         private string _includeDirectory;
+        private string _exclude;
         private string _excludeByFile;
-        private string _mergeWith;
         private string _excludeByAttribute;
+        private string _mergeWith;
+        private bool _useSourceLink;
 
         internal static Coverage Coverage
         {
@@ -28,12 +29,6 @@ public string Path
             set { _path = value; }
         }
 
-        public string Exclude
-        {
-            get { return _exclude; }
-            set { _exclude = value; }
-        }
-
         public string Include
         {
             get { return _include; }
@@ -46,35 +41,47 @@ public string IncludeDirectory
             set { _includeDirectory = value; }
         }
 
+        public string Exclude
+        {
+            get { return _exclude; }
+            set { _exclude = value; }
+        }
+
         public string ExcludeByFile
         {
             get { return _excludeByFile; }
             set { _excludeByFile = value; }
         }
 
+        public string ExcludeByAttribute
+        {
+            get { return _excludeByAttribute; }
+            set { _excludeByAttribute = value; }
+        }
+
         public string MergeWith
         {
             get { return _mergeWith; }
             set { _mergeWith = value; }
         }
 
-        public string ExcludeByAttribute
+        public bool UseSourceLink
         {
-            get { return _excludeByAttribute; }
-            set { _excludeByAttribute = value; }
+            get { return _useSourceLink; }
+            set { _useSourceLink = value; }
         }
 
         public override bool Execute()
         {
             try
             {
-                var excludedSourceFiles = _excludeByFile?.Split(',');
-                var excludeFilters = _exclude?.Split(',');
                 var includeFilters = _include?.Split(',');
                 var includeDirectories = _includeDirectory?.Split(',');
+                var excludeFilters = _exclude?.Split(',');
+                var excludedSourceFiles = _excludeByFile?.Split(',');
                 var excludeAttributes = _excludeByAttribute?.Split(',');
 
-                _coverage = new Coverage(_path, includeFilters, includeDirectories, excludeFilters, excludedSourceFiles, excludeAttributes, _mergeWith);
+                _coverage = new Coverage(_path, includeFilters, includeDirectories, excludeFilters, excludedSourceFiles, excludeAttributes, _mergeWith, _useSourceLink);
                 _coverage.PrepareModules();
             }
             catch (Exception ex)
diff --git a/src/coverlet.msbuild.tasks/coverlet.msbuild.tasks.csproj b/src/coverlet.msbuild.tasks/coverlet.msbuild.tasks.csproj
@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <OutputType>Library</OutputType>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
     <AssemblyVersion>2.3.0</AssemblyVersion>
   </PropertyGroup>
 
diff --git a/src/coverlet.msbuild/coverlet.msbuild.props b/src/coverlet.msbuild/coverlet.msbuild.props
@@ -1,15 +1,16 @@
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <CollectCoverage Condition="$(CollectCoverage) == ''">false</CollectCoverage>
-    <CoverletOutputFormat Condition="$(CoverletOutputFormat) == ''">json</CoverletOutputFormat>
-    <CoverletOutput Condition="$(CoverletOutput) == ''">$([MSBuild]::EnsureTrailingSlash('$(MSBuildProjectDirectory)'))</CoverletOutput>
     <Include Condition="$(Include) == ''"></Include>
+    <IncludeDirectory Condition="$(IncludeDirectory) == ''"></IncludeDirectory>
     <Exclude Condition="$(Exclude) == ''"></Exclude>
     <ExcludeByFile Condition="$(ExcludeByFile) == ''"></ExcludeByFile>
+    <ExcludeByAttribute Condition="$(ExcludeByAttribute) == ''"></ExcludeByAttribute>
     <MergeWith Condition="$(MergeWith) == ''"></MergeWith>
+    <UseSourceLink Condition="$(UseSourceLink) == ''">false</UseSourceLink>
+    <CoverletOutputFormat Condition="$(CoverletOutputFormat) == ''">json</CoverletOutputFormat>
+    <CoverletOutput Condition="$(CoverletOutput) == ''">$([MSBuild]::EnsureTrailingSlash('$(MSBuildProjectDirectory)'))</CoverletOutput>
     <Threshold Condition="$(Threshold) == ''">0</Threshold>
     <ThresholdType Condition="$(ThresholdType) == ''">line,branch,method</ThresholdType>
-    <IncludeDirectory Condition="$(IncludeDirectory) == ''"></IncludeDirectory>
-    <ExcludeByAttribute Condition="$(ExcludeByAttribute) == ''"></ExcludeByAttribute>
   </PropertyGroup>
 </Project>
diff --git a/src/coverlet.msbuild/coverlet.msbuild.targets b/src/coverlet.msbuild/coverlet.msbuild.targets
@@ -6,25 +6,27 @@
   <Target Name="InstrumentModulesNoBuild" BeforeTargets="VSTest">
     <Coverlet.MSbuild.Tasks.InstrumentationTask
       Condition="'$(VSTestNoBuild)' == 'true' and $(CollectCoverage) == 'true'"
+      Path="$(TargetPath)"
       Include="$(Include)"
       IncludeDirectory="$(IncludeDirectory)"
       Exclude="$(Exclude)"
       ExcludeByFile="$(ExcludeByFile)"
-      MergeWith="$(MergeWith)"
       ExcludeByAttribute="$(ExcludeByAttribute)"
-      Path="$(TargetPath)" />
+      MergeWith="$(MergeWith)"
+      UseSourceLink="$(UseSourceLink)" />
   </Target>
 
   <Target Name="InstrumentModulesAfterBuild" AfterTargets="BuildProject">
     <Coverlet.MSbuild.Tasks.InstrumentationTask
       Condition="'$(VSTestNoBuild)' != 'true' and $(CollectCoverage) == 'true'"
+      Path="$(TargetPath)"
       Include="$(Include)"
       IncludeDirectory="$(IncludeDirectory)"
       Exclude="$(Exclude)"
       ExcludeByFile="$(ExcludeByFile)"
-      MergeWith="$(MergeWith)"
       ExcludeByAttribute="$(ExcludeByAttribute)"
-      Path="$(TargetPath)" />
+      MergeWith="$(MergeWith)"
+      UseSourceLink="$(UseSourceLink)" />
   </Target>
 
   <Target Name="GenerateCoverageResult" AfterTargets="VSTest">
diff --git a/test/coverlet.core.tests/CoverageTests.cs b/test/coverlet.core.tests/CoverageTests.cs
@@ -27,7 +27,7 @@ public void TestCoverage()
             // Since Coverage only instruments dependancies, we need a fake module here
             var testModule = Path.Combine(directory.FullName, "test.module.dll");
 
-            var coverage = new Coverage(testModule, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), string.Empty);
+            var coverage = new Coverage(testModule, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), string.Empty, false);
             coverage.PrepareModules();
 
             var result = coverage.GetCoverageResult();

Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,7 @@ public InstrumenterResult()`
`43`	`43`	`public string Module;`
`44`	`44`	`public string HitsFilePath;`
`45`	`45`	`public string ModulePath;`
	`46`	`+ public string SourceLink;`
`46`	`47`	`public Dictionary<string, Document> Documents { get; private set; }`
`47`	`48`	`public List<(bool isBranch, int docIndex, int start, int end)> HitCandidates { get; private set; }`
`48`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,13 @@ public class InstrumentationTask : Task`
`9`	`9`	`{`
`10`	`10`	`private static Coverage _coverage;`
`11`	`11`	`private string _path;`
`12`		`- private string _exclude;`
`13`	`12`	`private string _include;`
`14`	`13`	`private string _includeDirectory;`
	`14`	`+ private string _exclude;`
`15`	`15`	`private string _excludeByFile;`
`16`		`- private string _mergeWith;`
`17`	`16`	`private string _excludeByAttribute;`
	`17`	`+ private string _mergeWith;`
	`18`	`+ private bool _useSourceLink;`
`18`	`19`
`19`	`20`	`internal static Coverage Coverage`
`20`	`21`	`{`
`@@ -28,12 +29,6 @@ public string Path`
`28`	`29`	`set { _path = value; }`
`29`	`30`	`}`
`30`	`31`
`31`		`- public string Exclude`
`32`		`- {`
`33`		`- get { return _exclude; }`
`34`		`- set { _exclude = value; }`
`35`		`- }`
`36`		`-`
`37`	`32`	`public string Include`
`38`	`33`	`{`
`39`	`34`	`get { return _include; }`
`@@ -46,35 +41,47 @@ public string IncludeDirectory`
`46`	`41`	`set { _includeDirectory = value; }`
`47`	`42`	`}`
`48`	`43`
	`44`	`+ public string Exclude`
	`45`	`+ {`
	`46`	`+ get { return _exclude; }`
	`47`	`+ set { _exclude = value; }`
	`48`	`+ }`
	`49`	`+`
`49`	`50`	`public string ExcludeByFile`
`50`	`51`	`{`
`51`	`52`	`get { return _excludeByFile; }`
`52`	`53`	`set { _excludeByFile = value; }`
`53`	`54`	`}`
`54`	`55`
	`56`	`+ public string ExcludeByAttribute`
	`57`	`+ {`
	`58`	`+ get { return _excludeByAttribute; }`
	`59`	`+ set { _excludeByAttribute = value; }`
	`60`	`+ }`
	`61`	`+`
`55`	`62`	`public string MergeWith`
`56`	`63`	`{`
`57`	`64`	`get { return _mergeWith; }`
`58`	`65`	`set { _mergeWith = value; }`
`59`	`66`	`}`
`60`	`67`
`61`		`- public string ExcludeByAttribute`
	`68`	`+ public bool UseSourceLink`
`62`	`69`	`{`
`63`		`- get { return _excludeByAttribute; }`
`64`		`- set { _excludeByAttribute = value; }`
	`70`	`+ get { return _useSourceLink; }`
	`71`	`+ set { _useSourceLink = value; }`
`65`	`72`	`}`
`66`	`73`
`67`	`74`	`public override bool Execute()`
`68`	`75`	`{`
`69`	`76`	`try`
`70`	`77`	`{`
`71`		`- var excludedSourceFiles = _excludeByFile?.Split(',');`
`72`		`- var excludeFilters = _exclude?.Split(',');`
`73`	`78`	`var includeFilters = _include?.Split(',');`
`74`	`79`	`var includeDirectories = _includeDirectory?.Split(',');`
	`80`	`+ var excludeFilters = _exclude?.Split(',');`
	`81`	`+ var excludedSourceFiles = _excludeByFile?.Split(',');`
`75`	`82`	`var excludeAttributes = _excludeByAttribute?.Split(',');`
`76`	`83`
`77`		`- _coverage = new Coverage(_path, includeFilters, includeDirectories, excludeFilters, excludedSourceFiles, excludeAttributes, _mergeWith);`
	`84`	`+ _coverage = new Coverage(_path, includeFilters, includeDirectories, excludeFilters, excludedSourceFiles, excludeAttributes, _mergeWith, _useSourceLink);`
`78`	`85`	`_coverage.PrepareModules();`
`79`	`86`	`}`
`80`	`87`	`catch (Exception ex)`