Merge pull request #11 from nickalie/master

added run icon for Taskfile.yml tasks

Author: lechuckroh

build.gradle

@@ -8,7 +8,7 @@ apply plugin: 'kotlin'
 apply plugin: 'org.jetbrains.intellij'
 
 group 'lechuck'
-version '1.5.0'
+version '1.6.0'
 
 sourceCompatibility = 17
 targetCompatibility = 17
@@ -39,6 +39,7 @@ dependencies {
 intellij {
     version = '2023.1'
     updateSinceUntilBuild = false
+    plugins = ['org.jetbrains.plugins.yaml']
 }
 
 buildSearchableOptions {

src/main/kotlin/lechuck/intellij/TaskLineMarkerProvider.kt

@@ -0,0 +1,100 @@
+package lechuck.intellij
+
+import com.intellij.execution.ExecutionException
+import com.intellij.execution.ExecutorRegistry
+import com.intellij.execution.executors.DefaultRunExecutor
+import com.intellij.execution.runners.ExecutionEnvironmentBuilder
+import com.intellij.execution.impl.RunManagerImpl
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
+import com.intellij.execution.lineMarker.RunLineMarkerContributor
+import com.intellij.icons.AllIcons
+import org.jetbrains.yaml.psi.YAMLKeyValue
+import org.jetbrains.yaml.psi.YAMLMapping
+
+class TaskLineMarkerProvider : RunLineMarkerContributor() {
+    companion object {
+        val TASKFILE_PATTERN = Regex("taskfile(?:\\.dist)?\\.ya?ml", RegexOption.IGNORE_CASE)
+    }
+
+    override fun getInfo(element: PsiElement): Info? {
+        // Only process YAML files named: Taskfile.yml, taskfile.yml, Taskfile.yaml, taskfile.yaml,
+        // Taskfile.dist.yml, taskfile.dist.yml, Taskfile.dist.yaml, taskfile.dist.yaml
+        val file = element.containingFile
+        if (!file.name.matches(TASKFILE_PATTERN)) {
+            return null
+        }
+
+        // We want to match only the key element of a task
+        if (element.parent !is YAMLKeyValue) {
+            return null
+        }
+        val keyValue = element.parent as YAMLKeyValue
+
+        // Check if this key is directly under the tasks section
+        val tasksSection = keyValue.parent?.parent
+        if (tasksSection !is YAMLKeyValue || tasksSection.keyText != "tasks") {
+            return null
+        }
+
+        // Check if the value is a mapping (has child elements)
+        if (keyValue.value !is YAMLMapping) {
+            return null
+        }
+
+        // Check if we're on the key element itself
+        if (element != keyValue.key) {
+            return null
+        }
+
+        // This is a task definition, create a run action
+        val taskName = keyValue.keyText
+        return Info(
+            AllIcons.Actions.Execute,
+            { "Run Task: $taskName" },
+            TaskRunAction(taskName, element.project, file.virtualFile.path)
+        )
+    }
+
+    private class TaskRunAction(
+        private val taskName: String,
+        private val project: Project,
+        private val taskfilePath: String
+    ) : AnAction() {
+        override fun actionPerformed(e: AnActionEvent) {
+            val runManager = RunManagerImpl.getInstanceImpl(project)
+            val configurationType = TaskRunConfigurationType()
+
+            val configurationName = "Task: $taskName"
+            val existingConfiguration = runManager.findConfigurationByName(configurationName)
+
+            val configuration = if (existingConfiguration != null) {
+                existingConfiguration
+            } else {
+                val factory = configurationType.configurationFactories[0]
+                runManager.createConfiguration(configurationName, factory)
+            }
+
+            val runConfig = configuration.configuration as TaskRunConfiguration
+            runConfig.task = taskName
+            runConfig.filename = taskfilePath
+
+            if (existingConfiguration == null) {
+                runManager.addConfiguration(configuration)
+            }
+
+            runManager.selectedConfiguration = configuration
+
+            try {
+                val executor = ExecutorRegistry.getInstance().getExecutorById(DefaultRunExecutor.EXECUTOR_ID)
+                if (executor != null) {
+                    ExecutionEnvironmentBuilder.create(executor, configuration)?.buildAndExecute()
+                }
+            } catch (ex: ExecutionException) {
+                ex.printStackTrace()
+            }
+        }
+    }
+}

src/main/resources/META-INF/plugin.xml

@@ -63,9 +63,13 @@
     <!-- please see https://plugins.jetbrains.com/docs/intellij/plugin-compatibility.html
          on how to target different products -->
     <depends>com.intellij.modules.platform</depends>
+    <depends>org.jetbrains.plugins.yaml</depends>
 
     <extensions defaultExtensionNs="com.intellij">
         <configurationType implementation="lechuck.intellij.TaskRunConfigurationType"/>
+        <runLineMarkerContributor
+                language="yaml"
+                implementationClass="lechuck.intellij.TaskLineMarkerProvider"/>
     </extensions>
 
     <actions>

src/test/kotlin/lechuck/intellij/TaskLineMarkerProvider.kt

@@ -0,0 +1,85 @@
+package lechuck.intellij
+
+import com.intellij.testFramework.fixtures.BasePlatformTestCase
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.yaml.psi.YAMLKeyValue
+
+class TaskLineMarkerProviderTest : BasePlatformTestCase() {
+    private val provider = TaskLineMarkerProvider()
+
+    fun testTaskfilePatternMatching() {
+        val validNames = listOf(
+            "Taskfile.yml",
+            "taskfile.yml",
+            "Taskfile.yaml",
+            "taskfile.yaml",
+            "Taskfile.dist.yml",
+            "taskfile.dist.yml",
+            "Taskfile.dist.yaml",
+            "taskfile.dist.yaml"
+        )
+
+        val invalidNames = listOf(
+            "other.yml",
+            "taskfile.json",
+            "taskfile.yaml.bak",
+            "mytaskfile.yml"
+        )
+
+        validNames.forEach { name ->
+            assertTrue("Should match: $name", name.matches(TaskLineMarkerProvider.TASKFILE_PATTERN))
+        }
+
+        invalidNames.forEach { name ->
+            assertFalse("Should not match: $name", name.matches(TaskLineMarkerProvider.TASKFILE_PATTERN))
+        }
+    }
+
+    fun testGetInfoForValidTaskKey() {
+        val yamlFile = """
+            tasks:
+              test:
+                cmds:
+                  - echo "test"
+        """.trimIndent()
+
+        val file = myFixture.configureByText("Taskfile.yml", yamlFile)
+        val taskKey = findTaskKey(file, "test")
+
+        assertNotNull(taskKey)
+        val info = provider.getInfo(taskKey!!)
+        assertNotNull("Should return Info for valid task key", info)
+        assertEquals("Run Task: test", info?.tooltipProvider?.apply(taskKey))
+    }
+
+    fun testGetInfoForNonTaskKey() {
+        val yamlFile = """
+            version: '3'
+            tasks:
+              test:
+                cmds:
+                  - echo "test"
+        """.trimIndent()
+
+        val file = myFixture.configureByText("Taskfile.yml", yamlFile)
+        val versionKey = findKey(file, "version")
+
+        assertNotNull(versionKey)
+        val info = provider.getInfo(versionKey!!)
+        assertNull("Should return null for non-task key", info)
+    }
+
+    private fun findTaskKey(file: PsiFile, taskName: String): PsiElement? {
+        return PsiTreeUtil.findChildrenOfType(file, YAMLKeyValue::class.java)
+            .find { it.keyText == taskName && it.parent?.parent is YAMLKeyValue }
+            ?.key
+    }
+
+    private fun findKey(file: PsiFile, keyName: String): PsiElement? {
+        return PsiTreeUtil.findChildrenOfType(file, YAMLKeyValue::class.java)
+            .find { it.keyText == keyName }
+            ?.key
+    }
+}