Add automatic database detection and binary control (#6)

* Add Database autoconfig

This commit adds the ability for the plugin to automatically
configure database connectivity to the Encore app.

* Add settings panel to Tools section of settings

Author: DomBlack

CHANGELOG.md

@@ -3,14 +3,18 @@
 # Encore IntelliJ Plugin Changelog
 
 ## [Unreleased]
+### Added
+- From Encore v1.9.3 services databases can be automatically detected and configured within the IDE.
+  This will add both the local database used by `encore run` and the test database used by `encore test`
+- New settings panel which allows the plugin to be configured to use a different encore binary (useful when testing features) 
 
 ## [0.0.3]
-### Bugs
-- Fix support for directory tests (previously only file and function level tests worked).
+### Bugs
+- Fix support for directory tests (previously only file and function level tests worked).
 - Changed the `newapi` live template to fix a typo and renamed the parameters prop to `p`
 
 ## [0.0.2]
 ### Added
 - Added support for running unit tests of Encore applications in GoLand
 - Added a live template `newapi` for creating a new API easily within GoLand
-- Add syntax highlighting and icon for `encore.app` files
+- Add syntax highlighting and icon for `encore.app` files

gradle.properties

@@ -4,7 +4,7 @@
 pluginGroup = dev.encore.intellij
 pluginName = Encore
 # SemVer format -> https://semver.org
-pluginVersion = 0.0.3
+pluginVersion = 0.1.0
 
 # See https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 # for insight into build numbers and IntelliJ Platform versions.
@@ -18,7 +18,7 @@ platformDownloadSources = true
 
 # Plugin Dependencies -> https://plugins.jetbrains.com/docs/intellij/plugin-dependencies.html
 # Example: platformPlugins = com.intellij.java, com.jetbrains.php:203.4449.22
-platformPlugins = org.jetbrains.plugins.go
+platformPlugins = org.jetbrains.plugins.go, com.intellij.database
 
 # Gradle Releases -> https://github.com/gradle/gradle/releases
 gradleVersion = 7.5.1

src/main/kotlin/dev/encore/intellij/Encore.kt

@@ -0,0 +1,25 @@
+package dev.encore.intellij
+
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.util.text.SemVer
+
+object Encore {
+    val LOG: Logger = Logger.getInstance(Encore.javaClass)
+
+    /* Is encore installed? */
+    @Volatile
+    var encoreInstalled = false
+
+    /* What version is Encore? */
+    @Volatile
+    var encoreVersion: SemVer? = null
+
+    /*
+    Returns true if Encore is at least at the given release
+     */
+    fun isAtLeast(major: Int, minor: Int, patch: Int): Boolean {
+        val version = encoreVersion ?: return false
+
+        return version.isGreaterOrEqualThan(major, minor, patch)
+    }
+}

src/main/kotlin/dev/encore/intellij/StartupActivity.kt

@@ -0,0 +1,46 @@
+package dev.encore.intellij
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.startup.StartupActivity
+import com.intellij.util.text.SemVer
+import dev.encore.intellij.sqldb.Detector
+import dev.encore.intellij.utils.isInEncoreApp
+import dev.encore.intellij.utils.runEncoreCommand
+
+/*
+ * Startup Activity allows us to run blocking external calls to the encore daemon to extract information
+ * about the project, which we can then store and reference at runtime
+ */
+class StartupActivity : StartupActivity.Background, StartupActivity.RequiredForSmartMode {
+    override fun runActivity(project: Project) {
+        // Skip our startup if it's not an Encore app
+        if (!isInEncoreApp(project)) {
+            return
+        }
+
+        Encore.LOG.info("Performing startup activity for Encore...")
+
+        // Verify Encore is installed
+        val versionOutput = runEncoreCommand(project, "version") ?: return
+        if (!versionOutput.startsWith("encore version ")) {
+            return
+        }
+        Encore.encoreInstalled = true
+
+        // Get the version
+        val versionString = versionOutput.trim().lines()[0].removePrefix("encore version ")
+        if (versionString.startsWith("v")) {
+            Encore.encoreVersion = SemVer.parseFromText(versionString.removePrefix("v"))
+        } else {
+            // If the version string doesn't start with v then it's a dev build, so default to 999.999.999
+            Encore.encoreVersion = SemVer(versionString, 999, 999, 999)
+        }
+        Encore.LOG.info("Verified that Encore is installed and running version ${Encore.encoreVersion}")
+
+        // Ask encore for the database connection info
+        if (Encore.isAtLeast(1, 9, 2)) {
+            Encore.LOG.info("Getting database connection information from Encore...")
+            Detector.loadDatabaseConnection(project)
+        }
+    }
+}

src/main/kotlin/dev/encore/intellij/liveTemplates/EncoreContext.kt

@@ -2,23 +2,10 @@ package dev.encore.intellij.liveTemplates
 
 import com.intellij.codeInsight.template.TemplateActionContext
 import com.intellij.codeInsight.template.TemplateContextType
-import com.intellij.psi.PsiDirectory
+import dev.encore.intellij.utils.isInEncoreApp
 
 class EncoreContext : TemplateContextType("ENCORE_GO_FILE", "Encore Go File") {
     override fun isInContext(templateActionContext: TemplateActionContext): Boolean {
-        return isEncoreApp(templateActionContext.file.originalFile.containingDirectory) && templateActionContext.file.name.endsWith(".go")
-    }
-
-    private fun isEncoreApp(dir: PsiDirectory?): Boolean {
-        if (dir == null) {
-            return false
-        }
-
-        val appFile = dir.findFile("encore.app")
-        if (appFile != null && appFile.isValid) {
-            return true
-        }
-
-        return isEncoreApp(dir.parentDirectory)
+        return isInEncoreApp(templateActionContext.file.originalFile.containingDirectory) && templateActionContext.file.name.endsWith(".go")
     }
 }

src/main/kotlin/dev/encore/intellij/runconfig/EncoreRunConfig.kt

@@ -8,12 +8,13 @@ import com.goide.execution.testing.GoTestRunConfiguration
 import com.intellij.execution.configurations.RunnerSettings
 import com.intellij.execution.target.TargetedCommandLineBuilder
 import com.intellij.execution.target.value.TargetValue
-import com.intellij.openapi.project.rootManager
+import dev.encore.intellij.settings.settingsState
+import dev.encore.intellij.utils.isInEncoreApp
 
 class EncoreRunConfig : GoRunConfigurationExtension() {
     override fun isApplicableFor(configuration: GoRunConfigurationBase<*>): Boolean {
         if (configuration is GoTestRunConfiguration) {
-            return isEncoreApp(configuration)
+            return isInEncoreApp(configuration.defaultModule)
         }
         return false
     }
@@ -23,7 +24,7 @@ class EncoreRunConfig : GoRunConfigurationExtension() {
         runnerSettings: RunnerSettings?
     ): Boolean {
         if (applicableConfiguration is GoTestRunConfiguration) {
-            return isEncoreApp(applicableConfiguration)
+            return isInEncoreApp(applicableConfiguration.defaultModule)
         }
         return false
     }
@@ -50,18 +51,8 @@ class EncoreRunConfig : GoRunConfigurationExtension() {
             }
         }
         if (useEncoreBinary) {
-            cmdLine.exePath = TargetValue.fixed("encore")
+            cmdLine.exePath = TargetValue.fixed(settingsState().encoreBinary)
         }
         super.patchCommandLine(configuration, runnerSettings, cmdLine, runnerId, state, commandLineType)
     }
