Support SLNX by using Microsoft.VisualStudio.SolutionPersistence

Directory.Packages.props

@@ -7,6 +7,7 @@
 
         <PackageVersion Include="Microsoft.Build.Prediction" Version="1.2.18" />
         <PackageVersion Include="Microsoft.Build.Locator" Version="1.7.8" />
+        <PackageVersion Include="Microsoft.VisualStudio.SolutionPersistence" Version="1.0.52" />
 
         <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
         <PackageVersion Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.12.1" Condition="'$(OS)' == 'Windows_NT'"/>

src/DotnetAffected.Core/DotnetAffected.Core.csproj

@@ -11,5 +11,6 @@
     <ItemGroup>
         <PackageReference Include="Microsoft.Build.Prediction" />
         <PackageReference Include="LibGit2Sharp" />
+        <PackageReference Include="Microsoft.VisualStudio.SolutionPersistence" />
     </ItemGroup>
 </Project>

src/DotnetAffected.Core/ProjectDiscovery/ProjectDiscoveryManager.cs

@@ -15,7 +15,7 @@ public IEnumerable<string> DiscoverProjects(IDiscoveryOptions options)
             }
 
             // When a filtering file is provided, use a specific discoverer based on its path.
-            if (options.FilterFilePath.EndsWith(".sln"))
+            if (options.FilterFilePath.EndsWith(".sln") || options.FilterFilePath.EndsWith(".slnx"))
             {
                 return new SolutionFileProjectDiscoverer().DiscoverProjects(options);
             }

src/DotnetAffected.Core/ProjectDiscovery/SolutionFileProjectDiscoverer.cs

@@ -1,19 +1,30 @@
 using DotnetAffected.Abstractions;
