Add Font Package "New" Support and ManifestRootType (#645)

* Add font support

* Feedback update

Author: dkbennett

src/WingetCreateCLI/Commands/BaseCommand.cs

@@ -166,10 +166,12 @@ public async Task<bool> LoadGitHubClient(bool requireToken = false)
         /// Creates a formatted directory of manifest files from the manifest object models and saves the directory to a local path.
         /// </summary>
         /// <param name="manifests">Wrapper object for manifest object models.</param>
+        /// <param name="manifestRoot">Manifest root name.</param>
         /// <param name="outputDir">Output directory where the manifests are saved locally.</param>
         /// <returns>Path to manifest directory.</returns>
         protected static string SaveManifestDirToLocalPath(
             Manifests manifests,
+            string manifestRoot,
             string outputDir)
         {
             VersionManifest versionManifest = manifests.VersionManifest;
@@ -180,7 +182,7 @@ protected static string SaveManifestDirToLocalPath(
             outputDir = Environment.ExpandEnvironmentVariables(outputDir);
             string version = versionManifest.PackageVersion;
             string packageId = versionManifest.PackageIdentifier;
-            string manifestDir = Utils.GetAppManifestDirPath(packageId, version);
+            string manifestDir = Utils.GetAppManifestDirPath(packageId, version, manifestRoot);
             string fullDirPath = Path.GetFullPath(Path.Combine(outputDir, manifestDir));
 
             try
@@ -739,11 +741,12 @@ protected async Task<bool> CheckGitHubTokenAndSetClient()
         /// Submits a pull request with multifile manifests using the user's GitHub access token.
         /// </summary>
         /// <param name="manifests">Wrapper object for manifest object models to be submitted.</param>
+        /// <param name="manifestRoot">Manifest root name.</param>
         /// <param name="prTitle">Optional parameter specifying the title for the pull request.</param>
         /// <param name="shouldReplace">Optional parameter specifying whether the new submission should replace an existing manifest.</param>
         /// <param name="replaceVersion">Optional parameter specifying the version of the manifest to be replaced.</param>
         /// <returns>A <see cref="Task"/> representing the success of the asynchronous operation.</returns>
-        protected async Task<bool> GitHubSubmitManifests(Manifests manifests, string prTitle = null, bool shouldReplace = false, string replaceVersion = null)
+        protected async Task<bool> GitHubSubmitManifests(Manifests manifests, string manifestRoot = Constants.WingetManifestRoot, string prTitle = null, bool shouldReplace = false, string replaceVersion = null)
         {
             // Community repo only supports yaml submissions.
             if (this.WingetRepo == DefaultWingetRepo &&
@@ -765,7 +768,7 @@ protected async Task<bool> GitHubSubmitManifests(Manifests manifests, string prT
 
             try
             {
-                Octokit.PullRequest pullRequest = await this.GitHubClient.SubmitPullRequestAsync(manifests, this.SubmitPRToFork, prTitle, shouldReplace, replaceVersion);
+                Octokit.PullRequest pullRequest = await this.GitHubClient.SubmitPullRequestAsync(manifests, this.SubmitPRToFork, manifestRoot, prTitle, shouldReplace, replaceVersion);
                 this.PullRequestNumber = pullRequest.Number;
                 PullRequestEvent pullRequestEvent = new PullRequestEvent { IsSuccessful = true, PullRequestNumber = pullRequest.Number };
                 TelemetryManager.Log.WriteEvent(pullRequestEvent);

src/WingetCreateCLI/Commands/NewCommand.cs

@@ -25,6 +25,7 @@ namespace Microsoft.WingetCreateCLI.Commands
     using Microsoft.WingetCreateCore.Models.DefaultLocale;
     using Microsoft.WingetCreateCore.Models.Installer;
     using Microsoft.WingetCreateCore.Models.Version;
+    using Newtonsoft.Json.Schema.Generation;
     using Sharprompt;
 
     /// <summary>
@@ -41,7 +42,20 @@ public class NewCommand : BaseCommand
         /// <summary>
         /// Installer type file extensions that are supported.
         /// </summary>
-        private static readonly string[] SupportedInstallerTypeExtensions = new[] { ".msix", ".msi", ".exe", ".msixbundle", ".appx", ".appxbundle" };
+        private static readonly string[] SupportedInstallerTypeExtensions =
+        [
+            ".msix",
+            ".msi",
+            ".exe",
+            ".msixbundle",
+            ".appx",
+            ".appxbundle",
+            ".otf",         // OpenType Font
+            ".ttf",         // TrueType Font
+            ".fnt",         // Font
+            ".ttc",         // TrueType Font Collection
+            ".otc",         // OpenType Font Collection
+        ];
 
         /// <summary>
         /// Gets the usage examples for the New command.
@@ -117,6 +131,7 @@ public override async Task<bool> Execute()
                 Prompt.Symbols.Prompt = new Symbol(string.Empty, string.Empty);
 
                 Manifests manifests = new Manifests();
+                PackageParser.ManifestRootType manifestRootType = PackageParser.ManifestRootType.Unknown;
 
                 if (!this.InstallerUrls.Any())
                 {
@@ -169,6 +184,29 @@ public override async Task<bool> Execute()
                             .ToList();
 
                         int extractedFilesCount = extractedFiles.Count();
+
+                        var rootTypeForFiles = PackageParser.GetManifestRootTypeForInstallerPaths(extractedFiles);
+                        var isFontPackage = rootTypeForFiles == PackageParser.ManifestRootType.Fonts;
+
+                        // Set the root type if it is unknown.
+                        if (manifestRootType == PackageParser.ManifestRootType.Unknown)
+                        {
+                            manifestRootType = rootTypeForFiles;
+                        }
+
+                        // Check for installer type mismatches or mixed installers.
+                        if ((manifestRootType != rootTypeForFiles) || (manifestRootType == PackageParser.ManifestRootType.Unknown))
+                        {
+                            // Mismatched root and installer types is a WinGet-Pkgs policy, not an invalid manifest.
+                            Logger.WarnLocalized(nameof(Resources.MixedInstallerRootTypes_ErrorMessage));
+                        }
+
+                        // If the root type is still unknown, it means a mixed package. We will assume manifests.
+                        if (manifestRootType == PackageParser.ManifestRootType.Unknown)
+                        {
+                            manifestRootType = PackageParser.ManifestRootType.Manifests;
+                        }
+
                         List<string> selectedInstallers;
 
                         if (extractedFilesCount == 0)
@@ -180,26 +218,70 @@ public override async Task<bool> Execute()
                         {
                             selectedInstallers = extractedFiles;
                         }
+                        else if (isFontPackage)
+                        {
+                            // If this is a font package, every installer is intended to be installed.
+                            selectedInstallers = extractedFiles;
+                        }
                         else
                         {
                             selectedInstallers = Prompt.MultiSelect(Resources.SelectInstallersFromZip_Message, extractedFiles, minimum: 1).ToList();
                         }
 
-                        foreach (var installer in selectedInstallers)
+                        if (isFontPackage)
                         {
+                            // If every installer is a single font package, we can convert the entire package into a single font nested installer.
+                            List<NestedInstallerFile> nestedInstallerFiles = [];
+                            foreach (var fontFile in selectedInstallers)
+                            {
+                                nestedInstallerFiles.Add(new NestedInstallerFile { RelativeFilePath = fontFile });
+                            }
+
                             installerUpdateList.Add(
                             new InstallerMetadata
                             {
                                 InstallerUrl = installerUrl,
                                 PackageFile = packageFile,
-                                NestedInstallerFiles = new List<NestedInstallerFile> { new NestedInstallerFile { RelativeFilePath = installer } },
+                                NestedInstallerFiles = nestedInstallerFiles,
+                                OverrideArchitecture = Architecture.Neutral,
                                 IsZipFile = true,
                                 ExtractedDirectory = extractDirectory,
                             });
                         }
+                        else
+                        {
+                            foreach (var installer in selectedInstallers)
+                            {
+                                installerUpdateList.Add(
+                                new InstallerMetadata
+                                {
+                                    InstallerUrl = installerUrl,
+                                    PackageFile = packageFile,
+                                    NestedInstallerFiles = new List<NestedInstallerFile> { new NestedInstallerFile { RelativeFilePath = installer } },
+                                    IsZipFile = true,
+                                    ExtractedDirectory = extractDirectory,
+                                });
+                            }
+                        }
                     }
-                    else
+                    else // Not a Zip package archive.
                     {
+                        // Set the manifest root type. There is only one file here so it can only be Font or Manifests.
+                        var rootTypeForInstaller = PackageParser.GetManifestRootTypeForInstallerPaths([packageFile]);
+
+                        // Set the root type if it is unknown.
+                        if (manifestRootType == PackageParser.ManifestRootType.Unknown)
+                        {
+                            manifestRootType = rootTypeForInstaller;
+                        }
+
+                        // Check for root type mismatches.
+                        if (manifestRootType != rootTypeForInstaller)
+                        {
+                            // Mismatched root and installer types is a WinGet-Pkgs policy, not an invalid manifest.
+                            Logger.WarnLocalized(nameof(Resources.MixedInstallerRootTypes_ErrorMessage));
+                        }
+
                         installerUpdateList.Add(new InstallerMetadata { InstallerUrl = installerUrl, PackageFile = packageFile });
                     }
                 }
@@ -282,7 +364,8 @@ public override async Task<bool> Execute()
                     this.OutputDir = Directory.GetCurrentDirectory();
                 }
 
-                SaveManifestDirToLocalPath(manifests, this.OutputDir);
+                var manifestRoot = manifestRootType == PackageParser.ManifestRootType.Fonts ? Constants.WingetFontRoot : Constants.WingetManifestRoot;
+                SaveManifestDirToLocalPath(manifests, manifestRoot, this.OutputDir);
 
                 if (isManifestValid && Prompt.Confirm(Resources.ConfirmGitHubSubmitManifest_Message))
                 {
@@ -494,13 +577,13 @@ private static void PromptForPortableFieldsIfApplicable(Installer installer)
 
         /// <summary>
         /// Merge nested installer files into a single installer if:
-        /// 1. Matching installers have NestedInstallerType: portable.
+        /// 1. Matching installers have NestedInstallerType: portable
         /// 2. Matching installers have the same architecture.
         /// 3. Matching installers have the same hash.
         /// </summary>
         private static void MergeNestedInstallerFilesIfApplicable(InstallerManifest installerManifest)
         {
-            var nestedPortableInstallers = installerManifest.Installers.Where(i => i.NestedInstallerType == NestedInstallerType.Portable).ToList();
+            var nestedPortableInstallers = installerManifest.Installers.Where(i => (i.NestedInstallerType == NestedInstallerType.Portable)).ToList();
             var mergeableInstallersList = nestedPortableInstallers.GroupBy(i => i.Architecture + i.InstallerSha256).ToList();
             foreach (var installers in mergeableInstallersList)
             {

src/WingetCreateCLI/Commands/NewLocaleCommand.cs

@@ -245,7 +245,10 @@ public override async Task<bool> Execute()
                     this.OutputDir = Directory.GetCurrentDirectory();
                 }
 
-                string manifestDirectoryPath = SaveManifestDirToLocalPath(originalManifests, this.OutputDir);
+                // TODO: Need to discern font root manifests. Assume default root for now.
+                // All of this locale code is generated assuming 'manifests' root, and updating it to support fonts
+                // would require significant restructuring. See issue https://github.com/microsoft/winget-create/issues/647
+                string manifestDirectoryPath = SaveManifestDirToLocalPath(originalManifests, Constants.WingetManifestRoot, this.OutputDir);
 
                 if (ValidateManifest(manifestDirectoryPath, this.Format))
                 {

src/WingetCreateCLI/Commands/SubmitCommand.cs

@@ -9,6 +9,7 @@ namespace Microsoft.WingetCreateCLI.Commands
     using System.Threading.Tasks;
     using CommandLine;
     using CommandLine.Text;
+    using Microsoft.VisualBasic;
     using Microsoft.WingetCreateCLI.Logging;
     using Microsoft.WingetCreateCLI.Properties;
     using Microsoft.WingetCreateCLI.Telemetry;
@@ -128,7 +129,9 @@ private async Task<bool> SubmitManifest()
                     return false;
                 }
 
-                return await this.GitHubSubmitManifests(manifests, this.PRTitle, this.Replace, this.ReplaceVersion);
+                // TODO: Add Font Root Support
+                // See issue: See issue https://github.com/microsoft/winget-create/issues/647
+                return await this.GitHubSubmitManifests(manifests, this.PRTitle, WingetCreateCore.Common.Constants.WingetManifestRoot, this.Replace, this.ReplaceVersion);
             }
             else if (Directory.Exists(expandedPath) && ValidateManifest(expandedPath, this.Format))
             {
@@ -140,7 +143,9 @@ private async Task<bool> SubmitManifest()
                     return false;
                 }
 
-                return await this.GitHubSubmitManifests(manifests, this.PRTitle, this.Replace, this.ReplaceVersion);
+                // TODO: Add Font Root Support
+                // See issue: See issue https://github.com/microsoft/winget-create/issues/647
+                return await this.GitHubSubmitManifests(manifests, this.PRTitle, WingetCreateCore.Common.Constants.WingetManifestRoot, this.Replace, this.ReplaceVersion);
             }
             else
             {

src/WingetCreateCLI/Commands/UpdateCommand.cs

@@ -287,7 +287,9 @@ await this.UpdateManifestsInteractively(initialManifests) :
                 this.OutputDir = Directory.GetCurrentDirectory();
             }
 
-            string manifestDirectoryPath = SaveManifestDirToLocalPath(updatedManifests, this.OutputDir);
+            // TODO: Font root support.
+            // See issue: See issue https://github.com/microsoft/winget-create/issues/647
+            string manifestDirectoryPath = SaveManifestDirToLocalPath(updatedManifests, Constants.WingetManifestRoot, this.OutputDir);
 
             if (ValidateManifest(manifestDirectoryPath, this.Format))
             {
@@ -314,9 +316,12 @@ await this.UpdateManifestsInteractively(initialManifests) :
                         }
                     }
 
+                    // TODO: Font root support.
+                    // See issue: See issue https://github.com/microsoft/winget-create/issues/647
                     return await this.LoadGitHubClient(true)
                         ? (commandEvent.IsSuccessful = await this.GitHubSubmitManifests(
                             updatedManifests,
+                            Constants.WingetManifestRoot,
                             this.GetPRTitle(updatedManifests, originalManifests),
                             this.Replace,
                             this.ReplaceVersion))

src/WingetCreateCLI/Commands/UpdateLocaleCommand.cs

@@ -176,7 +176,9 @@ public override async Task<bool> Execute()
                     this.OutputDir = Directory.GetCurrentDirectory();
                 }
 
-                string manifestDirectoryPath = SaveManifestDirToLocalPath(originalManifests, this.OutputDir);
+                // TODO: Font root support.
+                // See issue: See issue https://github.com/microsoft/winget-create/issues/647
+                string manifestDirectoryPath = SaveManifestDirToLocalPath(originalManifests, WingetCreateCore.Common.Constants.WingetManifestRoot, this.OutputDir);
 
                 if (ValidateManifest(manifestDirectoryPath, this.Format))
                 {

src/WingetCreateCLI/Properties/Resources.Designer.cs

@@ -1483,4 +1483,7 @@ Warning: Using this argument may result in the token being logged. Consider an a
   <data name="NoOpenPRInBrowser_HelpText" xml:space="preserve">
     <value>Boolean value that controls whether the pull request should not be open in the browser on submission. Default is false.</value>
   </data>
+  <data name="MixedInstallerRootTypes_ErrorMessage" xml:space="preserve">
+    <value>Found mixed font and non-font installer types in the manifest. This is not a supported configuration and the manifest should be edited to contain only font or non-font installers before submission.</value>
+  </data>
 </root>