Merge pull request #45 from gerardorodriguezdev/plugin-upgrades

plugin-upgrades

Author: gerardorodriguezdev

gradle-plugin/README.md

@@ -19,7 +19,7 @@ plugins {
 > This plugin is hosted on
 > the [Gradle Plugins Portal](https://plugins.gradle.org/plugin/io.github.gerardorodriguezdev.chamaleon)
 
-### 2. Run `./gradlew :chamaleonGenerateSample`
+### 2. Run `./gradlew :generateSample`
 
 This task will generate the following files:
 
@@ -195,7 +195,7 @@ You would need to generate your production environment file programmatically, as
 secrets.
 Here is an example of how to do it:
 
-`./gradlew :chamaleonGenerateEnvironment -Pchamaleon.environment="myProductionEnvironment.jvm.properties[mySecretName=mySecretValue]"`
+`./gradlew :generateEnvironment -Pchamaleon.environment="myProductionEnvironment.jvm.properties[mySecretName=mySecretValue]"`
 
 The input command, in this case `myProductionEnvironment.jvm.properties[mySecretName=mySecretValue]`, has the following
 structure:
@@ -209,7 +209,7 @@ After running this task, your production environment file will be generated on y
 > If you want to create an environment with more than one platform, you can run the same command with each of the
 > additional platforms, and they will be merged in the environment
 >
-> ./gradlew :chamaleonGenerateEnvironment
+> ./gradlew :generateEnvironment
 >
 > -Pchamaleon.environment="myProductionEnvironment.jvm.properties[mySecretName=mySecretValue]"
 >
@@ -221,7 +221,7 @@ After running this task, your production environment file will be generated on y
 
 Finally, the only remaining thing to do is to select the generated environment like this:
 
-`./gradlew :chamaleonSelectEnvironment -Pchamaleon.newSelectedEnvironment=myProductionEnvironment`
+`./gradlew :selectEnvironment -Pchamaleon.newSelectedEnvironment=myProductionEnvironment`
 
 It will create or update the `properties.chamaleon.json` file to point to your `myProductionEnvironment`
 
@@ -230,8 +230,8 @@ It will create or update the `properties.chamaleon.json` file to point to your `
 ```yaml
     - name: Generate and select production environment # Your step name
       run: |
-        ./gradlew :chamaleonGenerateEnvironment -Pchamaleon.environment="myProductionEnvironment.jvm.properties[mySecretName=${{ secrets.MY_GITHUB_SECRET }}]"
-        ./gradlew :chamaleonSelectEnvironment -Pchamaleon.newSelectedEnvironment=myProductionEnvironment
+        ./gradlew :generateEnvironment -Pchamaleon.environment="myProductionEnvironment.jvm.properties[mySecretName=${{ secrets.MY_GITHUB_SECRET }}]"
+        ./gradlew :selectEnvironment -Pchamaleon.newSelectedEnvironment=myProductionEnvironment
 ```
 
 ### Restricting some properties only for certain platforms

gradle-plugin/src/main/kotlin/io/github/gerardorodriguezdev/chamaleon/gradle/plugin/ChamaleonGradlePlugin.kt

@@ -70,6 +70,8 @@ public class ChamaleonGradlePlugin : Plugin<Project> {
 
     private fun Project.registerGenerateSampleTask(): TaskProvider<GenerateSampleTask> =
         tasks.register(GENERATE_SAMPLE_TASK_NAME, GenerateSampleTask::class.java) {
+            group = EXTENSION_NAME
+
             val generateSampleCommandLineArgument =
                 providers.gradleProperty(GENERATE_SAMPLE_COMMAND_LINE_ARGUMENT).orNull
 
@@ -86,6 +88,8 @@ public class ChamaleonGradlePlugin : Plugin<Project> {
         extension: ChamaleonExtension,
     ): TaskProvider<SelectEnvironmentTask> =
         tasks.register(SELECT_ENVIRONMENT_TASK_NAME, SelectEnvironmentTask::class.java) {
+            group = EXTENSION_NAME
+
             val newSelectedEnvironmentNameString =
                 providers.gradleProperty(SELECT_ENVIRONMENT_COMMAND_LINE_ARGUMENT).orNull
 
@@ -106,6 +110,8 @@ public class ChamaleonGradlePlugin : Plugin<Project> {
         extension: ChamaleonExtension,
     ): TaskProvider<GenerateEnvironmentTask> =
         tasks.register(GENERATE_ENVIRONMENT_TASK_NAME, GenerateEnvironmentTask::class.java) {
+            group = EXTENSION_NAME
+
             val generateEnvironmentCommands =
                 providers.gradlePropertiesPrefixedBy(GENERATE_ENVIRONMENT_COMMAND_LINE_ARGUMENT).orNull
 
@@ -116,7 +122,9 @@ public class ChamaleonGradlePlugin : Plugin<Project> {
 
     private fun Project.registerVersionTask(): TaskProvider<DefaultTask> =
         tasks.register(VERSION_TASK_NAME, DefaultTask::class.java) {
-            logger.chamaleonLog("Chamaleon version: ${Versions.CORE}")
+            group = EXTENSION_NAME
+
+            logger.chamaleonLog("Version: ${Versions.CORE}")
         }
 
     private fun Project.environmentsDirectory(): Directory = layout.projectDirectory.dir(ENVIRONMENTS_DIRECTORY_NAME)
@@ -129,12 +137,12 @@ public class ChamaleonGradlePlugin : Plugin<Project> {
     internal companion object {
         const val EXTENSION_NAME = "chamaleon"
 
-        const val GENERATE_SAMPLE_TASK_NAME = "chamaleonGenerateSample"
-        const val SELECT_ENVIRONMENT_TASK_NAME = "chamaleonSelectEnvironment"
-        const val GENERATE_ENVIRONMENT_TASK_NAME = "chamaleonGenerateEnvironment"
-        const val VERSION_TASK_NAME = "chamaleonVersion"
+        const val GENERATE_SAMPLE_TASK_NAME = "generateSample"
+        const val SELECT_ENVIRONMENT_TASK_NAME = "selectEnvironment"
+        const val GENERATE_ENVIRONMENT_TASK_NAME = "generateEnvironment"
+        const val VERSION_TASK_NAME = "version"
 
-        const val GENERATE_SAMPLE_COMMAND_LINE_ARGUMENT = "chamaleon.sampleOutputDirectory"
+        const val GENERATE_SAMPLE_COMMAND_LINE_ARGUMENT = "chamaleon.outputDirectory"
         const val SELECT_ENVIRONMENT_COMMAND_LINE_ARGUMENT = "chamaleon.newSelectedEnvironment"
         const val GENERATE_ENVIRONMENT_COMMAND_LINE_ARGUMENT = "chamaleon.environment"
     }

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 # Platforms
 kotlin = "2.1.10"
-java = "17"
+java = "21"
 
 # Libraries
 kmp-serialization = "1.8.0"
@@ -19,7 +19,7 @@ kmp-arrow = "2.0.1"
 jvm-test-parameterized = "5.12.1"
 
 # Releases
-release = "1.0.11"
+release = "1.0.12"
 
 [libraries]
 detekt-formatting = { module = "io.gitlab.arturbosch.detekt:detekt-formatting", version.ref = "detekt" }

intellij-plugin/plugin/build.gradle.kts

@@ -1,4 +1,5 @@
 import org.jetbrains.intellij.platform.gradle.TestFrameworkType
+import org.jetbrains.intellij.platform.gradle.tasks.RunIdeTask
 
 plugins {
     kotlin("jvm")
@@ -59,12 +60,17 @@ kotlin {
         implementation(projects.intellijPlugin.presentation) {
             exclude(group = "org.jetbrains.kotlinx")
         }
+        implementation(libs.kmp.arrow.core) {
+            exclude(group = "org.jetbrains.kotlinx")
+        }
 
         testImplementation(libs.kmp.test)
         testImplementation(libs.kmp.test.coroutines)
 
         intellijPlatform {
-            intellijIdeaCommunity("2023.3")
+            intellijIdeaCommunity("2024.2.1")
+
+            bundledPlugin("org.jetbrains.kotlin")
 
             pluginVerifier()
             zipSigner()
@@ -80,8 +86,8 @@ intellijPlatform {
         version = libs.versions.release.get()
 
         ideaVersion {
-            sinceBuild = "233"
-            untilBuild = "243.*"
+            sinceBuild = "242"
+            untilBuild = "252.*"
         }
     }
 
@@ -121,4 +127,10 @@ intellijPlatformTesting {
             }
         }
     }
+}
+
+tasks.named<RunIdeTask>("runIde") {
+    jvmArgumentProviders += CommandLineArgumentProvider {
+        listOf("-Didea.kotlin.plugin.use.k2=true")
+    }
 }

intellij-plugin/plugin/src/main/kotlin/io/github/gerardorodriguezdev/chamaleon/intellij/plugin/dialogs/BaseDialog.kt

@@ -28,14 +28,13 @@ internal abstract class BaseDialog(dialogTitle: String) : DialogWrapper(false) {
         finishButton()?.isEnabled = dialogsButtonsState.isFinishButtonEnabled
     }
 
-    override fun createActions(): Array<Action> {
-        return arrayOf(
+    override fun createActions(): Array<Action> =
+        arrayOf(
             cancel,
             previous,
             next,
             finish,
         )
-    }
 
     private fun previousButton(): JButton? = getButton(previous)
 

intellij-plugin/plugin/src/main/kotlin/io/github/gerardorodriguezdev/chamaleon/intellij/plugin/dialogs/createProjectDialog/CreateProjectDialog.kt

@@ -65,23 +65,6 @@ internal class CreateProjectDialog(
         )
     }
 
-    private fun collectState() {
-        uiScope.launch {
-            presenter.stateFlow.collect { createProjectState ->
-                setDialogButtonsState(createProjectState.toDialogButtonsState())
-
-                val newCreateProjectWindowState =
-                    createProjectState.toCreateProjectWindowState(
-                        projectDirectoryPath = projectDirectory.path.value,
-                        stringsProvider = BundleStringsProvider,
-                    )
-                newCreateProjectWindowState?.let {
-                    createProjectWindowState.value = newCreateProjectWindowState
-                }
-            }
-        }
-    }
-
     @OptIn(ExperimentalComposeUiApi::class, ExperimentalJewelApi::class)
     override fun createCenterPanel(): JComponent {
         enableNewSwingCompositing()
@@ -103,6 +86,23 @@ internal class CreateProjectDialog(
         }
     }
 
+    private fun collectState() {
+        uiScope.launch {
+            presenter.stateFlow.collect { createProjectState ->
+                setDialogButtonsState(createProjectState.toDialogButtonsState())
+
+                val newCreateProjectWindowState =
+                    createProjectState.toCreateProjectWindowState(
+                        projectDirectoryPath = projectDirectory.path.value,
+                        stringsProvider = BundleStringsProvider,
+                    )
+                newCreateProjectWindowState?.let {
+                    createProjectWindowState.value = newCreateProjectWindowState
+                }
+            }
+        }
+    }
+
     override fun onDialogAction(action: DialogAction) {
         presenter.dispatch(action.toCreateProjectAction())
     }

intellij-plugin/plugin/src/main/kotlin/io/github/gerardorodriguezdev/chamaleon/intellij/plugin/dialogs/createProjectDialog/mappers/CreateProjectStateToCreateProjectWindowState.kt

@@ -44,8 +44,8 @@ private fun Context.toSetupEnvironment(
 
 private fun Context.toEnvironmentsDirectoryPathField(
     projectDeserializationState: ProjectDeserializationState?
-): Field<String> {
-    return when (projectDeserializationState) {
+): Field<String> =
+    when (projectDeserializationState) {
         null -> Field(value = "", verification = null)
 
         is ProjectDeserializationState.Valid -> Field(
@@ -65,7 +65,6 @@ private fun Context.toEnvironmentsDirectoryPathField(
                 verification = Verification.Invalid(projectDeserializationState.errorMessage),
             )
     }
-}
 
 private fun Context.environmentsDirectoryPathValue(projectDeserializationState: ProjectDeserializationState): String =
     projectDeserializationState.environmentsDirectoryPath.value.removePrefix(projectDirectoryPath)

intellij-plugin/plugin/src/main/kotlin/io/github/gerardorodriguezdev/chamaleon/intellij/plugin/fileTypes/ChamaleonFileType.kt

@@ -0,0 +1,15 @@
+package io.github.gerardorodriguezdev.chamaleon.intellij.plugin.fileTypes
+
+import com.intellij.json.JsonLanguage
+import com.intellij.openapi.fileTypes.LanguageFileType
+import io.github.gerardorodriguezdev.chamaleon.intellij.plugin.icons.Icons
+import io.github.gerardorodriguezdev.chamaleon.intellij.plugin.shared.strings.StringsKeys
+import io.github.gerardorodriguezdev.chamaleon.intellij.plugin.ui.strings.BundleStringsProvider.string
+import javax.swing.Icon
+
+internal class ChamaleonFileType private constructor() : LanguageFileType(JsonLanguage.INSTANCE, true) {
+    override fun getName(): String = "Chamaleon"
+    override fun getDescription(): String = string(StringsKeys.fileTypeForChamaleonConfigFiles)
+    override fun getDefaultExtension(): String = "json"
+    override fun getIcon(): Icon = Icons.pluginIcon
+}

intellij-plugin/plugin/src/main/kotlin/io/github/gerardorodriguezdev/chamaleon/intellij/plugin/psi/PropertyDefinitionPsiReference.kt

@@ -0,0 +1,95 @@
+package io.github.gerardorodriguezdev.chamaleon.intellij.plugin.psi
+
+import arrow.core.Option
+import arrow.core.raise.option
+import com.intellij.extapi.psi.ASTDelegatePsiElement
+import com.intellij.json.psi.JsonArray
+import com.intellij.json.psi.JsonFile
+import com.intellij.json.psi.JsonObject
+import com.intellij.json.psi.JsonValue
+import com.intellij.openapi.module.ModuleUtilCore
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ModuleRootManager
+import com.intellij.openapi.vfs.VfsUtil
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiManager
+import com.intellij.psi.PsiReferenceBase
+import io.github.gerardorodriguezdev.chamaleon.core.models.Project.Companion.ENVIRONMENTS_DIRECTORY_NAME
+import io.github.gerardorodriguezdev.chamaleon.core.models.Project.Companion.SCHEMA_FILE
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
+
+class PropertyDefinitionPsiReference(element: KtStringTemplateExpression) :
+    PsiReferenceBase<KtStringTemplateExpression>(element, true) {
+
+    override fun resolve(): PsiElement? =
+        option {
+            val project = element.project
+
+            val schemaPsiFile = project.schemaPsiFile().bind()
+            val schemaJsonFile = (schemaPsiFile as? JsonFile).bind()
+
+            val schemaJsonObject = (schemaJsonFile.topLevelValue as? JsonObject).bind()
+
+            val propertyDefinitionsJsonValue = schemaJsonObject.findProperty(
+                PROPERTY_DEFINITIONS_PROPERTY_NAME
+            )?.value.bind()
+
+            propertyDefinitionPsiElement(
+                propertyDefinitionValueToFind = element.cleanedText(),
+                propertyDefinitionsJsonArray = (propertyDefinitionsJsonValue as? JsonArray).bind(),
+            ).bind()
+        }.getOrNull()
+
+    private fun Project.schemaPsiFile(): Option<PsiFile> =
+        option {
+            val module = ModuleUtilCore.findModuleForPsiElement(element).bind()
+            val moduleRootManager = ModuleRootManager.getInstance(module)
+            val virtualFiles = moduleRootManager.contentRoots
+            schemaPsiFile(this@schemaPsiFile, virtualFiles).bind()
+        }
+
+    private fun schemaPsiFile(
+        project: Project,
+        virtualFiles: Array<VirtualFile>,
+    ): Option<PsiFile> =
+        option {
+            val schemaVirtualFile = virtualFiles.firstNotNullOfOrNull { root ->
+                VfsUtil.findRelativeFile(SCHEMA_RELATIVE_PATH, root)
+            }.bind()
+            PsiManager.getInstance(project).findFile(schemaVirtualFile).bind()
+        }
+
+    private fun propertyDefinitionPsiElement(
+        propertyDefinitionValueToFind: String,
+        propertyDefinitionsJsonArray: JsonArray,
+    ): Option<PsiElement> =
+        option {
+            propertyDefinitionsJsonArray
+                .valueList
+                .firstOrNull { propertyDefinition ->
+                    val propertyDefinitionJsonObject = propertyDefinition as? JsonObject
+                    val propertyDefinitionJsonProperty = propertyDefinitionJsonObject?.findProperty(
+                        PROPERTY_DEFINITION_PROPERTY_NAME
+                    )
+                    propertyDefinitionJsonProperty?.value?.cleanedText() == propertyDefinitionValueToFind
+                }
+                .bind()
+                .firstChild
+        }
+
+    private fun String.clean(): String = removeSurrounding("\"")
+
+    private fun ASTDelegatePsiElement.cleanedText(): String = text.clean()
+
+    private fun JsonValue.cleanedText(): String = text.clean()
+
+    override fun getVariants(): Array<Any> = emptyArray()
+
+    private companion object {
+        const val PROPERTY_DEFINITIONS_PROPERTY_NAME = "propertyDefinitions"
+        const val PROPERTY_DEFINITION_PROPERTY_NAME = "name"
+        const val SCHEMA_RELATIVE_PATH = "$ENVIRONMENTS_DIRECTORY_NAME/$SCHEMA_FILE"
+    }
+}

intellij-plugin/plugin/src/main/kotlin/io/github/gerardorodriguezdev/chamaleon/intellij/plugin/psi/PropertyDefinitionReferenceContributor.kt

@@ -0,0 +1,22 @@
+package io.github.gerardorodriguezdev.chamaleon.intellij.plugin.psi
+
+import com.intellij.patterns.PlatformPatterns
+import com.intellij.patterns.PlatformPatterns.psiFile
+import com.intellij.psi.PsiReferenceContributor
+import com.intellij.psi.PsiReferenceRegistrar
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
+
+internal class PropertyDefinitionReferenceContributor : PsiReferenceContributor() {
+    override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
+        registrar.registerReferenceProvider(
+            PlatformPatterns
+                .psiElement(KtStringTemplateExpression::class.java)
+                .inFile(psiFile().withName(BUILD_GRADLE_FILE_NAME)),
+            PropertyDefinitionReferenceProvider(),
+        )
+    }
+
+    private companion object {
+        const val BUILD_GRADLE_FILE_NAME = "build.gradle.kts"
+    }
+}