-
-    private fun isEncoreApp(configuration: GoRunConfigurationBase<*>): Boolean {
-        for (folder in configuration.getDefaultModule().rootManager.contentRoots) {
-            val appFile = folder.findChild("encore.app")
-            if (appFile != null && appFile.exists()) {
-                return true
-            }
-        }
-        return false
-    }
 }

src/main/kotlin/dev/encore/intellij/settings/Settings.kt

@@ -0,0 +1,42 @@
+package dev.encore.intellij.settings
+
+import com.intellij.openapi.options.Configurable
+import javax.swing.JComponent
+
+class Settings : Configurable {
+    private var mySettingsComponent: SettingsPanel? = null
+
+    override fun createComponent(): JComponent {
+        mySettingsComponent = SettingsPanel()
+        return mySettingsComponent!!.getPanel()
+    }
+
+    override fun isModified(): Boolean {
+        val settings = settingsState()
+        var modified = false
+        modified = modified || mySettingsComponent!!.getEnable() != settings.enabled
+        modified = modified || mySettingsComponent!!.getFile() != settings.encoreBinary
+
+        return modified
+    }
+
+    override fun apply() {
+        val settings = settingsState()
+        settings.enabled = mySettingsComponent!!.getEnable()
+        settings.encoreBinary = mySettingsComponent!!.getFile()
+    }
+
+    override fun reset() {
+        val settings = settingsState()
+        mySettingsComponent!!.setEnable(settings.enabled)
+        mySettingsComponent!!.setFile(settings.encoreBinary)
+    }
+
+    override fun disposeUIResources() {
+        mySettingsComponent = null
+    }
+
+    override fun getDisplayName(): String {
+        return "Encore"
+    }
+}

