public PublishProject( ProjectReferenceDependencyProvider projectReferenceDependencyProvider, IProjectResolver projectResolver, LibraryDescription libraryDescription) { _projectReferenceDependencyProvider = projectReferenceDependencyProvider; _projectResolver = projectResolver; _libraryDescription = libraryDescription; }
private Item Resolve( Dictionary <LibraryRange, Item> resolvedItems, IEnumerable <IDependencyProvider> providers, LibraryRange packageKey, FrameworkName frameworkName) { Item item; if (resolvedItems.TryGetValue(packageKey, out item)) { return(item); } LibraryDescription match = null; foreach (var dependencyProvider in providers) { match = dependencyProvider.GetDescription(packageKey, frameworkName); if (match != null) { break; } } if (match == null) { resolvedItems[packageKey] = null; return(null); } if (resolvedItems.TryGetValue(match.Identity, out item)) { return(item); } item = new Item() { Description = match, Key = match.Identity, Dependencies = match.Dependencies }; resolvedItems[packageKey] = item; resolvedItems[match.Identity] = item; return(item); }
internal static Resolution FromLibrary(LibraryDescription lib) { if (lib.Identity != null) { var url = ""; var commit = ""; var repoFile = Path.Combine(lib.Path, REPO_FILE_NAME); if (File.Exists(repoFile)) { var content = File.ReadAllText(repoFile); var spec = JsonConvert.DeserializeObject<RepoJson>(content); if (spec.Url.Contains("github")) { url = spec.Url; commit = spec.Commit; } } return new Resolution { Raw = new ResolutionIdentity { Name = lib.Identity.Name, Version = lib.Identity.Version.ToString() }, ResolvedTarget = new Target { Unit = lib.Identity.Name, VersionString = lib.Identity.Version.ToString(), RepoCloneURL = url, RevSpec = commit } }; } else { return new Resolution { Raw = new ResolutionIdentity { Name = lib.RequestedRange.Name, Version = lib.RequestedRange.VersionRange.ToString() }, Error = "Dependensy resolution failed" }; } }
private LibraryExport ExportAssemblyLibrary(LibraryDescription library) { if (string.IsNullOrEmpty(library.Path)) { Logger.TraceError($"[{nameof(LibraryExporter)}] Failed to export: {library.Identity.Name}"); return null; } // We assume the path is to an assembly return new LibraryExport(new MetadataFileReference(library.Identity.Name, library.Path)); }
private LibraryExport GetExport(LibraryDescription library, string aspect) { // Don't even try to export unresolved libraries if(!library.Resolved) { return null; } if (string.Equals(LibraryTypes.Package, library.Type, StringComparison.Ordinal)) { return ExportPackage((PackageDescription)library); } else if (string.Equals(LibraryTypes.Project, library.Type, StringComparison.Ordinal)) { return ExportProject((ProjectDescription)library, aspect); } else { return ExportAssemblyLibrary(library); } }
private LibraryExport GetAllExports( LibraryDescription projectLibrary, string aspect, Func<Library, bool> include) { var dependencyStopWatch = Stopwatch.StartNew(); Logger.TraceInformation($"[{nameof(LibraryExporter)}]: Resolving references for '{projectLibrary.Identity.Name}' {aspect}"); var references = new Dictionary<string, IMetadataReference>(StringComparer.OrdinalIgnoreCase); var sourceReferences = new Dictionary<string, ISourceReference>(StringComparer.OrdinalIgnoreCase); // Walk the dependency tree and resolve the library export for all references to this project var queue = new Queue<Node>(); var processed = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var rootNode = new Node { Library = _manager.GetLibrary(projectLibrary.Identity.Name) }; queue.Enqueue(rootNode); while (queue.Count > 0) { var node = queue.Dequeue(); // Skip it if we've already seen it if (!processed.Add(node.Library.Name)) { continue; } if (include(node.Library)) { var libraryExport = GetExport(node.Library.Name); if (libraryExport != null) { if (node.Parent == rootNode) { // Only export sources from first level dependencies ProcessExport(libraryExport, references, sourceReferences); } else { // Skip source exports from anything else ProcessExport(libraryExport, references, sourceReferences: null); } } } foreach (var dependency in node.Library.Dependencies) { var childNode = new Node { Library = _manager.GetLibrary(dependency), Parent = node }; queue.Enqueue(childNode); } } dependencyStopWatch.Stop(); Logger.TraceInformation($"[{nameof(LibraryExporter)}]: Resolved {references.Count} references for '{projectLibrary.Identity.Name}' in {dependencyStopWatch.ElapsedMilliseconds}ms"); return new LibraryExport( references.Values.ToList(), sourceReferences.Values.ToList()); }
private LibraryExport ExportProject(LibraryDescription library, string aspect) { return ProjectExporter.ExportProject( ((ProjectDescription)library).Project, _compilationEngine, aspect, _targetFramework, _configuration); }
private LibraryExport ExportPackage(LibraryDescription library) { var packageLibrary = (PackageDescription)library; var references = new Dictionary<string, IMetadataReference>(StringComparer.OrdinalIgnoreCase); if (!TryPopulateMetadataReferences(packageLibrary, _targetFramework, references)) { return null; } // REVIEW: This requires more design var sourceReferences = new List<ISourceReference>(); foreach (var sharedSource in GetSharedSources(packageLibrary, _targetFramework)) { sourceReferences.Add(new SourceFileReference(sharedSource)); } return new LibraryExport(references.Values.ToList(), sourceReferences); }
private DiagnosticMessage ValidateDependency(LibraryDescription library, HashSet<string> projectCandidates) { if (!library.Resolved || projectCandidates == null) { return null; } var foundCandidate = projectCandidates.Contains(library.Identity.Name); if ((library.Type == LibraryTypes.Project && !foundCandidate) || (library.Type == LibraryTypes.Package && foundCandidate)) { library.Resolved = false; library.Type = LibraryTypes.Unresolved; return new DiagnosticMessage( DiagnosticMonikers.NU1010, $"The type of dependency {library.Identity.Name} was changed.", library.RequestedRange.FileName, DiagnosticMessageSeverity.Error, library.RequestedRange.Line, library.RequestedRange.Column, library); } return null; }
private static DependencyDescription CreateDependencyDescription(LibraryDescription library, IEnumerable<DiagnosticMessage> diagnostics, int protocolVersion) { var result = new DependencyDescription { Name = library.Identity.Name, DisplayName = library.Identity.IsGacOrFrameworkReference ? library.RequestedRange.GetReferenceAssemblyName() : library.Identity.Name, Version = library.Identity.Version?.ToString(), Type = library.Type, Resolved = library.Resolved, Path = library.Path, Dependencies = library.Dependencies.Select(dependency => new DependencyItem { Name = dependency.Name, Version = dependency.Library?.Identity?.Version?.ToString() }), Errors = diagnostics.Where(d => d.Severity == DiagnosticMessageSeverity.Error) .Select(d => new DiagnosticMessageView(d)), Warnings = diagnostics.Where(d => d.Severity == DiagnosticMessageSeverity.Warning) .Select(d => new DiagnosticMessageView(d)) }; if (protocolVersion < 3 && !library.Resolved) { result.Type = "Unresolved"; } return result; }
private static LibraryDependency CreateDependency(LibraryDescription libraryDescription) { return new LibraryDependency { LibraryRange = new LibraryRange(libraryDescription.Identity.Name, libraryDescription.Identity.IsGacOrFrameworkReference) { VersionRange = new SemanticVersionRange(libraryDescription.Identity.Version) } }; }
public PublishPackage(LibraryDescription libraryDescription) { _libraryDescription = libraryDescription; }