public void BuildTargetFrameworkGetsSourceFiles() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log); // When IReadOnlyList <string> sourceFiles = analyzer.Build("net462").GetSourceFiles(); // Then sourceFiles.ShouldNotBeNull(log.ToString()); sourceFiles.Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[] { "Class1", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); // When log.GetStringBuilder().Clear(); sourceFiles = analyzer.Build("netstandard2.0").GetSourceFiles(); // Then sourceFiles.ShouldNotBeNull(log.ToString()); sourceFiles.Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[] { "Class2", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); }
public void CompilesProject(EnvironmentPreference preference, string solutionPath, string projectPath) { // Given StringWriter log = new StringWriter(); AnalyzerManager manager = new AnalyzerManager(solutionPath, new AnalyzerManagerOptions { LogWriter = log }); ProjectAnalyzer analyzer = manager.GetProject(projectPath); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // Set some enviornment variables to make it seem like we're not in a CI build // Sometimes this messes up libraries like SourceLink since we're building as part of a test and not for CI options.EnvironmentVariables.Add("APPVEYOR", "False"); options.EnvironmentVariables.Add("ContinuousIntegrationBuild", null); options.EnvironmentVariables.Add("CI", "False"); options.EnvironmentVariables.Add("CI_LINUX", "False"); options.EnvironmentVariables.Add("CI_WINDOWS", "False"); // When DeleteProjectDirectory(analyzer.ProjectFile.Path, "obj"); DeleteProjectDirectory(analyzer.ProjectFile.Path, "bin"); analyzer.IgnoreFaultyImports = false; #pragma warning disable 0162 if (BinaryLog) { analyzer.AddBinaryLogger($@"E:\Temp\{Path.GetFileNameWithoutExtension(solutionPath)}.{Path.GetFileNameWithoutExtension(analyzer.ProjectFile.Path)}.core.binlog"); } #pragma warning restore 0162 #if Is_Windows AnalyzerResults results = analyzer.Build(options); #else // On non-Windows platforms we have to remove the .NET Framework target frameworks and only build .NET Core target frameworks // See https://github.com/dotnet/sdk/issues/826 string[] excludedTargetFrameworks = new[] { "net2", "net3", "net4", "portable" }; string[] targetFrameworks = analyzer.ProjectFile.TargetFrameworks.Where(x => !excludedTargetFrameworks.Any(y => x.StartsWith(y))).ToArray(); if (targetFrameworks.Length == 0) { Assert.Ignore(); } AnalyzerResults results = analyzer.Build(targetFrameworks, options); #endif // Then results.Count.ShouldBeGreaterThan(0, log.ToString()); results.OverallSuccess.ShouldBeTrue(log.ToString()); results.ShouldAllBe(x => x.Succeeded, log.ToString()); }
public void GetsSourceFiles( [ValueSource(nameof(Preferences))] EnvironmentPreference preference, [ValueSource(nameof(ProjectFiles))] string projectFile) { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When IReadOnlyList <string> sourceFiles = analyzer.Build(options).First().SourceFiles; // Then sourceFiles.ShouldNotBeNull(log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); }
private IEnumerable <PackageReferenceInfo> LoadPackageReferences(ProjectAnalyzer projectAnalyzer) { AnalyzerResults project = projectAnalyzer.Build(); var packageReferenceInfo = new List <PackageReferenceInfo>(); var packagesRootFolder = GetPackagesRootFolder(); foreach (var result in project.Results) { packageReferenceInfo.AddRange(result.PackageReferences.Select(packageReference => { var packageId = packageReference.Key; var version = packageReference.Value.First().Value; var packageFolderPath = Path.Combine(packagesRootFolder, packageId.ToLower(), version.ToLower()); return(new PackageReferenceInfo( packageId, version, rootFolderPath: packageFolderPath, libSubfolderPath: "lib")); })); } return(packageReferenceInfo); }
public static MetadataReference[] GetMetadataReferencesFromSolution(FileInfo solution) { List <MetadataReference> ret = new List <MetadataReference>(); //We are using Buildalyzer because it is xplat AnalyzerManager manager = new AnalyzerManager(solution.FullName); foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects) { ProjectAnalyzer analyzer = proj.Value; analyzer.IgnoreFaultyImports = true; if (analyzer.ProjectFile.RequiresNetFramework) { throw new Exception( ".NET Framework Solutions not supported. Please use a .NET Core Solution instead."); } AnalyzerResults results = analyzer.Build(); foreach (string filePath in results.SelectMany(s => s.References))//TODO - are these all references? Research needed { if (!File.Exists(filePath)) { Log.Warn("Library {0} is missing. Did you restore the Solution libraries?"); } ret.Add(MetadataReference.CreateFromFile(filePath)); } } return(ret.ToArray()); }
public void MultiTargetingBuildAllTargetFrameworksGetsSourceFiles() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log); // When AnalyzerResults results = analyzer.Build(); // Then results.Count.ShouldBe(2); results.TargetFrameworks.ShouldBe(new[] { "net462", "netstandard2.0" }, true, log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(results["net462"].SourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class2", "AssemblyInfo" }.ShouldBeSubsetOf(results["netstandard2.0"].SourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); }
public static FileInfo[] GetSourcesFromSolution(FileInfo solution) { List <FileInfo> ret = new List <FileInfo>(); //We are using Buildalyzer because it is xplat AnalyzerManager manager = new AnalyzerManager(solution.FullName); foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects) { ProjectAnalyzer analyzer = proj.Value; analyzer.IgnoreFaultyImports = true; if (analyzer.ProjectFile.RequiresNetFramework) { throw new Exception( ".NET Framework Solutions not supported. Please use a .NET Core Solution instead."); } AnalyzerResults results = analyzer.Build(); foreach (string filePath in results.SelectMany(s => s.SourceFiles)) { if (!File.Exists(filePath)) { Log.Warn("Source file {0} is missing."); } ret.Add(new FileInfo(filePath)); } } return(ret.ToArray()); }
public void MultiTargetingBuildAllTargetFrameworksGetsSourceFiles() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log); // When AnalyzerResults results = analyzer.Build(); // Then results.Count.ShouldBe(2); results.TargetFrameworks.ShouldBe(new[] { "net462", "netstandard2.0" }, true, log.ToString()); results["net462"].GetSourceFiles().Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[] { "Class1", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); results["netstandard2.0"].GetSourceFiles().Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[] { "Class2", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); }
public IEnumerable <FileInfo> GetSources(FileInfo solution) { List <FileInfo> ret = new List <FileInfo>(); AnalyzerManager manager = new AnalyzerManager(solution.FullName); foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects) { ProjectAnalyzer analyzer = proj.Value; analyzer.IgnoreFaultyImports = true; if (analyzer.ProjectFile.RequiresNetFramework) { throw new Exception( ".NET Framework Solutions not supported. Please use a .NET Core Solution instead."); } AnalyzerResults results = analyzer.Build(); foreach (string filePath in results.SelectMany(s => s.SourceFiles)) { if (!File.Exists(filePath)) { throw new Exception($"Source file {filePath} is missing!"); } ret.Add(new FileInfo(filePath)); } } return(ret); }
private static void RunDotNetCommand(string text, StringBuilder outputBuffer, StringBuilder errorBuffer) { if (!text.StartsWith("dotnet ")) { throw new ArgumentException("Unexpected dotnet command: " + text, nameof(text)); } using (Process dotnet = new Process()) { dotnet.StartInfo.FileName = "dotnet"; dotnet.StartInfo.Arguments = text.Substring("dotnet ".Length); dotnet.StartInfo.UseShellExecute = false; dotnet.StartInfo.CreateNoWindow = true; dotnet.StartInfo.RedirectStandardOutput = true; dotnet.StartInfo.RedirectStandardError = true; dotnet.OutputDataReceived += (sender, args) => outputBuffer.AppendLine(args.Data); dotnet.ErrorDataReceived += (sender, args) => errorBuffer.AppendLine(args.Data); dotnet.Start(); dotnet.BeginOutputReadLine(); dotnet.BeginErrorReadLine(); dotnet.WaitForExit(); dotnet.CancelOutputRead(); dotnet.CancelErrorRead(); } AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(@"C:\Users\wafuqua\.replay\ReplaySession20190302153809\Session\Session.csproj"); var result = analyzer.Build(); ; }
private IReadOnlyCollection <MetadataReference> ReadProjectReferences(string name) { return(analyzer.Build() .Results.Single() .References.Where(reference => reference.Contains(name)) .Select(file => MetadataReference.CreateFromFile(file)) .ToArray()); }
protected internal static AnalyzerResult CompileProjectAndTrace(ProjectAnalyzer analyzer, StringWriter log) { log.GetStringBuilder().Clear(); AnalyzerResult result = analyzer.Build(); if (result.OverallSuccess == false) { Trace.Error($"Could not compile project at {analyzer.ProjectFile.Path}"); Trace.Warning(log.ToString()); return(null); } return(result); }
/// <summary> /// Adds a project to an existing Roslyn workspace. Note that this will rebuild the project. Use an <see cref="AnalyzerResult"/> instead if you already have one available. /// </summary> /// <param name="analyzer">The Buildalyzer project analyzer.</param> /// <param name="workspace">A Roslyn workspace.</param> /// <param name="addProjectReferences"> /// <c>true</c> to add projects to the workspace for project references that exist in the same <see cref="AnalyzerManager"/>. /// If <c>true</c> this will trigger (re)building all referenced projects. Directly add <see cref="AnalyzerResult"/> instances instead if you already have them available. /// </param> /// <returns>The newly added Roslyn project.</returns> public static Project AddToWorkspace(this ProjectAnalyzer analyzer, Workspace workspace, bool addProjectReferences = false) { if (analyzer == null) { throw new ArgumentNullException(nameof(analyzer)); } if (workspace == null) { throw new ArgumentNullException(nameof(workspace)); } return(analyzer.Build().FirstOrDefault().AddToWorkspace(workspace, addProjectReferences)); }
public void LegacyFrameworkProjectWithPackageReferenceGetsReferences() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"LegacyFrameworkProjectWithPackageReference\LegacyFrameworkProjectWithPackageReference.csproj", log); // When IReadOnlyList <string> references = analyzer.Build().First().GetReferences(); // Then references.ShouldNotBeNull(log.ToString()); references.ShouldContain(x => x.EndsWith("NodaTime.dll"), log.ToString()); }
public void SdkProjectWithProjectReferenceGetsReferences() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkNetCoreProjectWithReference\SdkNetCoreProjectWithReference.csproj", log); // When IReadOnlyList <string> references = analyzer.Build().First().GetProjectReferences(); // Then references.ShouldNotBeNull(log.ToString()); references.ShouldContain(x => x.EndsWith("SdkNetStandardProjectWithPackageReference.csproj"), log.ToString()); references.ShouldContain(x => x.EndsWith("SdkNetStandardProject.csproj"), log.ToString()); }
public void BuildsFSharpProject() { // Given const string projectFile = @"FSharpProject\FSharpProject.fsproj"; StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); // When DeleteProjectDirectory(projectFile, "obj"); DeleteProjectDirectory(projectFile, "bin"); AnalyzerResults results = analyzer.Build(); // Then results.Count.ShouldBeGreaterThan(0, log.ToString()); results.OverallSuccess.ShouldBeTrue(log.ToString()); results.ShouldAllBe(x => x.Succeeded, log.ToString()); }
public void MultiTargetingBuildCoreTargetFrameworkGetsSourceFiles() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log); // When IReadOnlyList <string> sourceFiles = analyzer.Build("netstandard2.0").First().SourceFiles; // Then sourceFiles.ShouldNotBeNull(log.ToString()); new[] { "Class2", "AssemblyAttributes", "AssemblyInfo" }.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); }
public void GetsProjectGuidFromSolution([ValueSource(nameof(Preferences))] EnvironmentPreference preference) { // Given AnalyzerManager manager = new AnalyzerManager( GetProjectPath("TestProjects.sln")); ProjectAnalyzer analyzer = manager.Projects.First(x => x.Key.EndsWith("SdkNetStandardProject.csproj")).Value; EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When DeleteProjectDirectory(analyzer.ProjectFile.Path, "obj"); DeleteProjectDirectory(analyzer.ProjectFile.Path, "bin"); AnalyzerResults results = analyzer.Build(options); // Then results.First().ProjectGuid.ToString().ShouldBe("016713d9-b665-4272-9980-148801a9b88f"); }
protected internal static AnalyzerResult CompileProjectAndTrace(ProjectAnalyzer analyzer, StringWriter log) { log.GetStringBuilder().Clear(); Common.Tracing.Trace.Verbose($"Building project {analyzer.ProjectFile.Path}"); Stopwatch sw = new Stopwatch(); sw.Start(); AnalyzerResult result = analyzer.Build().FirstOrDefault(); sw.Stop(); Common.Tracing.Trace.Verbose($"Project {analyzer.ProjectFile.Path} built in {sw.ElapsedMilliseconds} ms"); if (result == null || !result.Succeeded) { Common.Tracing.Trace.Error($"Could not compile project at {analyzer.ProjectFile.Path}"); Common.Tracing.Trace.Warning(log.ToString()); return(null); } return(result); }
protected internal static AnalyzerResult CompileProject(IExecutionContext context, ProjectAnalyzer analyzer, StringWriter log) { log.GetStringBuilder().Clear(); context.LogDebug($"Building project {analyzer.ProjectFile.Path}"); Stopwatch sw = new Stopwatch(); sw.Start(); AnalyzerResult result = analyzer.Build().FirstOrDefault(); sw.Stop(); context.LogDebug($"Project {analyzer.ProjectFile.Path} built in {sw.ElapsedMilliseconds} ms"); if (result?.Succeeded != true) { context.LogError($"Could not compile project at {analyzer.ProjectFile.Path}"); context.LogWarning(log.ToString()); return(null); } return(result); }
public void GetsSourceFilesFromBinaryLog( [ValueSource(nameof(Preferences))] EnvironmentPreference preference, [ValueSource(nameof(ProjectFiles))] string projectFile) { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; string binLogPath = Path.ChangeExtension(Path.GetTempFileName(), ".binlog"); analyzer.AddBinaryLogger(binLogPath); try { // When analyzer.Build(options); IReadOnlyList <string> sourceFiles = analyzer.Manager.Analyze(binLogPath).First().SourceFiles; // Then sourceFiles.ShouldNotBeNull(log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); } finally { if (File.Exists(binLogPath)) { File.Delete(binLogPath); } } }
public void DesignTimeBuildsProject( [ValueSource(nameof(Preferences))] EnvironmentPreference preference, [ValueSource(nameof(ProjectFiles))] string projectFile) { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When DeleteProjectDirectory(projectFile, "obj"); DeleteProjectDirectory(projectFile, "bin"); AnalyzerResults results = analyzer.Build(options); // Then results.Count.ShouldBeGreaterThan(0, log.ToString()); results.ShouldAllBe(x => x.OverallSuccess, log.ToString()); }
public void MultiTargetingBuildFrameworkTargetFrameworkGetsSourceFiles() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log); // When IReadOnlyList <string> sourceFiles = analyzer.Build("net462").First().SourceFiles; // Then sourceFiles.ShouldNotBeNull(log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); }
public void GetsReferences( [ValueSource(nameof(Preferences))] EnvironmentPreference preference, [ValueSource(nameof(ProjectFiles))] string projectFile) { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When IReadOnlyList <string> references = analyzer.Build(options).First().GetReferences(); // Then references.ShouldNotBeNull(log.ToString()); references.ShouldContain(x => x.EndsWith("mscorlib.dll"), log.ToString()); if (projectFile.Contains("PackageReference")) { references.ShouldContain(x => x.EndsWith("NodaTime.dll"), log.ToString()); } }
public void CompilesProject(EnvironmentPreference preference, string solutionPath, string projectPath) { // Given StringWriter log = new StringWriter(); AnalyzerManager manager = new AnalyzerManager(solutionPath, new AnalyzerManagerOptions { LogWriter = log, LoggerVerbosity = Verbosity }); ProjectAnalyzer analyzer = manager.GetProject(projectPath); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // Set some enviornment variables to make it seem like we're not in a CI build // Sometimes this messes up libraries like SourceLink since we're building as part of a test and not for CI options.EnvironmentVariables.Add("APPVEYOR", "False"); options.EnvironmentVariables.Add("ContinuousIntegrationBuild", null); options.EnvironmentVariables.Add("CI", "False"); options.EnvironmentVariables.Add("CI_LINUX", "False"); options.EnvironmentVariables.Add("CI_WINDOWS", "False"); // When DeleteProjectDirectory(analyzer.ProjectFile.Path, "obj"); DeleteProjectDirectory(analyzer.ProjectFile.Path, "bin"); analyzer.IgnoreFaultyImports = false; if (BinaryLog) { analyzer.AddBinaryLogger($@"E:\Temp\{Path.GetFileNameWithoutExtension(solutionPath)}.{Path.GetFileNameWithoutExtension(analyzer.ProjectFile.Path)}.core.binlog"); } AnalyzerResults results = analyzer.Build(options); // Then results.Count.ShouldBeGreaterThan(0, log.ToString()); results.ShouldAllBe(x => x.OverallSuccess, log.ToString()); }
public void GetsSourceFiles( [ValueSource(nameof(Preferences))] EnvironmentPreference preference, [ValueSource(nameof(ProjectFiles))] string projectFile) { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When IReadOnlyList <string> sourceFiles = analyzer.Build(options).First().GetSourceFiles(); // Then sourceFiles.ShouldNotBeNull(log.ToString()); sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()).ShouldBe(new[] { "Class1", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); }
private DependencyGraph.Builder CreateBuilder(ProjectAnalyzer projectAnalyzer, string projectPath, DependencyGraph.Builder builder = null, string framework = null) { var analyzeResults = string.IsNullOrEmpty(framework) ? projectAnalyzer.Build() : projectAnalyzer.Build(framework); var analyzerResult = string.IsNullOrEmpty(framework) ? analyzeResults.FirstOrDefault() : analyzeResults[framework]; if (analyzerResult == null) { // Todo: Something went wrong, log and return better exception. throw new InvalidOperationException("Unable to load project."); } var projectNode = new ProjectReferenceNode(projectPath); if (builder == null) { builder = new DependencyGraph.Builder(projectNode); } else { builder.WithNode(projectNode); builder.WithEdge(new Edge(builder.Root, projectNode)); } var projectAssetsFilePath = analyzerResult.GetProjectAssetsFilePath(); if (!File.Exists(projectAssetsFilePath)) { if (analyzerResult.IsNetSdkProject()) { // a new project doesn't have an asset file throw new InvalidOperationException($"{projectAssetsFilePath} not found. Please run 'dotnet restore'"); } // Old csproj var oldStylePackageReferences = analyzerResult.GetItems("Reference").Where(x => x.ItemSpec.Contains("Version")); foreach (var reference in oldStylePackageReferences) { var split = reference.ItemSpec.Split(','); var version = split.Single(s => s.Contains("Version"))?.Split('=')[1]; var name = reference.ItemSpec.Split(',')[0]; var node = new PackageReferenceNode(name, version); builder.WithNode(node); builder.WithEdge(new Edge(projectNode, node, version)); } } else { // New csproj var lockFile = new LockFileFormat().Read(projectAssetsFilePath); var targetFramework = analyzerResult.GetTargetFramework(); var runtimeIdentifier = analyzerResult.GetRuntimeIdentifier(); var libraries = lockFile.Targets.Single( x => x.TargetFramework == targetFramework && x.RuntimeIdentifier == runtimeIdentifier) .Libraries.Where(x => x.IsPackage()).ToList(); var libraryNodes = new Dictionary <string, PackageReferenceNode>(StringComparer.OrdinalIgnoreCase); foreach (var library in libraries) { var libraryNode = library.ToNode(); builder.WithNode(libraryNode); libraryNodes.Add(libraryNode.PackageId, libraryNode); if (library.FrameworkAssemblies.Count > 0) { var assemblyNodes = library.FrameworkAssemblies .Select(x => new AssemblyReferenceNode($"{x}.dll")); builder.WithNodes(assemblyNodes); builder.WithEdges(assemblyNodes .Select(x => new Edge(libraryNode, x))); } if (library.RuntimeAssemblies.Count > 0) { var assemblyNodes = library.RuntimeAssemblies .Select(x => new AssemblyReferenceNode(Path.GetFileName(x.Path))) .Where(x => x.Id != "_._"); if (assemblyNodes.Any()) { builder.WithNodes(assemblyNodes); builder.WithEdges(assemblyNodes .Select(x => new Edge(libraryNode, x))); } } //if (library.CompileTimeAssemblies.Count > 0) //{ // var assemblyNodes = library.CompileTimeAssemblies // .Select(x => new AssemblyReferenceNode(Path.GetFileName(x.Path))); // builder.WithNodes(assemblyNodes); // builder.WithEdges(assemblyNodes // .Select(x => new Edge(libraryNode, x))); //} } foreach (var library in libraries) { var libraryNode = library.ToNode(); if (library.Dependencies.Count > 0) { builder.WithEdges(library.Dependencies .Select(x => new Edge(libraryNode, libraryNodes[x.Id], x.VersionRange.ToString()))); } } // Ignore unversioned references like implicit SDK packages builder.WithEdges(analyzerResult.GetItems("PackageReference") .Where(x => x.Metadata.ContainsKey("Version")) .Select(x => new Edge(projectNode, libraryNodes[x.ItemSpec], x.Metadata["Version"]))); } var references = analyzerResult.References.Select(x => new AssemblyReferenceNode(Path.GetFileName(x))); builder.WithNodes(references); builder.WithEdges(references.Select(x => new Edge(projectNode, x))); return(builder); }
public void LegacyFrameworkProjectWithPackageReferenceGetsPackageReferences() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"LegacyFrameworkProjectWithPackageReference\LegacyFrameworkProjectWithPackageReference.csproj", log); // When IReadOnlyDictionary <string, IReadOnlyDictionary <string, string> > packageReferences = analyzer.Build().First().PackageReferences; // Then packageReferences.ShouldNotBeNull(log.ToString()); packageReferences.Keys.ShouldContain("NodaTime", log.ToString()); }