Gallery (#2)

Added Gallery

- Refactored context menu handling
- Refactored undo stack

Author: ATrefzer

CSharpCodeAnalyst/App.xaml.cs

@@ -39,7 +39,7 @@ protected override void OnStartup(StartupEventArgs e)
 
         mainWindow.SetViewer(explorationGraphViewer);
         var viewModel = new MainViewModel(messaging, settings);
-        var graphViewModel = new GraphViewModel(explorationGraphViewer, explorer, settings);
+        var graphViewModel = new GraphViewModel(explorationGraphViewer, explorer, messaging, settings);
         var treeViewModel = new TreeViewModel(messaging);
         var cycleViewModel = new CycleSummaryViewModel();
         viewModel.GraphViewModel = graphViewModel;
@@ -64,8 +64,6 @@ protected override void OnStartup(StartupEventArgs e)
 
         messaging.Subscribe<CycleCalculationComplete>(cycleViewModel.HandleCycleCalculationComplete);
 
-        messaging.Subscribe<AddMissingDependenciesRequest>(graphViewModel.HandleAddMissingDependenciesRequest);
-
         messaging.Subscribe<DeleteFromModelRequest>(viewModel.HandleDeleteFromModel);
 
         mainWindow.DataContext = viewModel;

CSharpCodeAnalyst/Exploration/CodeGraphExplorer.cs

@@ -4,30 +4,89 @@ namespace CSharpCodeAnalyst.Exploration;
 
 public class CodeGraphExplorer : ICodeGraphExplorer
 {
-    public Invocation FindIncomingCalls(CodeGraph codeGraph, CodeElement method)
+    private CodeGraph? _codeGraph;
+
+    public void LoadCodeGraph(CodeGraph graph)
+    {
+        _codeGraph = graph;
+    }
+
+    public List<CodeElement> GetElements(List<string> ids)
     {
-        ArgumentNullException.ThrowIfNull(codeGraph);
-        ArgumentNullException.ThrowIfNull(method);
+        ArgumentNullException.ThrowIfNull(ids);
 
-        var callDependencies = GetCallDependencies(codeGraph);
+        if (_codeGraph is null)
+        {
+            return [];
+        }
+
+        List<CodeElement> elements = new();
+        foreach (var id in ids)
+        {
+            if (_codeGraph.Nodes.TryGetValue(id, out var element))
+            {
+                // The element is cloned internally and the dependencies discarded.
+                elements.Add(element);
+            }
+        }
+
+        return elements;
+    }
+
+    /// <summary>
+    ///     Returns all dependencies that link the given nodes (ids).
+    /// </summary>
+    public IEnumerable<Dependency> FindAllDependencies(HashSet<string> ids)
+    {
+        if (_codeGraph is null)
+        {
+            return [];
+        }
+
+        var dependencies = _codeGraph.Nodes.Values
+            .SelectMany(n => n.Dependencies)
+            .Where(d => ids.Contains(d.SourceId) && ids.Contains(d.TargetId))
+            .ToList();
+
+        return dependencies;
+    }
+
+    public Invocation FindIncomingCalls(string id)
+    {
+        ArgumentNullException.ThrowIfNull(id);
+
+        if (_codeGraph is null)
+        {
+            return new Invocation([], []);
+        }
+
+        var method = _codeGraph.Nodes[id];
+
+        var callDependencies = GetCallDependencies();
         var calls = callDependencies.Where(call => call.TargetId == method.Id).ToArray();
-        var methods = calls.Select(d => codeGraph.Nodes[d.SourceId]);
+        var methods = calls.Select(d => _codeGraph.Nodes[d.SourceId]);
 
         return new Invocation(methods, calls);
     }
 
-    public Invocation FindIncomingCallsRecursive(CodeGraph codeGraph, CodeElement method)
+    public Invocation FindIncomingCallsRecursive(string id)
     {
-        ArgumentNullException.ThrowIfNull(codeGraph);
-        ArgumentNullException.ThrowIfNull(method);
+        ArgumentNullException.ThrowIfNull(id);
+
+        if (_codeGraph is null)
+        {
+            return new Invocation([], []);
+        }
+
+        var method = _codeGraph.Nodes[id];
 
         var processingQueue = new Queue<CodeElement>();
         processingQueue.Enqueue(method);
 
         var allCalls = new HashSet<Dependency>();
         var allMethods = new HashSet<CodeElement>();
 
-        var callDependencies = GetCallDependencies(codeGraph);
+        var callDependencies = GetCallDependencies();
 
         var processed = new HashSet<string>();
         while (processingQueue.Any())
@@ -41,12 +100,12 @@ public Invocation FindIncomingCallsRecursive(CodeGraph codeGraph, CodeElement me
             var calls = callDependencies.Where(call => call.TargetId == element.Id).ToArray();
             allCalls.UnionWith(calls);
 
-            var methods = calls.Select(d => codeGraph.Nodes[d.SourceId]).ToArray();
+            var methods = calls.Select(d => _codeGraph.Nodes[d.SourceId]).ToArray();
             allMethods.UnionWith(methods);
 
             foreach (var methodToExplore in methods)
             {
-                processingQueue.Enqueue(codeGraph.Nodes[methodToExplore.Id]);
+                processingQueue.Enqueue(_codeGraph.Nodes[methodToExplore.Id]);
             }
         }
 
@@ -56,18 +115,24 @@ public Invocation FindIncomingCallsRecursive(CodeGraph codeGraph, CodeElement me
     /// <summary>
     ///     subclass -- inherits--> baseclass
     /// </summary>
-    public SearchResult FindFullInheritanceTree(CodeGraph codeGraph, CodeElement type)
+    public SearchResult FindFullInheritanceTree(string id)
     {
-        ArgumentNullException.ThrowIfNull(codeGraph);
-        ArgumentNullException.ThrowIfNull(type);
+        ArgumentNullException.ThrowIfNull(id);
+
+        if (_codeGraph is null)
+        {
+            return new SearchResult([], []);
+        }
+
+        var type = _codeGraph.Nodes[id];
 
         var types = new HashSet<CodeElement>();
         var relationships = new HashSet<Dependency>();
         var processingQueue = new Queue<CodeElement>();
         processingQueue.Enqueue(type);
         var processed = new HashSet<string>();
 
-        var inheritsAndImplements = FindInheritsAndImplementsRelationships(codeGraph);
+        var inheritsAndImplements = FindInheritsAndImplementsRelationships();
         while (processingQueue.Any())
         {
             var typeToAnalyze = processingQueue.Dequeue();
@@ -82,7 +147,7 @@ public SearchResult FindFullInheritanceTree(CodeGraph codeGraph, CodeElement typ
                 typeToAnalyze.Dependencies.Where(d => d.Type is DependencyType.Implements or DependencyType.Inherits);
             foreach (var abstraction in abstractionsOfAnalyzedType)
             {
-                var baseType = codeGraph.Nodes[abstraction.TargetId];
+                var baseType = _codeGraph.Nodes[abstraction.TargetId];
                 types.Add(baseType);
                 relationships.Add(abstraction);
                 processingQueue.Enqueue(baseType);
@@ -93,7 +158,7 @@ var specializationsOfAnalyzedType
                 = inheritsAndImplements.Where(d => typeToAnalyze.Id == d.TargetId);
             foreach (var specialization in specializationsOfAnalyzedType)
             {
-                var specializedType = codeGraph.Nodes[specialization.SourceId];
+                var specializedType = _codeGraph.Nodes[specialization.SourceId];
 
                 types.Add(specializedType);
                 relationships.Add(specialization);
@@ -105,104 +170,123 @@ var specializationsOfAnalyzedType
     }
 
     /// <summary>
-    ///     Returns all dependencies that link the given nodes (ids).
+    ///     x (source) -- derives from/overrides/implements --> y (target, search input)
     /// </summary>
-    public IEnumerable<Dependency> FindAllDependencies(HashSet<string> ids, CodeGraph? graph)
+    public SearchResult FindSpecializations(string id)
     {
-        if (graph is null)
+        ArgumentNullException.ThrowIfNull(id);
+
+        if (_codeGraph is null)
         {
-            return [];
+            return new SearchResult([], []);
         }
 
-        var dependencies = graph.Nodes.Values
-            .SelectMany(n => n.Dependencies)
-            .Where(d => ids.Contains(d.SourceId) && ids.Contains(d.TargetId))
-            .ToList();
-
-        return dependencies;
-    }
-
-    /// <summary>
-    ///     x (source) -- derives from/overrides/implements --> y (target, search input)
-    /// </summary>
-    public SearchResult FindSpecializations(CodeGraph codeGraph, CodeElement element)
-    {
-        ArgumentNullException.ThrowIfNull(codeGraph);
-        ArgumentNullException.ThrowIfNull(element);
+        var element = _codeGraph.Nodes[id];
 
-        var dependencies = codeGraph.GetAllDependencies()
+        var dependencies = _codeGraph.GetAllDependencies()
             .Where(d => (d.Type == DependencyType.Overrides ||
                          d.Type == DependencyType.Implements) &&
                         d.TargetId == element.Id).ToList();
-        var methods = dependencies.Select(m => codeGraph.Nodes[m.SourceId]).ToList();
+        var methods = dependencies.Select(m => _codeGraph.Nodes[m.SourceId]).ToList();
         return new SearchResult(methods, dependencies);
     }
 
     /// <summary>
     ///     x (source, search input) -- derives from/overrides/implements --> y (target)
     /// </summary>
-    public SearchResult FindAbstractions(CodeGraph codeGraph, CodeElement element)
+    public SearchResult FindAbstractions(string id)
     {
-        ArgumentNullException.ThrowIfNull(codeGraph);
-        ArgumentNullException.ThrowIfNull(element);
+        ArgumentNullException.ThrowIfNull(id);
+
+        if (_codeGraph is null)
+        {
+            return new SearchResult([], []);
+        }
+
+        var element = _codeGraph.Nodes[id];
 
         var dependencies = element.Dependencies
             .Where(d => (d.Type == DependencyType.Overrides ||
                          d.Type == DependencyType.Implements) &&
                         d.SourceId == element.Id).ToList();
-        var methods = dependencies.Select(m => codeGraph.Nodes[m.TargetId]).ToList();
+        var methods = dependencies.Select(m => _codeGraph.Nodes[m.TargetId]).ToList();
         return new SearchResult(methods, dependencies);
     }
 
 
-    public Invocation FindOutgoingCalls(CodeGraph codeGraph, CodeElement method)
+    public Invocation FindOutgoingCalls(string id)
     {
-        ArgumentNullException.ThrowIfNull(codeGraph);
-        ArgumentNullException.ThrowIfNull(method);
+        ArgumentNullException.ThrowIfNull(id);
+
+        if (_codeGraph is null)
+        {
+            return new Invocation([], []);
+        }
+
+        var method = _codeGraph.Nodes[id];
 
         var calls = method.Dependencies
             .Where(d => d.Type == DependencyType.Calls).ToList();
-        var methods = calls.Select(m => codeGraph.Nodes[m.TargetId]).ToList();
+        var methods = calls.Select(m => _codeGraph.Nodes[m.TargetId]).ToList();
         return new Invocation(methods, calls);
     }
 
-    public SearchResult FindOutgoingDependencies(CodeGraph codeGraph, CodeElement element)
+    public SearchResult FindOutgoingDependencies(string id)
     {
-        ArgumentNullException.ThrowIfNull(codeGraph);
-        ArgumentNullException.ThrowIfNull(element);
+        ArgumentNullException.ThrowIfNull(id);
 
+        if (_codeGraph is null)
+        {
+            return new SearchResult([], []);
+        }
+
+        var element = _codeGraph.Nodes[id];
         var dependencies = element.Dependencies;
-        var targets = dependencies.Select(m => codeGraph.Nodes[m.TargetId]).ToList();
+        var targets = dependencies.Select(m => _codeGraph.Nodes[m.TargetId]).ToList();
         return new SearchResult(targets, dependencies);
     }
 
-    public SearchResult FindIncomingDependencies(CodeGraph codeGraph, CodeElement element)
+    public SearchResult FindIncomingDependencies(string id)
     {
-        ArgumentNullException.ThrowIfNull(codeGraph);
-        ArgumentNullException.ThrowIfNull(element);
+        ArgumentNullException.ThrowIfNull(id);
+        if (_codeGraph is null)
+        {
+            return new SearchResult([], []);
+        }
 
-        var dependencies = codeGraph.Nodes.Values
+        var element = _codeGraph.Nodes[id];
+        var dependencies = _codeGraph.Nodes.Values
             .SelectMany(node => node.Dependencies)
             .Where(d => d.TargetId == element.Id).ToList();
 
-        var elements = dependencies.Select(d => codeGraph.Nodes[d.SourceId]);
+        var elements = dependencies.Select(d => _codeGraph.Nodes[d.SourceId]);
 
         return new SearchResult(elements, dependencies);
     }
 
-    private static List<Dependency> GetCallDependencies(CodeGraph codeGraph)
+    private List<Dependency> GetCallDependencies()
     {
-        var callDependencies = codeGraph.Nodes.Values
+        if (_codeGraph is null)
+        {
+            return [];
+        }
+
+        var callDependencies = _codeGraph.Nodes.Values
             .SelectMany(node => node.Dependencies)
             .Where(d => d.Type == DependencyType.Calls)
             .ToList();
         return callDependencies;
     }
 
-    private static HashSet<Dependency> FindInheritsAndImplementsRelationships(CodeGraph codeGraph)
+    private HashSet<Dependency> FindInheritsAndImplementsRelationships()
     {
+        if (_codeGraph is null)
+        {
+            return [];
+        }
+
         var inheritsAndImplements = new HashSet<Dependency>();
-        codeGraph.DfsHierarchy(Collect);
+        _codeGraph.DfsHierarchy(Collect);
         return inheritsAndImplements;
 
         void Collect(CodeElement c)
@@ -225,6 +309,4 @@ void Collect(CodeElement c)
 
 public record struct SearchResult(IEnumerable<CodeElement> Elements, IEnumerable<Dependency> Dependencies);
 
-public record struct Invocation(IEnumerable<CodeElement> Methods, IEnumerable<Dependency> Calls);
-
-public record struct Relationship(IEnumerable<CodeElement> Types, IEnumerable<Dependency> Relationships);
+public record struct Invocation(IEnumerable<CodeElement> Methods, IEnumerable<Dependency> Calls);

CSharpCodeAnalyst/Exploration/ICodeGraphExplorer.cs

@@ -4,26 +4,28 @@ namespace CSharpCodeAnalyst.Exploration;
 
 public interface ICodeGraphExplorer
 {
-    Invocation FindIncomingCalls(CodeGraph codeGraph, CodeElement method);
-    Invocation FindOutgoingCalls(CodeGraph codeGraph, CodeElement method);
-    Invocation FindIncomingCallsRecursive(CodeGraph codeGraph, CodeElement method);
-    SearchResult FindFullInheritanceTree(CodeGraph codeGraph, CodeElement type);
+    Invocation FindIncomingCalls(string id);
+    Invocation FindOutgoingCalls(string id);
+    Invocation FindIncomingCallsRecursive(string id);
+    SearchResult FindFullInheritanceTree(string id);
 
     /// <summary>
     ///     Finds all dependencies connect the given nodes.
     /// </summary>
-    IEnumerable<Dependency> FindAllDependencies(HashSet<string> ids, CodeGraph? graph);
+    IEnumerable<Dependency> FindAllDependencies(HashSet<string> ids);
 
     /// <summary>
     ///     Methods that implement or overload the given method
     /// </summary>
-    SearchResult FindSpecializations(CodeGraph codeGraph, CodeElement method);
+    SearchResult FindSpecializations(string id);
 
     /// <summary>
     ///     Methods that are implemented or overloaded by the given method
     /// </summary>
-    SearchResult FindAbstractions(CodeGraph codeGraph, CodeElement method);
+    SearchResult FindAbstractions(string id);
 
-    SearchResult FindOutgoingDependencies(CodeGraph codeGraph, CodeElement codeElement);
-    SearchResult FindIncomingDependencies(CodeGraph codeGraph, CodeElement codeElement);
+    SearchResult FindOutgoingDependencies(string id);
+    SearchResult FindIncomingDependencies(string id);
+    void LoadCodeGraph(CodeGraph graph);
+    List<CodeElement> GetElements(List<string> ids);
 }