find OpenAPI in more modules

Author: hauner

src/main/kotlin/io/openapiprocessor/intellij/MappingAnnotationLineMarker.kt

@@ -10,15 +10,19 @@ import com.intellij.codeInsight.daemon.RelatedItemLineMarkerProvider
 import com.intellij.codeInsight.navigation.NavigationGutterIconBuilder
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.ProjectRootManager
 import com.intellij.openapi.util.IconLoader
-import com.intellij.psi.*
+import com.intellij.psi.PsiAnnotation
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiManager
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.util.firstLeaf
 import com.intellij.util.IconUtil
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 
+/**
+ * line marker to navigate from mapping annotation (from interface) to the path in the OpenAPI document.
+ */
 class MappingAnnotationLineMarker: RelatedItemLineMarkerProvider() {
     private val log: Logger = LoggerFactory.getLogger(javaClass.name)
 
@@ -41,11 +45,14 @@ class MappingAnnotationLineMarker: RelatedItemLineMarkerProvider() {
         }
 
         val apiPath = match.path(element)
-        val module = findModule(element) ?: return null
+        val modules = findModules(element)
 
-        val scope = GlobalSearchScope.moduleScope(module)
-        val targets = findPsiElementsOfPath(apiPath!!, scope, element.project)
+        var searchScope = GlobalSearchScope.EMPTY_SCOPE
+        for (module in modules) {
+            searchScope = searchScope.uniteWith(GlobalSearchScope.moduleScope(module))
+        }
 
+        val targets = findPsiElementsOfPath(apiPath!!, searchScope, element.project)
         if (targets.isEmpty()) {
             log.warn("found no targets!")
             return null
@@ -62,18 +69,20 @@ class MappingAnnotationLineMarker: RelatedItemLineMarkerProvider() {
         return builder.createLineMarkerInfo(id)
     }
 
-    private fun findModule(element: PsiElement): Module? {
-        val found = ProjectRootManager.getInstance(element.project)
-            .fileIndex
-            .getModuleForFile(element.containingFile.virtualFile)
+    private fun findModules(element: PsiElement): List<Module> {
+        val finder = ModuleFinder(element.project)
+        val modules = finder.findModules(element.containingFile.virtualFile.presentableUrl)
 
-        if (found != null) {
-            log.debug("found module '{}' of file '{}'", found.name, element.containingFile.name)
+        if (modules.isNotEmpty()) {
+            modules.forEach {
+                log.debug("related modules of file '{}'", element.containingFile.name)
+                log.debug("found module '{}'", it.name)
+            }
         } else {
             log.debug("could not find module of file '{}'", element.containingFile.name)
         }
 
-        return found
+        return modules
     }
 
     private fun findPsiElementsOfPath(path: String, searchScope: GlobalSearchScope, project: Project): List<PsiElement> {

src/main/kotlin/io/openapiprocessor/intellij/ModuleFinder.kt

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2025 https://github.com/openapi-processor/openapi-processor-intellij
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.intellij
+
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleManager
+import com.intellij.openapi.project.Project
+import com.intellij.platform.backend.workspace.WorkspaceModel
+import com.intellij.platform.workspace.jps.entities.ModuleEntity
+import com.intellij.platform.workspace.jps.entities.sourceRoots
+import java.nio.file.Path
+import kotlin.io.path.name
+import kotlin.math.min
+
+class ModuleFinder(private val project: Project) {
+
+    fun findModules(sourceUrl: String): List<Module> {
+        val source = getRelativeUrl(sourceUrl)
+
+        val results = mutableMapOf<ModuleEntity, List<String>>()
+
+        val wm = WorkspaceModel.getInstance(project)
+
+        wm.currentSnapshot.entities(ModuleEntity::class.java)
+            .filter { it.sourceRoots.isNotEmpty() }
+            .forEach { moduleEntity ->
+                val sourceRoots = mutableListOf<Path>()
+
+                moduleEntity.sourceRoots.forEach {
+                    sourceRoots.add(Path.of(getRelativeUrl(it.url.presentableUrl)))
+                }
+
+                val matches = matchPaths(Path.of(source), sourceRoots)
+
+                if (matches.isNotEmpty()) {
+                    results.put(moduleEntity, matches)
+                }
+            }
+
+        val moduleManager = ModuleManager.getInstance(project)
+        val modules = results.filter {  it.value.isNotEmpty() }
+            .keys
+            .map { m -> moduleManager.findModuleByName(m.name)!! }
+
+        return modules
+    }
+
+    private fun matchPaths(source: Path, candidates: List<Path>): List<String> {
+        var matchingItems = listOf<String>()
+
+        val sourceItems = splitPath(source)
+
+        for (candidate in candidates) {
+            val canSplit = splitPath(candidate)
+
+            val min = min(sourceItems.size, canSplit.size)
+            val matching = mutableListOf<String>()
+
+            for (i in 0.. min - 1) {
+                if (sourceItems[i] != canSplit[i]) {
+                    break
+                }
+
+                matching.add(sourceItems[i])
+            }
+
+            if (matching.size > matchingItems.size) {
+                matchingItems = matching
+            }
+        }
+
+        return matchingItems
+    }
+
+    private fun splitPath(path: Path): List<String> {
+        val result = mutableListOf<String>()
+        path.forEach { result.add(it.name) }
+        return result
+    }
+
+    private fun getRelativeUrl(sourceUrl: String): String {
+        return sourceUrl.substring(project.presentableUrl!!.length)
+    }
+}