Skip to content

Commit b07e28c

Browse files
author
Pawel Badenski
committed
Refactor to use existing structures
1 parent 94cb73e commit b07e28c

File tree

6 files changed

+116
-97
lines changed

6 files changed

+116
-97
lines changed

‎src/main/java/org/axonframework/intellij/ide/plugin/annotator/AxonGutterAnnotator.java

Lines changed: 75 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -4,14 +4,13 @@
44
import com.intellij.lang.annotation.Annotation;
55
import com.intellij.lang.annotation.AnnotationHolder;
66
import com.intellij.lang.annotation.Annotator;
7-
import com.intellij.openapi.project.Project;
87
import com.intellij.openapi.util.IconLoader;
98
import com.intellij.openapi.util.NotNullLazyValue;
10-
import com.intellij.psi.*;
11-
import com.intellij.psi.search.GlobalSearchScope;
12-
import com.intellij.psi.search.searches.AnnotatedElementsSearch;
13-
import com.intellij.psi.util.PsiUtil;
14-
import com.intellij.util.CommonProcessors;
9+
import com.intellij.psi.PsiClass;
10+
import com.intellij.psi.PsiElement;
11+
import com.intellij.psi.PsiIdentifier;
12+
import com.intellij.psi.PsiMethodCallExpression;
13+
import com.intellij.psi.util.PsiTypesUtil;
1514
import org.axonframework.intellij.ide.plugin.handler.AnnotationTypes;
1615
import org.axonframework.intellij.ide.plugin.handler.EventHandler;
1716
import org.axonframework.intellij.ide.plugin.handler.HandlerProviderManager;
@@ -20,7 +19,10 @@
2019
import org.jetbrains.annotations.NotNull;
2120

2221
import javax.swing.*;
23-
import java.util.*;
22+
import java.util.ArrayList;
23+
import java.util.Collection;
24+
import java.util.Set;
25+
import java.util.TreeSet;
2426

