dependabot-nuget 0.322.0 → 0.322.1

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/AzurePackageDetailFinder.cs

@@ -0,0 +1,30 @@
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+internal class AzurePackageDetailFinder : IPackageDetailFinder
+{
+    public string GetCompareUrlPath(string? oldTag, string? newTag)
+    {
+        // azure devops doesn't support direct tag listing so both parameters are likely to be null, but just in case, this is the correct url format
+        if (oldTag is not null && newTag is not null)
+        {
+            return $"branchCompare?baseVersion=GT{oldTag}&targetVersion=GT{newTag}";
+        }
+
+        if (newTag is not null)
+        {
+            return $"commits?itemVersion=GT{newTag}";
+        }
+
+        return "commits";
+    }
+
+    public Task<Dictionary<NuGetVersion, (string TagName, string? Details)>> GetReleaseDataForVersionsAsync(string repoName, NuGetVersion oldVersion, NuGetVersion newVersion)
+    {
+        // azure devops doesn't support direct tag listing
+        return Task.FromResult(new Dictionary<NuGetVersion, (string TagName, string? Details)>());
+    }
+
+    public string GetReleasesUrlPath() => "tags";
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/DetailedPullRequestBodyGenerator.cs

@@ -0,0 +1,237 @@
+using System.Collections.Immutable;
+using System.Text;
+using System.Text.RegularExpressions;
+
+using NuGet.Versioning;
+
+using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Updater;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+internal class DetailedPullRequestBodyGenerator : IPullRequestBodyGenerator, IDisposable
+{
+    private readonly IHttpFetcher _httpFetcher;
+
+    public const string TruncatedMessage = "...\n\n_Description has been truncated_";
+
+    public DetailedPullRequestBodyGenerator(IHttpFetcher httpFetcher)
+    {
+        _httpFetcher = httpFetcher;
+    }
+
+    public void Dispose()
+    {
+        _httpFetcher.Dispose();
+    }
+
+    public async Task<string> GeneratePullRequestBodyTextAsync(Job job, ImmutableArray<UpdateOperationBase> updateOperationsPerformed, ImmutableArray<ReportedDependency> updatedDependencies)
+    {
+        var sb = new StringBuilder();
+        var dedupedUpdateOperations = updateOperationsPerformed
+            .DistinctBy(u => $"{u.DependencyName}/{u.OldVersion}/{u.NewVersion}", StringComparer.OrdinalIgnoreCase)
+            .OrderBy(u => u.DependencyName, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(u => u.OldVersion, NullableNuGetVersionComparer.Instance)
+            .ThenBy(u => u.NewVersion)
+            .ToImmutableArray();
+        foreach (var updateOperation in dedupedUpdateOperations)
+        {
+            if (sb.Length > 0)
+            {
+                // ensure a blank line between entries
+                sb.AppendLine();
+            }
+
+            var reportText = $"{updateOperation.GetReport(includeFileNames: false)}.";
+            var updatedDependency = updatedDependencies
+                .Where(d => d.Name.Equals(updateOperation.DependencyName, StringComparison.OrdinalIgnoreCase))
+                .Where(d => NuGetVersion.TryParse(d.Version, out var version) && version == updateOperation.NewVersion)
+                .FirstOrDefault();
+            var sourceUrl = (updatedDependency?.Requirements ?? [])
+                .Select(r => r.Source?.SourceUrl)
+                .FirstOrDefault(u => u is not null);
+            if (sourceUrl is null)
+            {
+                // no source url, just append the report text
+                sb.AppendLine(reportText);
+            }
+            else
+            {
+                // build detailed report
+                var packageNameIndex = reportText.IndexOf(updateOperation.DependencyName, StringComparison.OrdinalIgnoreCase);
+                if (packageNameIndex >= 0)
+                {
+                    // link the package name
+                    sb.AppendLine($"{reportText[..packageNameIndex]}[{updateOperation.DependencyName}]({sourceUrl}){reportText[(packageNameIndex + updateOperation.DependencyName.Length)..]}");
+                }
+                else
+                {
+                    sb.AppendLine(reportText);
+                }
+
+                // more details
+                if (Uri.TryCreate(sourceUrl, UriKind.Absolute, out var uri))
+                {
+                    IPackageDetailFinder? packageDetailFinder = uri.Host.ToLowerInvariant() switch
+                    {
+                        "dev.azure.com" => new AzurePackageDetailFinder(),
+                        "github.com" => new GitHubPackageDetailFinder(_httpFetcher),
+                        "gitlab.com" => new GitLabPackageDetailFinder(_httpFetcher),
+                        var host when host.EndsWith(".visualstudio.com") => new AzurePackageDetailFinder(),
+                        _ => null,
+                    };
+
+                    if (packageDetailFinder is not null &&
+                        updateOperation.OldVersion is not null)
+                    {
+                        var repoName = uri.LocalPath.TrimStart('/');
+                        var versionsAndDetails = await packageDetailFinder.GetReleaseDataForVersionsAsync(repoName, updateOperation.OldVersion, updateOperation.NewVersion);
+                        var ordered = versionsAndDetails
+                            .Where(kv => kv.Key != updateOperation.OldVersion)
+                            .OrderByDescending(kv => kv.Key)
+                            .ToList();
+
+                        sb.AppendLine();
+                        var detailsLineTemplate = IsHtmlSupported(job.Source.Provider)
+                            ? "<details>\n<summary>{0}</summary>"
+                            : "# {0}";
+                        sb.AppendLine(string.Format(detailsLineTemplate, "Release notes"));
+
+                        var releasesUrlPath = packageDetailFinder.GetReleasesUrlPath();
+                        if (releasesUrlPath is not null)
+                        {
+                            sb.AppendLine();
+                            sb.AppendLine($"_Sourced from [{updateOperation.DependencyName}'s releases]({sourceUrl}/{releasesUrlPath})._");
+                        }
+
+                        foreach (var (version, (tagName, body)) in ordered)
+                        {
+                            sb.AppendLine();
+                            sb.AppendLine($"## {version}");
+                            if (body is not null)
+                            {
+                                var truncatedBody = TruncateLineCount(body);
+                                sb.AppendLine();
+                                sb.AppendLine(truncatedBody);
+                            }
+                        }
+
+                        if (ordered.Count == 0)
+                        {
+                            sb.AppendLine();
+                            sb.AppendLine("No release notes found for this version range.");
+                        }
+
+                        string? oldTag = null;
+                        if (versionsAndDetails.TryGetValue(updateOperation.OldVersion, out var oldVersionDetails))
+                        {
+                            oldTag = oldVersionDetails.TagName;
+                        }
+
+                        string? newTag = null;
+                        if (versionsAndDetails.TryGetValue(updateOperation.NewVersion, out var newVersionDetails))
+                        {
+                            newTag = newVersionDetails.TagName;
+                        }
+
+                        var compareUrlPath = packageDetailFinder.GetCompareUrlPath(oldTag, newTag);
+                        sb.AppendLine();
+                        sb.AppendLine($"Commits viewable in [compare view]({sourceUrl}/{compareUrlPath}).");
+                        if (IsHtmlSupported(job.Source.Provider))
+                        {
+                            sb.AppendLine("</details>");
+                        }
+                    }
+                }
+            }
+        }
+
+        var prBody = sb.ToString().Replace("\r", "").TrimEnd();
+        var scrubbedBody = ScrubLinksAndMentions(prBody);
+        var truncatedPrBody = TruncateCharacterCount(scrubbedBody, GetMaxPrLength(job.Source.Provider));
+        return truncatedPrBody;
+    }
+
+    private static bool IsHtmlSupported(string sourceProvider)
+    {
+        return sourceProvider switch
+        {
+            "azure" or
+            "bitbucket" or
+            "codecommit" => false,
+            _ => true,
+        };
+    }
+
+    private static string TruncateLineCount(string text, int maxLines = 50)
+    {
+        var lines = text.Replace("\r", "").Split('\n');
+        if (lines.Length <= maxLines)
+        {
+            return text;
+        }
+
+        var truncatedText = string.Join("\n", lines.Take(maxLines)) + "\n ... (truncated)";
+        return truncatedText;
+    }
+
+    internal static int? GetMaxPrLength(string sourceProvider)
+    {
+        // values from, e.g., https://github.com/dependabot/dependabot-core/blob/5109e3e63925469ca0d6e7fa9449470d22c1847b/common/lib/dependabot/pull_request_creator/github.rb#L20
+        return sourceProvider switch
+        {
+            "azure" => 3999,
+            "bitbucket" => 262143,
+            "codecommit" => 10239,
+            "github" => 65535,
+            _ => null, // default case, no specific limit
+        };
+    }
+
+    private static string TruncateCharacterCount(string text, int? maxLength)
+    {
+        if (maxLength is null || text.Length <= maxLength)
+        {
+            return text;
+        }
+
+        var adjustedMaxLength = maxLength.Value - TruncatedMessage.Length;
+        var truncatedText = text[..adjustedMaxLength] + TruncatedMessage;
+        return truncatedText;
+    }
+
+    private static string ScrubLinksAndMentions(string text)
+    {
+        var mentionPattern = new Regex(@"(?<AtSymbol>@)(?<Name>[a-z0-9]+(-[a-z0-9]+)*)", RegexOptions.IgnoreCase);
+        var scrubbedOfMentions = mentionPattern.Replace(text, match => $"@\u200B{match.Groups["Name"].Value}");
+
+        var issuePattern = new Regex(@"(?<NumberSign>#)(?<Number>\d+)", RegexOptions.IgnoreCase);
+        var scrubbedOfIssues = issuePattern.Replace(scrubbedOfMentions, match => $"#\u200B{match.Groups["Number"].Value}");
+        return scrubbedOfIssues;
+    }
+
+    private class NullableNuGetVersionComparer : IComparer<NuGetVersion?>
+    {
+        public static readonly NullableNuGetVersionComparer Instance = new();
+
+        public int Compare(NuGetVersion? x, NuGetVersion? y)
+        {
+            if (x is null && y is null)
+            {
+                return 0;
+            }
+
+            if (x is null)
+            {
+                return -1;
+            }
+
+            if (y is null)
+            {
+                return 1;
+            }
+
+            return x.CompareTo(y);
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/GitHubPackageDetailFinder.cs

@@ -0,0 +1,101 @@
+using System.Text.Json;
+
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+internal class GitHubPackageDetailFinder : IPackageDetailFinder
+{
+    private readonly IHttpFetcher _httpFetcher;
+
+    public GitHubPackageDetailFinder(IHttpFetcher httpFetcher)
+    {
+        _httpFetcher = httpFetcher;
+    }
+
+    public string GetCompareUrlPath(string? oldTag, string? newTag)
+    {
+        if (oldTag is not null && newTag is not null)
+        {
+            return $"compare/{oldTag}...{newTag}";
+        }
+
+        if (newTag is not null)
+        {
+            return $"commits/{newTag}";
+        }
+
+        return "commits";
+    }
+
+    public async Task<Dictionary<NuGetVersion, (string TagName, string? Details)>> GetReleaseDataForVersionsAsync(string repoName, NuGetVersion oldVersion, NuGetVersion newVersion)
+    {
+        var result = new Dictionary<NuGetVersion, (string TagName, string? Details)>();
+        var url = $"https://api.github.com/repos/{repoName}/releases?per_page=100";
+        var jsonOption = await _httpFetcher.GetJsonElementAsync(url);
+        if (jsonOption is null)
+        {
+            return result;
+        }
+
+        var json = jsonOption.Value;
+        if (json.ValueKind != JsonValueKind.Array)
+        {
+            return result;
+        }
+
+        if (json.GetArrayLength() == 0)
+        {
+            return result;
+        }
+
+        foreach (var releaseObject in json.EnumerateArray())
+        {
+            if (releaseObject.ValueKind != JsonValueKind.Object)
+            {
+                continue;
+            }
+
+            // get release name
+            if (!releaseObject.TryGetProperty("name", out var releasenameElement) ||
+                releasenameElement.ValueKind != JsonValueKind.String)
+            {
+                continue;
+            }
+
+            var releaseName = releasenameElement.GetString()!;
+
+            // get tag name
+            if (!releaseObject.TryGetProperty("tag_name", out var tagNameElement) ||
+                tagNameElement.ValueKind != JsonValueKind.String)
+            {
+                continue;
+            }
+
+            var tagName = tagNameElement.GetString()!;
+
+            // find matching version
+            var correspondingVersion = IPackageDetailFinder.GetVersionFromNames(releaseName, tagName);
+            if (correspondingVersion is null)
+            {
+                continue;
+            }
+
+            if (correspondingVersion >= oldVersion && correspondingVersion <= newVersion)
+            {
+                if (!releaseObject.TryGetProperty("body", out var bodyElement) ||
+                bodyElement.ValueKind != JsonValueKind.String)
+                {
+                    continue;
+                }
+
+                var body = bodyElement.GetString()!;
+                result[correspondingVersion] = (tagName, body);
+            }
+        }
+
+        return result;
+    }
+
+    public string GetReleasesUrlPath() => "releases";
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/GitLabPackageDetailFinder.cs

@@ -0,0 +1,107 @@
+using System.Text.Json;
+
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+internal class GitLabPackageDetailFinder : IPackageDetailFinder
+{
+    private readonly IHttpFetcher _httpFetcher;
+
+    public GitLabPackageDetailFinder(IHttpFetcher httpFetcher)
+    {
+        _httpFetcher = httpFetcher;
+    }
+
+    public string GetCompareUrlPath(string? oldTag, string? newTag)
+    {
+        if (oldTag is not null && newTag is not null)
+        {
+            return $"-/compare/{oldTag}...{newTag}";
+        }
+
+        if (newTag is not null)
+        {
+            return $"-/commits/{newTag}";
+        }
+
+        return "-/commits";
+    }
+
+    public async Task<Dictionary<NuGetVersion, (string TagName, string? Details)>> GetReleaseDataForVersionsAsync(string repoName, NuGetVersion oldVersion, NuGetVersion newVersion)
+    {
+        var result = new Dictionary<NuGetVersion, (string TagName, string? Details)>();
+        var url = $"https://gitlab.com/api/v4/projects/{Uri.EscapeDataString(repoName)}/repository/tags";
+        var jsonOption = await _httpFetcher.GetJsonElementAsync(url);
+        if (jsonOption is null)
+        {
+            return result;
+        }
+
+        var json = jsonOption.Value;
+        if (json.ValueKind != JsonValueKind.Array)
+        {
+            return result;
+        }
+
+        if (json.GetArrayLength() == 0)
+        {
+            return result;
+        }
+
+        foreach (var responseObject in json.EnumerateArray())
+        {
+            if (responseObject.ValueKind != JsonValueKind.Object)
+            {
+                continue;
+            }
+
+            // get release name
+            if (!responseObject.TryGetProperty("name", out var releaseNameElement) ||
+                releaseNameElement.ValueKind != JsonValueKind.String)
+            {
+                continue;
+            }
+
+            var releaseName = releaseNameElement.GetString()!;
+
+            // get release info
+            string? tagName = null;
+            string? description = null;
+            if (responseObject.TryGetProperty("release", out var releaseObject) &&
+                releaseObject.ValueKind == JsonValueKind.Object)
+            {
+                if (releaseObject.TryGetProperty("tag_name", out var tagNameElement) &&
+                    tagNameElement.ValueKind == JsonValueKind.String)
+                {
+                    tagName = tagNameElement.GetString()!;
+                }
+
+                if (releaseObject.TryGetProperty("description", out var descriptionElement) &&
+                    descriptionElement.ValueKind == JsonValueKind.String)
+                {
+                    description = descriptionElement.GetString();
+                }
+            }
+
+            // find matching version
+            var correspondingVersion = IPackageDetailFinder.GetVersionFromNames(releaseName, tagName);
+            if (correspondingVersion is null)
+            {
+                continue;
+            }
+
+            var resultTag = tagName ?? releaseName;
+            if (resultTag is not null &&
+                correspondingVersion >= oldVersion &&
+                correspondingVersion <= newVersion)
+            {
+                result[correspondingVersion] = (resultTag, description);
+            }
+        }
+
+        return result;
+    }
+
+    public string GetReleasesUrlPath() => "-/releases";
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/HttpFetcher.cs

@@ -0,0 +1,32 @@
+using System.Net.Http.Headers;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+internal class HttpFetcher : IHttpFetcher
+{
+    private readonly HttpClient _httpClient;
+
+    public HttpFetcher()
+    {
+        _httpClient = new HttpClient();
+    }
+
+    public void Dispose()
+    {
+        _httpClient.Dispose();
+    }
+
+    public async Task<string?> GetStringAsync(string url)
+    {
+        var request = new HttpRequestMessage(HttpMethod.Get, url);
+        request.Headers.UserAgent.Add(new ProductInfoHeaderValue("dependabot-core", null));
+        var response = await _httpClient.SendAsync(request);
+        if (!response.IsSuccessStatusCode)
+        {
+            return null;
+        }
+
+        var result = await response.Content.ReadAsStringAsync();
+        return result;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/IHttpFetcher.cs

@@ -0,0 +1,30 @@
+using System.Text.Json;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+internal interface IHttpFetcher : IDisposable
+{
+    Task<string?> GetStringAsync(string url);
+}
+
+internal static class IHttpFetcherExtensions
+{
+    public static async Task<JsonElement?> GetJsonElementAsync(this IHttpFetcher fetcher, string url)
+    {
+        var jsonString = await fetcher.GetStringAsync(url);
+        if (jsonString is null)
+        {
+            return null;
+        }
+
+        try
+        {
+            var json = JsonSerializer.Deserialize<JsonElement>(jsonString);
+            return json;
+        }
+        catch (JsonException)
+        {
+            return null;
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/IPackageDetailFinder.cs

@@ -0,0 +1,47 @@
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+internal interface IPackageDetailFinder
+{
+    string GetReleasesUrlPath();
+    string GetCompareUrlPath(string? oldTag, string? newTag);
+    Task<Dictionary<NuGetVersion, (string TagName, string? Details)>> GetReleaseDataForVersionsAsync(string repoName, NuGetVersion oldVersion, NuGetVersion newVersion);
+
+    internal static NuGetVersion? GetVersionFromNames(string? releaseName, string? tagName)
+    {
+        var prefixesToTrim = new[]
+        {
+            "version-",
+            "version.",
+            "version ",
+            "version",
+            "v-",
+            "v.",
+            "v ",
+            "v",
+        };
+        foreach (var candidateName in new[] { releaseName, tagName }.Where(n => n is not null).Cast<string>())
+        {
+            foreach (var prefix in prefixesToTrim)
+            {
+                if (candidateName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    var trimmedCandidateName = candidateName[prefix.Length..];
+                    if (NuGetVersion.TryParse(trimmedCandidateName, out var versionFromTrimmed))
+                    {
+                        return versionFromTrimmed;
+                    }
+                }
+            }
+
+            // no prefix match, try the whole string
+            if (NuGetVersion.TryParse(candidateName, out var versionFromWhole))
+            {
+                return versionFromWhole;
+            }
+        }
+
+        return null;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/IPullRequestBodyGenerator.cs

@@ -0,0 +1,11 @@
+using System.Collections.Immutable;
+
+using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Updater;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+public interface IPullRequestBodyGenerator
+{
+    public Task<string> GeneratePullRequestBodyTextAsync(Job job, ImmutableArray<UpdateOperationBase> updateOperationsPerformed, ImmutableArray<ReportedDependency> updatedDependencies);
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/SimplePullRequestBodyGenerator.cs

@@ -0,0 +1,15 @@
+using System.Collections.Immutable;
+
+using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Updater;
+
+namespace NuGetUpdater.Core.Run.PullRequestBodyGenerator;
+
+internal class SimplePullRequestBodyGenerator : IPullRequestBodyGenerator
+{
+    public Task<string> GeneratePullRequestBodyTextAsync(Job job, ImmutableArray<UpdateOperationBase> updateOperationsPerformed, ImmutableArray<ReportedDependency> updatedDependencies)
+    {
+        var prBody = UpdateOperationBase.GenerateUpdateOperationReport(updateOperationsPerformed, includeFileNames: false);
+        return Task.FromResult(prBody);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestTextGenerator.cs

@@ -3,6 +3,7 @@ using System.Text;
 using System.Text.RegularExpressions;
 
 using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Run.PullRequestBodyGenerator;
 using NuGetUpdater.Core.Updater;
 
 using DependencySet = (string Name, (NuGet.Versioning.NuGetVersion? OldVersion, NuGet.Versioning.NuGetVersion NewVersion)[] Versions);
@@ -124,9 +125,12 @@ public class PullRequestTextGenerator
         return dependencySets;
     }
 
-    public static string GetPullRequestBody(Job job, ImmutableArray<UpdateOperationBase> updateOperationsPerformed, string? dependencyGroupName)
+    public static async Task<string> GetPullRequestBodyAsync(Job job, ImmutableArray<UpdateOperationBase> updateOperationsPerformed, ImmutableArray<ReportedDependency> updatedDependencies, ExperimentsManager experimentsManager)
     {
-        var report = UpdateOperationBase.GenerateUpdateOperationReport(updateOperationsPerformed, includeFileNames: false);
-        return report;
+        var bodyGenerator = experimentsManager.GenerateSimplePrBody
+            ? (IPullRequestBodyGenerator)new SimplePullRequestBodyGenerator()
+            : new DetailedPullRequestBodyGenerator(new HttpFetcher());
+        var prBody = await bodyGenerator.GeneratePullRequestBodyTextAsync(job, updateOperationsPerformed, updatedDependencies);
+        return prBody;
     }
 }