think maybe I'm happy now?

RocketSurgeonsGuild · Nov 19, 2024 · 8a44582 · 8a44582
1 parent c617a30
commit 8a44582
Show file tree

Hide file tree

Showing 6 changed files with 209 additions and 128 deletions.
diff --git a/src/Nuke/IHaveCodeCoverage.cs b/src/Nuke/IHaveCodeCoverage.cs
@@ -1,3 +1,4 @@
+using System.Xml.Linq;
 using Nuke.Common.IO;
 
 namespace Rocket.Surgery.Nuke;
@@ -20,11 +21,13 @@ public interface IHaveCodeCoverage : IHaveArtifacts
      ?? TryGetValue(() => CoverageDirectory)
      ?? NukeBuild.RootDirectory / "coverage";
 
-    public IEnumerable<string> IncludeModulePaths => [];
-    public IEnumerable<string> ExcludeModulePaths => [];
-    public IEnumerable<string> IncludeAttributes => [];
+    public static IEnumerable<string> DefaultIncludeModulePaths => [];
+    public static IEnumerable<string> DefaultExcludeModulePaths => [];
+    public static IEnumerable<string> DefaultIncludeSources => [];
+    public static IEnumerable<string> DefaultExcludeSources => [];
+    public static IEnumerable<string> DefaultIncludeAttributes => [];
 
-    public IEnumerable<string> ExcludeAttributes =>
+    public static IEnumerable<string> DefaultExcludeAttributes =>
     [
         "System.Diagnostics.DebuggerHiddenAttribute",
         "System.Diagnostics.DebuggerNonUserCodeAttribute",
@@ -33,23 +36,37 @@ public interface IHaveCodeCoverage : IHaveArtifacts
         "System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute",
     ];
 
-    public IEnumerable<string> IncludeNamespaces => [];
+    public static IEnumerable<string> DefaultIncludeNamespaces => [];
 
-    public IEnumerable<string> ExcludeNamespaces =>
+    public static IEnumerable<string> DefaultExcludeNamespaces =>
     [
-        "Bogus.",
-        "FakeItEasy.",
-        "Moq.",
-        "NSubstitute.",
-        "Verify.",
-        "XUnit.",
-        "TUnit.",
+        "Bogus",
+        "FakeItEasy",
+        "Moq",
+        "NSubstitute",
+        "Verify",
+        "XUnit",
+        "TUnit",
         "Microsoft.",
         "System.",
         "JetBrains.",
-        "DryIoc.",
-        "Nuke.",
-        "FluentAssertions.",
-        "Serilog.",
+        "DryIoc",
+        "Nuke",
+        "FluentAssertions",
+        "Serilog",
     ];
+
+    public IEnumerable<string> IncludeNamespaces => DefaultIncludeNamespaces;
+    public IEnumerable<string> ExcludeNamespaces => DefaultExcludeNamespaces;
+    public IEnumerable<string> IncludeAttributes => DefaultIncludeAttributes;
+    public IEnumerable<string> ExcludeAttributes => DefaultExcludeAttributes;
+    public IEnumerable<string> IncludeSources => DefaultIncludeSources;
+    public IEnumerable<string> ExcludeSources => DefaultExcludeSources;
+    public IEnumerable<string> IncludeModulePaths => DefaultIncludeModulePaths;
+    public IEnumerable<string> ExcludeModulePaths => DefaultExcludeModulePaths;
+
+    public XDocument CustomizeCoverageRunSettings(XDocument document)
+    {
+        return document;
+    }
 }
diff --git a/src/Nuke/ITriggerCodeCoverageReports.cs b/src/Nuke/ITriggerCodeCoverageReports.cs
@@ -1,6 +1,7 @@
 using Nuke.Common.IO;
 using Nuke.Common.Tooling;
 using Nuke.Common.Tools.ReportGenerator;
+using Rocket.Surgery.Nuke.ProjectModel;
 
 // ReSharper disable SuspiciousTypeConversion.Global
 
@@ -13,7 +14,7 @@ namespace Rocket.Surgery.Nuke;
 ///     This causes code coverage to trigger
 /// </remarks>
 [PublicAPI]
