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");
}
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));
}
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;
}
/// <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 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));
}
/// <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 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);
}
/// <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 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);
}
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);
}
/// <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;
}
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);
}
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);
}
/// <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);
}
}
}
}
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));
}
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");
}
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;
}