private static bool IsPackageSemVer2(NuspecReader package) { if (package.GetVersion().IsSemVer2()) { return(true); } if (package.GetDependencyGroups() != null) { foreach (var dependencySet in package.GetDependencyGroups()) { foreach (var dependency in dependencySet.Packages) { var range = dependency.VersionRange; if (range == null) { continue; } if (range.MinVersion != null && range.MinVersion.IsSemVer2()) { return(true); } if (range.MaxVersion != null && range.MaxVersion.IsSemVer2()) { return(true); } } } } return(false); }
public static V2FeedPackageInfo ToV2FeedPackageInfo( this NuspecReader reader, PackageDerivedData packageDerivedData, string downloadUrl, long downloadCount) { return(new V2FeedPackageInfo( identity: new PackageIdentity(reader.GetId(), reader.GetVersion()), title: reader.GetTitle(), summary: reader.GetSummary(), description: reader.GetDescription(), authors: reader.GetAuthors().Split(','), owners: reader.GetOwners().Split(','), iconUrl: reader.GetIconUrl(), licenseUrl: reader.GetLicenseUrl(), projectUrl: reader.GetProjectUrl(), reportAbuseUrl: reader.GetProjectUrl(), tags: reader.GetTags(), created: packageDerivedData.Created, lastEdited: packageDerivedData.LastUpdated, published: packageDerivedData.LastUpdated, dependencies: DependencySetsAsString(reader.GetDependencyGroups()), requireLicenseAccept: reader.GetRequireLicenseAcceptance(), downloadUrl: downloadUrl, downloadCount: downloadCount.ToString(), packageHash: packageDerivedData.PackageHash, packageHashAlgorithm: packageDerivedData.PackageHashAlgorithm, minClientVersion: reader.GetMinClientVersion() )); }
private static void AddDependencies(IEnumerable <LibraryDependency> dependencies, LockFileTargetLibrary lockFileLib, NuGetFramework framework, NuspecReader nuspec) { if (dependencies == null) { // AssetFallbackFramework does not apply to dependencies. // Convert it to a fallback framework if needed. var currentFramework = (framework as AssetTargetFallbackFramework)?.AsFallbackFramework() ?? framework; var dependencySet = nuspec .GetDependencyGroups() .GetNearest(currentFramework); if (dependencySet != null) { var set = dependencySet.Packages; if (set != null) { lockFileLib.Dependencies = set.AsList(); } } } else { // Filter the dependency set down to packages and projects. // Framework references will not be displayed lockFileLib.Dependencies = dependencies .Where(ld => ld.LibraryRange.TypeConstraintAllowsAnyOf(LibraryDependencyTarget.PackageProjectExternal)) .Select(ld => new PackageDependency(ld.Name, ld.LibraryRange.VersionRange)) .ToList(); } }
public static Package GetPackage(string nupkgPath) { var result = new Package(); using (var packageFile = File.Open(nupkgPath, FileMode.Open, FileAccess.Read)) { using (var packageReader = new PackageArchiveReader(packageFile)) { var manifestReader = new NuspecReader(packageReader.GetNuspec()); result.Authors = manifestReader.GetAuthors(); result.DependencySets = manifestReader.GetDependencyGroups(); result.Description = manifestReader.GetDescription(); result.Id = manifestReader.GetIdentity().Id; result.LicenseUrl = manifestReader.GetLicenseUrl(); result.ProjectUrl = manifestReader.GetProjectUrl(); result.Summary = manifestReader.GetSummary(); result.Version = manifestReader.GetIdentity().Version; result.RequireLicenseAcceptance = manifestReader.GetRequireLicenseAcceptance(); result.Files = packageReader.GetFiles() .Where(x => x != "[Content_Types].xml" && x != "_rels/.rels" && !x.EndsWith(".nuspec") && !x.EndsWith(".psmdcp")) .Select(x => x.Replace("/", "\\")) .OrderBy(x => x).ToList(); } } return(result); }
public static Package CreatePackageObject(string packagePath) { List <PackageAsset> packageAssets = new List <PackageAsset>(); Dictionary <NuGetFramework, List <PackageDependency> > packageDependencies = new Dictionary <NuGetFramework, List <PackageDependency> >(); PackageArchiveReader nupkgReader = new PackageArchiveReader(packagePath); NuspecReader nuspecReader = nupkgReader.NuspecReader; string packageId = nuspecReader.GetId(); string version = nuspecReader.GetVersion().ToString(); IEnumerable <PackageDependencyGroup> dependencyGroups = nuspecReader.GetDependencyGroups(); foreach (var item in dependencyGroups) { packageDependencies.Add(item.TargetFramework, item.Packages.ToList()); } var files = nupkgReader.GetFiles().ToList().Where(t => t.EndsWith(".dll")).Where(t => t.Contains(packageId + ".dll")); foreach (var file in files) { packageAssets.Add(ExtractAssetFromFile(file)); } return(new Package(packageId, version, packageAssets, packageDependencies)); }
public async Task <IEnumerable <LibraryDependency> > GetDependencies(RemoteMatch match, NuGetFramework targetFramework) { using (var stream = await _source.OpenNuspecStreamAsync(new PackageInfo { Id = match.Library.Name, Version = match.Library.Version, ContentUri = match.Path })) { var nuspecReader = new NuspecReader(stream); var reducer = new FrameworkReducer(); var groups = nuspecReader.GetDependencyGroups() .ToDictionary(g => new NuGetFramework(g.TargetFramework), g => g.Packages); var nearest = reducer.GetNearest(targetFramework, groups.Keys); if (nearest != null) { return(groups[nearest].Select(p => new LibraryDependency { LibraryRange = new LibraryRange { Name = p.Id, VersionRange = new NuGetVersionRange(p.VersionRange) } }) .ToList()); } } return(Enumerable.Empty <LibraryDependency>()); }
private static void ReadPackage() { // This code region is referenced by the NuGet docs. Please update the docs if you rename the region // or move it to a different file. #region ReadPackage using FileStream inputStream = new FileStream("MyPackage.nupkg", FileMode.Open); using PackageArchiveReader reader = new PackageArchiveReader(inputStream); NuspecReader nuspec = reader.NuspecReader; Console.WriteLine($"ID: {nuspec.GetId()}"); Console.WriteLine($"Version: {nuspec.GetVersion()}"); Console.WriteLine($"Description: {nuspec.GetDescription()}"); Console.WriteLine($"Authors: {nuspec.GetAuthors()}"); Console.WriteLine("Dependencies:"); foreach (var dependencyGroup in nuspec.GetDependencyGroups()) { Console.WriteLine($" - {dependencyGroup.TargetFramework.GetShortFolderName()}"); foreach (var dependency in dependencyGroup.Packages) { Console.WriteLine($" > {dependency.Id} {dependency.VersionRange}"); } } Console.WriteLine("Files:"); foreach (var file in reader.GetFiles()) { Console.WriteLine($" - {file}"); } #endregion }
public static NuGetDependencyInfo GetDependencyInfo(FileInfo nupkgPath) { if (!nupkgPath.Exists) { throw new FileNotFoundException(nupkgPath.FullName); } using (var stream = nupkgPath.OpenRead()) { ZipFileSystem zip = new ZipFileSystem(stream); using (PackageReader packageReader = new PackageReader(zip)) { using (var nuspecStream = packageReader.GetNuspec()) { NuspecReader reader = new NuspecReader(nuspecStream); NuGetPackageId package = CreateIdentity(reader, nupkgPath.FullName); List <NuGetDependencyGroup> dependencyGroups = new List <NuGetDependencyGroup>(); foreach (var depGroup in reader.GetDependencyGroups()) { FrameworkName framework = Utilities.GetFrameworkName(depGroup.TargetFramework); NuGetDependency[] dependencies = depGroup.Packages.Select(d => new NuGetDependency(d.Id, VersionRange.Parse(d.VersionRange))).ToArray(); dependencyGroups.Add(new NuGetDependencyGroup(framework, dependencies)); } return(new NuGetDependencyInfo(package, dependencyGroups)); } } } }
private List <BaGetPackageDependency> GetDependencies(NuspecReader nuspec) { var dependencies = new List <BaGetPackageDependency>(); foreach (var group in nuspec.GetDependencyGroups()) { var targetFramework = group.TargetFramework.GetShortFolderName(); if (!group.Packages.Any()) { dependencies.Add(new BaGetPackageDependency { Id = null, VersionRange = null, TargetFramework = targetFramework, }); } foreach (var dependency in group.Packages) { dependencies.Add(new BaGetPackageDependency { Id = dependency.Id, VersionRange = dependency.VersionRange?.ToString(), TargetFramework = targetFramework, }); } } return(dependencies); }
private IEnumerable <LibraryDependency> GetDependencies(NuspecReader nuspecReader, NuGetFramework targetFramework) { var dependencies = NuGetFrameworkUtility.GetNearest(nuspecReader.GetDependencyGroups(), targetFramework, item => item.TargetFramework); return(GetDependencies(targetFramework, dependencies)); }
public static PackageMetadata FromNuspecReader(NuspecReader nuspecReader) { return(new PackageMetadata( nuspecReader.GetMetadata().ToDictionary(kvp => kvp.Key, kvp => kvp.Value), nuspecReader.GetDependencyGroups(), nuspecReader.GetFrameworkReferenceGroups() )); }
public void NuspecReaderTests_DependencyGroups() { NuspecReader reader = GetReader(BasicNuspec); var dependencies = reader.GetDependencyGroups().ToList(); Assert.Equal(2, dependencies.Count); }
public void NuspecReaderTests_EmptyGroups() { NuspecReader reader = GetReader(EmptyGroups); var dependencies = reader.GetDependencyGroups().ToList(); var references = reader.GetReferenceGroups().ToList(); Assert.Equal(2, dependencies.Count); Assert.Equal(2, references.Count); }
/// <summary> /// Gets package metadata from a the provided <see cref="NuspecReader"/> instance. /// </summary> /// <param name="nuspecReader">The <see cref="NuspecReader"/> instance used to read the <see cref="PackageMetadata"/></param> /// <param name="strict"> /// Whether or not to be strict when reading the <see cref="NuspecReader"/>. This should be <code>true</code> /// on initial ingestion but false when a package that has already been accepted is being processed.</param> /// <exception cref="PackagingException"> /// We default to use a strict version-check on dependency groups. /// When an invalid dependency version range is detected, a <see cref="PackagingException"/> will be thrown. /// </exception> public static PackageMetadata FromNuspecReader(NuspecReader nuspecReader, bool strict) { return(new PackageMetadata( nuspecReader.GetMetadata().ToDictionary(kvp => kvp.Key, kvp => kvp.Value), nuspecReader.GetDependencyGroups(useStrictVersionCheck: strict), nuspecReader.GetFrameworkReferenceGroups(), nuspecReader.GetPackageTypes(), nuspecReader.GetMinClientVersion() )); }
/// <summary> /// Gets package metadata from a the provided <see cref="NuspecReader"/> instance. /// </summary> /// <param name="nuspecReader">The <see cref="NuspecReader"/> instance used to read the <see cref="PackageMetadata"/></param> /// <param name="strict"> /// Whether or not to be strict when reading the <see cref="NuspecReader"/>. This should be <code>true</code> /// on initial ingestion but false when a package that has already been accepted is being processed.</param> /// <exception cref="PackagingException"> /// We default to use a strict version-check on dependency groups. /// When an invalid dependency version range is detected, a <see cref="PackagingException"/> will be thrown. /// </exception> public static PackageMetadata FromNuspecReader(NuspecReader nuspecReader, bool strict) { var strictNuspecReader = new StrictNuspecReader(nuspecReader.Xml); var metadataLookup = strictNuspecReader.GetMetadataLookup(); if (strict) { var duplicates = metadataLookup .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); if (duplicates.Any()) { throw new PackagingException(string.Format( CoreStrings.Manifest_DuplicateMetadataElements, string.Join("', '", duplicates))); } } // Reject invalid metadata element names. Today this only rejects element names that collide with // properties generated downstream. var metadataKeys = new HashSet <string>(metadataLookup.Select(g => g.Key)); metadataKeys.IntersectWith(RestrictedMetadataElements); if (metadataKeys.Any()) { throw new PackagingException(string.Format( CoreStrings.Manifest_InvalidMetadataElements, string.Join("', '", metadataKeys.OrderBy(x => x)))); } // Reject non-boolean values for boolean metadata. foreach (var booleanName in BooleanMetadataElements) { foreach (var unparsedBoolean in metadataLookup[booleanName]) { if (!bool.TryParse(unparsedBoolean, out var parsedBoolean)) { throw new PackagingException(string.Format( CoreStrings.Manifest_InvalidBooleanMetadata, booleanName)); } } } return(new PackageMetadata( nuspecReader.GetMetadata().ToDictionary(kvp => kvp.Key, kvp => kvp.Value), nuspecReader.GetDependencyGroups(useStrictVersionCheck: strict), nuspecReader.GetFrameworkReferenceGroups(), nuspecReader.GetPackageTypes(), nuspecReader.GetMinClientVersion(), nuspecReader.GetRepositoryMetadata(), nuspecReader.GetLicenseMetadata())); }
/// <summary> /// Read dependency info from a nuspec. /// </summary> /// <remarks>This also verifies minClientVersion.</remarks> protected static FindPackageByIdDependencyInfo GetDependencyInfo(NuspecReader reader) { // Since this is the first place a package is read after selecting it as the best version // check the minClientVersion here to verify we are okay to read this package. MinClientVersionUtility.VerifyMinClientVersion(reader); // Create dependency info return(new FindPackageByIdDependencyInfo( reader.GetDependencyGroups(), reader.GetFrameworkReferenceGroups())); }
public async Task RunAsync(string packageFilepath, string outputPath) { var packageFilename = new FileInfo(packageFilepath).Name; if (_packagesChecked.Contains(packageFilename)) { return; } _packagesChecked.Add(packageFilename); using var zipFile = ZipFile.OpenRead(packageFilepath); var nuspec = zipFile.Entries .SingleOrDefault(e => e.FullName.EndsWith(".nuspec")); if (nuspec == null) { Console.WriteLine($"ERROR: Package {zipFile.ToString()} does not contain a nuspec file."); return; } Directory.CreateDirectory(outputPath); await using var stream = nuspec.Open(); var reader = new NuspecReader(stream); var groups = reader.GetDependencyGroups().ToList(); foreach (var group in groups) { foreach (var package in group.Packages) { var version = package.VersionRange.ToShortString(); var url = $"https://www.nuget.org/api/v2/package/{package.Id}/{version}"; var filename = $"{package.Id}.{version}.nupkg"; var outputFilepath = Path.Combine(outputPath, filename); try { if (!File.Exists(outputFilepath)) { Console.WriteLine($"{packageFilename} GET {url}"); await new WebClient().DownloadFileTaskAsync(url, outputFilepath); } } catch (WebException wex) { Console.WriteLine($"ERROR: {wex.Message}"); return; } await RunAsync(outputFilepath, outputPath); } } }
public void NuspecReaderTests_UnsupportedDependencyGroups() { NuspecReader reader = GetReader(UnknownDependencyGroupsNuspec); // verify we can handle multiple unsupported dependency groups gracefully var dependencies = reader.GetDependencyGroups().ToList(); // unsupported frameworks remain ungrouped Assert.Equal(5, dependencies.Count); Assert.Equal(4, dependencies.Where(g => g.TargetFramework == NuGetFramework.UnsupportedFramework).Count()); }
public void NuspecReaderTests_DependencyWithSingleIncludeExclude() { // Arrange NuspecReader reader = GetReader(IncludeExcludeNuspec); // Act var group = reader.GetDependencyGroups().Single(); var dependency = group.Packages.Single(package => package.Id == "packageA"); // Assert Assert.Equal("all", string.Join("|", dependency.Include.OrderBy(s => s))); Assert.Equal("none", string.Join("|", dependency.Exclude.OrderBy(s => s))); }
public void NuspecReaderTests_DependencyWithBlankExclude() { // Arrange NuspecReader reader = GetReader(IncludeExcludeNuspec); // Act var group = reader.GetDependencyGroups().Single(); var dependency = group.Packages.Single(package => package.Id == "packageD"); // Assert bad flags stay as is Assert.Equal(0, dependency.Include.Count); Assert.Equal("a|b", string.Join("|", dependency.Exclude.OrderBy(s => s))); }
public void NuspecReaderTests_DependencyEmptyAttributesForIncludeExclude() { // Arrange NuspecReader reader = GetReader(IncludeExcludeNuspec); // Act var group = reader.GetDependencyGroups().Single(); var dependency = group.Packages.Single(package => package.Id == "emptyValues"); // Assert Assert.Equal(0, dependency.Include.Count); Assert.Equal(0, dependency.Exclude.Count); }
public void NuspecReaderTests_DependencyWithMultipleExclude() { // Arrange NuspecReader reader = GetReader(IncludeExcludeNuspec); // Act var group = reader.GetDependencyGroups().Single(); var dependency = group.Packages.Single(package => package.Id == "packageC"); // Assert Assert.Equal(0, dependency.Include.Count); Assert.Equal("compile|runtime", string.Join("|", dependency.Exclude.OrderBy(s => s))); }
public static Package CreatePackageObject(string packagePath) { PackageArchiveReader nupkgReader = new(packagePath); NuspecReader nuspecReader = nupkgReader.NuspecReader; string packageId = nuspecReader.GetId(); string version = nuspecReader.GetVersion().ToString(); NuGetFramework[] dependencyFrameworks = nuspecReader.GetDependencyGroups() .Select(dg => dg.TargetFramework) .Where(tfm => tfm != null) .ToArray(); IEnumerable <string> files = nupkgReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll")); return(new Package(packageId, version, files, dependencyFrameworks)); }
private static Package CreatePackage(PackageArchiveReader packageReader, RuntimeGraph runtimeGraph) { NuspecReader nuspecReader = packageReader.NuspecReader; string packageId = nuspecReader.GetId(); string version = nuspecReader.GetVersion().ToString(); IEnumerable <PackageDependencyGroup> dependencyGroups = nuspecReader.GetDependencyGroups(); Dictionary <NuGetFramework, IEnumerable <PackageDependency> > packageDependencies = new Dictionary <NuGetFramework, IEnumerable <PackageDependency> >(); foreach (PackageDependencyGroup item in dependencyGroups) { packageDependencies.Add(item.TargetFramework, item.Packages); } return(new Package(packageId, version, packageReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll")), packageDependencies, runtimeGraph)); }
internal static IEnumerable <(string PackageName, VersionRange PackageVersion)> GetNuspecDependencies(string nuspecFilePath) { if (!NuGet.Packaging.PackageHelper.IsNuspec(nuspecFilePath)) { throw new Exception(); } using var fileStream = File.OpenRead(nuspecFilePath); var reader = new NuspecReader(fileStream); // var currentFramework = new NuGetFramework(FrameworkConstants.FrameworkIdentifiers.NetCore, FrameworkConstants.FrameworkIdentifiers. // var targetFramework = NuGetFramework.Parse(_targetFramework); // var dependencyGroup = NuGetFrameworkUtility.GetNearest(reader.GetDependencyGroups(), targetFramework); // var dependencyGroup = GetNearest(reader.GetDependencyGroups()); var dependencyGroup = reader.GetDependencyGroups().Single(); return(dependencyGroup.Packages.Select(package => (package.Id, package.VersionRange))); }
public ServerPackage(NuspecReader package, PackageDerivedData packageDerivedData) { Id = package.GetId(); Version = package.GetVersion(); Title = package.GetTitle(); Authors = package.GetAuthors(); Owners = package.GetOwners(); IconUrl = package.GetIconUrl(); LicenseUrl = package.GetLicenseUrl(); ProjectUrl = package.GetProjectUrl(); RequireLicenseAcceptance = package.GetRequireLicenseAcceptance(); DevelopmentDependency = package.GetDevelopmentDependency(); Description = package.GetDescription(); Summary = package.GetSummary(); ReleaseNotes = package.GetReleaseNotes(); Language = package.GetLanguage(); Tags = package.GetTags(); Copyright = package.GetCopyright(); MinClientVersion = package.GetMinClientVersion(); ReportAbuseUrl = null; DownloadCount = 0; SemVer1IsAbsoluteLatest = false; SemVer1IsLatest = false; SemVer2IsAbsoluteLatest = false; SemVer2IsLatest = false; //FIXME is this OK? Listed = true; IsSemVer2 = IsPackageSemVer2(package); _dependencySets = package.GetDependencyGroups().ToList(); Dependencies = _dependencySets.DependencySetsAsString(); _supportedFrameworks = package.GetFrameworkReferenceGroups().Select(f => f.TargetFramework).ToList(); SupportedFrameworks = string.Join("|", _supportedFrameworks.Select(f => f.GetFrameworkString())); PackageSize = packageDerivedData.PackageSize; PackageHash = packageDerivedData.PackageHash; PackageHashAlgorithm = packageDerivedData.PackageHashAlgorithm; LastUpdated = packageDerivedData.LastUpdated; Created = packageDerivedData.Created; Path = packageDerivedData.Path; FullPath = packageDerivedData.FullPath; }
private static PackageDependencyGroup GetDependencyGroup(PackageIdentity package, NuGetFramework targetFramework) { var nuspecFile = Path.Combine(_globalPackagesPath, package.Id, package.Version.ToNormalizedString(), $"{package.Id}.nuspec"); if (!NuGet.Packaging.PackageHelper.IsNuspec(nuspecFile)) { throw new PackageException($"Could not locate the .nuspec file for package: {package}"); } var reader = new NuspecReader(nuspecFile); var dependencyGroups = reader.GetDependencyGroups(); if (dependencyGroups.FirstOrDefault() != null) { var compatibleGroups = dependencyGroups.Where(dependencyGroup => NuGetFrameworkUtility.IsCompatibleWithFallbackCheck(targetFramework, dependencyGroup.TargetFramework)); // TODO: how to select best match framework? return(compatibleGroups.First()); } return(null); }
public static NuGetDependencyInfo GetDependencyInfo(string folderPath) { NuspecReader reader = GetNuspec(folderPath); NuGetPackageId package = CreateIdentity(reader, folderPath); List <NuGetDependencyGroup> dependencyGroups = new List <NuGetDependencyGroup>(); foreach (var depGroup in reader.GetDependencyGroups()) { FrameworkName framework = Utilities.GetFrameworkName(depGroup.TargetFramework); NuGetDependency[] dependencies = depGroup.Packages.Select(d => new NuGetDependency(d.Id, VersionRange.Parse(d.VersionRange))).ToArray(); dependencyGroups.Add(new NuGetDependencyGroup(framework, dependencies)); } return(new NuGetDependencyInfo(package, dependencyGroups)); }
// Based off https://github.com/NuGet/NuGetGallery/blob/master/src/NuGetGallery.Core/SemVerLevelKey.cs private static SemVerLevel GetSemVerLevel(NuspecReader nuspec) { if (nuspec.GetVersion().IsSemVer2) { return(SemVerLevel.SemVer2); } foreach (var dependencyGroup in nuspec.GetDependencyGroups()) { foreach (var dependency in dependencyGroup.Packages) { if ((dependency.VersionRange.MinVersion != null && dependency.VersionRange.MinVersion.IsSemVer2) || (dependency.VersionRange.MaxVersion != null && dependency.VersionRange.MaxVersion.IsSemVer2)) { return(SemVerLevel.SemVer2); } } } return(SemVerLevel.Unknown); }
private void ProcessDependencies(NuspecReader nuspec, out IEnumerable <ParsedDependencyInfo> dependencies, out SemVerLevel semVerLevel) { semVerLevel = SemVerLevel.SemVer_2_0_0; var deps = new List <ParsedDependencyInfo>(); dependencies = deps; foreach (var depgroup in nuspec.GetDependencyGroups()) { foreach (var dep in depgroup.Packages) { deps.Add(new ParsedDependencyInfo { Framework = depgroup.TargetFramework, PackageId = dep.Id, MinVersion = dep.VersionRange.MinVersion, MaxVersion = dep.VersionRange.MaxVersion, IsMinInclusive = dep.VersionRange.IsMinInclusive, IsMaxInclusive = dep.VersionRange.IsMaxInclusive }); } } }