Merge pull request #63 from AxonFramework/43-links-to-message-handlers-that-handle-a-specific-message-type-should-also-work-when-message-is-constructed-using-a-builder-pattern

[#43] Support builder method references, both ways

Author: CodeDrivenMitch

CHANGELOG.md

@@ -12,6 +12,7 @@
 
 ### Added
 
+- [#43] Support builder method references, both ways
 - [#38] Aggregate structure hierarchy is now shown in model popup
 - [#41] Mark methods annotated with @ResetHandler as used
 - [#31] Aggregate structure hierarchy is now shown in model popup

src/main/kotlin/org/axonframework/intellij/ide/plugin/markers/publishers/PublishMethodLineMarkerProvider.kt

@@ -21,19 +21,23 @@ import com.intellij.codeInsight.daemon.LineMarkerProvider
 import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.openapi.util.NotNullLazyValue
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiIdentifier
+import com.intellij.psi.PsiMethod
 import org.axonframework.intellij.ide.plugin.AxonIcons
 import org.axonframework.intellij.ide.plugin.api.MessageHandlerType
 import org.axonframework.intellij.ide.plugin.markers.AxonNavigationGutterIconRenderer
 import org.axonframework.intellij.ide.plugin.resolving.MessageHandlerResolver
 import org.axonframework.intellij.ide.plugin.resolving.handlers.types.CommandHandlerInterceptor
 import org.axonframework.intellij.ide.plugin.resolving.handlers.types.DeadlineHandler
+import org.axonframework.intellij.ide.plugin.util.containingClassFqn
 import org.axonframework.intellij.ide.plugin.util.handlerResolver
 import org.axonframework.intellij.ide.plugin.util.toQualifiedName
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.uast.UAnnotation
 import org.jetbrains.uast.UCallExpression
 import org.jetbrains.uast.UClassLiteralExpression
 import org.jetbrains.uast.UIdentifier
+import org.jetbrains.uast.UQualifiedReferenceExpression
 import org.jetbrains.uast.USimpleNameReferenceExpression
 import org.jetbrains.uast.UTypeReferenceExpression
 import org.jetbrains.uast.UastCallKind
@@ -81,6 +85,11 @@ class PublishMethodLineMarkerProvider : LineMarkerProvider {
 
     private fun qualifiedNameForKotlin(element: PsiElement): String? {
         val uElement = element.toUElementOfType<UIdentifier>() ?: return null
+        if (element.text.contains("build", ignoreCase = true)) {
+            // If the method is a builder, show handlers of that class
+            val referenceExpression = uElement.getParentOfType<UQualifiedReferenceExpression>() ?: return null
+            return (referenceExpression.resolve() as? PsiMethod?)?.containingClassFqn()
+        }
         val callExpression = uElement.getParentOfType(UCallExpression::class.java, false, USimpleNameReferenceExpression::class.java)
         if (callExpression != null && callExpression.kind == UastCallKind.CONSTRUCTOR_CALL) {
             return callExpression.classReference.getQualifiedName()
@@ -93,6 +102,11 @@ class PublishMethodLineMarkerProvider : LineMarkerProvider {
     }
 
     private fun qualifiedNameForJava(element: PsiElement): String? {
+        if (element is PsiIdentifier && element.text.contains("build", ignoreCase = true)) {
+            // If the method is a builder, show handlers of that class
+            val referenceExpression = element.toUElement()?.getParentOfType<UQualifiedReferenceExpression>() ?: return null
+            return (referenceExpression.resolve() as? PsiMethod?)?.containingClassFqn()
+        }
         val referenceExpression = getUParentForIdentifier(element) as? USimpleNameReferenceExpression ?: return null
         val uElementParent = element.parent.parent.toUElement()
         val isConstructor = uElementParent is UCallExpression && uElementParent.kind == UastCallKind.CONSTRUCTOR_CALL

src/main/kotlin/org/axonframework/intellij/ide/plugin/resolving/MessageCreationResolver.kt

@@ -67,43 +67,19 @@ class MessageCreationResolver(private val project: Project) {
         return resolveCreatorsForFqns(classesForQualifiedName)
     }
 
-    private fun findAll(): List<MessageCreator> {
-        val handlers = handlerResolver.findAllHandlers()
-        val payloads = handlers.map { it.payload }.distinct()
-        return payloads.flatMap { findByPayload(it) }
-    }
-
     private fun resolveCreatorsForFqns(fqns: List<String>): List<MessageCreator> {
         return fqns.flatMap { typeFqn ->
             psiFacade.findClasses(typeFqn, project.axonScope()).flatMap { clazz ->
-                clazz.constructors
+                // Account for constructors and builder methods (builder(), toBuilder(), etc)
+                val methods = clazz.constructors + clazz.methods.filter { it.name.contains("build", ignoreCase = true) }
+                methods
                     .flatMap { MethodReferencesSearch.search(it, project.axonScope(), true) }
                     .flatMap { ref -> createCreators(typeFqn, ref.element) }
                     .distinct()
             }
         }
     }
 
-    /**
-     * Finds the already constructed/found creator in the caches. Useful for quick filtering in line marker popups.
-     */
-    fun findCreatorByElement(element: PsiElement): MessageCreator? {
-        return constructorsByPayloadCache.values.filter { it.hasUpToDateValue() }
-            .flatMap { it.value }
-            .firstOrNull { it.element == element }
-    }
-
-    /**
-     * This action is VERY expensive. Should only be used if the user does not depend on it or is expected to wait.
-     * For example, when creating an Event Modeling board based on this info.
-     *
-     * @return List of all message creators in an application
-     */
-    fun resolveAllCreators(): List<MessageCreator> {
-        return findAll()
-            .flatMap { createCreators(it.payload, it.element) }
-    }
-
     private fun createCreators(payload: String, element: PsiElement): List<MessageCreator> {
         val parentHandlers = element.findParentHandlers()
         if (parentHandlers.isEmpty()) {

src/test/kotlin/org/axonframework/intellij/ide/plugin/creators/MessageCreatorResolverTest.kt

@@ -162,4 +162,41 @@ class MessageCreatorResolverTest : AbstractAxonFixtureTestCase() {
             it.renderContainerText() == null
         }
     }
+
+    fun `test resolves builder method as payload creator`() {
+        addFile("MyBuilderBasedEvent.java", """
+            public class MyBuilderBasedEvent {
+                public static class Builder {
+                    public MyBuilderBasedEvent build() {
+                        return new MyBuilderBasedEvent();
+                    }
+                }
+                
+                public Builder builder() {
+                    return new Builder();
+                }
+            }
+        """.trimIndent())
+
+        addFile(
+            "MyAggregate.java", """        
+            import test.MyBuilderBasedEvent;
+            
+            @AggregateRoot
+            class MyAggregate {
+               @CommandHandler
+               public void handle(MyCommand command) {
+                    AggregateLifecycle.apply(MyBuilderBasedEvent.builder().build());
+               }
+           }
+        """.trimIndent(), open = true
+        )
+
+        val creators = project.creatorResolver().getCreatorsForPayload("test.MyBuilderBasedEvent")
+        Assertions.assertThat(creators).anyMatch {
+            it.payload == "test.MyBuilderBasedEvent" &&
+                    it.renderText() == "MyAggregate.handle"
+            it.renderContainerText() == null
+        }
+    }
 }

src/test/kotlin/org/axonframework/intellij/ide/plugin/markers/ClassLineMarkerProviderTest.kt

@@ -21,7 +21,6 @@ import org.axonframework.intellij.ide.plugin.AbstractAxonFixtureTestCase
 import org.axonframework.intellij.ide.plugin.AxonIcons
 
 class ClassLineMarkerProviderTest : AbstractAxonFixtureTestCase() {
-
     fun `test shows line marker when is used in a command`() {
         addFile(
             "MyAggregate.kt", """

src/test/kotlin/org/axonframework/intellij/ide/plugin/markers/publishers/PublishMethodLineMarkerProviderTest.kt

@@ -229,4 +229,51 @@ class PublishMethodLineMarkerProviderTest : AbstractAxonFixtureTestCase() {
             OptionSummary("MyProcessingGroup", "test", AxonIcons.Handler)
         )
     }
+
+    fun `test shows publish icon on builder method`() {
+        addFile("MyBuilderBasedEvent.java", """
+            public class MyBuilderBasedEvent {
+                public static class Builder {
+                    public MyBuilderBasedEvent build() {
+                        return new MyBuilderBasedEvent();
+                    }
+                }
+                
+                public Builder builder() {
+                    return new Builder();
+                }
+            }
+        """.trimIndent())
+
+        addFile(
+            "MyAggregate.java", """        
+            import test.MyBuilderBasedEvent;
+            
+            @AggregateRoot
+            class MyAggregate {
+               @CommandHandler
+               public void handle(MyCommand command) {
+                    AggregateLifecycle.apply(MyBuilderBasedEvent.builder().build());<caret>
+               }
+           }
+        """.trimIndent(), open = true
+        )
+
+        addFile(
+            "MyProcessingGroup.java", """        
+            import test.MyBuilderBasedEvent;
+            
+            class MyProcessingGroup {
+               @EventHandler
+               public void handle(MyBuilderBasedEvent event) {
+               }
+           }
+        """.trimIndent()
+        )
+
+        assertThat(hasLineMarker(PublishMethodLineMarkerProvider::class.java)).isTrue
+        assertThat(getLineMarkerOptions(PublishMethodLineMarkerProvider::class.java)).containsExactly(
+            OptionSummary("MyProcessingGroup", "test", AxonIcons.Handler)
+        )
+    }
 }