feat: show "inside" references for package graph

#61 #58

src/ch/docksnet/rgraph/PsiUtils.java

@@ -38,6 +38,7 @@
 import com.intellij.psi.PsiJavaFile;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.impl.file.PsiJavaDirectoryImpl;
+import com.intellij.psi.impl.source.tree.CompositePsiElement;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.Nullable;
 
@@ -50,7 +51,7 @@
 public class PsiUtils {
 
     @Nullable
-    public static PsiElement getRootPsiElement(PsiClass psiClass, PsiElement psiElement) {
+    public static PsiElement getRootPsiElement(PsiClass psiClass, CompositePsiElement psiElement) {
         return getRootPsiElementWithStack(psiClass, psiElement, new LinkedList<PsiElement>());
     }
 
@@ -135,7 +136,7 @@ public static PsiClass getPsiClass(String classFQN, Project project) {
     }
 
     public static PsiDirectory getPsiJavaDirectory(String packageFQN, Project project) {
-        return JavaPsiFacade.getInstance(project).findPackage("ch.sbb.aps.safetylogic.interfaces.l0").getDirectories()[0];
+        return JavaPsiFacade.getInstance(project).findPackage(packageFQN).getDirectories()[0];
     }
 
     private static String getName(PsiClassInitializer psiClassInitializer) {

src/ch/docksnet/rgraph/directory/PackageReferenceDiagramDataModel.java

@@ -18,24 +18,33 @@
 
 import ch.docksnet.rgraph.PsiUtils;
 import ch.docksnet.rgraph.ReferenceDiagramProvider;
-import ch.docksnet.rgraph.method.MethodReferenceDiagramDataModel;
+import ch.docksnet.rgraph.method.ReferenceEdge;
 import ch.docksnet.rgraph.method.ReferenceNode;
+import ch.docksnet.rgraph.method.SourceTargetPair;
+import ch.docksnet.utils.IncrementableSet;
 import com.intellij.diagram.DiagramDataModel;
 import com.intellij.diagram.DiagramEdge;
 import com.intellij.diagram.DiagramNode;
 import com.intellij.diagram.DiagramProvider;
+import com.intellij.diagram.DiagramRelationshipInfo;
+import com.intellij.diagram.DiagramRelationshipInfoAdapter;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.ModificationTracker;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiJavaFile;
 import com.intellij.psi.PsiManager;
+import com.intellij.psi.PsiReference;
 import com.intellij.psi.SmartPointerManager;
 import com.intellij.psi.SmartPsiElementPointer;
 import com.intellij.psi.impl.file.PsiJavaDirectoryImpl;
+import com.intellij.psi.impl.source.tree.CompositePsiElement;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.search.searches.ReferencesSearch;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.awt.*;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -123,6 +132,16 @@ private synchronized void updateDataModel() {
                 this.nodes.add(getReferenceNode(provider, element));
             }
         }
+
+        IncrementableSet<SourceTargetPair> relationships = resolveRelationships();
+        for (Map.Entry<SourceTargetPair, Long> sourceTargetPair : relationships.elements()) {
+            SourceTargetPair key = sourceTargetPair.getKey();
+            DiagramNode<PsiElement> source = findNode(key.getSource().getContainingFile());
+            DiagramNode<PsiElement> target = findNode(key.getTarget());
+            if (source != null && target != null) {
+                this.edges.add(toEdge(source, target, sourceTargetPair.getValue()));
+            }
+        }
     }
 
     private Set<PsiElement> getElements() {
@@ -151,10 +170,78 @@ private ReferenceNode getReferenceNode(DiagramProvider provider, PsiElement elem
         return node;
     }
 
+    @Nullable
+    private DiagramEdge<PsiElement> toEdge(final @NotNull DiagramNode<PsiElement> from, final @NotNull DiagramNode<PsiElement> to,
+                                           Long value) {
+        final DiagramRelationshipInfo relationship = createEdgeFromNonField(value == null ? 0 : value);
+        return new ReferenceEdge(from, to, relationship);
+    }
+
+    @NotNull
+    private DiagramRelationshipInfo createEdgeFromNonField(final long count) {
+        DiagramRelationshipInfo r;
+        r = new DiagramRelationshipInfoAdapter(ReferenceEdge.Type.REFERENCE.name()) {
+            @Override
+            public Shape getStartArrow() {
+                return STANDARD;
+            }
+
+            @Override
+            public String getToLabel() {
+                if (count == 1) {
+                    return "";
+                } else {
+                    return Long.toString(count);
+                }
+            }
+
+            @Override
+            public boolean equals(Object obj) {
+                if (!(obj instanceof DiagramRelationshipInfoAdapter)) {
+                    return false;
+                }
+                return toString().equals(obj.toString()) && getToLabel().equals(((DiagramRelationshipInfoAdapter) obj).getToLabel());
+            }
+        };
+        return r;
+    }
+
     private boolean isAllowedToShow(PsiElement element) {
         return true;
     }
 
+    @NotNull
+    private IncrementableSet<SourceTargetPair> resolveRelationships() {
+        IncrementableSet<SourceTargetPair> incrementableSet = new IncrementableSet<>();
+
+        for (DiagramNode<PsiElement> node : this.nodes) {
+            PsiElement callee = node.getIdentifyingElement();
+
+
+            if (callee instanceof PsiJavaFile) {
+                PsiClass[] classes = ((PsiJavaFile) callee).getClasses();
+                for (PsiClass psiClass : classes) {
+                    Collection<PsiReference> references = ReferencesSearch.search(psiClass, GlobalSearchScope.projectScope(getProject())).findAll();
+
+                    for (PsiReference psiReference : references) {
+                        if (!(psiReference instanceof CompositePsiElement)) {
+                            continue;
+                        }
+                        PsiElement caller = ((CompositePsiElement) psiReference).getContainingFile();
+
+                        if (caller == null) {
+                            continue;
+                        }
+
+                        incrementableSet.increment(new SourceTargetPair(caller, callee));
+                    }
+
+                }
+            }
+        }
+        return incrementableSet;
+    }
+
     @NotNull
     @Override
     public ModificationTracker getModificationTracker() {

src/ch/docksnet/rgraph/method/MethodReferenceDiagramDataModel.java

@@ -27,6 +27,7 @@
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.ModificationTracker;
 import com.intellij.psi.*;
+import com.intellij.psi.impl.source.tree.CompositePsiElement;
 import com.intellij.psi.search.GlobalSearchScopes;
 import com.intellij.psi.search.LocalSearchScope;
 import com.intellij.psi.search.searches.ReferencesSearch;
@@ -114,8 +115,8 @@ public String getNodeName(DiagramNode<PsiElement> diagramNode) {
     }
 
     @Nullable
-    private DiagramEdge<PsiElement> addEdge(final @NotNull DiagramNode<PsiElement> from, final @NotNull DiagramNode<PsiElement> to,
-                                            Long value) {
+    private DiagramEdge<PsiElement> toEdge(final @NotNull DiagramNode<PsiElement> from, final @NotNull DiagramNode<PsiElement> to,
+                                           Long value) {
         final DiagramRelationshipInfo relationship;
         if (from.getIdentifyingElement() instanceof PsiField) {
             relationship = createEdgeFromField();
@@ -218,7 +219,7 @@ private synchronized void updateDataModel() {
             DiagramNode<PsiElement> source = findNode(key.getSource());
             DiagramNode<PsiElement> target = findNode(key.getTarget());
             if (source != null && target != null) {
-                this.edges.add(addEdge(source, target, sourceTargetPair.getValue()));
+                this.edges.add(toEdge(source, target, sourceTargetPair.getValue()));
             }
         }
     }
@@ -277,11 +278,10 @@ private IncrementableSet<SourceTargetPair> resolveRelationships(PsiClass psiClas
                     (psiClass)).findAll();
 
             for (PsiReference psiReference : all) {
-                if (!(psiReference instanceof PsiReferenceExpression)) {
+                if (!(psiReference instanceof CompositePsiElement)) {
                     continue;
                 }
-                PsiReferenceExpression referenceExpression = (PsiReferenceExpression) psiReference;
-                PsiElement caller = PsiUtils.getRootPsiElement(psiClass, referenceExpression);
+                PsiElement caller = PsiUtils.getRootPsiElement(psiClass, (CompositePsiElement) psiReference);
 
                 if (caller == null) {
                     continue;

src/ch/docksnet/rgraph/method/ReferenceEdge.java

@@ -32,7 +32,7 @@ public ReferenceEdge(DiagramNode<PsiElement> source, DiagramNode<PsiElement> tar
         super(source, target, relationship);
     }
 
-    enum Type {
+    public enum Type {
         FIELD_TO_METHOD, REFERENCE
     }