Add support for overriding repository url, version and uploading multiple packages simultaneously using a glob pattern (wildcards)

src/GprTool/GlobExtensions.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Linq;
+using System.Text;
+using DotNet.Globbing;
+using DotNet.Globbing.Token;
+
+namespace GprTool
+{
+    public static class GlobExtensions
+    {
+        public static bool IsGlobPattern(this Glob glob)
+        {
+            return glob.Tokens.Any(x => !(x is PathSeparatorToken || x is LiteralToken));
+        }
+
+        public static string BuildBasePathFromGlob(this Glob glob, string fallbackPath = null)
+        {
+            if (glob == null) throw new ArgumentNullException(nameof(glob));
+
+            var tokensLength = glob.Tokens.Length;
+
+            var path = new StringBuilder();
+
+            for (var index = 0; index < tokensLength; index++)
+            {
+                var token = glob.Tokens[index];
+                var tokenNext = index + 1 < tokensLength ? glob.Tokens[index + 1] : null;
+                var tokenPrevious = index - 1 >= 0 ? glob.Tokens[index - 1] : null;
+                var tokenPreviousPrevious = index - 2 >= 0 ? glob.Tokens[index - 2] : null;
+
+                switch (token)
+                {
+                    case PathSeparatorToken pathSeparatorToken when(tokenNext is LiteralToken):
+                        path.Append(pathSeparatorToken.Value);
+                        break;
+                    case LiteralToken literalToken:
+
+                        if (tokenPrevious is WildcardToken
+                            || tokenPreviousPrevious is WildcardDirectoryToken)
+                        {
+                            goto done;
+                        }
+
+                        path.Append(literalToken.Value);
+
+                        if (tokenNext is WildcardToken 
+                            || tokenNext is WildcardDirectoryToken)
+                        {
+                            goto done;
+                        }
+
+                        break;
+                }
+            }
+
+            done:
+
+            var pathStr = path.ToString();
+            if (fallbackPath != null && string.IsNullOrWhiteSpace(pathStr))
+            {
+                return fallbackPath;
+            }
+
+            return pathStr;
+        }
+    }
+}

src/GprTool/GprTool.csproj

@@ -22,9 +22,11 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="DotNet.Glob" Version="3.0.9" />
     <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.4.1" />
     <PackageReference Include="Octokit.GraphQL" Version="0.1.4-packages-preview2" />
     <PackageReference Include="RestSharp" Version="106.10.1" />
+    <PackageReference Include="NuGet.Packaging" Version="5.6.0"/>
   </ItemGroup>
 
 </Project>

src/GprTool/IoExtensions.cs

@@ -0,0 +1,21 @@
+using System.IO;
+
+namespace GprTool
+{
+    public static class IoExtensions
+    {
+        public static FileStream OpenReadShared(this string filename)
+        {
+            return File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
+        }
+
+        public static MemoryStream ReadSharedToStream(this string filename)
+        {
+            using var fileStream = filename.OpenReadShared();
+            var outputStream = new MemoryStream();
+            fileStream.CopyTo(outputStream);
+            outputStream.Seek(0, SeekOrigin.Begin);
+            return outputStream;
+        }
+    }
+}

src/GprTool/NuGetUtilities.cs

@@ -1,11 +1,191 @@
 using System;
 using System.IO;
+using System.IO.Compression;
+using System.Linq;
 using System.Xml;
