Refactor generate intermediate solution folders

Author: edvilme

src/Cli/dotnet/commands/dotnet-sln/add/Program.cs

@@ -23,6 +23,7 @@ internal class AddProjectToSolutionCommand : CommandBase
         private readonly bool _inRoot;
         private readonly IReadOnlyCollection<string> _projects;
         private readonly string? _solutionFolderPath;
+        private string _solutionFileFullPath = string.Empty;
 
         private static string GetSolutionFolderPathWithForwardSlashes(string path)
         {
@@ -31,9 +32,9 @@ private static string GetSolutionFolderPathWithForwardSlashes(string path)
             return "/" + string.Join("/", PathUtility.GetPathWithDirectorySeparator(path).Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries)) + "/";
         }
 
-        private static bool DoesSolutionFolderPathContainInvalidChars(string pathFragment)
+        private static bool IsValidSolutionFolderPath(string pathFragment)
         {
-            return pathFragment
+            return !string.IsNullOrEmpty(pathFragment) && !pathFragment
                 .Split(Path.DirectorySeparatorChar)
                 .Any(pathFragment => pathFragment == ".." || pathFragment == "." || Path.GetInvalidFileNameChars().Any(c => pathFragment.Contains(c)));
         }
@@ -45,6 +46,7 @@ public AddProjectToSolutionCommand(ParseResult parseResult) : base(parseResult)
             _inRoot = parseResult.GetValue(SlnAddParser.InRootOption);
             _solutionFolderPath = parseResult.GetValue(SlnAddParser.SolutionFolderOption);
             SlnArgumentValidator.ParseAndValidateArguments(_fileOrDirectory, _projects, SlnArgumentValidator.CommandType.Add, _inRoot, _solutionFolderPath);
+            _solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory);
         }
 
         public override int Execute()
@@ -53,7 +55,6 @@ public override int Execute()
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToAdd);
             }
-            string solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory);
 
             try
             {
@@ -63,24 +64,24 @@ public override int Execute()
                     var fullPath = Path.GetFullPath(project);
                     return Directory.Exists(fullPath) ? MsbuildProject.GetProjectFileFromDirectory(fullPath).FullName : fullPath;
                 });
-                AddProjectsToSolutionAsync(solutionFileFullPath, fullProjectPaths, CancellationToken.None).GetAwaiter().GetResult();
+                AddProjectsToSolutionAsync(fullProjectPaths, CancellationToken.None).GetAwaiter().GetResult();
                 return 0;
             }
             catch (Exception ex) when (ex is not GracefulException)
             {
                 {
                     if (ex is SolutionException || ex.InnerException is SolutionException)
                     {
-                        throw new GracefulException(CommonLocalizableStrings.InvalidSolutionFormatString, solutionFileFullPath, ex.Message);
+                        throw new GracefulException(CommonLocalizableStrings.InvalidSolutionFormatString, _solutionFileFullPath, ex.Message);
                     }
                     throw new GracefulException(ex.Message, ex);
                 }
             }
         }
 