src/main/kotlin/dev/encore/intellij/settings/SettingsPanel.kt

@@ -0,0 +1,57 @@
+package dev.encore.intellij.settings
+
+import com.intellij.openapi.ui.TextComponentAccessor
+import com.intellij.openapi.ui.TextFieldWithBrowseButton
+import com.intellij.ui.components.JBCheckBox
+import com.intellij.ui.components.JBLabel
+import com.intellij.util.ui.FormBuilder
+import javax.swing.JComponent
+import javax.swing.JPanel
+
+class SettingsPanel {
+    private val myMainPanel: JPanel
+    private val enableStatus: JBCheckBox = JBCheckBox("Enable Encore plugin", true)
+    private val file = TextFieldWithBrowseButton()
+
+    init {
+        myMainPanel = FormBuilder.createFormBuilder()
+            .addSeparator()
+            .addLabeledComponent("Enable plugin", enableStatus)
+            .addLabeledComponent("Path to Encore binary", file)
+            .addComponent(JBLabel("If changing the Encore binary, you will need to reopen your project to pickup the new version"))
+            .addComponentFillVertically(JPanel(), 0)
+            .panel
+    }
+
+    fun getPanel(): JPanel {
+        file.addBrowseFolderListener(
+            "",
+            "Path to encore binary",
+            null,
+            encoreBinaryDescriptor(),
+            TextComponentAccessor.TEXT_FIELD_WHOLE_TEXT,
+        )
+
+        return myMainPanel
+    }
+
+    fun getPreferredFocusedComponent(): JComponent {
+        return enableStatus
+    }
+
+    fun getEnable(): Boolean {
+        return enableStatus.isSelected
+    }
+
+    fun setEnable(newStatus: Boolean) {
+        enableStatus.isSelected = newStatus
+    }
+
+    fun getFile(): String {
+        return file.text
+    }
+
+    fun setFile(newFile: String) {
+        file.text = newFile
+    }
+}

src/main/kotlin/dev/encore/intellij/settings/SettingsState.kt

@@ -0,0 +1,28 @@
+package dev.encore.intellij.settings
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.components.PersistentStateComponent
+import com.intellij.openapi.components.State
+import com.intellij.openapi.components.Storage
+import com.intellij.util.xmlb.XmlSerializerUtil
+
+@State(
+    name = "SettingsState",
+    storages = [Storage("EncorePlugin.xml")]
+)
+class SettingsState : PersistentStateComponent<SettingsState> {
+    var enabled: Boolean = true
+    var encoreBinary: String = "encore"
+
+    override fun getState(): SettingsState {
+        return this
+    }
+
+    override fun loadState(state: SettingsState) {
+        XmlSerializerUtil.copyBean(state, this)
+    }
+}
+
+fun settingsState(): SettingsState {
+    return ApplicationManager.getApplication().getService(SettingsState::class.java)
+}

src/main/kotlin/dev/encore/intellij/settings/encoreBinaryDescriptor.kt

@@ -0,0 +1,39 @@
+package dev.encore.intellij.settings
+
+import com.intellij.openapi.fileChooser.FileChooserDescriptor
+import com.intellij.openapi.vfs.VirtualFile
+import java.util.concurrent.TimeUnit
+
+class encoreBinaryDescriptor: FileChooserDescriptor(true, false, false, false, false, false) {
+    override fun validateSelectedFiles(files: Array<out VirtualFile>) {
+        if (files.isEmpty()) {
+            throw Exception("You must select an path to the encore binary")
+        }
+
+        if (files.size > 1) {
+            throw Exception("You must only pick one binary")
+        }
+
+        if (files[0].isDirectory) {
+            throw Exception("Cannot be passed a directory")
+        }
+
+        val command = "${files[0].path} version"
+        val parts = command.split("\\s".toRegex())
+        val proc = ProcessBuilder(*parts.toTypedArray())
+            .redirectOutput(ProcessBuilder.Redirect.PIPE)
+            .redirectError(ProcessBuilder.Redirect.PIPE)
+            .start()
+
+        proc.waitFor(5, TimeUnit.SECONDS)
+        if (proc.exitValue() != 0) {
+            val error = proc.errorStream.bufferedReader().readText()
+            throw Exception("When querying for the Encore version, got an error:\n\n${error}")
+        }
+        proc.destroy()
+        val versionString = proc.inputStream.bufferedReader().readText()
+        if (!versionString.trim().startsWith("encore version ")) {
+            throw Exception("Binary did not report `encore version ` as a response to a request for version parameters")
+        }
+    }
+}