public PackageDescription GetDescription(LockFilePackageLibrary package, LockFileTargetLibrary targetLibrary)
{
// If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with
// current target framework, we should mark this dependency as unresolved
var containsAssembly = package.Files
.Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") ||
x.StartsWith($"lib{Path.DirectorySeparatorChar}"));
var compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any() ||
!containsAssembly;
var resolved = compatible;
var dependencies = new List <LibraryDependency>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary);
var packageDescription = new PackageDescription(
new LibraryRange(package.Name, frameworkReference: false)
{
VersionRange = new SemanticVersionRange(package.Version)
},
package,
targetLibrary,
dependencies,
resolved,
compatible);
Initialize(packageDescription);
return(packageDescription);
}
private void Initialize(PackageDescription package)
{
string packagePath = ResolvePackagePath(package);
// If the package path doesn't exist then mark this dependency as unresolved
if (!Directory.Exists(packagePath))
{
package.Resolved = false;
}
package.Path = packagePath;
var assemblies = new List <string>();
foreach (var runtimeAssemblyPath in package.Target.RuntimeAssemblies)
{
if (IsPlaceholderFile(runtimeAssemblyPath))
{
continue;
}
var name = Path.GetFileNameWithoutExtension(runtimeAssemblyPath);
assemblies.Add(name);
}
package.Assemblies = assemblies;
}
private string ResolvePackagePath(PackageDescription package)
{
string expectedHash = package.Library.Sha512;
foreach (var resolver in _cacheResolvers)
{
var cacheHashFile = resolver.GetHashPath(package.Identity.Name, package.Identity.Version);
// REVIEW: More efficient compare?
if (File.Exists(cacheHashFile) &&
File.ReadAllText(cacheHashFile) == expectedHash)
{
return(resolver.GetInstallPath(package.Identity.Name, package.Identity.Version));
}
}
return(_packagePathResolver.GetInstallPath(package.Identity.Name, package.Identity.Version));
}
private void Initialize(PackageDescription package)
{
package.Path = ResolvePackagePath(package);
var assemblies = new List <string>();
foreach (var runtimeAssemblyPath in package.Target.RuntimeAssemblies)
{
if (IsPlaceholderFile(runtimeAssemblyPath))
{
continue;
}
var name = Path.GetFileNameWithoutExtension(runtimeAssemblyPath);
assemblies.Add(name);
}
package.Assemblies = assemblies;
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
LockFileTargetLibrary targetLibrary = _lockFileLookup.GetTargetLibrary(targetFramework, libraryRange.Name);
if (targetLibrary != null)
{
var package = _lockFileLookup.GetPackage(targetLibrary.Name, targetLibrary.Version);
Debug.Assert(package != null);
// If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with
// current target framework, we should mark this dependency as unresolved
var containsAssembly = package.Files
.Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") ||
x.StartsWith($"lib{Path.DirectorySeparatorChar}"));
var compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any() ||
!containsAssembly;
var resolved = compatible;
var packageDescription = new PackageDescription(
libraryRange,
package,
targetLibrary,
GetDependencies(targetLibrary),
resolved,
compatible);
Initialize(packageDescription);
return(packageDescription);
}
return(null);
}
private bool TryPopulateMetadataReferences(PackageDescription library, FrameworkName targetFramework, IDictionary<string, IMetadataReference> paths)
{
foreach (var assemblyPath in library.LockFileLibrary.CompileTimeAssemblies)
{
if (NuGetDependencyResolver.IsPlaceholderFile(assemblyPath))
{
continue;
}
var name = Path.GetFileNameWithoutExtension(assemblyPath);
var path = Path.Combine(library.Path, assemblyPath);
paths[name] = new MetadataFileReference(name, path);
}
return true;
}
private IEnumerable<string> GetSharedSources(PackageDescription library, FrameworkName targetFramework)
{
var directory = Path.Combine(library.Path, "shared");
return library
.Package
.LockFileLibrary
.Files
.Where(path => path.StartsWith("shared" + Path.DirectorySeparatorChar))
.Select(path => Path.Combine(library.Path, path));
}
public PublishPackage(PackageDescription package)
{
_package = package;
}
private void PopulateMetadataReferences(PackageDescription package, IDictionary<string, IMetadataReference> paths)
{
foreach (var assemblyPath in package.Target.CompileTimeAssemblies)
{
if (PackageDependencyProvider.IsPlaceholderFile(assemblyPath))
{
continue;
}
var name = Path.GetFileNameWithoutExtension(assemblyPath);
var path = Path.Combine(package.Path, assemblyPath);
paths[name] = new MetadataFileReference(name, path);
}
}
private IEnumerable<string> GetSharedSources(PackageDescription package)
{
var directory = Path.Combine(package.Path, "shared");
return package
.Library
.Files
.Where(path => path.StartsWith("shared" + Path.DirectorySeparatorChar))
.Select(path => Path.Combine(package.Path, path));
}
private LibraryExport ExportPackage(PackageDescription package)
{
var references = new Dictionary<string, IMetadataReference>(StringComparer.OrdinalIgnoreCase);
PopulateMetadataReferences(package, references);
var sourceReferences = new List<ISourceReference>();
foreach (var sharedSource in GetSharedSources(package))
{
sourceReferences.Add(new SourceFileReference(sharedSource));
}
return new LibraryExport(references.Values.ToList(), sourceReferences);
}
