/// <summary> /// Adds refresh files to the specified project for all assemblies references belonging to the packages /// specified by packageNames. /// </summary> /// <param name="project">The project.</param> /// <param name="repositoryPath">The file system pointing to 'packages' folder under the solution.</param> /// <param name="packageNames">The package names.</param> private void AddRefreshFilesForReferences(EnvDTE.Project project, string repositoryPath, IEnumerable <PackageIdentity> packageNames) { if (project == null) { throw new ArgumentNullException("project"); } if (repositoryPath == null) { throw new ArgumentNullException("repositoryPath"); } if (!packageNames.Any()) { return; } VSAPIProjectContext context = new VSAPIProjectContext(skipAssemblyReferences: true, bindingRedirectsDisabled: true); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); context.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, new LoggerAdapter(context), signedPackageVerifier, SignedPackageVerifierSettings.GetDefault()); WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context); foreach (var packageName in packageNames) { string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version); DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath)); PackageFolderReader reader = new PackageFolderReader(packageFolder); var frameworkGroups = reader.GetReferenceItems(); var groups = reader.GetReferenceItems(); var fwComparer = new NuGetFrameworkFullComparer(); FrameworkReducer reducer = new FrameworkReducer(); NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework)); if (targetGroupFramework != null) { var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault(); foreach (string refItem in refGroup.Items) { string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar)); // create one refresh file for each assembly reference, as per required by Website projects // projectSystem.CreateRefreshFile(assemblyPath); RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath); } } } }
public IEnumerable <string> GetCompatibleAssemblyPaths() { List <string> assemblyPaths = new List <string>(); FrameworkReducer reducer = new FrameworkReducer(); NuGetFramework targetFramework = new NuGetFramework(".NETFramework", Version.Parse("4.5")); // If alternate versions of Wyam are developed (I.e., for DNX), this will need to be switched NuGetFrameworkFullComparer frameworkComparer = new NuGetFrameworkFullComparer(); IPackageRepository packageRepository = PackageRepositoryFactory.Default.CreateRepository(Path); PackageManager packageManager = new PackageManager(packageRepository, Path); foreach (IPackage package in packageManager.LocalRepository.GetPackages()) { List <KeyValuePair <IPackageFile, NuGetFramework> > filesAndFrameworks = package.GetLibFiles() .Select(x => new KeyValuePair <IPackageFile, NuGetFramework>(x, new NuGetFramework(x.TargetFramework.Identifier, x.TargetFramework.Version, x.TargetFramework.Profile))) .ToList(); NuGetFramework targetPackageFramework = reducer.GetNearest(targetFramework, filesAndFrameworks.Select(x => x.Value)); if (targetPackageFramework != null) { assemblyPaths.AddRange(filesAndFrameworks .Where(x => frameworkComparer.Equals(targetPackageFramework, x.Value)) .Select(x => System.IO.Path.Combine(Path, String.Format(CultureInfo.InvariantCulture, "{0}.{1}", package.Id, package.Version), x.Key.Path)) .Where(x => System.IO.Path.GetExtension(x) == ".dll")); } } return(assemblyPaths); }
public async Task <IEnumerable <PackageDependency> > GetDependencies(string package, List <Uri> sources, NuGetVersion referencedVersion, NuGetFramework targetFramework) { var allDependencies = new List <PackageDependency>(); foreach (var source in sources) { var findPackageById = await FindResourceForSource(source); var dependencyInfo = await findPackageById.GetDependencyInfoAsync(package, referencedVersion, _context, _logger, CancellationToken.None); var reducer = new FrameworkReducer(); var comparer = new NuGetFrameworkFullComparer(); if (dependencyInfo != null) { var nearestFramework = reducer.GetNearest(targetFramework, dependencyInfo.DependencyGroups.Select(x => x.TargetFramework)); foreach (var dependencyGroup in dependencyInfo.DependencyGroups.Where(d => comparer.Equals(nearestFramework, d.TargetFramework))) { foreach (var groupPackage in dependencyGroup.Packages) { allDependencies.Add(groupPackage); } } } } return(allDependencies); }
/// <summary> /// Creates a FrameworkReducer using custom framework mappings. /// </summary> public FrameworkReducer(IFrameworkNameProvider mappings, IFrameworkCompatibilityProvider compat) { _mappings = mappings; _compat = compat; _fullComparer = new NuGetFrameworkFullComparer(); _fwNameComparer = new NuGetFrameworkNameComparer(); }
public IEnumerable<string> GetCompatibleAssemblyPaths() { List<string> assemblyPaths = new List<string>(); FrameworkReducer reducer = new FrameworkReducer(); NuGetFramework targetFramework = new NuGetFramework(".NETFramework", Version.Parse("4.5")); // If alternate versions of Wyam are developed (I.e., for DNX), this will need to be switched NuGetFrameworkFullComparer frameworkComparer = new NuGetFrameworkFullComparer(); IPackageRepository packageRepository = PackageRepositoryFactory.Default.CreateRepository(Path); PackageManager packageManager = new PackageManager(packageRepository, Path); foreach (IPackage package in packageManager.LocalRepository.GetPackages()) { List<KeyValuePair<IPackageFile, NuGetFramework>> filesAndFrameworks = package.GetLibFiles() .Select(x => new KeyValuePair<IPackageFile, NuGetFramework>(x, new NuGetFramework(x.TargetFramework.Identifier, x.TargetFramework.Version, x.TargetFramework.Profile))) .ToList(); NuGetFramework targetPackageFramework = reducer.GetNearest(targetFramework, filesAndFrameworks.Select(x => x.Value)); if (targetPackageFramework != null) { assemblyPaths.AddRange(filesAndFrameworks .Where(x => frameworkComparer.Equals(targetPackageFramework, x.Value)) .Select(x => System.IO.Path.Combine(Path, String.Format(CultureInfo.InvariantCulture, "{0}.{1}", package.Id, package.Version), x.Key.Path)) .Where(x => System.IO.Path.GetExtension(x) == ".dll")); } } return assemblyPaths; }
public void NuGetFrameworkFullComparer_WithAssetTargetFallback_Succeeds(string shortFrameworkName) { var nugetFramework = NuGetFramework.Parse(shortFrameworkName); var assetTargetFallback = new AssetTargetFallbackFramework(nugetFramework, fallbackFrameworks: SampleFrameworkList); var comparer = new NuGetFrameworkFullComparer(); Assert.True(comparer.Equals(nugetFramework, assetTargetFallback)); }
public void NuGetFrameworkEquals_WithDualCompatibilityFramework_Succeeds(string shortFrameworkName, string rootFrameworkName, bool equals) { var nugetFramework = NuGetFramework.Parse(shortFrameworkName); var extendedFramework = new DualCompatibilityFramework(NuGetFramework.Parse(rootFrameworkName), secondaryFramework: NuGetFramework.Parse(rootFrameworkName)); var comparer = new NuGetFrameworkFullComparer(); comparer.Equals(nugetFramework, extendedFramework).Should().Be(equals); nugetFramework.Equals(extendedFramework).Should().Be(equals); }
private IReadOnlyCollection <IFile> GetAddinAssemblies(DirectoryPath path, PackageReference package) { if (!_fileSystem.Exist(path)) { return(new List <IFile>()); } // Get current framework. var provider = DefaultFrameworkNameProvider.Instance; var current = NuGetFramework.Parse(_environment.Runtime.BuiltFramework.FullName, provider); // Get all ref assemblies. var refAssemblies = _globber.GetFiles(path.FullPath + "/ref/**/*.dll"); // Get all candidate files. var pathComparer = PathComparer.Default; var assemblies = GetFiles(path, package, new[] { path.FullPath + "/**/*.dll" }) .Where(file => !"Cake.Core.dll".Equals(file.Path.GetFilename().FullPath, StringComparison.OrdinalIgnoreCase) && IsCLRAssembly(file) && !refAssemblies.Contains(file.Path, pathComparer)) .ToList(); // Iterate all found files. var comparer = new NuGetFrameworkFullComparer(); var mapping = new Dictionary <NuGetFramework, List <FilePath> >(comparer); foreach (var assembly in assemblies) { // Get relative path. var relative = path.GetRelativePath(assembly.Path); var framework = ParseFromDirectoryPath(current, relative.GetDirectory()); if (!mapping.ContainsKey(framework)) { mapping.Add(framework, new List <FilePath>()); } mapping[framework].Add(assembly.Path); } // Reduce found frameworks to the closest one. var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(current, mapping.Keys); if (nearest == null || !mapping.ContainsKey(nearest)) { return(new List <IFile>()); } if (nearest == NuGetFramework.AnyFramework) { var framework = _environment.Runtime.BuiltFramework; _log.Warning("Could not find any assemblies compatible with {0} in NuGet package {1}. " + "Falling back to using root folder of NuGet package.", framework.FullName, package.Package); } // Return the result. return(mapping[nearest].Select(p => _fileSystem.GetFile(p)).ToList()); }
/// <summary> /// Retrieve a registration blob /// </summary> /// <returns>Returns Null if the package does not exist</returns> public static async Task <RegistrationInfo> GetRegistrationInfo( HttpSource httpClient, Uri registrationUri, string packageId, VersionRange range, SourceCacheContext cacheContext, NuGetFramework projectTargetFramework, ILogger log, CancellationToken token) { var frameworkComparer = new NuGetFrameworkFullComparer(); var frameworkReducer = new FrameworkReducer(); var dependencies = await GetDependencies(httpClient, registrationUri, packageId, range, cacheContext, log, token); var result = new HashSet <RegistrationInfo>(); var registrationInfo = new RegistrationInfo(); registrationInfo.IncludePrerelease = true; foreach (var item in dependencies) { var packageInfo = new PackageInfo { Listed = item.Listed, Version = item.Identity.Version, PackageContent = new Uri(item.ContentUri) }; // only one target framework group will be used at install time, which means // we can filter down to that group now by using the project target framework var depFrameworks = item.DependencyGroups.Select(e => e.TargetFramework); var targetFramework = frameworkReducer.GetNearest(projectTargetFramework, depFrameworks); // If no frameworks are compatible we just ignore them - Should this be an exception? if (targetFramework != null) { var dependencyGroup = item.DependencyGroups.FirstOrDefault(d => frameworkComparer.Equals(targetFramework, d.TargetFramework)); if (dependencyGroup != null) { foreach (var dependency in dependencyGroup.Packages) { var dependencyInfo = new DependencyInfo { Id = dependency.Id, Range = dependency.VersionRange }; packageInfo.Dependencies.Add(dependencyInfo); } } } registrationInfo.Add(packageInfo); registrationInfo.Id = item.Identity.Id; } return(registrationInfo); }
public void FrameworkComparer_PCLNormalize() { var fw1 = NuGetFramework.Parse("portable-net45+win8+wp8+wpa81+monotouch+monoandroid"); var fw2 = NuGetFramework.Parse("portable-net45+win8+wp8+wpa81"); var fw3 = NuGetFramework.Parse(".NETPortable, Version=v0.0, Profile=Profile259"); var comparer = new NuGetFrameworkFullComparer(); Assert.True(comparer.Equals(fw1, fw2), "2"); Assert.True(comparer.Equals(fw1, fw3), "3"); }
/// <summary> /// Adds refresh files to the specified project for all assemblies references belonging to the packages specified by packageNames. /// </summary> /// <param name="project">The project.</param> /// <param name="packagesFileSystem">The file system pointing to 'packages' folder under the solution.</param> /// <param name="packageNames">The package names.</param> private void AddRefreshFilesForReferences(Project project, string repositoryPath, IEnumerable <PackageIdentity> packageNames) { if (project == null) { throw new ArgumentNullException("project"); } if (repositoryPath == null) { throw new ArgumentNullException("repositoryPath"); } if (!packageNames.Any()) { return; } VSAPIProjectContext context = new VSAPIProjectContext(); WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(project, context); var root = EnvDTEProjectUtility.GetFullPath(project); foreach (var packageName in packageNames) { string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version); DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath)); PackageFolderReader reader = new PackageFolderReader(packageFolder); var frameworkGroups = reader.GetReferenceItems(); var groups = reader.GetReferenceItems(); var fwComparer = new NuGetFrameworkFullComparer(); FrameworkReducer reducer = new FrameworkReducer(); NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework)); if (targetGroupFramework != null) { var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault(); foreach (string refItem in refGroup.Items) { string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar)); // create one refresh file for each assembly reference, as per required by Website projects // projectSystem.CreateRefreshFile(assemblyPath); RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath, context); } } } }
/// <summary> /// Get the nearest framework available in the project. /// </summary> public static TargetFrameworkInformation GetTargetFramework(this PackageSpec project, NuGetFramework targetFramework) { var frameworkInfo = project.TargetFrameworks.FirstOrDefault(f => NuGetFrameworkFullComparer.Equals(targetFramework, f)); if (frameworkInfo == null) { frameworkInfo = NuGetFrameworkUtility.GetNearest(project.TargetFrameworks, targetFramework, item => item.FrameworkName); } return(frameworkInfo ?? new TargetFrameworkInformation()); }
public void FrameworkComparer_VersionNormalize() { var fw1 = NuGetFramework.Parse("net45"); var fw2 = NuGetFramework.Parse("net4.5"); var fw3 = NuGetFramework.Parse("net4.5.0"); var fw4 = NuGetFramework.Parse("net450"); var fw5 = NuGetFramework.Parse(".NETFramework45"); var comparer = new NuGetFrameworkFullComparer(); Assert.True(comparer.Equals(fw1, fw2)); Assert.True(comparer.Equals(fw1, fw3)); Assert.True(comparer.Equals(fw1, fw4)); Assert.True(comparer.Equals(fw1, fw5)); }
protected override IReadOnlyCollection <IFile> GetAddinAssemblies(DirectoryPath path, PackageReference package) { if (!_fileSystem.Exist(path)) { return(new List <IFile>()); } // Get current framework. var provider = DefaultFrameworkNameProvider.Instance; var current = NuGetFramework.Parse(_environment.Runtime.TargetFramework.FullName, provider); // Get all candidate files. var assemblies = GetFiles(path, package, new[] { path.FullPath + "/**/*.dll" }) .Where(file => !"Cake.Core.dll".Equals(file.Path.GetFilename().FullPath, StringComparison.OrdinalIgnoreCase) && IsCLRAssembly(file)) .ToList(); // Iterate all found files. var comparer = new NuGetFrameworkFullComparer(); var mapping = new Dictionary <NuGetFramework, List <FilePath> >(comparer); foreach (var assembly in assemblies) { // Get relative path. var relative = path.GetRelativePath(assembly.Path); var framework = ParseFromDirectoryPath(current, relative.GetDirectory()); if (!mapping.ContainsKey(framework)) { mapping.Add(framework, new List <FilePath>()); } mapping[framework].Add(assembly.Path); } // Reduce found frameworks to the closest one. var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(current, mapping.Keys); if (nearest == null || !mapping.ContainsKey(nearest)) { return(new List <IFile>()); } // Return the result. return(mapping[nearest].Select(p => _fileSystem.GetFile(p)).ToList()); }
public void AsFallbackFramework_WhenCalledMultipleTimes_CachesFallbackObjectReference() { var nugetFramework = CommonFrameworks.Net50; var dualCompatibilityFramework = new DualCompatibilityFramework(nugetFramework, secondaryFramework: NuGetFramework.AnyFramework); FallbackFramework fallbackFramework = dualCompatibilityFramework.AsFallbackFramework(); var comparer = new NuGetFrameworkFullComparer(); Assert.True(comparer.Equals(fallbackFramework, nugetFramework)); fallbackFramework.Fallback.Should().HaveCount(1); fallbackFramework.Fallback.Single().Should().Be(NuGetFramework.AnyFramework); FallbackFramework fallbackFramework2 = dualCompatibilityFramework.AsFallbackFramework(); fallbackFramework.Should().BeSameAs(fallbackFramework2); }
protected override IReadOnlyCollection <IFile> GetAddinAssemblies(DirectoryPath path) { if (!_fileSystem.Exist(path)) { return(new List <IFile>()); } // Get current framework. var provider = DefaultFrameworkNameProvider.Instance; var current = NuGetFramework.Parse(_environment.Runtime.TargetFramework.FullName, provider); // Get all candidate files. var assemblies = _fileSystem.GetDirectory(path).GetFiles("*.dll", SearchScope.Recursive); // Iterate all found files. var comparer = new NuGetFrameworkFullComparer(); var mapping = new Dictionary <NuGetFramework, List <FilePath> >(comparer); foreach (var assembly in assemblies) { // Get relative path. var relative = path.GetRelativePath(assembly.Path); var framework = ParseFromDirectoryPath(current, relative.GetDirectory()); if (!mapping.ContainsKey(framework)) { mapping.Add(framework, new List <FilePath>()); } mapping[framework].Add(assembly.Path); } // Reduce found frameworks to the closest one. var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(current, mapping.Keys); if (nearest == null || !mapping.ContainsKey(nearest)) { return(new List <IFile>()); } // Return the result. return(mapping[nearest].Select(p => _fileSystem.GetFile(p)).ToList()); }
public IEnumerable <FilePath> GetCompatibleAssemblyPaths() { List <FilePath> assemblyPaths = new List <FilePath>(); FrameworkReducer reducer = new FrameworkReducer(); NuGetFramework targetFramework = new NuGetFramework(".NETFramework", Version.Parse("4.6")); // TODO: If alternate versions of Wyam are developed (I.e., for DNX), this will need to be switched NuGetFrameworkFullComparer frameworkComparer = new NuGetFrameworkFullComparer(); IPackageRepository packageRepository = PackageRepositoryFactory.Default.CreateRepository(AbsolutePackagesPath.FullPath); PackageManager packageManager = new PackageManager(packageRepository, AbsolutePackagesPath.FullPath); foreach (IPackage package in packageManager.LocalRepository.GetPackages()) { List <KeyValuePair <IPackageFile, NuGetFramework> > filesAndFrameworks = package.GetLibFiles() .Where(x => x.TargetFramework != null) .Select(x => new KeyValuePair <IPackageFile, NuGetFramework>(x, new NuGetFramework(x.TargetFramework.Identifier, x.TargetFramework.Version, x.TargetFramework.Profile))) .ToList(); NuGetFramework targetPackageFramework = reducer.GetNearest(targetFramework, filesAndFrameworks.Select(x => x.Value)); if (targetPackageFramework != null) { List <FilePath> packageAssemblyPaths = filesAndFrameworks .Where(x => frameworkComparer.Equals(targetPackageFramework, x.Value)) .Select(x => AbsolutePackagesPath.Combine(String.Format(CultureInfo.InvariantCulture, "{0}.{1}", package.Id, package.Version)).CombineFile(x.Key.Path)) .Where(x => x.Extension == ".dll") .ToList(); foreach (FilePath packageAssemblyPath in packageAssemblyPaths) { Trace.Verbose("Added assembly file {0} from package {1}.{2}", packageAssemblyPath.ToString(), package.Id, package.Version); } assemblyPaths.AddRange(packageAssemblyPaths); } else { Trace.Verbose("Could not find compatible framework for package {0}.{1} (this is normal for content-only packages)", package.Id, package.Version); } } return(assemblyPaths); }
public static async Task <RegistrationInfo> GetRegistrationInfo(HttpClient httpClient, Uri registrationUri, VersionRange range, NuGetFramework projectTargetFramework, ConcurrentDictionary <Uri, JObject> sessionCache = null) { NuGetFrameworkFullComparer frameworkComparer = new NuGetFrameworkFullComparer(); FrameworkReducer frameworkReducer = new FrameworkReducer(); JObject index = await LoadResource(httpClient, registrationUri, sessionCache); if (index == null) { throw new ArgumentException(registrationUri.AbsoluteUri); } VersionRange preFilterRange = Utils.SetIncludePrerelease(range, true); IList <Task <JObject> > rangeTasks = new List <Task <JObject> >(); foreach (JObject item in index["items"]) { NuGetVersion lower = NuGetVersion.Parse(item["lower"].ToString()); NuGetVersion upper = NuGetVersion.Parse(item["upper"].ToString()); if (ResolverMetadataClientUtility.IsItemRangeRequired(preFilterRange, lower, upper)) { JToken items; if (!item.TryGetValue("items", out items)) { Uri rangeUri = item["@id"].ToObject <Uri>(); rangeTasks.Add(LoadResource(httpClient, rangeUri, sessionCache)); } else { rangeTasks.Add(Task.FromResult(item)); } } } await Task.WhenAll(rangeTasks.ToArray()); RegistrationInfo registrationInfo = new RegistrationInfo(); registrationInfo.IncludePrerelease = range.IncludePrerelease; string id = string.Empty; foreach (JObject rangeObj in rangeTasks.Select((t) => t.Result)) { if (rangeObj == null) { throw new InvalidDataException(registrationUri.AbsoluteUri); } foreach (JObject packageObj in rangeObj["items"]) { JObject catalogEntry = (JObject)packageObj["catalogEntry"]; NuGetVersion packageVersion = NuGetVersion.Parse(catalogEntry["version"].ToString()); id = catalogEntry["id"].ToString(); int publishedDate = 0; JToken publishedValue; if (catalogEntry.TryGetValue("published", out publishedValue)) { publishedDate = int.Parse(publishedValue.ToObject <DateTime>().ToString("yyyyMMdd")); } //publishedDate = 0 means the property doesn't exist in index.json //publishedDate = 19000101 means the property exists but the package is unlisted if (range.Satisfies(packageVersion) && (publishedDate != 19000101)) { PackageInfo packageInfo = new PackageInfo(); packageInfo.Version = packageVersion; packageInfo.PackageContent = new Uri(packageObj["packageContent"].ToString()); JArray dependencyGroupsArray = (JArray)catalogEntry["dependencyGroups"]; if (dependencyGroupsArray != null) { // only one target framework group will be used at install time, which means // we can filter down to that group now by using the project target framework var depFrameworks = dependencyGroupsArray.Select(e => GetFramework(e as JObject)); var targetFramework = frameworkReducer.GetNearest(projectTargetFramework, depFrameworks); // If no frameworks are compatible we just ignore them - Should this be an exception? if (targetFramework != null) { foreach (JObject dependencyGroupObj in dependencyGroupsArray) { NuGetFramework currentFramework = GetFramework(dependencyGroupObj); if (frameworkComparer.Equals(currentFramework, targetFramework)) { foreach (JObject dependencyObj in dependencyGroupObj["dependencies"]) { DependencyInfo dependencyInfo = new DependencyInfo(); dependencyInfo.Id = dependencyObj["id"].ToString(); dependencyInfo.Range = Utils.CreateVersionRange((string)dependencyObj["range"], range.IncludePrerelease); dependencyInfo.RegistrationUri = dependencyObj["registration"].ToObject <Uri>(); packageInfo.Dependencies.Add(dependencyInfo); } } } } } registrationInfo.Add(packageInfo); } } registrationInfo.Id = id; } return(registrationInfo); }
public static async Task<RegistrationInfo> GetRegistrationInfo(HttpClient httpClient, Uri registrationUri, VersionRange range, NuGetFramework projectTargetFramework, ConcurrentDictionary<Uri, JObject> sessionCache = null) { NuGetFrameworkFullComparer frameworkComparer = new NuGetFrameworkFullComparer(); FrameworkReducer frameworkReducer = new FrameworkReducer(); JObject index = await LoadResource(httpClient, registrationUri, sessionCache); if (index == null) { throw new ArgumentException(registrationUri.AbsoluteUri); } VersionRange preFilterRange = Utils.SetIncludePrerelease(range, true); IList<Task<JObject>> rangeTasks = new List<Task<JObject>>(); foreach (JObject item in index["items"]) { NuGetVersion lower = NuGetVersion.Parse(item["lower"].ToString()); NuGetVersion upper = NuGetVersion.Parse(item["upper"].ToString()); if (ResolverMetadataClientUtility.IsItemRangeRequired(preFilterRange, lower, upper)) { JToken items; if (!item.TryGetValue("items", out items)) { Uri rangeUri = item["@id"].ToObject<Uri>(); rangeTasks.Add(LoadResource(httpClient, rangeUri, sessionCache)); } else { rangeTasks.Add(Task.FromResult(item)); } } } await Task.WhenAll(rangeTasks.ToArray()); RegistrationInfo registrationInfo = new RegistrationInfo(); registrationInfo.IncludePrerelease = range.IncludePrerelease; string id = string.Empty; foreach (JObject rangeObj in rangeTasks.Select((t) => t.Result)) { if (rangeObj == null) { throw new InvalidDataException(registrationUri.AbsoluteUri); } foreach (JObject packageObj in rangeObj["items"]) { JObject catalogEntry = (JObject)packageObj["catalogEntry"]; NuGetVersion packageVersion = NuGetVersion.Parse(catalogEntry["version"].ToString()); id = catalogEntry["id"].ToString(); int publishedDate = 0; JToken publishedValue; if (catalogEntry.TryGetValue("published", out publishedValue)) { publishedDate = int.Parse(publishedValue.ToObject<DateTime>().ToString("yyyyMMdd")); } //publishedDate = 0 means the property doesn't exist in index.json //publishedDate = 19000101 means the property exists but the package is unlisted if (range.Satisfies(packageVersion) && (publishedDate!= 19000101)) { PackageInfo packageInfo = new PackageInfo(); packageInfo.Version = packageVersion; packageInfo.PackageContent = new Uri(packageObj["packageContent"].ToString()); JArray dependencyGroupsArray = (JArray)catalogEntry["dependencyGroups"]; if (dependencyGroupsArray != null) { // only one target framework group will be used at install time, which means // we can filter down to that group now by using the project target framework var depFrameworks = dependencyGroupsArray.Select(e => GetFramework(e as JObject)); var targetFramework = frameworkReducer.GetNearest(projectTargetFramework, depFrameworks); // If no frameworks are compatible we just ignore them - Should this be an exception? if (targetFramework != null) { foreach (JObject dependencyGroupObj in dependencyGroupsArray) { NuGetFramework currentFramework = GetFramework(dependencyGroupObj); if (frameworkComparer.Equals(currentFramework, targetFramework)) { foreach (JObject dependencyObj in dependencyGroupObj["dependencies"]) { DependencyInfo dependencyInfo = new DependencyInfo(); dependencyInfo.Id = dependencyObj["id"].ToString(); dependencyInfo.Range = Utils.CreateVersionRange((string)dependencyObj["range"], range.IncludePrerelease); dependencyInfo.RegistrationUri = dependencyObj["registration"].ToObject<Uri>(); packageInfo.Dependencies.Add(dependencyInfo); } } } } } registrationInfo.Add(packageInfo); } } registrationInfo.Id = id; } return registrationInfo; }
public PackageBuilder GetPackageBuilder(IPackTaskRequest <IMSBuildItem> request) { // Load the assets JSON file produced by restore. var assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName); if (!File.Exists(assetsFilePath)) { throw new PackagingException(NuGetLogCode.NU5023, string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileNotFound, assetsFilePath)); } var builder = new PackageBuilder(request.Deterministic) { Id = request.PackageId, Description = request.Description, Title = request.Title, Copyright = request.Copyright, ReleaseNotes = request.ReleaseNotes, RequireLicenseAcceptance = request.RequireLicenseAcceptance, PackageTypes = ParsePackageTypes(request) }; if (request.DevelopmentDependency) { builder.DevelopmentDependency = true; } if (request.PackageVersion != null) { NuGetVersion version; if (!NuGetVersion.TryParse(request.PackageVersion, out version)) { throw new PackagingException(NuGetLogCode.NU5024, string.Format( CultureInfo.CurrentCulture, Strings.InvalidPackageVersion, request.PackageVersion)); } builder.Version = version; } else { builder.Version = new NuGetVersion("1.0.0"); } if (request.Authors != null) { builder.Authors.AddRange(request.Authors); } if (request.Tags != null) { builder.Tags.AddRange(request.Tags); } Uri tempUri; if (Uri.TryCreate(request.LicenseUrl, UriKind.Absolute, out tempUri)) { builder.LicenseUrl = tempUri; } if (Uri.TryCreate(request.ProjectUrl, UriKind.Absolute, out tempUri)) { builder.ProjectUrl = tempUri; } if (Uri.TryCreate(request.IconUrl, UriKind.Absolute, out tempUri)) { builder.IconUrl = tempUri; } if (!string.IsNullOrEmpty(request.RepositoryUrl) || !string.IsNullOrEmpty(request.RepositoryType)) { builder.Repository = new RepositoryMetadata( request.RepositoryType, request.RepositoryUrl, request.RepositoryBranch, request.RepositoryCommit); } builder.LicenseMetadata = BuildLicenseMetadata(request); builder.Icon = request.PackageIcon; if (request.MinClientVersion != null) { Version version; if (!Version.TryParse(request.MinClientVersion, out version)) { throw new PackagingException(NuGetLogCode.NU5022, string.Format( CultureInfo.CurrentCulture, Strings.InvalidMinClientVersion, request.MinClientVersion)); } builder.MinClientVersion = version; } // The assets file is necessary for project and package references. Pack should not do any traversal, // so we leave that work up to restore (which produces the assets file). var lockFileFormat = new LockFileFormat(); var assetsFile = lockFileFormat.Read(assetsFilePath); if (assetsFile.PackageSpec == null) { throw new PackagingException(NuGetLogCode.NU5025, string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileDoesNotHaveValidPackageSpec, assetsFilePath)); } var projectRefToVersionMap = new Dictionary <string, string>(PathUtility.GetStringComparerBasedOnOS()); if (request.ProjectReferencesWithVersions != null && request.ProjectReferencesWithVersions.Any()) { projectRefToVersionMap = request .ProjectReferencesWithVersions .ToDictionary(msbuildItem => msbuildItem.Identity, msbuildItem => msbuildItem.GetProperty("ProjectVersion"), PathUtility.GetStringComparerBasedOnOS()); } var nuGetFrameworkComparer = new NuGetFrameworkFullComparer(); var frameworksWithSuppressedDependencies = new HashSet <NuGetFramework>(nuGetFrameworkComparer); if (request.FrameworksWithSuppressedDependencies != null && request.FrameworksWithSuppressedDependencies.Any()) { frameworksWithSuppressedDependencies = new HashSet <NuGetFramework>(request.FrameworksWithSuppressedDependencies .Select(t => NuGetFramework.Parse(t.Identity)).ToList(), nuGetFrameworkComparer); } PopulateProjectAndPackageReferences(builder, assetsFile, projectRefToVersionMap, frameworksWithSuppressedDependencies); PopulateFrameworkAssemblyReferences(builder, request); PopulateFrameworkReferences(builder, assetsFile); return(builder); }
/// <summary> /// Adds refresh files to the specified project for all assemblies references belonging to the packages specified by packageNames. /// </summary> /// <param name="project">The project.</param> /// <param name="packagesFileSystem">The file system pointing to 'packages' folder under the solution.</param> /// <param name="packageNames">The package names.</param> private void AddRefreshFilesForReferences(Project project, string repositoryPath, IEnumerable<PackageIdentity> packageNames) { if (project == null) { throw new ArgumentNullException("project"); } if (repositoryPath == null) { throw new ArgumentNullException("repositoryPath"); } if (!packageNames.Any()) { return; } VSAPIProjectContext context = new VSAPIProjectContext(); WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(project, context); var root = EnvDTEProjectUtility.GetFullPath(project); foreach (var packageName in packageNames) { string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version); DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath)); PackageFolderReader reader = new PackageFolderReader(packageFolder); var frameworkGroups = reader.GetReferenceItems(); var groups = reader.GetReferenceItems(); var fwComparer = new NuGetFrameworkFullComparer(); FrameworkReducer reducer = new FrameworkReducer(); NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework)); if (targetGroupFramework != null) { var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault(); foreach (string refItem in refGroup.Items) { string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar)); // create one refresh file for each assembly reference, as per required by Website projects // projectSystem.CreateRefreshFile(assemblyPath); RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath, context); } } } }
/// <summary> /// Retrieve a registration blob /// </summary> /// <returns>Returns Null if the package does not exist</returns> public static async Task<RegistrationInfo> GetRegistrationInfo( HttpClient httpClient, Uri registrationUri, VersionRange range, NuGetFramework projectTargetFramework, CancellationToken token) { var frameworkComparer = new NuGetFrameworkFullComparer(); var frameworkReducer = new FrameworkReducer(); var dependencies = await GetDependencies(httpClient, registrationUri, range, token); var registrationInfo = new RegistrationInfo(); registrationInfo.IncludePrerelease = range.IncludePrerelease; foreach (var item in dependencies) { var packageInfo = new PackageInfo { Listed = item.Listed, Version = item.Identity.Version, PackageContent = new Uri(item.ContentUri) }; // only one target framework group will be used at install time, which means // we can filter down to that group now by using the project target framework var depFrameworks = item.DependencyGroups.Select(e => e.TargetFramework); var targetFramework = frameworkReducer.GetNearest(projectTargetFramework, depFrameworks); // If no frameworks are compatible we just ignore them - Should this be an exception? if (targetFramework != null) { var dependencyGroup = item.DependencyGroups.FirstOrDefault(d => frameworkComparer.Equals(targetFramework, d.TargetFramework)); if (dependencyGroup != null) { foreach (var dependency in dependencyGroup.Packages) { var dependencyInfo = new DependencyInfo { Id = dependency.Id, Range = dependency.VersionRange }; packageInfo.Dependencies.Add(dependencyInfo); } } } registrationInfo.Add(packageInfo); registrationInfo.Id = item.Identity.Id; } return registrationInfo; }
/// <summary> /// Remove duplicates found in the equivalence mappings. /// </summary> public IEnumerable<NuGetFramework> Reduce(IEnumerable<NuGetFramework> frameworks) { // order first so we get consistent results for equivalent frameworks var input = frameworks.OrderBy(f => f.DotNetFrameworkName, StringComparer.OrdinalIgnoreCase).ToArray(); var comparer = new NuGetFrameworkFullComparer(); for (var i = 0; i < input.Length; i++) { var dupe = false; IEnumerable<NuGetFramework> eqFrameworks = null; if (!_mappings.TryGetEquivalentFrameworks(input[i], out eqFrameworks)) { eqFrameworks = new List<NuGetFramework>() { input[i] }; } for (var j = i + 1; !dupe && j < input.Length; j++) { dupe = eqFrameworks.Contains(input[j], comparer); } if (!dupe) { yield return input[i]; } } yield break; }