-public interface ITriggerCodeCoverageReports : IHaveCodeCoverage, IHaveTestTarget, IHaveTestArtifacts, ITrigger
+public interface ITriggerCodeCoverageReports : IHaveCodeCoverage, IHaveTestTarget, IHaveTestArtifacts, ITrigger, IHaveSolution
 {
     /// <summary>
     ///     The input reports
@@ -89,17 +90,38 @@ public interface ITriggerCodeCoverageReports : IHaveCodeCoverage, IHaveTestTarge
     /// </summary>
     /// <param name="settings"></param>
     /// <returns></returns>
-    protected ReportGeneratorSettings Defaults(ReportGeneratorSettings settings) => ( this switch
-                                                                                      {
-                                                                                          IHaveGitVersion gitVersion => settings.SetTag(
-                                                                                              gitVersion.GitVersion.InformationalVersion
-                                                                                          ),
-                                                                                          IHaveGitRepository { GitRepository: { } } gitRepository => settings
-                                                                                             .SetTag(gitRepository.GitRepository.Head),
-                                                                                          _ => settings,
-                                                                                      }
-                                                                                    )
-                                                                                   .SetReports(InputReports)
-                                                                                   .SetSourceDirectories(NukeBuild.RootDirectory)
-                                                                                   .SetFramework(Constants.ReportGeneratorFramework);
+    protected ReportGeneratorSettings Defaults(ReportGeneratorSettings settings)
+        => ( this switch
+             {
+                 IHaveGitVersion gitVersion => settings.SetTag(
+                     gitVersion.GitVersion.InformationalVersion
+                 ),
+                 IHaveGitRepository { GitRepository: { } } gitRepository => settings
+                    .SetTag(gitRepository.GitRepository.Head),
+                 _ => settings,
+             }
+           )
+          .SetReports(InputReports)
+          .SetSourceDirectories(NukeBuild.RootDirectory)
+          .SetFramework(Constants.ReportGeneratorFramework)
+           // this is more or less a hack / compromise because
+           // I was unable to coverage to exclude everything in a given assembly by default.
+          .AddAssemblyFilters(
+               Solution
+                  .AnalyzeAllProjects()
+                  .Select(z => z.GetProperty("AssemblyName") ?? "")
+                  .Where(z => !string.IsNullOrWhiteSpace(z))
+                  .Distinct()
+                  .Select(z => "+" + z)
+           )
+          .AddAssemblyFilters(
+               Solution
+                  .AnalyzeAllProjects()
+                  .SelectMany(z => z.PackageReferences)
+                  .Select(z => z.Name)
+                  .Where(z => !string.IsNullOrWhiteSpace(z))
+                  .Distinct()
+                  .Select(z => "-" + z)
+           )
+           ;
 }
diff --git a/src/Nuke/TestMethodExtensions.cs b/src/Nuke/TestMethodExtensions.cs
@@ -1,6 +1,9 @@
+using System.Collections.Immutable;
 using System.Xml.Linq;
 using Nuke.Common.IO;
+using Nuke.Common.ProjectModel;
 using Rocket.Surgery.Nuke.DotNetCore;
+using Rocket.Surgery.Nuke.ProjectModel;
 
 namespace Rocket.Surgery.Nuke;
 
@@ -19,7 +22,7 @@ public static class TestMethodExtensions
     // ReSharper disable once IdentifierTypo
     // ReSharper disable once StringLiteralTypo
     public static ITargetDefinition EnsureRunSettingsExists<T>(this ITargetDefinition target, T build)
-        where T : IHaveCodeCoverage, IComprehendTests
+        where T : IHaveCodeCoverage, IComprehendTests, IHaveSolution
     {
         return target.Executes(
             async () =>
@@ -38,28 +41,46 @@ await typeof(ICanTestWithDotNetCore)
                          .GetManifestResourceStream("Rocket.Surgery.Nuke.default.runsettings")!.CopyToAsync(tempFile);
                 }
 
+                var projects = build
+                              .Solution.AnalyzeAllProjects()
+                              .ToImmutableArray();
+                var includeNames = projects
+                                  .Select(z => z.GetProperty("AssemblyName") ?? "")
+                                  .Where(z => !string.IsNullOrWhiteSpace(z))
+                                  .Distinct()
+                                  .Select(z => ( z + ".dll" ).Replace(".", "\\."));
+                var excludePackages = projects
+                                     .SelectMany(z => z.PackageReferences)
+                                     .Select(z => z.Name)
+                                     .Where(z => !string.IsNullOrWhiteSpace(z))
+                                     .Distinct()
+                                     .Select(z => ( z + ".dll" ).Replace(".", "\\."));
+
+
                 ManageRunSettings(
+                    build,
                     runsettings,
-                    build.IncludeModulePaths,
-                    build.ExcludeModulePaths,
-                    build.IncludeAttributes,
-                    build.ExcludeAttributes,
-                    build.IncludeNamespaces,
-                    build.ExcludeNamespaces
+                    (
+                        build.IncludeModulePaths.Union(includeNames),
+                        build.ExcludeModulePaths .Union(excludePackages)
+                    ),
+                    ( build.IncludeAttributes, build.ExcludeAttributes ),
+                    ( build.IncludeNamespaces, build.ExcludeNamespaces ),
+                    ( build.IncludeSources, build.ExcludeSources )
                 );
             }
         );
     }
 