2527
/**
2628
* This class shows an icon in the gutter when an Axon annotation is found. The icon can be used to navigate to all
@@ -33,114 +35,103 @@ public class AxonGutterAnnotator implements Annotator {
3335

3436
@Override
3537
public void annotate(@NotNull final PsiElement element, @NotNull AnnotationHolder holder) {
38+
final PublisherProviderManager publisherManager = PublisherProviderManager.getInstance(element.getProject());
39+
final HandlerProviderManager handlerManager = HandlerProviderManager.getInstance(element.getProject());
3640
if (element instanceof PsiClass) {
37-
tryAnnotateEventClass(holder, (PsiClass) element);
38-
tryAnnotateCommandClass(holder, (PsiClass) element);
41+
tryAnnotateEventClass(holder, (PsiClass) element, publisherManager, handlerManager);
42+
tryAnnotateCommandClass(holder, (PsiClass) element, handlerManager);
3943
}
44+
4045
if (!(element instanceof PsiMethodCallExpression || element instanceof PsiIdentifier)) {
4146
return;
4247
}
4348

44-
final PublisherProviderManager publisherManager = PublisherProviderManager.getInstance(element.getProject());
45-
final HandlerProviderManager handlerManager = HandlerProviderManager.getInstance(element.getProject());
4649
final EventPublisher publisher = publisherManager.resolveEventPublisher(element);
4750
final EventHandler handler = handlerManager.resolveEventHandler(element.getContext());
4851
if (publisher != null) {
49-
NotNullLazyValue<Collection<? extends PsiElement>> targetResolver = new NotNullLazyValue<Collection<? extends PsiElement>>() {
50-
@NotNull
51-
@Override
52-
protected Collection<? extends PsiElement> compute() {
53-
Set<EventHandler> handlers = handlerManager.getRepository().findHandlers(publisher.getPublishedType());
54-
Set<PsiEventHandlerWrapper> destinations = new TreeSet<PsiEventHandlerWrapper>();
55-
for (EventHandler eventHandler : handlers) {
56-
PsiElement elementForAnnotation = eventHandler.getElementForAnnotation();
57-
if (elementForAnnotation.isValid()) {
58-
destinations.add(new PsiEventHandlerWrapper(elementForAnnotation, eventHandler));
59-
}
60-
}
61-
return destinations;
62-
}
63-
};
52+
NotNullLazyValue<Collection<? extends PsiElement>> targetResolver =
53+
createNotNullLazyValueForHandlers(handlerManager.getRepository().findHandlers(publisher.getPublishedType()));
6454
Annotation gutterIconForPublisher = createGutterIconForEventHandlers(element, holder, targetResolver, handlerManager);
6555
if (targetResolver.getValue().isEmpty()) {
6656
addCreateEventHandlerQuickFixes(publisher, gutterIconForPublisher);
6757
}
6858
}
6959

7060
if (handler != null) {
71-
createGutterIconForEventPublishers(handler.getElementForAnnotation(), holder, new NotNullLazyValue<Collection<? extends PsiElement>>() {
72-
@NotNull
73-
@Override
74-
protected Collection<? extends PsiElement> compute() {
75-
Collection<EventPublisher> publishers = publisherManager.getRepository()
76-
.getPublishersFor(handler.getHandledType());
77-
Collection<PsiElement> publishLocations = new ArrayList<PsiElement>();
78-
for (EventPublisher eventPublisher : publishers) {
79-
PsiElement psiElement = eventPublisher.getPsiElement();
80-
if (psiElement.isValid()) {
81-
publishLocations.add(psiElement);
82-
}
83-
}
84-
return publishLocations;
85-
}
86-
});
87-
}
88-
}
89-
90-
private void tryAnnotateCommandClass(AnnotationHolder holder, PsiClass classElement) {
91-
final Collection<PsiMethod> commandHandlerMethods =
92-
findHandlerMethod(classElement.getProject(), classElement, AnnotationTypes.COMMAND_EVENT_HANDLER.getFullyQualifiedName());
93-
if (!commandHandlerMethods.isEmpty()) {
94-
createGutterIconForCommandHandlers(
95-
classElement.getNameIdentifier(),
61+
Collection<EventPublisher> publishers = publisherManager.getRepository()
62+
.getPublishersFor(handler.getHandledType());
63+
createGutterIconForEventPublishers(
64+
handler.getElementForAnnotation(),
9665
holder,
97-
constantNotNullLazyValue(commandHandlerMethods));
66+
createNotNullLazyValueForPublishers(publishers));
9867
}
9968
}
10069

101-
private void tryAnnotateEventClass(AnnotationHolder holder, PsiClass classElement) {
102-
List<AnnotationTypes> eventAnnotations = Arrays.asList(
103-
AnnotationTypes.EVENT_HANDLER,
104-
AnnotationTypes.EVENT_SOURCING_HANDLER,
105-
AnnotationTypes.SAGA_EVENT_HANDLER);
106-
Collection<PsiMethod> eventHandlerMethods = new ArrayList<PsiMethod>();
107-
for (AnnotationTypes eventAnnotation : eventAnnotations) {
108-
eventHandlerMethods.addAll(findHandlerMethod(classElement.getProject(), classElement, eventAnnotation.getFullyQualifiedName()));
109-
}
110-
if (!eventHandlerMethods.isEmpty()) {
111-
createGutterIconForEventHandlers(
112-
classElement.getNameIdentifier(),
113-
holder,
114-
constantNotNullLazyValue(eventHandlerMethods),
115-
HandlerProviderManager.getInstance(classElement.getProject()));
116-
}
117-
}
118-
119-
public Collection<PsiMethod> findHandlerMethod(Project project, final PsiClass clazz, String handlerAnnotation) {
120-
GlobalSearchScope scope = GlobalSearchScope.allScope(project);
121-
PsiClass handlerClass =
122-
JavaPsiFacade.getInstance(project).findClass(handlerAnnotation, scope);
123-
CommonProcessors.CollectProcessor<PsiMethod> collectProcessor = new CommonProcessors.CollectProcessor<PsiMethod>() {
70+
private NotNullLazyValue<Collection<? extends PsiElement>> createNotNullLazyValueForPublishers(final Collection<EventPublisher> publishers) {
71+
return new NotNullLazyValue<Collection<? extends PsiElement>>() {
72+
@NotNull
12473
@Override
125-
protected boolean accept(PsiMethod psiMethod) {
126-
return psiMethod.getParameterList().getParametersCount() > 0
127-
&& clazz.isEquivalentTo(PsiUtil.resolveClassInType(psiMethod.getParameterList().getParameters()[0].getType()));
74+
protected Collection<? extends PsiElement> compute() {
75+
Collection<PsiElement> publishLocations = new ArrayList<PsiElement>();
76+
for (EventPublisher eventPublisher : publishers) {
77+
PsiElement psiElement = eventPublisher.getPsiElement();
78+
if (psiElement.isValid()) {
79+
publishLocations.add(psiElement);
80+
}
81+
}
82+
return publishLocations;
12883
}
12984
};
130-
AnnotatedElementsSearch.searchPsiMethods(handlerClass, scope).forEach(collectProcessor);
131-
return collectProcessor.getResults();
13285
}
13386

134-
private NotNullLazyValue<Collection<? extends PsiElement>> constantNotNullLazyValue(final Collection<? extends PsiElement> psiElements) {
87+
private NotNullLazyValue<Collection<? extends PsiElement>> createNotNullLazyValueForHandlers(final Set<EventHandler> handlers) {
13588
return new NotNullLazyValue<Collection<? extends PsiElement>>() {
13689
@NotNull
13790
@Override
13891
protected Collection<? extends PsiElement> compute() {
139-
return psiElements;
92+
Set<PsiEventHandlerWrapper> destinations = new TreeSet<PsiEventHandlerWrapper>();
93+
for (EventHandler eventHandler : handlers) {
94+
PsiElement elementForAnnotation = eventHandler.getElementForAnnotation();
95+
if (elementForAnnotation.isValid()) {
96+
destinations.add(new PsiEventHandlerWrapper(elementForAnnotation, eventHandler));
97+
}
98+
}
99+
return destinations;
140100
}
141101
};
142102
}
143103

104+
private void tryAnnotateCommandClass(AnnotationHolder holder, PsiClass classElement, HandlerProviderManager handlerManager) {
105+
Set<EventHandler> handlers =
106+
handlerManager.getRepository().findCommandHandlers(PsiTypesUtil.getClassType(classElement));
107+
if (!handlers.isEmpty()) {
108+
createGutterIconForCommandHandlers(
109+
classElement.getNameIdentifier(),
110+
holder,
111+
createNotNullLazyValueForHandlers(handlers));
112+
}
113+
}
114+
115+
private void tryAnnotateEventClass(AnnotationHolder holder, PsiClass classElement,
116+
PublisherProviderManager publisherManager, HandlerProviderManager handlerManager) {
117+
Set<EventPublisher> publishers = publisherManager.getRepository().getPublishersFor(PsiTypesUtil.getClassType(classElement));
118+
if (!publishers.isEmpty()) {
119+
createGutterIconForEventPublishers(
120+
classElement.getNameIdentifier(),
121+
holder,
122+
createNotNullLazyValueForPublishers(publishers));
123+
}
124+
Set<EventHandler> handlers =
125+
handlerManager.getRepository().findEventHandlers(PsiTypesUtil.getClassType(classElement));
126+
if (!handlers.isEmpty()) {
127+
createGutterIconForEventHandlers(
128+
classElement.getNameIdentifier(),
129+
holder,
130+
createNotNullLazyValueForHandlers(handlers),
131+
handlerManager);
132+
}
133+
}
134+
144135
private void addCreateEventHandlerQuickFixes(EventPublisher publisher, Annotation gutterIconForPublisher) {
145136
gutterIconForPublisher.registerFix(new CreateEventHandlerQuickfix(publisher.getPublishedType(), AnnotationTypes.EVENT_HANDLER));
146137
gutterIconForPublisher.registerFix(new CreateEventHandlerQuickfix(publisher.getPublishedType(), AnnotationTypes.EVENT_SOURCING_HANDLER));
@@ -170,7 +161,8 @@ private static Annotation createGutterIconForCommandHandlers(PsiElement psiEleme
170161
}
171162

172163
private static Annotation createGutterIconForEventHandlers(PsiElement psiElement, AnnotationHolder holder,
173-
NotNullLazyValue<Collection<? extends PsiElement>> targetResolver, HandlerProviderManager handlerManager) {
164+
NotNullLazyValue<Collection<? extends PsiElement>> targetResolver,
165+
HandlerProviderManager handlerManager) {
174166
return NavigationGutterIconBuilder.create(AxonIconOut)
175167
.setEmptyPopupText("No handlers found for this event")
176168
.setTargets(targetResolver)

‎src/main/java/org/axonframework/intellij/ide/plugin/handler/AnnotationTypes.java

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,4 @@ public String getRequiredProperty() {
3232
return requiredProperty;
3333
}
3434

35-
public boolean isCommand() {
36-
return this.annotation.equals("@CommandHandler");
37-
}
3835
}

‎src/main/java/org/axonframework/intellij/ide/plugin/handler/DefaultEventHandlerProvider.java

Lines changed: 12 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,6 @@
99
import com.intellij.util.Query;
1010

1111
class DefaultEventHandlerProvider implements EventHandlerProvider {
12-
1312
@Override
1413
public void scanHandlers(Project project, GlobalSearchScope scope, final Registrar registrar) {
1514
for (final AnnotationTypes annotationType : AnnotationTypes.values()) {
@@ -27,12 +26,7 @@ public boolean process(PsiReference psiReference) {
2726
// this doesn't say the method is annotated
2827
final PsiAnnotation annotation = locateAnnotation(method);
2928
if (annotation != null) {
30-
EventHandler handler;
31-
if (annotationType.isCommand()) {
32-
handler = CommandEventHandler.createEventHandler(method);
33-
} else {
34-
handler = DefaultEventHandler.createEventHandler(method, annotation);
35-
}
29+
EventHandler handler = createHandlerBasedOnAnnotation(method, annotation);
3630
if (handler != null) {
3731
registrar.registerHandler(handler);
3832
}
@@ -48,14 +42,23 @@ public boolean process(PsiReference psiReference) {
4842
@Override
4943
public EventHandler resolve(PsiElement element) {
5044
if (element instanceof PsiMethod) {
51-
final PsiAnnotation annotation = locateAnnotation((PsiMethod) element);
45+
PsiMethod methodElement = (PsiMethod) element;
46+
final PsiAnnotation annotation = locateAnnotation(methodElement);
5247
if (annotation != null) {
53-
return DefaultEventHandler.createEventHandler((PsiMethod) element, annotation);
48+
return createHandlerBasedOnAnnotation(methodElement, annotation);
5449
}
5550
}
5651
return null;
5752
}
5853

54+
private EventHandler createHandlerBasedOnAnnotation(PsiMethod method, PsiAnnotation annotation) {
55+
if (annotation.getText().equals("@CommandHandler")) {
56+
return CommandEventHandler.createEventHandler(method);
57+
} else {
58+
return DefaultEventHandler.createEventHandler(method, annotation);
59+
}
60+
}
61+
5962
private PsiAnnotation locateAnnotation(PsiMethod element) {
6063
for (AnnotationTypes annotationType : AnnotationTypes.values()) {
6164
PsiAnnotation annotation = element.getModifierList().findAnnotation(annotationType.getFullyQualifiedName());

‎src/main/java/org/axonframework/intellij/ide/plugin/handler/DefaultEventHandlerRepository.java

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -33,4 +33,26 @@ public Set<EventHandler> findHandlers(PsiType eventType) {
3333
}
3434
return found;
3535
}
36+
37+
@Override
38+
public Set<EventHandler> findEventHandlers(PsiType eventType) {
39+
Set<EventHandler> found = new HashSet<EventHandler>();
40+
for (EventHandler eventHandler : findHandlers(eventType)) {
41+
if (!(eventHandler instanceof CommandEventHandler)) {
42+
found.add(eventHandler);
43+
}
44+
}
45+
return found;
46+
}
47+
48+
@Override
49+
public Set<EventHandler> findCommandHandlers(PsiType eventType) {
50+
Set<EventHandler> found = new HashSet<EventHandler>();
51+
for (EventHandler eventHandler : findHandlers(eventType)) {
52+
if (eventHandler instanceof CommandEventHandler) {
53+
found.add(eventHandler);
54+
}
55+
}
56+
return found;
57+
}
3658
}

‎src/main/java/org/axonframework/intellij/ide/plugin/handler/EventHandlerRepository.java

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,4 +9,8 @@ public interface EventHandlerRepository {
99
void registerHandler(EventHandler eventHandler);
1010

1111
Set<EventHandler> findHandlers(PsiType eventType);
12+
13+
Set<EventHandler> findEventHandlers(PsiType eventType);
14+
15+
Set<EventHandler> findCommandHandlers(PsiType eventType);
1216
}

‎src/main/java/org/axonframework/intellij/ide/plugin/publisher/DefaultEventPublisher.java

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20,8 +20,9 @@ public boolean canPublishType(PsiType eventType) {
2020
&& publishedType != null
2121
&& eventType.isValid()
2222
&& (eventType.isAssignableFrom(publishedType)
23-
|| eventType instanceof PsiImmediateClassType
24-
&& ((PsiImmediateClassType) eventType).getParameters()[0].isAssignableFrom(publishedType));
23+
|| (eventType instanceof PsiImmediateClassType
24+
&& ((PsiImmediateClassType) eventType).getParameterCount() > 0
25+
&& ((PsiImmediateClassType) eventType).getParameters()[0].isAssignableFrom(publishedType)));
2526

2627
}
2728

0 commit comments

Comments
 (0)