/// <summary>
/// Apply standard properties in a property group.
/// Additionally add a SourceRoot item to point to the package folders.
/// </summary>
public static void AddNuGetProperties(
XDocument doc,
IEnumerable <string> packageFolders,
string repositoryRoot,
ProjectStyle projectStyle,
string assetsFilePath,
bool success)
{
doc.Root.AddFirst(
new XElement(Namespace + "PropertyGroup",
new XAttribute("Condition", ExcludeAllCondition),
GenerateProperty("RestoreSuccess", success.ToString()),
GenerateProperty("RestoreTool", "NuGet"),
GenerateProperty("ProjectAssetsFile", assetsFilePath),
GenerateProperty("NuGetPackageRoot", ReplacePathsWithMacros(repositoryRoot)),
GenerateProperty("NuGetPackageFolders", string.Join(";", packageFolders)),
GenerateProperty("NuGetProjectStyle", projectStyle.ToString()),
GenerateProperty("NuGetToolVersion", MinClientVersionUtility.GetNuGetClientVersion().ToFullString())),
new XElement(Namespace + "ItemGroup",
new XAttribute("Condition", ExcludeAllCondition),
packageFolders.Select(e => GenerateItem("SourceRoot", PathUtility.EnsureTrailingSlash(e)))));
}
private static string ResolvePath(IPackageFile packageFile, string basePath)
{
var physicalPackageFile = packageFile as PhysicalPackageFile;
// For PhysicalPackageFiles, we want to filter by SourcePaths, the path on disk. The Path value maps to the TargetPath
if (physicalPackageFile == null)
{
return(packageFile.Path);
}
var path = physicalPackageFile.SourcePath;
// Make sure that the basepath has a directory separator
int index = path.IndexOf(PathUtility.EnsureTrailingSlash(basePath), StringComparison.OrdinalIgnoreCase);
if (index != -1)
{
// Since wildcards are going to be relative to the base path, remove the BasePath portion of the file's source path.
// Also remove any leading path separator slashes
path = path.Substring(index + basePath.Length).TrimStart(Path.DirectorySeparatorChar);
}
return(path);
}
/// <summary>
/// Create a library for a project.
/// </summary>
public static LockFileTargetLibrary CreateLockFileTargetProject(
GraphItem <RemoteResolveResult> graphItem,
LibraryIdentity library,
LibraryIncludeFlags dependencyType,
RestoreTargetGraph targetGraph,
ProjectStyle rootProjectStyle)
{
var localMatch = (LocalMatch)graphItem.Data.Match;
// Target framework information is optional and may not exist for csproj projects
// that do not have a project.json file.
string projectFramework = null;
object frameworkInfoObject;
if (localMatch.LocalLibrary.Items.TryGetValue(
KnownLibraryProperties.TargetFrameworkInformation,
out frameworkInfoObject))
{
// Retrieve the resolved framework name, if this is null it means that the
// project is incompatible. This is marked as Unsupported.
var targetFrameworkInformation = (TargetFrameworkInformation)frameworkInfoObject;
projectFramework = targetFrameworkInformation.FrameworkName?.DotNetFrameworkName
?? NuGetFramework.UnsupportedFramework.DotNetFrameworkName;
}
// Create the target entry
var projectLib = new LockFileTargetLibrary()
{
Name = library.Name,
Version = library.Version,
Type = LibraryType.Project,
Framework = projectFramework,
// Find all dependencies which would be in the nuspec
// Include dependencies with no constraints, or package/project/external
// Exclude suppressed dependencies, the top level project is not written
// as a target so the node depth does not matter.
Dependencies = graphItem.Data.Dependencies
.Where(
d => (d.LibraryRange.TypeConstraintAllowsAnyOf(
LibraryDependencyTarget.PackageProjectExternal)) &&
d.SuppressParent != LibraryIncludeFlags.All)
.Select(d => GetDependencyVersionRange(d))
.ToList()
};
if (rootProjectStyle == ProjectStyle.PackageReference)
{
// Add files under asset groups
object filesObject;
object msbuildPath;
if (localMatch.LocalLibrary.Items.TryGetValue(KnownLibraryProperties.MSBuildProjectPath, out msbuildPath))
{
var files = new List <ProjectRestoreMetadataFile>();
var fileLookup = new Dictionary <string, ProjectRestoreMetadataFile>(StringComparer.OrdinalIgnoreCase);
// Find the project path, this is provided by the resolver
var msbuildFilePathInfo = new FileInfo((string)msbuildPath);
// Ensure a trailing slash for the relative path helper.
var projectDir = PathUtility.EnsureTrailingSlash(msbuildFilePathInfo.Directory.FullName);
// Read files from the project if they were provided.
if (localMatch.LocalLibrary.Items.TryGetValue(KnownLibraryProperties.ProjectRestoreMetadataFiles, out filesObject))
{
files.AddRange((List <ProjectRestoreMetadataFile>)filesObject);
}
var targetFrameworkShortName = targetGraph.Framework.GetShortFolderName();
var libAnyPath = $"lib/{targetFrameworkShortName}/any.dll";
if (files.Count == 0)
{
// If the project did not provide a list of assets, add in default ones.
// These are used to detect transitive vs non-transitive project references.
var absolutePath = Path.Combine(projectDir, "bin", "placeholder", $"{localMatch.Library.Name}.dll");
files.Add(new ProjectRestoreMetadataFile(libAnyPath, absolutePath));
}
// Process and de-dupe files
for (var i = 0; i < files.Count; i++)
{
var path = files[i].PackagePath;
// LIBANY avoid compatibility checks and will always be used.
if (LIBANY.Equals(path, StringComparison.Ordinal))
{
path = libAnyPath;
}
if (!fileLookup.ContainsKey(path))
{
fileLookup.Add(path, files[i]);
}
}
var contentItems = new ContentItemCollection();
contentItems.Load(fileLookup.Keys);
// Create an ordered list of selection criteria. Each will be applied, if the result is empty
// fallback frameworks from "imports" will be tried.
// These are only used for framework/RID combinations where content model handles everything.
var orderedCriteria = CreateCriteria(targetGraph, targetGraph.Framework);
// Compile
// ref takes precedence over lib
var compileGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.CompileRefAssemblies,
targetGraph.Conventions.Patterns.CompileLibAssemblies);
projectLib.CompileTimeAssemblies.AddRange(
ConvertToProjectPaths(fileLookup, projectDir, compileGroup));
// Runtime
var runtimeGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.RuntimeAssemblies);
projectLib.RuntimeAssemblies.AddRange(
ConvertToProjectPaths(fileLookup, projectDir, runtimeGroup));
}
}
// Add frameworkAssemblies for projects
object frameworkAssembliesObject;
if (localMatch.LocalLibrary.Items.TryGetValue(
KnownLibraryProperties.FrameworkAssemblies,
out frameworkAssembliesObject))
{
projectLib.FrameworkAssemblies.AddRange((List <string>)frameworkAssembliesObject);
}
// Exclude items
ExcludeItems(projectLib, dependencyType);
return(projectLib);
}