-    private static void ManageRunSettings(
+    private static void ManageRunSettings<T>(
+        T build,
         AbsolutePath runsettingsPath,
-        IEnumerable<string> includeModulePaths,
-        IEnumerable<string> excludeModulePaths,
-        IEnumerable<string> includeAttributes,
-        IEnumerable<string> excludeAttributes,
-        IEnumerable<string> includeNamespaces,
-        IEnumerable<string> excludeNamespaces
+        (IEnumerable<string> include, IEnumerable<string> exclude) modulePaths,
+        (IEnumerable<string> include, IEnumerable<string> exclude) attributes,
+        (IEnumerable<string> include, IEnumerable<string> exclude) namespaces,
+        (IEnumerable<string> include, IEnumerable<string> exclude) sources
     )
+        where T : IHaveCodeCoverage, IComprehendTests
     {
         var doc = XDocument.Load(runsettingsPath);
 
@@ -81,28 +102,29 @@ IEnumerable<string> excludeNamespaces
             dataCollector.Element("Configuration")?.Add(codeCoverage);
         }
 
-        AddIncludeItems(codeCoverage, "ModulePaths", "ModulePath", includeModulePaths);
-        AddExcludeItems(codeCoverage, "ModulePaths", "ModulePath", excludeModulePaths);
-        AddIncludeItems(codeCoverage, "Attributes", "Attribute", includeAttributes.Select(TransformAttribute));
-        AddExcludeItems(codeCoverage, "Attributes", "Attribute", excludeAttributes.Select(TransformAttribute));
-        AddIncludeItems(codeCoverage, "Functions", "Function", includeNamespaces.Select(TransformNamespace));
-        AddExcludeItems(codeCoverage, "Functions", "Function", excludeNamespaces.Select(TransformNamespace));
+        AddItems(codeCoverage, "Attributes", "Attribute", transform(attributes, transformAttribute));
+        AddItems(codeCoverage, "Functions", "Function", transform(namespaces, transformNamespace));
+        AddItems(codeCoverage, "ModulePaths", "ModulePath", transform(modulePaths, transformModulePath));
+        AddItems(codeCoverage, "Sources", "Source", sources);
+
+        build.CustomizeCoverageRunSettings(doc);
 
-        DistinctAndOrganize(codeCoverage, "ModulePaths");
         DistinctAndOrganize(codeCoverage, "Attributes");
         DistinctAndOrganize(codeCoverage, "Functions");
+        DistinctAndOrganize(codeCoverage, "ModulePaths");
+        DistinctAndOrganize(codeCoverage, "Sources");
 
         doc.Save(runsettingsPath);
 
-        static string TransformAttribute(string ns)
-        {
-            return $"^{ns.Replace(".", "\\.")}$";
-        }
+        static (IEnumerable<string> include, IEnumerable<string> exclude) transform(
+            (IEnumerable<string> include, IEnumerable<string> exclude) attributes,
+            Func<string, IEnumerable<string>> transformer
+        ) => ( attributes.include.SelectMany(transformer), attributes.exclude.SelectMany(transformer) );
 
-        static string TransformNamespace(string ns)
-        {
-            return $"^{ns.Replace(".", "\\.")}.*";
-        }
+
+        static IEnumerable<string> transformAttribute(string attr) => [$"^{attr.Replace(".", "\\.")}$"];
+        static IEnumerable<string> transformModulePath(string ns) => [$".*{ns}"];
+        static IEnumerable<string> transformNamespace(string ns) => [$"^{ns.Replace(".", "\\.")}.*"];
     }
 
     private static XElement EnsureElement(XElement parent, string name)
@@ -117,47 +139,45 @@ private static XElement EnsureElement(XElement parent, string name)
         return element;
     }
 
-    private static void AddIncludeItems(XElement parent, string parentName, string childName, IEnumerable<string> values)
+    private static void AddItems(XElement parent, string parentName, string childName, (IEnumerable<string> include, IEnumerable<string> exclude) values)
     {
         var parentElement = EnsureElement(parent, parentName);
-        var element = EnsureElement(parentElement, "Include");
+        var include = EnsureElement(parentElement, "Include");
+        var exclude = EnsureElement(parentElement, "Exclude");
 
-        element.RemoveAll();
-        foreach (var value in values)
+        include.RemoveAll();
+        exclude.RemoveAll();
+
+        foreach (var value in values.include)
         {
-            element.Add(new XElement(childName, value));
+            include.Add(new XElement(childName, value));
         }
-    }
 
