Add fileMappings to the DTOs

Author: jimmylewis

src/LibraryManager.Contracts/FileMapping.cs

@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System.Collections.Generic;
+
+namespace Microsoft.Web.LibraryManager.Contracts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class FileMapping
+    {
+        /// <summary>
+        /// Root path within the library content for this file mapping entry.
+        /// </summary>
+        public string? Root { get; set; }
+
+        /// <summary>
+        /// Destination folder within the project.
+        /// </summary>
+        public string? Destination { get; set; }
+
+        /// <summary>
+        /// The file patterns to match for this mapping, relative to <see cref="Root"/>.  Accepts glob patterns.
+        /// </summary>
+        public IReadOnlyList<string>? Files { get; set; }
+    }
+}

src/LibraryManager.Contracts/ILibraryInstallationState.cs

@@ -30,6 +30,11 @@ public interface ILibraryInstallationState
         /// </summary>
         IReadOnlyList<string> Files { get; }
 
+        /// <summary>
+        /// List of mappings of a portion of library assets to a unique destination.
+        /// </summary>
+        IReadOnlyList<FileMapping> FileMappings { get; }
+
         /// <summary>
         /// The path relative to the working directory to copy the files to.
         /// </summary>

src/LibraryManager/Json/FileMapping.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+#nullable enable
+
+namespace Microsoft.Web.LibraryManager.Json
+{
+    internal class FileMapping
+    {
+        [JsonProperty(ManifestConstants.Root)]
+        public string? Root { get; set; }
+
+        [JsonProperty(ManifestConstants.Destination)]
+        public string? Destination { get; set; }
+
+        [JsonProperty(ManifestConstants.Files)]
+        public IReadOnlyList<string>? Files { get; set; }
+    }
+}

src/LibraryManager/Json/LibraryInstallationStateOnDisk.cs

@@ -1,9 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Collections.Generic;
-using System.Text;
 using Newtonsoft.Json;
 
 namespace Microsoft.Web.LibraryManager.Json
@@ -21,5 +19,8 @@ internal class LibraryInstallationStateOnDisk
 
         [JsonProperty(ManifestConstants.Files)]
         public IReadOnlyList<string> Files { get; set; }
+
+        [JsonProperty(ManifestConstants.FileMappings)]
+        public IReadOnlyList<FileMapping> FileMappings { get; set; }
     }
 }

src/LibraryManager/Json/LibraryStateToFileConverter.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Linq;
 using Microsoft.Web.LibraryManager.Contracts;
 using Microsoft.Web.LibraryManager.LibraryNaming;
 
@@ -33,7 +34,8 @@ public ILibraryInstallationState ConvertToLibraryInstallationState(LibraryInstal
                 IsUsingDefaultProvider = string.IsNullOrEmpty(stateOnDisk.ProviderId),
                 ProviderId = provider,
                 DestinationPath = destination,
-                Files = stateOnDisk.Files
+                Files = stateOnDisk.Files,
+                FileMappings = stateOnDisk.FileMappings.Select(f => new Contracts.FileMapping { Destination = f.Destination, Root = f.Root, Files = f.Files }).ToList(),
             };
 
             (state.Name, state.Version) = LibraryIdToNameAndVersionConverter.Instance.GetLibraryNameAndVersion(stateOnDisk.LibraryId, provider);
@@ -49,13 +51,22 @@ public LibraryInstallationStateOnDisk ConvertToLibraryInstallationStateOnDisk(IL
             }
 
             string provider = string.IsNullOrEmpty(state.ProviderId) ? _defaultProvider : state.ProviderId;
-            return new LibraryInstallationStateOnDisk()
+            var serializeState = new LibraryInstallationStateOnDisk()
             {
                 ProviderId = state.IsUsingDefaultProvider ? null : state.ProviderId,
                 DestinationPath = state.IsUsingDefaultDestination ? null : state.DestinationPath,
                 Files = state.Files,
-                LibraryId = LibraryIdToNameAndVersionConverter.Instance.GetLibraryId(state.Name, state.Version, provider)
+                LibraryId = LibraryIdToNameAndVersionConverter.Instance.GetLibraryId(state.Name, state.Version, provider),
+                FileMappings = state.FileMappings?.Select(f => new FileMapping { Destination = f.Destination, Root = f.Root, Files = f.Files }).ToList(),
             };
+
+            if (serializeState is { FileMappings: { Count: 0} })
+            {
+                // if FileMappings is empty, omit it from serialization
+                serializeState.FileMappings = null;
+            }
+
+            return serializeState;
         }
     }
 }

src/LibraryManager/LibraryInstallationState.cs

@@ -46,6 +46,11 @@ internal class LibraryInstallationState : ILibraryInstallationState
         /// </summary>
         public string Version { get; set; }
 
+        /// <summary>
+        /// Mappings for multiple different files within the library to different destinations.
+        /// </summary>
+        public IReadOnlyList<FileMapping> FileMappings { get; set; }
+
         /// <summary>Internal use only</summary>
         public static LibraryInstallationState FromInterface(ILibraryInstallationState state,
                                                              string defaultProviderId = null,

src/LibraryManager/ManifestConstants.cs

@@ -13,45 +13,55 @@ namespace Microsoft.Web.LibraryManager
     public static class ManifestConstants
     {
         /// <summary>
-        /// libman.json libraries element 
+        /// libman.json libraries element
         /// </summary>
         public const string Version = "version";
 
         /// <summary>
-        /// libman.json libraries element 
+        /// libman.json libraries element
         /// </summary>
         public const string Libraries = "libraries";
 
         /// <summary>
-        /// libman.json library element 
+        /// libman.json library element
         /// </summary>
         public const string Library = "library";
 
         /// <summary>
-        /// libman.json destination element 
+        /// libman.json destination element
         /// </summary>
         public const string Destination = "destination";
 
         /// <summary>
-        /// libman.json defaultDestination element 
+        /// libman.json defaultDestination element
         /// </summary>
         public const string DefaultDestination = "defaultDestination";
 
         /// <summary>
-        /// libman.json provider element 
+        /// libman.json provider element
         /// </summary>
         public const string Provider = "provider";
 
         /// <summary>
-        /// libman.json defaultProvider element 
+        /// libman.json defaultProvider element
         /// </summary>
         public const string DefaultProvider = "defaultProvider";
 
         /// <summary>
-        /// libman.json files element 
+        /// libman.json files element
         /// </summary>
         public const string Files = "files";
 
+        /// <summary>
+        /// libman.json fileMappings element
+        /// </summary>
+        public const string FileMappings = "fileMappings";
+
+        /// <summary>
+        /// libman.json root element
+        /// </summary>
+        public const string Root = "root";
+
         /// <summary>
         /// For providers that support versioned libraries, this represents the evergreen latest version
         /// </summary>

test/LibraryManager.Mocks/LibraryInstallationState.cs

@@ -46,5 +46,7 @@ public class LibraryInstallationState : ILibraryInstallationState
         /// Indicates whether the library is using the default provider.
         /// </summary>
         public bool IsUsingDefaultProvider { get; set; }
+
+        public IReadOnlyList<FileMapping> FileMappings => throw new System.NotImplementedException();
     }
 }