/// <summary>
/// Gets the list of packages to install along with there dependencies
/// </summary>
/// <param name="repository">The package repository</param>
/// <param name="seederConfiguration">The seeder configuration</param>
/// <returns>The list of packages</returns>
private static async Task <IEnumerable <PackageIdentity> > GetPackagesToInstall(
IPackageRepository repository,
SeederConfiguration seederConfiguration)
{
// TODO: extract to helper method along with Configuration extensions
var supportedFramework = NuGetFramework.ParseFrameworkName(
PackageRepositoryExtensions.CurrentRuntime,
DefaultFrameworkNameProvider.Instance);
var packageTasks =
seederConfiguration.RequiredPackages.Select(
async packageName =>
{
var package = await repository.GetAsync(packageName);
if (package == null)
{
throw new PackageNotFoundException(packageName);
}
return(package);
});
var packagesToInstall = (await Task.WhenAll(packageTasks)).ToDictionary(p => p.Identity.Id);
var queue = new Queue <IPackageSearchMetadata>(packagesToInstall.Values);
while (queue.Count > 0)
{
var package = queue.Dequeue();
var dependencySet =
NuGetFrameworkUtility.GetNearest(package.DependencySets, supportedFramework);
if (dependencySet == null || !NuGetFrameworkUtility.IsCompatibleWithFallbackCheck(
supportedFramework,
dependencySet.TargetFramework))
{
continue;
}
foreach (var dependency in dependencySet.Packages)
{
IPackageSearchMetadata packageToInstall;
if (!packagesToInstall.TryGetValue(dependency.Id, out packageToInstall))
{
packageToInstall = await repository.GetAsync(dependency.Id);
if (packageToInstall == null)
{
throw new PackageNotFoundException(dependency.Id);
}
packagesToInstall.Add(dependency.Id, packageToInstall);
if (queue.All(p => p.Identity.Id != packageToInstall.Identity.Id))
{
queue.Enqueue(packageToInstall);
}
}
}
}
return(packagesToInstall.Values.Select(p => p.Identity));
}
/// <summary>
/// Determines if the targetframework the package was installed against is compatible with the project's new target framework
/// </summary>
/// <param name="items">lib/ref/content/build items in the packages</param>
/// <param name="newProjectFramework">The project's new target framework</param>
/// <param name="oldProjectFramework">The target framework that the package was installed against</param>
private static bool IsNearestFrameworkSpecificGroupEqual(IEnumerable <FrameworkSpecificGroup> items, NuGetFramework newProjectFramework, NuGetFramework oldProjectFramework)
{
if (items.Any())
{
var newNearestFramework = NuGetFrameworkUtility.GetNearest(items, newProjectFramework);
var oldNearestFramework = NuGetFrameworkUtility.GetNearest(items, oldProjectFramework);
if (newNearestFramework != null && oldNearestFramework != null)
{
return(newNearestFramework.Equals(oldNearestFramework));
}
if (newNearestFramework == null && oldNearestFramework == null)
{
return(true);
}
else
{
return(false);
}
}
// If there are no items, return true, i.e. does not need to retarget.
return(true);
}
public ApiFrameworkAvailability?GetAvailability(ApiModel api, NuGetFramework nugetFramework)
{
// Try to resolve an in-box assembly
if (_frameworkIds.TryGetValue(nugetFramework, out var frameworkId))
{
if (_frameworkAssemblies.TryGetValue(frameworkId, out var frameworkAssemblies))
{
foreach (var declaration in api.Declarations)
{
if (frameworkAssemblies.Contains(declaration.Assembly.Id))
{
return(new ApiFrameworkAvailability(nugetFramework, declaration, null, null));
}
}
}
}
// Try to resolve an assembly in a package for the given framework
foreach (var declaration in api.Declarations)
{
foreach (var(package, _) in declaration.Assembly.Packages)
{
if (_packageFolders.TryGetValue(package.Id, out var folders))
{
var folder = NuGetFrameworkUtility.GetNearest(folders, nugetFramework);
if (folder is not null && folder.Assemblies.Contains(declaration.Assembly))
{
return(new ApiFrameworkAvailability(nugetFramework, declaration, package, folder.TargetFramework));
}
}
}
}
return(null);
}
private async Task GetDependenciesAsync(Dictionary <string, PackageArchiveReader> packages, PackageArchiveReader root, NuGetFramework target)
{
var dependencies = root.GetPackageDependencies();
var dependencyGroup = NuGetFrameworkUtility.GetNearest(dependencies, target);
if (dependencyGroup != null)
{
foreach (var d in dependencyGroup.Packages)
{
if (packages.TryGetValue(d.Id, out var existingPackage))
{
if (d.VersionRange.MinVersion > existingPackage.NuspecReader.GetVersion())
{
existingPackage.Dispose();
packages.Remove(d.Id);
existingPackage = null;
}
}
if (existingPackage != null)
{
continue;
}
var requestedVersion = d.VersionRange.MinVersion?.ToNormalizedString() ?? "0.0.0";
var dependency = await _store.GetPackageAsync(d.Id, requestedVersion);
packages.Add(d.Id, dependency);
await GetDependenciesAsync(packages, dependency, target);
}
}
}
private static IEnumerable <LibraryDependency> GetDependencies(
FindPackageByIdDependencyInfo packageInfo,
NuGetFramework targetFramework)
{
if (packageInfo == null)
{
return(Enumerable.Empty <LibraryDependency>());
}
var dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
if (dependencyGroup == null && DeconstructFallbackFrameworks(targetFramework) is DualCompatibilityFramework dualCompatibilityFramework)
{
dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups, dualCompatibilityFramework.SecondaryFramework, item => item.TargetFramework);
}
// FrameworkReducer.GetNearest does not consider ATF since it is used for more than just compat
if (dependencyGroup == null &&
targetFramework is AssetTargetFallbackFramework assetTargetFallbackFramework)
{
dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
assetTargetFallbackFramework.AsFallbackFramework(),
item => item.TargetFramework);
}
if (dependencyGroup != null)
{
return(dependencyGroup.Packages.Select(PackagingUtility.GetLibraryDependencyFromNuspec).ToArray());
}
return(Enumerable.Empty <LibraryDependency>());
}
private ITaskItem AssignNearestFrameworkForSingleReference(ITaskItem project, IList <NuGetFramework> currentProjectTargetFrameworks)
{
var itemWithProperties = new TaskItem(project);
var targetFrameworks = project.GetMetadata(TARGET_FRAMEWORKS);
if (string.IsNullOrEmpty(targetFrameworks))
{
// No target frameworks set, nothing to do.
return(itemWithProperties);
}
var possibleTargetFrameworks = MSBuildStringUtility.Split(targetFrameworks);
foreach (var currentProjectTargetFramework in currentProjectTargetFrameworks)
{
var nearestNuGetFramework = NuGetFrameworkUtility.GetNearest(possibleTargetFrameworks, currentProjectTargetFramework, NuGetFramework.Parse);
if (nearestNuGetFramework != null)
{
itemWithProperties.SetMetadata(NEAREST_TARGET_FRAMEWORK, nearestNuGetFramework);
return(itemWithProperties);
}
}
// no match found
Log.LogError(string.Format(Strings.NoCompatibleTargetFramework, project.ItemSpec, CurrentProjectTargetFramework, targetFrameworks));
return(itemWithProperties);
}
public static NuGetFramework GetSuitableFrameworkFromProject(System.Collections.Generic.IEnumerable <NuGetFramework> frameworksInProject)
{
var nearestFramework = NuGetFrameworkUtility.GetNearest(
frameworksInProject,
FrameworkConstants.CommonFrameworks.NetCoreApp10,
f => new NuGetFramework(f));
if (nearestFramework == null)
{
nearestFramework = NuGetFrameworkUtility.GetNearest(
frameworksInProject,
FrameworkConstants.CommonFrameworks.Net46,
f => new NuGetFramework(f));
}
if (nearestFramework == null)
{
// This should never happen as long as we dispatch correctly.
var msg = Resources.NoCompatibleFrameworks
+ Environment.NewLine
+ string.Format(Resources.AvailableFrameworks, string.Join($"{Environment.NewLine} -", frameworksInProject.Select(f => f.GetShortFolderName())));
throw new InvalidOperationException(msg);
}
return(nearestFramework);
}
private static FrameworkSpecificGroup GetReferenceItems(PackageArchiveReader root, NuGetFramework current)
{
var referenceItems = GetReferenceItems(root);
var referenceGroup = NuGetFrameworkUtility.GetNearest(referenceItems, current);
return(referenceGroup);
}
private IEnumerable <LibraryDependency> GetDependencies(
FindPackageByIdDependencyInfo packageInfo,
NuGetFramework targetFramework)
{
if (packageInfo == null)
{
return(Enumerable.Empty <LibraryDependency>());
}
var dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
if (dependencyGroup == null && DeconstructFallbackFrameworks(targetFramework) is DualCompatibilityFramework dualCompatibilityFramework)
{
dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups, dualCompatibilityFramework.SecondaryFramework, item => item.TargetFramework);
}
if (dependencyGroup != null)
{
return(dependencyGroup.Packages.Select(PackagingUtility.GetLibraryDependencyFromNuspec).ToArray());
}
return(Enumerable.Empty <LibraryDependency>());
}
/// <summary>
/// Group all items by the primary key, then select the nearest TxM
/// within each group.
/// Items that do not contain the primaryKey will be filtered out.
/// </summary>
private static List <ContentItemGroup> GetContentGroupsForFramework(
NuGetFramework framework,
List <ContentItemGroup> contentGroups,
string primaryKey,
MaccatalystFallback maccatalystFallback)
{
var groups = new List <ContentItemGroup>();
// Group by primary key and find the nearest TxM under each.
var primaryGroups = new Dictionary <string, List <ContentItemGroup> >(StringComparer.Ordinal);
foreach (var group in contentGroups)
{
object keyObj;
if (group.Properties.TryGetValue(primaryKey, out keyObj))
{
var key = (string)keyObj;
List <ContentItemGroup> index;
if (!primaryGroups.TryGetValue(key, out index))
{
index = new List <ContentItemGroup>(1);
primaryGroups.Add(key, index);
}
index.Add(group);
}
}
// Find the nearest TxM within each primary key group.
foreach (var primaryGroup in primaryGroups)
{
var groupedItems = primaryGroup.Value;
var nearestGroup = NuGetFrameworkUtility.GetNearest <ContentItemGroup>(groupedItems, framework,
group =>
{
// In the case of /native there is no TxM, here any should be used.
object frameworkObj;
if (group.Properties.TryGetValue(
ManagedCodeConventions.PropertyNames.TargetFrameworkMoniker,
out frameworkObj))
{
return((NuGetFramework)frameworkObj);
}
return(NuGetFramework.AnyFramework);
});
// If a compatible group exists within the secondary key add it to the results
if (nearestGroup != null)
{
MaccatalystFallback.CheckFallback(maccatalystFallback, nearestGroup.Properties);
groups.Add(nearestGroup);
}
}
return(groups);
}
private IEnumerable <LibraryDependency> GetDependencies(NuspecReader nuspecReader, NuGetFramework targetFramework)
{
var dependencies = NuGetFrameworkUtility.GetNearest(nuspecReader.GetDependencyGroups(),
targetFramework,
item => item.TargetFramework);
return(GetDependencies(targetFramework, dependencies));
}
/// <summary>
/// Extracts the lib files to execution directory
/// </summary>
/// <param name="package">
/// The package to extract
/// </param>
/// <param name="runtime">
/// The current runtime
/// </param>
/// <param name="frameworkName">
/// The current framework name
/// </param>
/// <param name="executionDir">
/// The execution directory to load packages
/// </param>
/// <param name="logAction">The log writing action</param>
/// <returns>
/// The list of extracted files
/// </returns>
private static IEnumerable <string> ExtractPackage(
DownloadResourceResult package,
string runtime,
NuGetFramework frameworkName,
string executionDir,
Action <string> logAction = null)
{
try
{
var id = package.PackageReader.GetIdentity();
var files = NuGetFrameworkUtility.GetNearest(package.PackageReader.GetLibItems(), frameworkName)?.Items.ToList()
?? NuGetFrameworkUtility.GetNearest(package.PackageReader.GetToolItems(), frameworkName)?.Items.ToList();
if (files == null || files.Count == 0)
{
var collection = new ContentItemCollection();
collection.Load(package.PackageReader.GetFiles());
var conventions = new ManagedCodeConventions(runtimeGraph);
var criteria = conventions.Criteria.ForFrameworkAndRuntime(
NuGetFramework.ParseFrameworkName(
PackageRepositoryExtensions.CurrentRuntime,
DefaultFrameworkNameProvider.Instance),
runtime);
files = collection.FindBestItemGroup(criteria, conventions.Patterns.NativeLibraries)?.Items
.Select(i => i.Path).ToList();
if (files == null || files.Count == 0)
{
files = collection.FindBestItemGroup(criteria, conventions.Patterns.RuntimeAssemblies)?.Items
.Select(i => i.Path).ToList();
}
if (files == null || files.Count == 0)
{
return(new string[0]);
}
else
{
logAction?.Invoke($"{id.Id}: {string.Join(", ", files)}");
}
}
foreach (var file in files)
{
using (var fileStream = File.Create(Path.Combine(executionDir, Path.GetFileName(file) ?? file)))
{
package.PackageReader.GetStream(file).CopyTo(fileStream);
}
}
return(files.Select(file => Path.GetFileName(file) ?? file));
}
finally
{
package.Dispose();
}
}
private ITaskItem AssignNearestFrameworkForSingleReference(
ITaskItem project,
NuGetFramework projectNuGetFramework,
IList <NuGetFramework> fallbackNuGetFrameworks,
MSBuildLogger logger)
{
var itemWithProperties = new TaskItem(project);
var referencedProjectFrameworkString = project.GetMetadata(TARGET_FRAMEWORKS);
var referencedProjectFile = project.GetMetadata(MSBUILD_SOURCE_PROJECT_FILE);
if (string.IsNullOrEmpty(referencedProjectFrameworkString))
{
// No target frameworks set, nothing to do.
return(itemWithProperties);
}
var referencedProjectFrameworks = MSBuildStringUtility.Split(referencedProjectFrameworkString);
// try project framework
var nearestNuGetFramework = NuGetFrameworkUtility.GetNearest(referencedProjectFrameworks, projectNuGetFramework, NuGetFramework.Parse);
if (nearestNuGetFramework != null)
{
itemWithProperties.SetMetadata(NEAREST_TARGET_FRAMEWORK, nearestNuGetFramework);
return(itemWithProperties);
}
// try project fallback frameworks
foreach (var currentProjectTargetFramework in fallbackNuGetFrameworks)
{
nearestNuGetFramework = NuGetFrameworkUtility.GetNearest(referencedProjectFrameworks, currentProjectTargetFramework, NuGetFramework.Parse);
if (nearestNuGetFramework != null)
{
var message = string.Format(CultureInfo.CurrentCulture,
Strings.ImportsFallbackWarning,
referencedProjectFile,
currentProjectTargetFramework.DotNetFrameworkName,
projectNuGetFramework.DotNetFrameworkName);
var warning = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1702, message);
warning.LibraryId = referencedProjectFile;
warning.ProjectPath = CurrentProjectName;
// log NU1702 for ATF on project reference
logger.Log(warning);
itemWithProperties.SetMetadata(NEAREST_TARGET_FRAMEWORK, nearestNuGetFramework);
return(itemWithProperties);
}
}
// no match found
logger.LogError(string.Format(Strings.NoCompatibleTargetFramework, project.ItemSpec, CurrentProjectTargetFramework, referencedProjectFrameworkString));
return(itemWithProperties);
}
private IEnumerable <LibraryDependency> GetDependencies(FindPackageByIdDependencyInfo packageInfo, NuGetFramework targetFramework)
{
var dependencies = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
var frameworkAssemblies = NuGetFrameworkUtility.GetNearest(packageInfo.FrameworkReferenceGroups,
targetFramework,
item => item.TargetFramework);
return(GetDependencies(targetFramework, dependencies, frameworkAssemblies));
}
private IEnumerable <LibraryDependency> GetDependencies(FindPackageByIdDependencyInfo packageInfo, NuGetFramework targetFramework)
{
if (packageInfo == null)
{
return(new List <LibraryDependency>());
}
PackageDependencyGroup dependencies = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
return(GetDependencies(targetFramework, dependencies));
}
/// <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 => NuGetFramework.Comparer.Equals(targetFramework, f.FrameworkName));
if (frameworkInfo == null)
{
frameworkInfo = NuGetFrameworkUtility.GetNearest(project.TargetFrameworks,
targetFramework,
item => item.FrameworkName);
}
return(frameworkInfo ?? new TargetFrameworkInformation());
}
public void NuGetFrameworkUtility_GetNearest_NullReturnsNull()
{
// Arrange
var project = NuGetFramework.Parse("net45");
List <FrameworkSpecificGroup> items = null;
// Act
var nearestWithSelector = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(items, project, (item) => item.TargetFramework);
var nearest = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(items, project);
// Assert
Assert.Null(nearest);
Assert.Null(nearestWithSelector);
}
/// <summary>
/// Convert a package into a PackageDependencyInfo
/// </summary>
private SourcePackageDependencyInfo CreateDependencyInfo(LocalPackageInfo package, NuGetFramework projectFramework)
{
// Take only the dependency group valid for the project TFM
var group = NuGetFrameworkUtility.GetNearest <PackageDependencyGroup>(package.Nuspec.GetDependencyGroups(), projectFramework);
var dependencies = group?.Packages ?? Enumerable.Empty <PackageDependency>();
var result = new SourcePackageDependencyInfo(
package.Identity,
dependencies,
listed: true,
source: _source,
downloadUri: UriUtility.CreateSourceUri(package.Path, UriKind.Absolute),
packageHash: null);
return(result);
}
public static IEnumerable <string> GetCompatibleAssemblyReferences(this IPackageContentReaderWithRef package, FrameworkName target)
{
var framework = NuGetFramework.ParseFrameworkName(target.FullName, DefaultFrameworkNameProvider.Instance);
var result = NuGetFrameworkUtility.GetNearest(package.GetRefItems(), framework);
if (result != null)
{
var items = result.Items.ToArray();
if (items.Length != 0)
{
return(items);
}
}
result = NuGetFrameworkUtility.GetNearest(package.GetLibItems(), framework);
return(result == null?Enumerable.Empty <string>() : result.Items);
}
private ProjectContext GetCompatibleStartupProjectContext(string startupProjectPath, NuGetFramework projectFramework)
{
var startupProject = ProjectReader.GetProject(startupProjectPath);
var frameworks = startupProject.GetTargetFrameworks()
.Select(f => f.FrameworkName);
var startupFramework = frameworks.FirstOrDefault(f => f.Equals(projectFramework));
if (startupFramework == null)
{
if (projectFramework.IsDesktop())
{
startupFramework = frameworks.FirstOrDefault(f => f.IsDesktop())
?? NuGetFrameworkUtility.GetNearest(
frameworks,
FrameworkConstants.CommonFrameworks.NetStandard15,
f => f);
}
else
{
startupFramework = NuGetFrameworkUtility.GetNearest(
frameworks,
FrameworkConstants.CommonFrameworks.NetCoreApp10,
f => f)
// TODO remove fallback to dnxcore50
?? NuGetFrameworkUtility.GetNearest(
frameworks,
FrameworkConstants.CommonFrameworks.DnxCore50,
f => f);
}
}
if (startupFramework == null)
{
throw new OperationException(
ToolsCliStrings.IncompatibleStartupProject(startupProject.Name, projectFramework.GetShortFolderName()));
}
Reporter.Verbose.WriteLine(
ToolsCliStrings.LogUsingFramework(startupFramework.GetShortFolderName(), startupProject.Name).Bold().Black());
return(new ProjectContextBuilder()
.WithProject(startupProject)
.WithTargetFramework(startupFramework)
.WithRuntimeIdentifiers(PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers())
.Build());
}
public void NuGetFrameworkUtility_GetNearest_NoMatch()
{
// Arrange
var project = NuGetFramework.Parse("net45");
var items = new List <FrameworkSpecificGroup>();
items.Add(new FrameworkSpecificGroup(NuGetFramework.Parse("win"), new string[] { "lib/win/test.dll" }));
items.Add(new FrameworkSpecificGroup(NuGetFramework.Parse("net46"), new string[] { "lib/net46/test.dll" }));
// Act
var nearestWithSelector = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(items, project, (item) => item.TargetFramework);
var nearest = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(items, project);
// Assert
Assert.Null(nearestWithSelector);
Assert.Null(nearest);
}
public void NuGetFrameworkUtility_GetNearest_Any()
{
// Arrange
var project = NuGetFramework.Parse("net45");
var items = new List <FrameworkSpecificGroup>();
items.Add(new FrameworkSpecificGroup(NuGetFramework.Parse("win"), new string[] { "lib/win/test.dll" }));
items.Add(new FrameworkSpecificGroup(NuGetFramework.Parse("any"), new string[] { "lib/test.dll" }));
// Act
var nearestWithSelector = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(items, project, (item) => item.TargetFramework);
var nearest = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(items, project);
// Assert
Assert.Equal("any", nearestWithSelector.TargetFramework.GetShortFolderName());
Assert.Equal("any", nearest.TargetFramework.GetShortFolderName());
}
private IEnumerable <PackageDependency> ResolveDependencies(
IPackageSearchMetadata packageMetadata,
NuGetFramework targetFramework)
{
if (packageMetadata.DependencySets.Any())
{
var packageDependencyGroup = NuGetFrameworkUtility.GetNearest(packageMetadata.DependencySets, targetFramework);
if (packageDependencyGroup == null)
{
throw new IncompatibleFrameworkException($"Package \"{packageMetadata.Identity.ToString()}\" is not compatible with {targetFramework.GetShortFolderName()}");
}
return(packageDependencyGroup.Packages);
}
return(Enumerable.Empty <PackageDependency>());
}
public PackageManifest GetManifest(PackageKey key, NuGet.Frameworks.NuGetFramework projectFramework)
{
Guard.NotNull(projectFramework, nameof(projectFramework));
var packageIdentity = new NuGet.Packaging.Core.PackageIdentity(key.PackageId, key.Version);
var packagesResource = _sourceRepository.GetResource <PackageMetadataResource>();
var packageInfo = packagesResource.GetMetadataAsync(packageIdentity, NullSourceCacheContext.Instance, NullLogger.Instance, CancellationToken.None).Result;
NuGet.Packaging.PackageDependencyGroup dependencies = null;
if (packageInfo.DependencySets.Count() == 1 && packageInfo.DependencySets.First().TargetFramework.IsUnsupported)
{
dependencies = packageInfo.DependencySets.First();
}
else if (packageInfo.DependencySets.Any())
{
dependencies = NuGetFrameworkUtility.GetNearest(packageInfo.DependencySets, projectFramework);
if (dependencies == null)
{
throw new ApplicationException($"Could not find compatible dependencies for '{packageInfo.Identity}' and framework '{projectFramework}'");
}
}
var manifest = new PackageManifest
{
PackageId = packageInfo.Identity.Id,
Version = packageInfo.Identity.Version,
Dependencies = new List <PackageDependency>()
};
if (dependencies == null)
{
return(manifest);
}
foreach (var dependency in dependencies.Packages)
{
manifest.Dependencies.Add(new PackageDependency(dependency.Id, dependency.VersionRange));
}
return(manifest);
}
/// <summary>
/// Get all content groups that have the nearest TxM
/// </summary>
internal static List <ContentItemGroup> GetContentGroupsForFramework(
LockFileTargetLibrary lockFileLib,
NuGetFramework framework,
IEnumerable <ContentItemGroup> contentGroups,
MaccatalystFallback maccatalystFallback)
{
var groups = new List <ContentItemGroup>();
// Group by content by code language and find the nearest TxM under each language.
var groupsByLanguage = new Dictionary <string, List <ContentItemGroup> >(StringComparer.OrdinalIgnoreCase);
foreach (var group in contentGroups)
{
var codeLanguage = (string)group.Properties[ManagedCodeConventions.PropertyNames.CodeLanguage];
List <ContentItemGroup> index;
if (!groupsByLanguage.TryGetValue(codeLanguage, out index))
{
index = new List <ContentItemGroup>(1);
groupsByLanguage.Add(codeLanguage, index);
}
index.Add(group);
}
// Find the nearest TxM within each language
foreach (var codeLanguagePair in groupsByLanguage)
{
var languageGroups = codeLanguagePair.Value;
var nearestGroup = NuGetFrameworkUtility.GetNearest <ContentItemGroup>(languageGroups, framework,
group =>
(NuGetFramework)group.Properties[ManagedCodeConventions.PropertyNames.TargetFrameworkMoniker]);
// If a compatible group exists within the code language add it to the results
if (nearestGroup != null)
{
MaccatalystFallback.CheckFallback(maccatalystFallback, nearestGroup.Properties);
groups.Add(nearestGroup);
}
}
return(groups);
}
private static IEnumerable <String> GetSuitableFiles(
NuGetFramework thisFramework,
Lazy <RuntimeGraph> runtimeGraph,
String runtimeIdentifier,
LockFileTargetLibrary targetLibrary,
Lazy <IDictionary <String, LockFileLibrary> > libraries
)
{
var retVal = NuGetUtility.GetRuntimeAssembliesDelegate(runtimeGraph, runtimeIdentifier, targetLibrary, libraries);
if (!retVal.Any() && libraries.Value.TryGetValue(targetLibrary.Name, out var lib))
{
// targetLibrary does not list stuff like build/net45/someassembly.dll
// So let's do manual matching
var fwGroups = lib.Files.Where(f =>
{
return(f.StartsWith(PackagingConstants.Folders.Build, StringComparison.OrdinalIgnoreCase) &&
PackageHelper.IsAssembly(f) &&
Path.GetDirectoryName(f).Length > PackagingConstants.Folders.Build.Length + 1);
}).GroupBy(f =>
{
try
{
return(NuGetFramework.ParseFolder(f.Split('/')[1]));
}
catch
{
return(null);
}
})
.Where(g => g.Key != null)
.Select(g => new FrameworkSpecificGroup(g.Key, g));
var matchingGroup = NuGetFrameworkUtility.GetNearest(
fwGroups,
thisFramework,
g => g.TargetFramework);
retVal = matchingGroup?.Items;
}
return(retVal);
}
private IEnumerable <LibraryDependency> GetDependencies(
FindPackageByIdDependencyInfo packageInfo,
NuGetFramework targetFramework)
{
if (packageInfo == null)
{
return(Enumerable.Empty <LibraryDependency>());
}
var dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
if (dependencyGroup != null)
{
return(dependencyGroup.Packages.Select(PackagingUtility.GetLibraryDependencyFromNuspec).ToArray());
}
return(Enumerable.Empty <LibraryDependency>());
}
public void PackageReader_RespectReferencesAccordingToDifferentFrameworks()
{
// Copy of the InstallPackageRespectReferencesAccordingToDifferentFrameworks functional test
// Arrange
var zip = TestPackages.GetZip(TestPackages.GetNearestReferenceFilteringPackage());
var reader = new PackageReader(zip);
// Act
var references = reader.GetReferenceItems();
var netResult = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(references, NuGetFramework.Parse("net45"));
var slResult = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(references, NuGetFramework.Parse("sl5"));
// Assert
Assert.Equal(2, netResult.Items.Count());
Assert.Equal(1, slResult.Items.Count());
Assert.Equal("lib/sl40/a.dll", slResult.Items.First());
Assert.Equal("lib/net40/one.dll", netResult.Items.First());
Assert.Equal("lib/net40/three.dll", netResult.Items.Skip(1).First());
}
public static ResolvedLibraryDirectory ResolveNuGetFolder(string packageDirectory, NuGetFramework framework, Runtime runtime, Architecture architecture)
{
var libFolder = new DirectoryInfo(Path.Combine(packageDirectory, "lib"));
if (libFolder.Exists)
{
var frameworkFolders = libFolder.GetDirectories()
.ToDictionary(x => NuGetFramework.ParseFolder(x.Name), x => x, NuGetFramework.Comparer);
if (!frameworkFolders.Any() && libFolder.GetFiles("*.dll").Any())
{
return(new ResolvedLibraryDirectory(libFolder, framework));
}
var bestFramework =
NuGetFrameworkUtility.GetNearest(frameworkFolders.Select(x => x.Key), framework, x => x);
if (bestFramework != null)
{
return(new ResolvedLibraryDirectory(frameworkFolders[bestFramework], bestFramework));
}
}
var runtimesFolder = new DirectoryInfo(Path.Combine(packageDirectory, "runtimes"));
if (runtimesFolder.Exists)
{
var expectedFolders = GetExpectedRuntimeFolders(runtime, architecture);
var baseFolder = runtimesFolder.GetDirectories().FirstOrDefault(x => expectedFolders.Contains(x.Name));
if (baseFolder != null)
{
libFolder = new DirectoryInfo(Path.Combine(baseFolder.FullName, "lib"));
if (libFolder.Exists)
{
return(ResolveNuGetFolder(baseFolder.FullName, framework, runtime, architecture));
}
}
}
return(null);
}
private IEnumerable <IPackageAssemblyReference> GetAssemblyReferencesCore()
{
var result = new List <PackageAssemblyReference>();
if (Directory.Exists(_installPath))
{
var nupkg = new FileInfo(
Path.Combine(_installPath, Id + "." + Version + PackagingCoreConstants.NupkgExtension));
if (nupkg.Exists)
{
var referenceItems = GetReferenceItems(nupkg);
var files = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(referenceItems,
NuGetFramework.AnyFramework);
if (files != null)
{
result = files.Items.Select(file => new PackageAssemblyReference(file)).ToList();
}
}
}
return(result);
}