fix: search result for selector is template labels (redhat-developer#642)

Author: adietish

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/editor/ResourceEditor.kt

@@ -428,7 +428,7 @@ open class ResourceEditor(
 
     override fun dispose() {
         resourceModel.removeListener(onNamespaceContextChanged)
-        editorResources.dispose()
         connection.dispose()
+        editorResources.dispose()
     }
 }

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/editor/inlay/ResourceEditorInlayHintsProvider.kt

@@ -102,7 +102,6 @@ internal class ResourceEditorInlayHintsProvider : InlayHintsProvider<NoSettings>
 
 			val fileType = editor.virtualFile?.fileType ?: return
 			val project = editor.project ?: return
-			//PsiElements.getAll(fileType, project)
 			val allElements = PsiElements.getAllNoExclusions(fileType, project)
 			SelectorPresentations.createForSelector(element, allElements, sink, editor, factory)
 			SelectorPresentations.createForAllLabels(element, allElements, sink, editor, factory)

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/editor/inlay/selector/SelectorPresentations.kt

@@ -157,8 +157,6 @@ object SelectorPresentations {
             val project = editor.project
             if (project != null) {
                 ShowUsagesAction.startFindUsages(hintedKeyValue, RelativePoint(event), editor)
-                //ShowUsagesDispatcher.runWithCustomScope(project, hintedKeyValue)
-                //ShowUsagesDispatcher.findUsageManager(project, hintedKeyValue, editor)
             }
         }
     }

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/editor/inlay/selector/ShowUsagesDispatcher.kt

@@ -13,16 +13,12 @@ package com.redhat.devtools.intellij.kubernetes.model
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.util.concurrency.AppExecutorUtil
 import io.fabric8.kubernetes.api.model.HasMetadata
-import io.fabric8.kubernetes.client.KubernetesClientException
 import io.fabric8.kubernetes.client.Watch
 import io.fabric8.kubernetes.client.Watcher
 import io.fabric8.kubernetes.client.WatcherException
-import org.jetbrains.concurrency.runAsync
 import java.util.*
 import java.util.concurrent.BlockingDeque
 import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.ExecutorService
-import java.util.concurrent.Executors
 import java.util.concurrent.LinkedBlockingDeque
 
 /**
@@ -32,7 +28,8 @@ import java.util.concurrent.LinkedBlockingDeque
 open class ResourceWatch<T>(
     protected val watchOperations: BlockingDeque<WatchOperation<*>> = LinkedBlockingDeque(),
     watchOperationsRunner: Runnable = WatchOperationsRunner(watchOperations),
-    private val executor: (runnable: Runnable) -> Unit = { runnable -> AppExecutorUtil.getAppExecutorService().execute(runnable) }
+    private val executor: (runnable: Runnable) -> Unit = { runnable ->
+        AppExecutorUtil.getAppExecutorService().execute(runnable) }
 ) {
     companion object {
         @JvmField val WATCH_OPERATION_ENQUEUED: Watch = Watch {  }

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/model/ResourceWatch.kt

@@ -11,7 +11,6 @@
 package com.redhat.devtools.intellij.kubernetes.usage
 
 import com.intellij.psi.PsiElement
-import com.intellij.psi.util.PsiElementFilter
 import com.redhat.devtools.intellij.common.validation.KubernetesTypeInfo
 import com.redhat.devtools.intellij.kubernetes.editor.util.areMatchingMatchExpressions
 import com.redhat.devtools.intellij.kubernetes.editor.util.areMatchingMatchLabels
@@ -38,7 +37,7 @@ import com.redhat.devtools.intellij.kubernetes.editor.util.isStatefulSet
 /**
  * A filter that accepts labels, that are matching a given selector.
  */
