Refactor computing goal state and errors to be extensible

This allows FileSystemProvider to handle its special cases (i.e. rename support for a single file).

FileSystemProvider did not get support for fileMappings prior to this.  This will enable it to support that feature as well.

Author: jimmylewis

src/LibraryManager/Providers/BaseProvider.cs

@@ -165,6 +165,13 @@ public async Task<OperationResult<LibraryInstallationGoalState>> GetInstallation
 
         #endregion
 
+        /// <summary>
+        /// Generates the goal state for library installation based on the desired state and library information.
+        /// </summary>
+        /// <param name="desiredState">Specifies the target state for the library installation, including file mappings and destination paths.</param>
+        /// <param name="library">Represents the library from which files are being installed, containing file information and validation
+        /// methods.</param>
+        /// <returns>Returns an operation result containing the goal state or errors encountered during the generation process.</returns>
         private OperationResult<LibraryInstallationGoalState> GenerateGoalState(ILibraryInstallationState desiredState, ILibrary library)
         {
             var mappings = new List<FileMapping>(desiredState.FileMappings ?? []);
@@ -212,33 +219,26 @@ private OperationResult<LibraryInstallationGoalState> GenerateGoalState(ILibrary
                     fileFilters = fileFilters.Select(f => $"{mappingRoot}/{f}").ToList();
                 }
 
-                List<string> outFiles = FileGlobbingUtility.ExpandFileGlobs(fileFilters, library.Files.Keys).ToList();
+                List<string> filteredFiles = FileGlobbingUtility.ExpandFileGlobs(fileFilters, library.Files.Keys).ToList();
 
-                if (library.GetInvalidFiles(outFiles) is IReadOnlyList<string> invalidFiles
-    && invalidFiles.Count > 0)
+                if (library.GetInvalidFiles(filteredFiles) is IReadOnlyList<string> { Count: > 0 } invalidFiles)
                 {
                     errors ??= [];
                     errors.Add(PredefinedErrors.InvalidFilesInLibrary(desiredState.Name, invalidFiles, library.Files.Keys));
+                    filteredFiles.RemoveAll(file => invalidFiles.Contains(file));
                 }
 
-                foreach (string outFile in outFiles)
-                {
-                    // strip the source prefix
-                    string relativeOutFile = mappingRoot.Length > 0 ? outFile.Substring(mappingRoot.Length + 1) : outFile;
-                    string destinationFile = Path.Combine(HostInteraction.WorkingDirectory, destination, relativeOutFile);
-                    destinationFile = FileHelpers.NormalizePath(destinationFile);
+                Dictionary<string, string> fileMappings = GetFileMappings(library, filteredFiles, mappingRoot, destination, desiredState, errors);
 
+                foreach ((string destinationFile, string sourceFile) in fileMappings)
+                {
                     if (!FileHelpers.IsUnderRootDirectory(destinationFile, HostInteraction.WorkingDirectory))
                     {
                         errors ??= [];
                         errors.Add(PredefinedErrors.PathOutsideWorkingDirectory());
                         continue;
                     }
 
-                    // include the cache folder in the path
-                    string sourceFile = GetCachedFileLocalPath(desiredState, outFile);
-                    sourceFile = FileHelpers.NormalizePath(sourceFile);
-
                     // map destination back to the library-relative file it originated from
                     if (installFiles.ContainsKey(destinationFile))
                     {
@@ -248,10 +248,8 @@ private OperationResult<LibraryInstallationGoalState> GenerateGoalState(ILibrary
                         errors.Add(PredefinedErrors.LibraryCannotBeInstalledDueToConflicts(destinationFile, [libraryId]));
                         continue;
                     }
-                    else
-                    {
-                        installFiles.Add(destinationFile, sourceFile);
-                    }
+
+                    installFiles.Add(destinationFile, sourceFile);
                 }
             }
 
@@ -264,6 +262,28 @@ private OperationResult<LibraryInstallationGoalState> GenerateGoalState(ILibrary
             return OperationResult<LibraryInstallationGoalState>.FromSuccess(goalState);
         }
 
+
+        protected virtual Dictionary<string, string> GetFileMappings(ILibrary library, IReadOnlyList<string> libraryFiles, string mappingRoot, string destination, ILibraryInstallationState desiredState, List<IError> errors)
+        {
+            Dictionary<string, string> installFiles = new(StringComparer.OrdinalIgnoreCase);
+
+            foreach (string file in libraryFiles)
+            {
+                // strip the source prefix
+                string relativeOutFile = mappingRoot.Length > 0 ? file.Substring(mappingRoot.Length + 1) : file;
+                string destinationFile = Path.Combine(HostInteraction.WorkingDirectory, destination, relativeOutFile);
+                destinationFile = FileHelpers.NormalizePath(destinationFile);
+
+                // include the cache folder in the path
+                string sourceFile = GetCachedFileLocalPath(desiredState, file);
+                sourceFile = FileHelpers.NormalizePath(sourceFile);
+
+                installFiles.Add(destinationFile, sourceFile);
+            }
+
+            return installFiles;
+        }
+
         public bool IsSourceCacheReady(LibraryInstallationGoalState goalState)
         {
             foreach (KeyValuePair<string, string> item in goalState.InstalledFiles)

src/LibraryManager/Providers/FileSystem/FileSystemProvider.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
@@ -221,5 +222,25 @@ protected override string GetCachedFileLocalPath(ILibraryInstallationState state
             // be handled elsewhere.
             return Path.Combine(state.Name, sourceFile);
         }
+
+        /// <inheritdoc />
+        protected override Dictionary<string, string> GetFileMappings(ILibrary library, IReadOnlyList<string> fileFilters, string mappingRoot, string destination, ILibraryInstallationState desiredState, List<IError> errors)
+        {
+            Dictionary<string, string> fileMappings = new();
+            // Handle single-file edge cases for FileSystem
+            if (library.Files.Count == 1
+                && fileFilters.Count == 1
+                && GetCachedFileLocalPath(desiredState, library.Files.Keys.First()) == library.Name)
+            {
+                // direct 1:1 file mapping, allowing file rename
+                string destinationFile = Path.Combine(HostInteraction.WorkingDirectory, destination, fileFilters[0]);
+                destinationFile = FileHelpers.NormalizePath(destinationFile);
+
+                fileMappings.Add(destinationFile, library.Files.Keys.First());
+                return fileMappings;
+            }
+
+            return base.GetFileMappings(library, fileFilters, mappingRoot, destination, desiredState, errors);
+        }
     }
 }