-    private static void AddExcludeItems(XElement parent, string parentName, string childName, IEnumerable<string> values)
-    {
-        var parentElement = EnsureElement(parent, parentName);
-        var element = EnsureElement(parentElement, "Exclude");
-
-        element.RemoveAll();
-        foreach (var value in values)
+        foreach (var value in values.exclude)
         {
-            element.Add(new XElement(childName, value));
+            exclude.Add(new XElement(childName, value));
         }
     }
 
     private static void DistinctAndOrganize(XElement parent, string parentName)
     {
-        var element = EnsureElement(parent, parentName);
-        if (element.Element("Include") is { } include)
+        if (parent.Element(parentName) is not { } item) return;
+        if (item.Element("Include") is { } include)
         {
             var values = include.Elements().DistinctBy(z => z.Value).OrderBy(x => x.Value).ToArray();
             include.RemoveAll();
             include.Add([..values]);
             if (!include.Elements().Any()) include.Remove();
         }
 
-        if (element.Element("Exclude") is { } exclude)
+        if (item.Element("Exclude") is { } exclude)
         {
             var values = exclude.Elements().DistinctBy(z => z.Value).OrderBy(x => x.Value).ToArray();
             exclude.RemoveAll();
             exclude.Add([..values]);
             if (!exclude.Elements().Any()) exclude.Remove();
         }
+
+        if (!item.Elements().Any()) item.Remove();
     }
 }
diff --git a/src/Nuke/Xamarin/ICanTestXamarin.cs b/src/Nuke/Xamarin/ICanTestXamarin.cs
@@ -37,7 +37,7 @@ public interface ICanTestXamarin : IHaveTestTarget,
                                                   .SetLoggers("trx")
                                                   .SetProperty("CollectCoverage", "true")
                                                   .SetProperty(
-                                                       "DeterministicSourcePaths",
+                                                        "DeterministicSourcePaths",
                                                        "false"
                                                    ) // DeterministicSourcePaths being true breaks coverlet!
                                                   .SetProperty("CoverageDirectory", CoverageDirectory)

diff --git a/src/Nuke/default.runsettings b/src/Nuke/default.runsettings
@@ -1,47 +1,17 @@
-<RunSettings>
+<?xml version="1.0" encoding="utf-8"?>
+<RunSettings>
   <DataCollectionRunSettings>
     <DataCollectors>
-      <DataCollector friendlyName="Code Coverage"
-                     uri="datacollector://Microsoft/CodeCoverage/2.0"
-                     assemblyQualifiedName="Microsoft.VisualStudio.Coverage.DynamicCoverageDataCollector, Microsoft.VisualStudio.TraceCollector, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+      <DataCollector friendlyName="Code Coverage">
         <Configuration>
           <Format>Cobertura</Format>
           <CodeCoverage>
             <EnableStaticManagedInstrumentation>True</EnableStaticManagedInstrumentation>
             <EnableDynamicManagedInstrumentation>True</EnableDynamicManagedInstrumentation>
-            <ModulePaths>
-              <Exclude>
-                <ModulePath>.*DryIoc.dll</ModulePath>
-                <ModulePath>.*FluentAssertions.dll</ModulePath>
-              </Exclude>
-            </ModulePaths>
-            <Attributes>
-              <Exclude>
-                <Attribute>^System\.Diagnostics\.DebuggerHiddenAttribute$</Attribute>
-                <Attribute>^System\.Diagnostics\.DebuggerNonUserCodeAttribute$</Attribute>
-                <Attribute>^System\.CodeDom\.Compiler\.GeneratedCodeAttribute$</Attribute>
-                <Attribute>^System\.Runtime\.CompilerServices\.CompilerGeneratedAttribute$</Attribute>
-                <Attribute>^System\.Diagnostics\.CodeAnalysis\.ExcludeFromCodeCoverageAttribute$</Attribute>
-              </Exclude>
-            </Attributes>
-            <Functions>
-              <Exclude>
-                <Function>^Bogus\..*</Function>
-                <Function>^FakeItEasy\..*</Function>
-                <Function>^Moq\..*</Function>
-                <Function>^NSubstitute\..*</Function>
-                <Function>^Verify\..*</Function>
-                <Function>^XUnit\..*</Function>
-                <Function>^TUnit\..*</Function>
-                <Function>^Microsoft\..*</Function>
-                <Function>^System\..*</Function>
-                <Function>^JetBrains\..*</Function>
-                <Function>^DryIoc\..*</Function>
-                <Function>^Nuke\..*</Function>
-                <Function>^FluentAssertions\..*</Function>
-                <Function>^Serilog\..*</Function>
-              </Exclude>
-            </Functions>
+            <Attributes />
+            <Functions />
+            <Sources />
+            <ModulePaths/>
           </CodeCoverage>
         </Configuration>
       </DataCollector>