-class LabelsFilter(selector: PsiElement): PsiElementFilter {
+class LabelsFilter(selector: PsiElement): PsiElementMappingsFilter {
 
     private val selectorResource: PsiElement? by lazy {
         selector.getResource()
@@ -129,6 +128,11 @@ class LabelsFilter(selector: PsiElement): PsiElementFilter {
         }
     }
 
+    override fun getMatchingElement(element: PsiElement): PsiElement? {
+        val labeledType = element.getKubernetesTypeInfo() ?: return null
+        return getLabels(labeledType, element, selectorResourceType)
+    }
+
     private fun getLabels(
         labeledType: KubernetesTypeInfo,
         labeledResource: PsiElement,

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/usage/LabelsFilter.kt

@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Red Hat, Inc.
+ * Distributed under license by Red Hat, Inc. All rights reserved.
+ * This program is made available under the terms of the
+ * Eclipse Public License v2.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v20.html
+ *
+ * Contributors:
+ * Red Hat, Inc. - initial API and implementation
+ ******************************************************************************/
+package com.redhat.devtools.intellij.kubernetes.usage
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiElementFilter
+
+interface PsiElementMappingsFilter: PsiElementFilter {
+    fun getMatchingElement(element: PsiElement): PsiElement?
+}

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/usage/PsiElementMappingsFilter.kt

@@ -20,9 +20,7 @@ import com.intellij.usages.Usage
 import com.intellij.usages.UsageInfo2UsageAdapter
 import com.intellij.util.Processor
 import com.redhat.devtools.intellij.kubernetes.editor.util.PsiElements
-import com.redhat.devtools.intellij.kubernetes.editor.util.getLabels
 import com.redhat.devtools.intellij.kubernetes.editor.util.getResource
-import com.redhat.devtools.intellij.kubernetes.editor.util.getSelector
 import com.redhat.devtools.intellij.kubernetes.editor.util.isLabels
 import com.redhat.devtools.intellij.kubernetes.editor.util.isSelector
 
@@ -53,9 +51,10 @@ class SelectorUsageSearcher : CustomUsageSearcher() {
              **/
             //val searchScope = options.searchScope
             //if (searchScope.contains(file.virtualFile)) {
-            getAllMatching(searchParameter)
+            val filter = getFilter(searchParameter) ?:  return@run
+            getAllMatching(searchParameter, filter)
                 .forEach { matchingElement ->
-                    val searchResult = getMatchingAttribute(searchParameter, matchingElement)
+                    val searchResult = filter.getMatchingElement(matchingElement)?.parent
                     if (searchResult != null) {
                         processor.process(
                             UsageInfo2UsageAdapter(UsageInfo(searchResult))
@@ -65,15 +64,14 @@ class SelectorUsageSearcher : CustomUsageSearcher() {
         }
     }
 
-    private fun getAllMatching(searchParameter: PsiElement): Collection<PsiElement> {
+    private fun getAllMatching(searchParameter: PsiElement, filter:  PsiElementFilter): Collection<PsiElement> {
         val fileType = searchParameter.containingFile.fileType
         val project = searchParameter.project
-        val filter = getFilter(searchParameter) ?: return emptyList()
         return PsiElements.getAllNoExclusions(fileType, project)
             .filter(filter::isAccepted)
     }
 
-    private fun getFilter(searchParameter: PsiElement): PsiElementFilter? {
+    private fun getFilter(searchParameter: PsiElement): PsiElementMappingsFilter? {
         val resource = searchParameter.getResource() ?: return null
         return when {
             searchParameter.isSelector() ->
@@ -87,14 +85,4 @@ class SelectorUsageSearcher : CustomUsageSearcher() {
         }
     }
 
-    private fun getMatchingAttribute(searchParameter: PsiElement, matchingElement: PsiElement): PsiElement? {
-        return when {
-            searchParameter.isSelector() ->
-                matchingElement.getLabels()?.parent // beginning of labels block/property
-            searchParameter.isLabels() ->
-                matchingElement.getSelector()?.parent // beginning of selector block/property
-            else ->
-                null
-        }
-    }
 }

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/usage/SelectorUsageSearcher.kt

@@ -14,14 +14,15 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiElementFilter
 import com.redhat.devtools.intellij.common.validation.KubernetesTypeInfo
 import com.redhat.devtools.intellij.kubernetes.editor.util.getKubernetesTypeInfo
+import com.redhat.devtools.intellij.kubernetes.editor.util.getSelector
 import com.redhat.devtools.intellij.kubernetes.editor.util.hasLabels
 import com.redhat.devtools.intellij.kubernetes.editor.util.hasSelector
 import com.redhat.devtools.intellij.kubernetes.editor.util.hasTemplateLabels
 
 /**
  * A filter that accepts selectors that are matching a given label
  */
-class SelectorsFilter(private val labeledResource: PsiElement): PsiElementFilter {
+class SelectorsFilter(private val labeledResource: PsiElement): PsiElementMappingsFilter {
 
     private val labeledResourceType: KubernetesTypeInfo? by lazy {
         labeledResource.getKubernetesTypeInfo()
@@ -32,6 +33,10 @@ class SelectorsFilter(private val labeledResource: PsiElement): PsiElementFilter
                 || labeledResource.hasTemplateLabels()
     }
 
+    override fun getMatchingElement(element: PsiElement): PsiElement? {
+        return element.getSelector()
+    }
+
     override fun isAccepted(toAccept: PsiElement): Boolean {
         if (labeledResourceType == null
             || !hasLabels

src/main/kotlin/com/redhat/devtools/intellij/kubernetes/usage/SelectorsFilter.kt

@@ -35,6 +35,7 @@ class LabelsFilterTest {
 
     private lateinit var hasMatchLabelsAndExpressions: YAMLMapping
     private lateinit var matchingPod: YAMLMapping
+    private lateinit var matchingPodLabels: YAMLMapping
 
     @Before
     fun before() {
@@ -59,11 +60,11 @@ class LabelsFilterTest {
         this.matchingPod = createYAMLMapping(listOf(
             createYAMLKeyValue("kind", "Pod")
         ))
-        matchingPod.createLabels(
+        this.matchingPodLabels = matchingPod.createLabels(
             createYAMLMapping(listOf(
                 createYAMLKeyValue(LABEL_KEY, LABEL_VALUE)
             ))
-        )
+        ).value as YAMLMapping
 
         this.filter = LabelsFilter(hasMatchLabelsAndExpressions)
     }
@@ -213,4 +214,40 @@ class LabelsFilterTest {
         assertThat(isAccepted).isTrue()
     }
 
+    @Test
+    fun `#getMatchingElement returns pod labels that match given deployment selector`() {
+        // given
+        // when
+        val matchingElement = filter.getMatchingElement(matchingPod)
+        // then
+        assertThat(matchingElement).isEqualTo(matchingPodLabels)
+    }
+
+    @Test
+    fun `#getMatchingElement returns deployment template labels that match given deployment selector`() {
+        // given
+        val matchingTemplateLabels = createYAMLMapping(listOf(
+            createYAMLKeyValue("kind", "Deployment")
+        ))
+        val templateLabels = createYAMLMapping(listOf(
+            createYAMLKeyValue(LABEL_KEY, LABEL_VALUE) // matching labels in spec>template
+        ))
+        matchingTemplateLabels.createTemplate(
+            createYAMLMapping(listOf(
+                createYAMLKeyValue(
+                    "metadata",
+                    createYAMLMapping(listOf(
+                        createYAMLKeyValue(
+                            "labels",
+                            templateLabels
+                        )
+                    ))
+                )
+            ))
+        )
+        // when
+        val matchingElement = filter.getMatchingElement(matchingTemplateLabels)
+        // then
+        assertThat(matchingElement).isEqualTo(templateLabels)
+    }
 }