dependabot-nuget 0.240.0 → 0.241.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/ProjectBuildFile.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core;
+
+internal sealed class ProjectBuildFile : XmlBuildFile
+{
+    public static ProjectBuildFile Open(string repoRootPath, string path)
+        => Parse(repoRootPath, path, File.ReadAllText(path));
+    public static ProjectBuildFile Parse(string repoRootPath, string path, string xml)
+        => new(repoRootPath, path, Parser.ParseText(xml));
+
+    public ProjectBuildFile(string repoRootPath, string path, XmlDocumentSyntax contents)
+        : base(repoRootPath, path, contents)
+    {
+    }
+
+    public IEnumerable<IXmlElementSyntax> PropertyNodes => Contents.RootSyntax
+        .GetElements("PropertyGroup", StringComparison.OrdinalIgnoreCase)
+        .SelectMany(e => e.Elements);
+
+    public IEnumerable<KeyValuePair<string, string>> GetProperties() => PropertyNodes
+        .Select(e => new KeyValuePair<string, string>(e.Name, e.GetContentValue()));
+
+    public IEnumerable<IXmlElementSyntax> ItemNodes => Contents.RootSyntax
+        .GetElements("ItemGroup", StringComparison.OrdinalIgnoreCase)
+        .SelectMany(e => e.Elements);
+
+    public IEnumerable<IXmlElementSyntax> PackageItemNodes => ItemNodes.Where(e =>
+            e.Name.Equals("PackageReference", StringComparison.OrdinalIgnoreCase) ||
+            e.Name.Equals("GlobalPackageReference", StringComparison.OrdinalIgnoreCase) ||
+            e.Name.Equals("PackageVersion", StringComparison.OrdinalIgnoreCase));
+
+    public IEnumerable<Dependency> GetDependencies() => PackageItemNodes
+        .Select(GetDependency)
+        .OfType<Dependency>();
+
+    private static Dependency? GetDependency(IXmlElementSyntax element)
+    {
+        var name = element.GetAttributeOrSubElementValue("Include", StringComparison.OrdinalIgnoreCase)
+            ?? element.GetAttributeOrSubElementValue("Update", StringComparison.OrdinalIgnoreCase);
+        if (name is null || name.StartsWith("@("))
+        {
+            return null;
+        }
+
+        var isVersionOverride = false;
+        var version = element.GetAttributeOrSubElementValue("Version", StringComparison.OrdinalIgnoreCase);
+        if (version is null)
+        {
+            version = element.GetAttributeOrSubElementValue("VersionOverride", StringComparison.OrdinalIgnoreCase);
+            isVersionOverride = version is not null;
+        }
+
+        return new Dependency(
+            Name: name,
+            Version: version?.Length == 0 ? null : version,
+            Type: GetDependencyType(element.Name),
+            IsOverride: isVersionOverride);
+    }
+
+    private static DependencyType GetDependencyType(string name)
+    {
+        return name.ToLower() switch
+        {
+            "packagereference" => DependencyType.PackageReference,
+            "globalpackagereference" => DependencyType.GlobalPackageReference,
+            "packageversion" => DependencyType.PackageVersion,
+            _ => throw new InvalidOperationException($"Unknown dependency type: {name}")
+        };
+    }
+
+    public IEnumerable<string> GetReferencedProjectPaths() => ItemNodes
+        .Where(e =>
+            e.Name.Equals("ProjectReference", StringComparison.OrdinalIgnoreCase) ||
+            e.Name.Equals("ProjectFile", StringComparison.OrdinalIgnoreCase))
+        .Select(e => PathHelper.GetFullPathFromRelative(System.IO.Path.GetDirectoryName(Path)!, e.GetAttribute("Include").Value));
+
+    public void NormalizeDirectorySeparatorsInProject()
+    {
+        var hintPathNodes = Contents.Descendants()
+            .Where(e =>
+                e.Name.Equals("HintPath", StringComparison.OrdinalIgnoreCase) &&
+                e.Parent.Name.Equals("Reference", StringComparison.OrdinalIgnoreCase))
+            .Select(e => (XmlElementSyntax)e.AsNode);
+        var updatedXml = Contents.ReplaceNodes(hintPathNodes,
+            (_, n) => n.WithContent(n.GetContentValue().Replace("/", "\\")).AsNode);
+        Update(updatedXml);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/XmlBuildFile.cs

@@ -0,0 +1,14 @@
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core;
+
+internal abstract class XmlBuildFile : BuildFile<XmlDocumentSyntax>
+{
+    public XmlBuildFile(string repoRootPath, string path, XmlDocumentSyntax contents)
+        : base(repoRootPath, path, contents)
+    {
+    }
+
+    protected override string GetContentsString(XmlDocumentSyntax contents)
+        => contents.ToFullString();
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/CompatabilityChecker.cs

@@ -0,0 +1,39 @@
+using System.Linq;
+
+using NuGet.Frameworks;
+
+namespace NuGetUpdater.Core.FrameworkChecker;
+
+public class CompatibilityChecker
+{
+    public static bool IsCompatible(string[] projectTfms, string[] packageTfms, Logger logger)
+    {
+        var projectFrameworks = projectTfms.Select(ParseFramework);
+        var packageFrameworks = packageTfms.Select(ParseFramework);
+
+        var compatibilityService = new FrameworkCompatibilityService();
+        var compatibleFrameworks = compatibilityService.GetCompatibleFrameworks(packageFrameworks);
+
+        var incompatibleFrameworks = projectFrameworks.Where(f => !compatibleFrameworks.Contains(f)).ToArray();
+        if (incompatibleFrameworks.Length > 0)
+        {
+            logger.Log($"The package is not compatible. Incompatible project frameworks: {string.Join(", ", incompatibleFrameworks.Select(f => f.GetShortFolderName()))}");
+            return false;
+        }
+
+        logger.Log("The package is compatible.");
+        return true;
+
+        static NuGetFramework ParseFramework(string tfm)
+        {
+            var framework = NuGetFramework.Parse(tfm);
+            if (framework.HasPlatform && framework.PlatformVersion != FrameworkConstants.EmptyVersion)
+            {
+                // Platform versions are not well supported by the FrameworkCompatibilityService. Make a best
+                // effort by including just the platform.
+                framework = new NuGetFramework(framework.Framework, framework.Version, framework.Platform, FrameworkConstants.EmptyVersion);
+            }
+            return framework;
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/FrameworkCompatibilityService.cs

@@ -0,0 +1,73 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+
+using NuGet.Frameworks;
+using NuGetGallery.Frameworks;
+
+namespace NuGetUpdater.Core.FrameworkChecker;
+
+public class FrameworkCompatibilityService
+{
+    private static readonly IFrameworkCompatibilityProvider CompatibilityProvider = DefaultCompatibilityProvider.Instance;
+    private static readonly IReadOnlyList<NuGetFramework> AllSupportedFrameworks = SupportedFrameworks.AllSupportedNuGetFrameworks;
+    private static readonly IReadOnlyDictionary<NuGetFramework, ISet<NuGetFramework>> CompatibilityMatrix = GetCompatibilityMatrix();
+
+    public ISet<NuGetFramework> GetCompatibleFrameworks(IEnumerable<NuGetFramework> packageFrameworks)
+    {
+        if (packageFrameworks == null)
+        {
+            throw new ArgumentNullException(nameof(packageFrameworks));
+        }
+
+        var allCompatibleFrameworks = new HashSet<NuGetFramework>();
+
+        foreach (var packageFramework in packageFrameworks)
+        {
+            if (packageFrameworks == null || packageFramework.IsUnsupported || packageFramework.IsPCL)
+            {
+                continue;
+            }
+
+            if (CompatibilityMatrix.TryGetValue(packageFramework, out var compatibleFrameworks))
+            {
+                allCompatibleFrameworks.UnionWith(compatibleFrameworks);
+            }
+            else
+            {
+                allCompatibleFrameworks.Add(packageFramework);
+            }
+        }
+
+        return allCompatibleFrameworks;
+    }
+
+    private static IReadOnlyDictionary<NuGetFramework, ISet<NuGetFramework>> GetCompatibilityMatrix()
+    {
+        var matrix = new Dictionary<NuGetFramework, ISet<NuGetFramework>>();
+
+        foreach (var packageFramework in AllSupportedFrameworks)
+        {
+            var compatibleFrameworks = new HashSet<NuGetFramework>();
+            matrix.Add(packageFramework, compatibleFrameworks);
+
+            foreach (var projectFramework in AllSupportedFrameworks)
+            {
+                // This compatibility check is to know if the packageFramework can be installed on a certain projectFramework
+                if (CompatibilityProvider.IsCompatible(projectFramework, packageFramework))
+                {
+                    compatibleFrameworks.Add(projectFramework);
+                }
+            }
+        }
+
+        matrix.Add(SupportedFrameworks.Net60Windows7,
+            new HashSet<NuGetFramework>() {
+                    SupportedFrameworks.Net60Windows, SupportedFrameworks.Net60Windows7,
+                    SupportedFrameworks.Net70Windows, SupportedFrameworks.Net70Windows7 });
+
+        return matrix;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/SupportedFrameworks.cs

@@ -0,0 +1,146 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using NuGet.Frameworks;
+using static NuGet.Frameworks.FrameworkConstants;
+using static NuGet.Frameworks.FrameworkConstants.CommonFrameworks;
+
+namespace NuGetGallery.Frameworks
+{
+    /// <summary>
+    /// This class contains documented supported frameworks.
+    /// </summary>
+    /// <remarks>
+    /// All these frameworks were retrieved from the following sources:
+    /// dotnet documentation: https://docs.microsoft.com/en-us/dotnet/standard/frameworks.
+    /// nuget documentation: https://docs.microsoft.com/en-us/nuget/reference/target-frameworks.
+    /// nuget client FrameworkConstants.CommonFrameworks: https://github.com/NuGet/NuGet.Client/blob/dev/src/NuGet.Core/NuGet.Frameworks/FrameworkConstants.cs.
+    /// Deprecated frameworks are not included on the list https://docs.microsoft.com/en-us/dotnet/standard/frameworks#deprecated-target-frameworks.
+    /// </remarks>
+    public static class SupportedFrameworks
+    {
+        public static readonly Version Version8 = new Version(8, 0, 0, 0); // https://github.com/NuGet/Engineering/issues/5112
+
+        public static readonly NuGetFramework MonoAndroid = new NuGetFramework(FrameworkIdentifiers.MonoAndroid, EmptyVersion);
+        public static readonly NuGetFramework MonoTouch = new NuGetFramework(FrameworkIdentifiers.MonoTouch, EmptyVersion);
+        public static readonly NuGetFramework MonoMac = new NuGetFramework(FrameworkIdentifiers.MonoMac, EmptyVersion);
+        public static readonly NuGetFramework Net3 = new NuGetFramework(FrameworkIdentifiers.Net, new Version(3, 0, 0, 0));
+        public static readonly NuGetFramework Net48 = new NuGetFramework(FrameworkIdentifiers.Net, new Version(4, 8, 0, 0));
+        public static readonly NuGetFramework Net481 = new NuGetFramework(FrameworkIdentifiers.Net, new Version(4, 8, 1, 0));
+        public static readonly NuGetFramework Net50Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version5, "windows", EmptyVersion);
+        public static readonly NuGetFramework Net60Android = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "android", EmptyVersion);
+        public static readonly NuGetFramework Net60Ios = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "ios", EmptyVersion);
+        public static readonly NuGetFramework Net60MacOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "macos", EmptyVersion);
+        public static readonly NuGetFramework Net60MacCatalyst = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "maccatalyst", EmptyVersion);
+        public static readonly NuGetFramework Net60TvOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "tvos", EmptyVersion);
+        public static readonly NuGetFramework Net60Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "windows", EmptyVersion);
+        public static readonly NuGetFramework Net70Android = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "android", EmptyVersion);
+        public static readonly NuGetFramework Net70Ios = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "ios", EmptyVersion);
+        public static readonly NuGetFramework Net70MacOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "macos", EmptyVersion);
+        public static readonly NuGetFramework Net70MacCatalyst = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "maccatalyst", EmptyVersion);
+        public static readonly NuGetFramework Net70TvOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "tvos", EmptyVersion);
+        public static readonly NuGetFramework Net70Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "windows", EmptyVersion);
+        public static readonly NuGetFramework Net80 = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8); // https://github.com/NuGet/Engineering/issues/5112
+        public static readonly NuGetFramework Net80Android = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "android", EmptyVersion);
+        public static readonly NuGetFramework Net80Ios = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "ios", EmptyVersion);
+        public static readonly NuGetFramework Net80MacOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "macos", EmptyVersion);
+        public static readonly NuGetFramework Net80MacCatalyst = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "maccatalyst", EmptyVersion);
+        public static readonly NuGetFramework Net80TvOs = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "tvos", EmptyVersion);
+        public static readonly NuGetFramework Net80Windows = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version8, "windows", EmptyVersion);
+        public static readonly NuGetFramework NetCore = new NuGetFramework(FrameworkIdentifiers.NetCore, EmptyVersion);
+        public static readonly NuGetFramework NetMf = new NuGetFramework(FrameworkIdentifiers.NetMicro, EmptyVersion);
+        public static readonly NuGetFramework UAP = new NuGetFramework(FrameworkIdentifiers.UAP, EmptyVersion);
+        public static readonly NuGetFramework WP = new NuGetFramework(FrameworkIdentifiers.WindowsPhone, EmptyVersion);
+        public static readonly NuGetFramework XamarinIOs = new NuGetFramework(FrameworkIdentifiers.XamarinIOs, EmptyVersion);
+        public static readonly NuGetFramework XamarinMac = new NuGetFramework(FrameworkIdentifiers.XamarinMac, EmptyVersion);
+        public static readonly NuGetFramework XamarinTvOs = new NuGetFramework(FrameworkIdentifiers.XamarinTVOS, EmptyVersion);
+        public static readonly NuGetFramework XamarinWatchOs = new NuGetFramework(FrameworkIdentifiers.XamarinWatchOS, EmptyVersion);
+
+        public static readonly NuGetFramework Net60Windows7 = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version6, "windows", Version7);
+        public static readonly NuGetFramework Net70Windows7 = new NuGetFramework(FrameworkIdentifiers.NetCoreApp, Version7, "windows", Version7);
+
+        public static readonly IReadOnlyList<NuGetFramework> AllSupportedNuGetFrameworks;
+
+        static SupportedFrameworks()
+        {
+            AllSupportedNuGetFrameworks = new List<NuGetFramework>
+            {
+                MonoAndroid, MonoMac, MonoTouch,
+                Native,
+                Net11, Net2, Net35, Net4, Net403, Net45, Net451, Net452, Net46, Net461, Net462, Net463, Net47, Net471, Net472, Net48, Net481,
+                Net50, Net50Windows,
+                Net60, Net60Android, Net60Ios, Net60MacCatalyst, Net60MacOs, Net60TvOs, Net60Windows,
+                Net70, Net70Android, Net70Ios, Net70MacCatalyst, Net70MacOs, Net70TvOs, Net70Windows,
+                Net80, Net80Android, Net80Ios, Net80MacCatalyst, Net80MacOs, Net80TvOs, Net80Windows,
+                NetCore, NetCore45, NetCore451,
+                NetCoreApp10, NetCoreApp11, NetCoreApp20, NetCoreApp21, NetCoreApp22, NetCoreApp30, NetCoreApp31,
+                NetMf,
+                NetStandard, NetStandard10, NetStandard11, NetStandard12, NetStandard13, NetStandard14, NetStandard15, NetStandard16, NetStandard20, NetStandard21,
+                SL4, SL5,
+                Tizen3, Tizen4, Tizen6,
+                UAP, UAP10,
+                WP, WP7, WP75, WP8, WP81, WPA81,
+                XamarinIOs, XamarinMac, XamarinTvOs, XamarinWatchOs
+            };
+        }
+
+        /// <summary>
+        /// Lists of TFMs that users can filter packages by (for each Framework Generation) on NuGet.org search
+        /// </summary>
+        public static class TfmFilters
+        {
+            public static readonly List<NuGetFramework> NetTfms = new List<NuGetFramework>
+            {
+                Net80,
+                Net70,
+                Net60,
+                Net50
+            };
+
+            public static readonly List<NuGetFramework> NetCoreAppTfms = new List<NuGetFramework>
+            {
+                NetCoreApp31,
+                NetCoreApp30,
+                NetCoreApp22,
+                NetCoreApp21,
+                NetCoreApp20,
+                NetCoreApp11,
+                NetCoreApp10
+            };
+
+            public static readonly List<NuGetFramework> NetStandardTfms = new List<NuGetFramework>
+            {
+                NetStandard21,
+                NetStandard20,
+                NetStandard16,
+                NetStandard15,
+                NetStandard14,
+                NetStandard13,
+                NetStandard12,
+                NetStandard11,
+                NetStandard10
+            };
+
+            public static readonly List<NuGetFramework> NetFrameworkTfms = new List<NuGetFramework>
+            {
+                Net481,
+                Net48,
+                Net472,
+                Net471,
+                Net47,
+                Net462,
+                Net461,
+                Net46,
+                Net452,
+                Net451,
+                Net45,
+                Net4,
+                Net35,
+                Net3,
+                Net2
+            };
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/NuGetUpdater.Core.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>$(CommonTargetFramework)</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <Nullable>enable</Nullable>
+    <GeneratePathProperty>true</GeneratePathProperty>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NuGetProjects\NuGet.CommandLine\NuGet.CommandLine.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GuiLabs.Language.Xml" Version="1.2.60" />
+    <PackageReference Include="DiffPlex" Version="1.7.1" />
+    <PackageReference Include="Microsoft.Build.Locator" Version="1.6.1" />
+    <PackageReference Include="Microsoft.Build" Version="17.5.0" ExcludeAssets="Runtime" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.Build.Utilities.Core" Version="17.5.0" ExcludeAssets="Runtime" PrivateAssets="All" />
+    <PackageReference Include="NuGet.Core" Version="2.14.0-rtm-832" Aliases="CoreV2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="NuGetUpdater.Core.Test"/>
+  </ItemGroup>
+
+</Project>