+using System.Xml.Linq;
+using NuGet.Packaging;
+using NuGet.Versioning;
 
 namespace GprTool
 {
+    public class PackageFile
+    {
+        public string Filename { get; set; }
+        public string Owner { get; set; }
+        public string RepositoryName { get; set; }
+        public string RepositoryUrl { get; set; }
+        public bool IsGithubRepository { get; set; }
+        public bool IsNuspecRewritten { get; set; }
+
+        public string FilenameWithoutGprPrefixAndPath
+        {
+            get
+            {
+                var gprIndex = !IsNuspecRewritten ? -1 : Filename.LastIndexOf("_gpr", StringComparison.OrdinalIgnoreCase);
+                if (gprIndex == -1)
+                {
+                    return Filename;
+                }
+
+                // Support case sensitive filename extensions (e.g. test_gpr.NuPkg -> test.NuPkg)
+
+                var filenameUntilGpr = Filename.Substring(0, gprIndex);
+                var filenameExcludingGpr = Filename.Substring(gprIndex + 4);
+
+                return Path.GetFileName(filenameUntilGpr + filenameExcludingGpr);
+            }
+        }
+    }
+
     public class NuGetUtilities
     {
+        public static bool BuildOwnerAndRepositoryFromUrl(PackageFile packageFile, string repositoryUrl)
+        {
+            if (repositoryUrl == null 
+                || !Uri.TryCreate(repositoryUrl, UriKind.Absolute, out var repositoryUri))
+            {
+                return false;
+            }
+
+            var ownerAndRepositoryName = repositoryUri.PathAndQuery
+                .Substring(1)
+                .Replace("\\", "/")
+                .Split("/", StringSplitOptions.RemoveEmptyEntries)
+                .Take(2)
+                .ToList();
+
+            if (ownerAndRepositoryName.Count != 2)
+            {
+                return false;
+            }
+
+            packageFile.Owner = ownerAndRepositoryName[0];
+            packageFile.RepositoryName = ownerAndRepositoryName[1];
+            packageFile.RepositoryUrl = repositoryUri.ToString();
+            packageFile.IsGithubRepository = string.Equals("github.com", repositoryUri.Host, StringComparison.OrdinalIgnoreCase);
+
+            return true;
+        }
+
+        public static bool TryReadPackageFileMetadata(PackageFile packageFile)
+        {
+            if (!File.Exists(packageFile.Filename))
+            {
+                return false;
+            }
+
+            Manifest manifest;
+
+            try
+            {
+                manifest = ReadNupkgManifest(packageFile.Filename);
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+
+            return BuildOwnerAndRepositoryFromUrl(packageFile, manifest.Metadata.Repository?.Url);
+        }
+
+        public static PackageFile BuildPackageFile(string filename, string repositoryUrl)
+        {
+            var packageFile = new PackageFile
+            {
+                Filename = filename
+            };
+
+            BuildOwnerAndRepositoryFromUrl(packageFile, repositoryUrl);
+
+            return packageFile;
+        }
+
+        public static Manifest ReadNupkgManifest(string nupkgPath)
+        {
+            if (nupkgPath == null) throw new ArgumentNullException(nameof(nupkgPath));
+            using var packageArchiveReader = new PackageArchiveReader(nupkgPath.ReadSharedToStream());
+            return Manifest.ReadFrom(packageArchiveReader.GetNuspec(), false);
+        }
+
+        public static bool ShouldRewriteNupkg(string nupkgPath, string repositoryUrl, NuGetVersion nuGetVersion = null)
+        {
+            if (nupkgPath == null) throw new ArgumentNullException(nameof(nupkgPath));
+
+            var manifest = ReadNupkgManifest(nupkgPath);
+
+            if (nuGetVersion != null && !nuGetVersion.Equals(manifest.Metadata.Version))
+            {
+                return true;
+            }
+
+            return !string.Equals(repositoryUrl, manifest.Metadata.Repository?.Url, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public static string RewriteNupkg(string nupkgPath, string repositoryUrl, NuGetVersion nuGetVersion = null)
+        {
+            if (nupkgPath == null) throw new ArgumentNullException(nameof(nupkgPath));
+            if (repositoryUrl == null) throw new ArgumentNullException(nameof(repositoryUrl));
+
+            var randomDirectoryId = Guid.NewGuid().ToString("N");
+            var nupkgFilename = Path.GetFileName(nupkgPath);
+            var nupkgFilenameWithoutExt = Path.GetFileNameWithoutExtension(nupkgFilename);
+            var nupkgWorkingDirectoryAbsolutePath = Path.GetDirectoryName(nupkgPath);
+            var workingDirectory = Path.Combine(nupkgWorkingDirectoryAbsolutePath, $"{nupkgFilenameWithoutExt}_{randomDirectoryId}");
+
+            using var tmpDirectory = new DisposableDirectory(workingDirectory);
+            using var packageArchiveReader = new PackageArchiveReader(nupkgPath.ReadSharedToStream(), false);
+            using var nuspecMemoryStream = new MemoryStream();
+
+            var nuspecXDocument = packageArchiveReader.NuspecReader.Xml;
+            var packageXElement = nuspecXDocument.Single("package");
+            var metadataXElement = packageXElement.Single("metadata");
+            var packageId = packageXElement.Single("id").Value;
+            var versionXElement = metadataXElement.Single("version");
+
+            if (nuGetVersion != null)
+            {
+                versionXElement.SetValue(nuGetVersion); 
+            }
+            else
+            {
+                nuGetVersion = NuGetVersion.Parse(versionXElement.Value);
+            }
+
+            var repositoryXElement = metadataXElement.SingleOrDefault("repository");
+            if (repositoryXElement == null)
+            {
+                repositoryXElement = new XElement("repository");
+                repositoryXElement.SetAttributeValue("url", repositoryUrl);
+                repositoryXElement.SetAttributeValue("type", "git");
+                metadataXElement.Add(repositoryXElement);
+            }
+            else
+            {
+                repositoryXElement.SetAttributeValue("url", repositoryUrl);
+                repositoryXElement.SetAttributeValue("type", "git");
+            }
+
+            nuspecXDocument.Save(nuspecMemoryStream);
+            nuspecMemoryStream.Seek(0, SeekOrigin.Begin);
+
+            ZipFile.ExtractToDirectory(nupkgPath, tmpDirectory.WorkingDirectory, true);
+
+            var nuspecDstFilename = Path.Combine(tmpDirectory.WorkingDirectory, $"{packageId}.nuspec");
+            File.WriteAllBytes(nuspecDstFilename, nuspecMemoryStream.ToArray());
+
+            using var outputStream = new MemoryStream();
+
+            var packageBuilder = new PackageBuilder(nuspecMemoryStream, tmpDirectory.WorkingDirectory, propertyProvider => throw new NotImplementedException());
+            packageBuilder.Save(outputStream);
+
+            var nupkgDstFilenameAbsolutePath = Path.Combine(nupkgWorkingDirectoryAbsolutePath, $"{packageId}.{nuGetVersion}_gpr.nupkg");
+
+            File.WriteAllBytes(nupkgDstFilenameAbsolutePath, outputStream.ToArray());
+
+            return nupkgDstFilenameAbsolutePath;
+        }
+
         public static string FindTokenInNuGetConfig(Action<string> warning = null)
         {
             var configFile = GetDefaultConfigFile(warning);
@@ -97,5 +277,22 @@ public static string GetDefaultConfigFile(Action<string> warning = null)
 
             return Path.Combine(baseDir, "NuGet", "NuGet.Config");
         }
+
+    }
+
+    public class DisposableDirectory : IDisposable
+    {
+        public string WorkingDirectory { get; }
+
+        public DisposableDirectory(string workingDirectory)
+        {
+            WorkingDirectory = workingDirectory;
+            Directory.CreateDirectory(workingDirectory);
+        }
+
+        public void Dispose()
+        {
+            Directory.Delete(WorkingDirectory, true);
+        }
     }
 }