-        private async Task AddProjectsToSolutionAsync(string solutionFileFullPath, IEnumerable<string> projectPaths, CancellationToken cancellationToken)
+        private async Task AddProjectsToSolutionAsync(IEnumerable<string> projectPaths, CancellationToken cancellationToken)
         {
-            SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(solutionFileFullPath);
+            SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(_solutionFileFullPath);
             ISolutionSerializer serializer = solution.SerializerExtension.Serializer;
             // set UTF8 BOM encoding for .sln
             if (serializer is ISolutionSerializer<SlnV12SerializerSettings> v12Serializer)
@@ -95,51 +96,74 @@ private async Task AddProjectsToSolutionAsync(string solutionFileFullPath, IEnum
                 _defaultBuildTypes.ToList().ForEach(solution.AddBuildType);
             }
 
-            SolutionFolderModel? solutionFolder = (!_inRoot && !string.IsNullOrEmpty(_solutionFolderPath))
-                ? solution.AddFolder(GetSolutionFolderPathWithForwardSlashes(_solutionFolderPath))
-                : null;
-
+            
             foreach (var projectPath in projectPaths)
             {
-                string relativePath = Path.GetRelativePath(Path.GetDirectoryName(solutionFileFullPath), projectPath);
-
-                // Add fallback solution folder if relative path does not contain invalid characters
-                string relativeSolutionFolder = DoesSolutionFolderPathContainInvalidChars(relativePath) ? string.Empty : Path.GetDirectoryName(relativePath);
-
-                if (!_inRoot && solutionFolder is null && !string.IsNullOrEmpty(relativeSolutionFolder))
-                {
-                    if (relativeSolutionFolder.Split(Path.DirectorySeparatorChar).LastOrDefault() == Path.GetFileNameWithoutExtension(relativePath))
-                    {
-                        relativeSolutionFolder = Path.Combine(relativeSolutionFolder.Split(Path.DirectorySeparatorChar).SkipLast(1).ToArray());
-                    }
-                    if (!string.IsNullOrEmpty(relativeSolutionFolder))
-                    {
-                        solutionFolder = solution.AddFolder(GetSolutionFolderPathWithForwardSlashes(relativeSolutionFolder));
-                    }
-                }
+                string relativePath = Path.GetRelativePath(Path.GetDirectoryName(_solutionFileFullPath), projectPath);
 
                 try
                 {
-                    AddProject(solution, relativePath, projectPath, solutionFolder, serializer);
+                    AddProject(solution, relativePath, projectPath, serializer);
                 }
                 catch (InvalidProjectFileException ex)
                 {
                     Reporter.Error.WriteLine(string.Format(CommonLocalizableStrings.InvalidProjectWithExceptionMessage, projectPath, ex.Message));
                 }
                 catch (SolutionArgumentException ex) when (solution.FindProject(relativePath) != null || ex.Type == SolutionErrorType.DuplicateProjectName)
                 {
-                    Reporter.Output.WriteLine(CommonLocalizableStrings.SolutionAlreadyContainsProject, solutionFileFullPath, relativePath);
+                    Reporter.Output.WriteLine(CommonLocalizableStrings.SolutionAlreadyContainsProject, _solutionFileFullPath, relativePath);
+                }
+            }
+            await serializer.SaveAsync(_solutionFileFullPath, solution, cancellationToken);
+        }
+
+        private SolutionFolderModel? GenerateIntermediateSolutionFoldersForProjectPath(SolutionModel solution, string relativeProjectPath)
+        {
+            if (_inRoot)
+            {
+                return null;
+            }
+
+            string relativeSolutionFolderPath = string.Empty;
+
+            if (string.IsNullOrEmpty(_solutionFolderPath))
+            {
+                // Generate the solution folder path based on the project path
+                relativeSolutionFolderPath = Path.GetDirectoryName(relativeProjectPath);
+
+                // If the project is in a folder with the same name as the project, we need to go up one level
+                if (relativeSolutionFolderPath.Split(Path.DirectorySeparatorChar).LastOrDefault() == Path.GetFileNameWithoutExtension(relativeProjectPath))
+                {
+                    relativeSolutionFolderPath = Path.Combine([.. relativeSolutionFolderPath.Split(Path.DirectorySeparatorChar).SkipLast(1)]);
+                }
+
+                // If the generated path is invalid, make it empty
+                if (!IsValidSolutionFolderPath(relativeSolutionFolderPath))
+                {
+                    relativeSolutionFolderPath = string.Empty;
                 }
             }
-            await serializer.SaveAsync(solutionFileFullPath, solution, cancellationToken);
+            else
+            {
+                // Use the provided solution folder path
+                relativeSolutionFolderPath = _solutionFolderPath;
+            }
+
+            return string.IsNullOrEmpty(relativeSolutionFolderPath)
+                ? null
+                : solution.AddFolder(GetSolutionFolderPathWithForwardSlashes(relativeSolutionFolderPath));
         }
 
-        private void AddProject(SolutionModel solution, string solutionRelativeProjectPath, string fullPath, SolutionFolderModel? solutionFolder, ISolutionSerializer serializer = null)
+        private void AddProject(SolutionModel solution, string solutionRelativeProjectPath, string fullProjectPath, ISolutionSerializer serializer = null)
         {
             // Open project instance to see if it is a valid project
-            ProjectRootElement projectRootElement = ProjectRootElement.Open(fullPath);
+            ProjectRootElement projectRootElement = ProjectRootElement.Open(fullProjectPath);
             ProjectInstance projectInstance = new ProjectInstance(projectRootElement);
             SolutionProjectModel project;
+
+            // Generate the solution folder path based on the project path
+            SolutionFolderModel? solutionFolder = GenerateIntermediateSolutionFoldersForProjectPath(solution, solutionRelativeProjectPath);
+
             try
             {
                 project = solution.AddProject(solutionRelativeProjectPath, null, solutionFolder);
@@ -150,13 +174,15 @@ private void AddProject(SolutionModel solution, string solutionRelativeProjectPa
                 var guid = projectRootElement.GetProjectTypeGuid() ?? projectInstance.GetDefaultProjectTypeGuid();
                 if (string.IsNullOrEmpty(guid))
                 {
-                    Reporter.Error.WriteLine(CommonLocalizableStrings.UnsupportedProjectType, fullPath);
+                    Reporter.Error.WriteLine(CommonLocalizableStrings.UnsupportedProjectType, fullProjectPath);
                     return;
                 }
                 project = solution.AddProject(solutionRelativeProjectPath, guid, solutionFolder);
             }
+
             // Add settings based on existing project instance
             string projectInstanceId = projectInstance.GetProjectId();
+
             if (!string.IsNullOrEmpty(projectInstanceId) && serializer is ISolutionSerializer<SlnV12SerializerSettings>)
             {
                 project.Id = new Guid(projectInstanceId);
@@ -178,6 +204,7 @@ private void AddProject(SolutionModel solution, string solutionRelativeProjectPa
                     buildType => buildType.Replace(" ", string.Empty) == solutionBuildType.Replace(" ", string.Empty), projectInstanceBuildTypes.FirstOrDefault());
                 project.AddProjectConfigurationRule(new ConfigurationRule(BuildDimension.BuildType, solutionBuildType, "*", projectBuildType));
             }
+
             Reporter.Output.WriteLine(CommonLocalizableStrings.ProjectAddedToTheSolution, solutionRelativeProjectPath);
         }
     }