-using Microsoft.Build.Construction;
+using Microsoft.VisualStudio.SolutionPersistence.Serializer;
+using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Threading;
 
 namespace DotnetAffected.Core
 {
     internal class SolutionFileProjectDiscoverer : IProjectDiscoverer
     {
         public IEnumerable<string> DiscoverProjects(IDiscoveryOptions options)
         {
-            var solution = SolutionFile.Parse(options.FilterFilePath);
+            // It should not be possible for this to be null based on call paths - but this makes the warning go away
+            ArgumentNullException.ThrowIfNull(options.FilterFilePath);
 
-            return solution.ProjectsInOrder
-                .Where(x => x.ProjectType != SolutionProjectType.SolutionFolder)
-                .Select(x => x.AbsolutePath)
+            var serializer = SolutionSerializers.GetSerializerByMoniker(options.FilterFilePath);
+
+            if (serializer is null) throw new NotSupportedException($"Filtering by {options.FilterFilePath} is not supported");
+
+            var solution = serializer.OpenAsync(options.FilterFilePath, CancellationToken.None).GetAwaiter().GetResult();
+
+            var solutionDir = Path.GetDirectoryName(options.FilterFilePath);
+
+            return solution.SolutionProjects
+                .Select(x => Path.IsPathRooted(x.FilePath) ? x.FilePath : Path.Join(solutionDir, x.FilePath))
                 .ToArray();
         }
     }

src/dotnet-affected/Commands/AffectedGlobalOptions.cs

@@ -28,7 +28,7 @@ internal static class AffectedGlobalOptions
             {
                 "--filter-file-path"
             },
-            description: "Path to a filter file (.sln) used to discover projects that may be affected.\n" +
+            description: "Path to a filter file (.sln, .slnx) used to discover projects that may be affected.\n" +
                          "When omitted, will search for project files inside --repository-path.");
 
         public static readonly Option<bool> VerboseOption = new(aliases: new[]

test/DotnetAffected.Core.Tests/ChangeDetectionUsingXmlSolutionTests.cs

@@ -0,0 +1,82 @@
+using DotnetAffected.Testing.Utils;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DotnetAffected.Core.Tests
+{
+    /// <summary>
+    /// Tests for detecting changed projects when using a SolutionFile to filter.
+    /// This should cover all tests where filtering should be applied
+    /// </summary>
+    public class ChangeDetectionUsingXmlSolutionTests
+        : BaseDotnetAffectedTest
+    {
+        private readonly string _solutionPath = "test-solution.slnx";
+
+        protected override AffectedOptions Options => new AffectedOptions(
+            this.Repository.Path,
+            Path.Combine(this.Repository.Path, this._solutionPath));
+
+        [Fact]
+        public async Task When_project_inside_solution_has_changes_project_should_have_changed()
+        {
+            // Create a project
+            var projectName = "InventoryManagement";
+            var msBuildProject = this.Repository.CreateCsProject(projectName);
+
+            // Create a solution which includes the project
+            await this.Repository.CreateXmlSolutionAsync(_solutionPath, msBuildProject.FullPath);
+
+            Assert.Single(AffectedSummary.ProjectsWithChangedFiles);
+            Assert.Empty(AffectedSummary.AffectedProjects);
+
+            var projectInfo = AffectedSummary.ProjectsWithChangedFiles.Single();
+            Assert.Equal(projectName, projectInfo.GetProjectName());
+            Assert.Equal(msBuildProject.FullPath, projectInfo.GetFullPath());
+        }
+
+        [Fact]
+        public async Task When_project_inside_solution_should_ignore_changes_outside_solution()
+        {
+            // Create a project
+            var projectName = "InventoryManagement";
+            var msBuildProject = this.Repository.CreateCsProject(projectName);
+
+            // Create a solution which includes the project
+            await this.Repository.CreateXmlSolutionAsync(_solutionPath, msBuildProject.FullPath);
+
+            // Create a project that is outside the solution
+            var outsiderproject = "OutsiderProject";
+            this.Repository.CreateCsProject(outsiderproject);
+
+            Assert.Single(AffectedSummary.ProjectsWithChangedFiles);
+            Assert.Empty(AffectedSummary.AffectedProjects);
+
+            var projectInfo = AffectedSummary.ProjectsWithChangedFiles.Single();
+            Assert.Equal(projectName, projectInfo.GetProjectName());
+            Assert.Equal(msBuildProject.FullPath, projectInfo.GetFullPath());
+        }
+
+        [Fact]
+        public async Task When_project_outside_solution_has_changed_nothing_should_be_affected()
+        {
+            // Create a project
+            var projectName = "InventoryManagement";
+            var msBuildProject = this.Repository.CreateCsProject(projectName);
+
+            // Create a solution which includes the project
+            await this.Repository.CreateXmlSolutionAsync(_solutionPath, msBuildProject.FullPath);
+
+            // Commit so there are no changes
+            this.Repository.StageAndCommit();
+
+            // Create a project that is outside the solution
+            var outsiderName = "OutsiderProject";
+            this.Repository.CreateCsProject(outsiderName);
+
+            Assert.Empty(AffectedSummary.AffectedProjects);
+        }
+    }
+}

test/DotnetAffected.Testing.Utils/Repository/TemporaryRepositoryExtensions.cs

@@ -149,6 +149,20 @@ public static async Task CreateSolutionAsync(
             await File.WriteAllTextAsync(solutionPath, solutionContents);
         }
 
+        public static async Task CreateXmlSolutionAsync(
+            this TemporaryRepository repo,
+            string solutionName,
+            params string[] projectPaths)
+        {
+            var i = 0;
+            var solutionContents = new SolutionFileBuilder { Projects = projectPaths.ToDictionary(p => i++.ToString()) }
+                .BuildXmlSolution();
+
+            var solutionPath = Path.Combine(repo.Path, solutionName);
+
+            await File.WriteAllTextAsync(solutionPath, solutionContents);
+        }
+
         public static Task CreateTraversalProjectAsync(
             this TemporaryRepository repo,
             string traversalProjectPath,

test/DotnetAffected.Testing.Utils/SolutionFileBuilder.cs

@@ -97,5 +97,26 @@ public string BuildSolution()
 
             return sb.ToString();
         }
+
+        public string BuildXmlSolution()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine(@"<Solution>");
+            sb.AppendLine(@"  <Configurations>");
+            sb.AppendLine(@"    <Platform Name=""Any CPU"" />");
+            sb.AppendLine(@"    <Platform Name=""x64"" />");
+            sb.AppendLine(@"    <Platform Name=""x86"" />");
+            sb.AppendLine(@"  </Configurations>");
+
+            foreach (var project in Projects.Values)
+            {
+                sb.AppendLine(@$"  <Project Path=""{project}"" />");
+
+            }
+
+            sb.AppendLine(@"</Solution>");
+
+            return sb.ToString();
+        }
     }
 }