private string ResolveFilePath(string relativePath, string resolvedPackagePath) { if (NuGetUtils.IsPlaceholderFile(relativePath)) { return(null); } relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar); relativePath = relativePath.Replace('\\', Path.DirectorySeparatorChar); return(resolvedPackagePath != null ? Path.Combine(resolvedPackagePath, relativePath) : string.Empty); }
private void GetFileDependencies(LockFileTargetLibrary package, string targetName) { string packageId = $"{package.Name}/{package.Version.ToNormalizedString()}"; string frameworkAlias = _targetNameToAliasMap[targetName]; // for each type of file group foreach (var fileGroup in (FileGroup[])Enum.GetValues(typeof(FileGroup))) { var filePathList = fileGroup.GetFilePathAndProperties(package); foreach (var entry in filePathList) { string filePath = entry.Item1; IDictionary <string, string> properties = entry.Item2; if (NuGetUtils.IsPlaceholderFile(filePath) || !EmitLegacyAssetsFileItems) { continue; } var fileKey = $"{packageId}/{filePath}"; var item = new TaskItem(fileKey); item.SetMetadata(MetadataKeys.FileGroup, fileGroup.ToString()); item.SetMetadata(MetadataKeys.ParentTarget, frameworkAlias); // Foreign Key item.SetMetadata(MetadataKeys.ParentPackage, packageId); // Foreign Key if (fileGroup == FileGroup.FrameworkAssembly) { // NOTE: the path provided for framework assemblies is the name of the framework reference item.SetMetadata("FrameworkAssembly", filePath); item.SetMetadata(MetadataKeys.NuGetPackageId, package.Name); item.SetMetadata(MetadataKeys.NuGetPackageVersion, package.Version.ToNormalizedString()); } foreach (var property in properties) { item.SetMetadata(property.Key, property.Value); } _fileDependencies.Add(item); // map each file key to a Type metadata value SaveFileKeyType(fileKey, fileGroup); } } }
private void GetFileDependencies(LockFileTargetLibrary package, string targetName) { string packageId = $"{package.Name}/{package.Version.ToNormalizedString()}"; TaskItem item; // for each type of file group foreach (var fileGroup in (FileGroup[])Enum.GetValues(typeof(FileGroup))) { var filePathList = fileGroup.GetFilePathAndProperties(package); foreach (var entry in filePathList) { string filePath = entry.Item1; IDictionary <string, string> properties = entry.Item2; if (NuGetUtils.IsPlaceholderFile(filePath)) { continue; } var fileKey = $"{packageId}/{filePath}"; item = new TaskItem(fileKey); item.SetMetadata(MetadataKeys.FileGroup, fileGroup.ToString()); item.SetMetadata(MetadataKeys.ParentTarget, targetName); // Foreign Key item.SetMetadata(MetadataKeys.ParentPackage, packageId); // Foreign Key foreach (var property in properties) { item.SetMetadata(property.Key, property.Value); } _fileDependencies.Add(item); // map each file key to a Type metadata value SaveFileKeyType(fileKey, fileGroup); } } }
// get library and file definitions private void GetPackageAndFileDefinitions() { TaskItem item; foreach (var package in LockFile.Libraries) { string packageId = $"{package.Name}/{package.Version.ToNormalizedString()}"; item = new TaskItem(packageId); item.SetMetadata(MetadataKeys.Name, package.Name); item.SetMetadata(MetadataKeys.Type, package.Type); item.SetMetadata(MetadataKeys.Version, package.Version.ToNormalizedString()); item.SetMetadata(MetadataKeys.Path, package.Path ?? string.Empty); string resolvedPackagePath = ResolvePackagePath(package); item.SetMetadata(MetadataKeys.ResolvedPath, resolvedPackagePath ?? string.Empty); _packageDefinitions.Add(item); foreach (var file in package.Files) { if (NuGetUtils.IsPlaceholderFile(file)) { continue; } var fileKey = $"{packageId}/{file}"; var fileItem = new TaskItem(fileKey); fileItem.SetMetadata(MetadataKeys.Path, file); string resolvedPath = ResolveFilePath(file, resolvedPackagePath); fileItem.SetMetadata(MetadataKeys.ResolvedPath, resolvedPath ?? string.Empty); if (IsAnalyzer(file)) { fileItem.SetMetadata(MetadataKeys.Analyzer, "true"); fileItem.SetMetadata(MetadataKeys.Type, "AnalyzerAssembly"); // get targets that contain this package var parentTargets = LockFile.Targets .Where(t => t.Libraries.Any(lib => lib.Name == package.Name)); foreach (var target in parentTargets) { var fileDepsItem = new TaskItem(fileKey); fileDepsItem.SetMetadata(MetadataKeys.ParentTarget, target.Name); // Foreign Key fileDepsItem.SetMetadata(MetadataKeys.ParentPackage, packageId); // Foreign Key _fileDependencies.Add(fileDepsItem); } } else { // get a type for the file if one is available string fileType; if (!_fileTypes.TryGetValue(fileKey, out fileType)) { fileType = "unknown"; } fileItem.SetMetadata(MetadataKeys.Type, fileType); } _fileDefinitions.Add(fileItem); } } }
// get library and file definitions private void GetPackageAndFileDefinitions() { foreach (var package in LockFile.Libraries) { var packageName = package.Name; var packageVersion = package.Version.ToNormalizedString(); string packageId = $"{packageName}/{packageVersion}"; var item = new TaskItem(packageId); item.SetMetadata(MetadataKeys.Name, packageName); item.SetMetadata(MetadataKeys.Type, package.Type); item.SetMetadata(MetadataKeys.Version, packageVersion); item.SetMetadata(MetadataKeys.Path, package.Path ?? string.Empty); string resolvedPackagePath = ResolvePackagePath(package); item.SetMetadata(MetadataKeys.ResolvedPath, resolvedPackagePath ?? string.Empty); item.SetMetadata(MetadataKeys.DiagnosticLevel, GetPackageDiagnosticLevel(package)); _packageDefinitions.Add(item); if (!EmitLegacyAssetsFileItems) { continue; } foreach (var file in package.Files) { if (NuGetUtils.IsPlaceholderFile(file)) { continue; } var fileKey = $"{packageId}/{file}"; var fileItem = new TaskItem(fileKey); fileItem.SetMetadata(MetadataKeys.Path, file); fileItem.SetMetadata(MetadataKeys.NuGetPackageId, packageName); fileItem.SetMetadata(MetadataKeys.NuGetPackageVersion, packageVersion); string resolvedPath = ResolveFilePath(file, resolvedPackagePath); fileItem.SetMetadata(MetadataKeys.ResolvedPath, resolvedPath ?? string.Empty); if (NuGetUtils.IsApplicableAnalyzer(file, ProjectLanguage)) { fileItem.SetMetadata(MetadataKeys.Analyzer, "true"); fileItem.SetMetadata(MetadataKeys.Type, "AnalyzerAssembly"); // get targets that contain this package var parentTargets = LockFile.Targets .Where(t => t.Libraries.Any(lib => lib.Name == package.Name)); foreach (var target in parentTargets) { string frameworkAlias = _targetNameToAliasMap[target.Name]; var fileDepsItem = new TaskItem(fileKey); fileDepsItem.SetMetadata(MetadataKeys.ParentTarget, frameworkAlias); // Foreign Key fileDepsItem.SetMetadata(MetadataKeys.ParentPackage, packageId); // Foreign Key _fileDependencies.Add(fileDepsItem); } } else { // get a type for the file if one is available if (!_fileTypes.TryGetValue(fileKey, out string fileType)) { fileType = "unknown"; } fileItem.SetMetadata(MetadataKeys.Type, fileType); } _fileDefinitions.Add(fileItem); } } string GetPackageDiagnosticLevel(LockFileLibrary package) { string target = TargetFramework ?? ""; var messages = LockFile.LogMessages.Where(log => log.LibraryId == package.Name && log.TargetGraphs .Select(tg => { var parsedTargetGraph = NuGetFramework.Parse(tg); var alias = _lockFile.PackageSpec.TargetFrameworks.FirstOrDefault(tf => tf.FrameworkName == parsedTargetGraph)?.TargetAlias; return(alias ?? tg); }).Contains(target)); if (!messages.Any()) { return(string.Empty); } return(messages.Max(log => log.Level).ToString()); } }
public static bool IsPlaceholderFile(this LockFileItem item) => NuGetUtils.IsPlaceholderFile(item.Path);
private void ProcessContentFileInputs() { var preprocessorValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); // If a preprocessor directory isn't set, then we won't have a place to generate. if (!string.IsNullOrEmpty(ContentPreprocessorOutputDirectory)) { // Assemble the preprocessor values up-front var duplicatedPreprocessorKeys = new HashSet <string>(StringComparer.OrdinalIgnoreCase); foreach (var preprocessorValueItem in ContentPreprocessorValues ?? Enumerable.Empty <ITaskItem>()) { if (preprocessorValues.ContainsKey(preprocessorValueItem.ItemSpec)) { duplicatedPreprocessorKeys.Add(preprocessorValueItem.ItemSpec); } preprocessorValues[preprocessorValueItem.ItemSpec] = preprocessorValueItem.GetMetadata("Value"); } foreach (var duplicatedPreprocessorKey in duplicatedPreprocessorKeys) { Log.LogWarning(Strings.DuplicatePreprocessorToken, duplicatedPreprocessorKey, preprocessorValues[duplicatedPreprocessorKey]); } AssetPreprocessor.ConfigurePreprocessor(ContentPreprocessorOutputDirectory, preprocessorValues); } var contentFileDeps = ContentFileDependencies ?? Enumerable.Empty <ITaskItem>(); var contentFileGroups = contentFileDeps.GroupBy(t => t.GetMetadata(MetadataKeys.ParentPackage)); foreach (var grouping in contentFileGroups) { // Is there an asset with our exact language? If so, we use that. Otherwise we'll simply collect "any" assets. string codeLanguageToSelect; if (string.IsNullOrEmpty(ProjectLanguage)) { codeLanguageToSelect = "any"; } else { string projectLanguage = NuGetUtils.GetLockFileLanguageName(ProjectLanguage); if (grouping.Any(t => t.GetMetadata("codeLanguage") == projectLanguage)) { codeLanguageToSelect = projectLanguage; } else { codeLanguageToSelect = "any"; } } foreach (var contentFile in grouping) { // Ignore magic _._ placeholder files. We couldn't ignore them during the project language // selection, since you could imagine somebody might have a package that puts assets under // "any" but then uses _._ to opt some languages out of it if (NuGetUtils.IsPlaceholderFile(contentFile.ItemSpec)) { continue; } if (contentFile.GetMetadata("codeLanguage") == codeLanguageToSelect) { ProduceContentAsset(contentFile); } } } }
// A package is a TransitiveProjectReference if it is a project, is not directly referenced, // and does not contain a placeholder compile time assembly private bool IsTransitiveProjectReference(LockFileTargetLibrary package) => string.Equals(package.Type, ProjectTypeKey, StringComparison.OrdinalIgnoreCase) && !_projectFileDependencies.Contains(package.Name) && package.CompileTimeAssemblies.FirstOrDefault(f => NuGetUtils.IsPlaceholderFile(f.Path)) == null;