Warnings as errors

DotNetSolutionTools.Core/SolutionProjectParity.cs

@@ -21,7 +21,6 @@ public static class SolutionProjectParity
     {
         var csprojList = RetrieveAllCSharpProjectFullPathsFromFolder(solutionFolderPath);
 
-        csprojList = csprojList.Select(x => x.Replace(solutionFolderPath, "")).ToArray();
         return csprojList;
     }
 
@@ -57,7 +56,7 @@ public static class SolutionProjectParity
 
         foreach (var project in csprojList)
         {
-            var projectInSolution = projects.FirstOrDefault(x => x.RelativePath == project);
+            var projectInSolution = projects.FirstOrDefault(x => NormalizePath(x.AbsolutePath) == NormalizePath(project));
 
             if (projectInSolution == null)
             {
@@ -79,4 +78,10 @@ public static class SolutionProjectParity
 
         return projectList;
     }
+    
+    private static string NormalizePath(string path)
+    {
+        return Path.GetFullPath(new Uri(path).LocalPath)
+            .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+    }
 }

DotNetSolutionTools.Core/WarningsAsErrors.cs

@@ -0,0 +1,78 @@
+using Microsoft.Build.Construction;
+
+namespace DotNetSolutionTools.Core;
+
+public static class WarningsAsErrors
+{
+    public static List<string> FindCSharpProjectsMissingTreatWarningsAsErrors(string solutionFilePath)
+    {
+        var solutionFile = SolutionFile.Parse(solutionFilePath);
+        var csprojList = SolutionProjectParity.GetCSharpProjectObjectsFromSolutionFile(
+            solutionFile
+        );
+        var projectsMissingImplicitUsings = FindCSharpProjectsMissingTreatWarningsAsErrors(csprojList);
+        var projectsMissingImplicitUsingsStringList = projectsMissingImplicitUsings
+            .Select(x => x.FullPath)
+            .ToList();
+
+        return projectsMissingImplicitUsingsStringList;
+    }
+
+    public static List<ProjectRootElement> FindCSharpProjectsMissingTreatWarningsAsErrors(
+        List<ProjectRootElement> projectList
+    )
+    {
+        var projectsMissingTreatWarningsAsErrors = new List<ProjectRootElement>();
+
+        foreach (var project in projectList)
+        {
+            var treatWarningsAsErrors = project.PropertyGroups
+                .SelectMany(x => x.Properties)
+                .FirstOrDefault(x => x.Name == "TreatWarningsAsErrors");
+            if (treatWarningsAsErrors is null || treatWarningsAsErrors.Value is not "true")
+            {
+                projectsMissingTreatWarningsAsErrors.Add(project);
+            }
+        }
+
+        return projectsMissingTreatWarningsAsErrors;
+    }
+
+    public static void AddMissingTreatWarningsAsErrors(
+        List<ProjectRootElement> projectsMissingImplicitUsings
+    )
+    {
+        foreach (var project in projectsMissingImplicitUsings)
+        {
+            if (ProjectIsMissingTreatWarningsAsErrors(project))
+            {
+                
+                project.AddProperty("TreatWarningsAsErrors", "true");
+                project.Save();
+                FormatCsproj.FormatCsprojFile(project.FullPath);
+            }
+        }
+    }
+
+    public static bool ProjectIsMissingTreatWarningsAsErrors(ProjectRootElement project)
+    {
+        var implicitUsings = project.PropertyGroups
+            .SelectMany(x => x.Properties)
+            .FirstOrDefault(x => x.Name == "TreatWarningsAsErrors");
+        if (implicitUsings is null)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public static bool ProjectBuildSuccessfully(ProjectRootElement project)
+    {
+        // build the project
+        var buildProject = new Microsoft.Build.Evaluation.Project(project); 
+        // retrieve warnings
+        var buildResult = buildProject.Build();
+        return buildResult;
+    }
+}