Merge pull request #505 from koxudaxi/Remove_projectRuffExecutablePat…

…h_in_config_file Remove projectRuffExecutablePath in config file
koxudaxi · Sep 13, 2024 · 9ea2edd · 9ea2edd
2 parents 784dd00 + 9e53d31
commit 9ea2edd
Show file tree

Hide file tree

Showing 10 changed files with 54 additions and 43 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,7 @@
 # Changelog
 
 ## [Unreleased]
+- Remove projectRuffExecutablePath in config file [[#505](https://github.com/koxudaxi/ruff-pycharm-plugin/pull/505)]
 
 ## [0.0.39] - 2024-09-12
 

diff --git a/gradle.properties b/gradle.properties
@@ -4,7 +4,7 @@ pluginGroup = com.koxudaxi.ruff
 pluginName = Ruff
 pluginRepositoryUrl = https://github.com/koxudaxi/ruff-pycharm-plugin
 # SemVer format -> https://semver.org
-pluginVersion = 0.0.39
+pluginVersion = 0.0.40
 
 # Supported build number ranges and IntelliJ Platform versions -> https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 pluginSinceBuild = 242.20224.89

diff --git a/src/com/koxudaxi/ruff/Ruff.kt b/src/com/koxudaxi/ruff/Ruff.kt
@@ -169,13 +169,13 @@ val lsp4ijSupported: Boolean
 
 val lspSupported: Boolean get() = intellijLspClientSupported || lsp4ijSupported
 
-fun detectRuffExecutable(project: Project, ruffConfigService: RuffConfigService, lsp: Boolean): File? {
+fun detectRuffExecutable(project: Project, ruffConfigService: RuffConfigService, lsp: Boolean, ruffCacheService: RuffCacheService): File? {
     project.pythonSdk?.let {
         findRuffExecutableInSDK(it, lsp)
     }.let {
         when {
-            lsp -> ruffConfigService.projectRuffLspExecutablePath = it?.absolutePath
-            else -> ruffConfigService.projectRuffExecutablePath = it?.absolutePath
+            lsp -> ruffCacheService.setProjectRuffLspExecutablePath(it?.absolutePath)
+            else -> ruffCacheService.setProjectRuffExecutablePath(it?.absolutePath)
         }
         it
     }?.let { return it }
@@ -238,13 +238,21 @@ val PsiFile.isApplicableTo: Boolean
         else -> language.isKindOf(PythonLanguage.getInstance())
     }
 
-fun getRuffExecutable(project: Project, ruffConfigService: RuffConfigService, lsp: Boolean): File? {
-    return when {
-        lsp -> ruffConfigService.ruffLspExecutablePath
-        else -> ruffConfigService.ruffExecutablePath
-    }?.let { File(it) }?.takeIf { it.exists() } ?: detectRuffExecutable(
-        project, ruffConfigService, lsp
-    )
+fun getRuffExecutable(project: Project, ruffConfigService: RuffConfigService, lsp: Boolean, ruffCacheService: RuffCacheService): File? {
+    with(ruffConfigService) {
+        return when {
+            lsp -> when {
+                alwaysUseGlobalRuff -> globalRuffLspExecutablePath
+                else -> ruffCacheService.getProjectRuffLspExecutablePath() ?: globalRuffLspExecutablePath
+            }
+            else -> when {
+                alwaysUseGlobalRuff -> globalRuffExecutablePath
+                else -> ruffCacheService.getProjectRuffExecutablePath() ?: globalRuffExecutablePath
+            }
+        }?.let { File(it) }?.takeIf { it.exists() } ?: detectRuffExecutable(
+            project, ruffConfigService, lsp, ruffCacheService
+        )
+    }
 }
 
 fun getConfigArgs(ruffConfigService: RuffConfigService): List<String>? {
@@ -398,10 +406,9 @@ fun generateCommandArgs(
     withoutConfig: Boolean = false
 ): CommandArgs? {
     val ruffConfigService = RuffConfigService.getInstance(project)
+    val ruffCacheService = RuffCacheService.getInstance(project)
     val executable =
-        ruffConfigService.ruffExecutablePath?.let { File(it) }?.takeIf { it.exists() } ?: detectRuffExecutable(
-            project, ruffConfigService, false
-        ) ?: return null
+        getRuffExecutable(project, ruffConfigService, false, ruffCacheService) ?: return null
     val customConfigArgs = if (withoutConfig) null else ruffConfigService.ruffConfigPath?.let {
         args + listOf(CONFIG_ARG, it)
     }

diff --git a/src/com/koxudaxi/ruff/RuffCacheService.kt b/src/com/koxudaxi/ruff/RuffCacheService.kt
@@ -11,6 +11,8 @@ class RuffCacheService(val project: Project) {
     private var hasCheck: Boolean? = null
     private var hasLsp: Boolean? = null
     private var hasStableServer: Boolean? = null
+    private var projectRuffExecutablePath: String? = null
+    private var projectRuffLspExecutablePath: String? = null
 
     fun getVersion(): RuffVersion? {
         return version
@@ -76,6 +78,25 @@ class RuffCacheService(val project: Project) {
     internal fun hasStableServer(): Boolean? {
         return hasStableServer
     }
+
+    internal fun getProjectRuffExecutablePath(): String? {
+        return projectRuffExecutablePath
+    }
+
+    @Synchronized
+    internal fun setProjectRuffExecutablePath(path: String?) {
+        projectRuffExecutablePath = path
+    }
+
+    internal fun getProjectRuffLspExecutablePath(): String? {
+        return projectRuffLspExecutablePath
+    }
+
+    @Synchronized
+    internal fun setProjectRuffLspExecutablePath(path: String?) {
+        projectRuffLspExecutablePath = path
+    }
+
     internal
     companion object {
         fun hasFormatter(project: Project): Boolean = getInstance(project).hasFormatter()

diff --git a/src/com/koxudaxi/ruff/RuffConfigPanel.kt b/src/com/koxudaxi/ruff/RuffConfigPanel.kt
@@ -46,6 +46,7 @@ class RuffConfigPanel(project: Project) {
 
     init {
         val ruffConfigService = getInstance(project)
+        val ruffCacheService = RuffCacheService.getInstance(project)
         runRuffOnSaveCheckBox.isSelected = ruffConfigService.runRuffOnSave
         runRuffOnSaveCheckBox.isEnabled = true
         runRuffOnReformatCodeCheckBox.isSelected = ruffConfigService.runRuffOnReformatCode
@@ -123,7 +124,7 @@ class RuffConfigPanel(project: Project) {
         }
         updateLspFields()
         alwaysUseGlobalRuffCheckBox.addActionListener { updateProjectExecutableFields() }
-        when (val projectRuffExecutablePath = ruffConfigService.projectRuffExecutablePath?.takeIf { File(it).exists() } ?: getProjectRuffExecutablePath(project, false)) {
+        when (val projectRuffExecutablePath = ruffCacheService.getProjectRuffExecutablePath()?.takeIf { File(it).exists() } ?: getProjectRuffExecutablePath(project, false)) {
             is String -> projectRuffExecutablePathField.text = projectRuffExecutablePath
             else -> {
                 projectRuffExecutablePathField.text = ""
@@ -132,7 +133,7 @@ class RuffConfigPanel(project: Project) {
         }
 
 
-        when (val projectRuffLspExecutablePath = ruffConfigService.projectRuffLspExecutablePath?.takeIf { File(it).exists() } ?: getProjectRuffExecutablePath(project, true)) {
+        when (val projectRuffLspExecutablePath = ruffCacheService.getProjectRuffLspExecutablePath()?.takeIf { File(it).exists() } ?: getProjectRuffExecutablePath(project, true)) {
             is String -> projectRuffLspExecutablePathField.text = projectRuffLspExecutablePath
             else -> {
                 projectRuffLspExecutablePathField.text = ""

diff --git a/src/com/koxudaxi/ruff/RuffConfigService.kt b/src/com/koxudaxi/ruff/RuffConfigService.kt
@@ -1,9 +1,6 @@
 package com.koxudaxi.ruff
 
-import com.intellij.openapi.components.PersistentStateComponent
-import com.intellij.openapi.components.Service
-import com.intellij.openapi.components.State
-import com.intellij.openapi.components.Storage
+import com.intellij.openapi.components.*
 import com.intellij.openapi.project.Project
 import com.intellij.util.xmlb.XmlSerializerUtil
 import org.jetbrains.annotations.SystemDependent
@@ -17,8 +14,6 @@ class RuffConfigService : PersistentStateComponent<RuffConfigService> {
     var globalRuffExecutablePath: @SystemDependent String? = null
     var globalRuffLspExecutablePath: @SystemDependent String? = null
     var alwaysUseGlobalRuff: Boolean = false
-    var projectRuffExecutablePath: @SystemDependent String? = null
-    var projectRuffLspExecutablePath: @SystemDependent String? = null
     var ruffConfigPath: @SystemDependent String? = null
     var disableOnSaveOutsideOfProject: Boolean = true
     var useRuffLsp: Boolean = false
@@ -35,20 +30,6 @@ class RuffConfigService : PersistentStateComponent<RuffConfigService> {
     override fun loadState(config: RuffConfigService) {
         XmlSerializerUtil.copyBean(config, this)
     }
-    val ruffExecutablePath: @SystemDependent String?
-        get() {
-        return when {
-            alwaysUseGlobalRuff -> globalRuffExecutablePath
-            else -> projectRuffExecutablePath ?: globalRuffExecutablePath
-        }
-    }
-    val ruffLspExecutablePath: @SystemDependent String?
-        get() {
-            return when {
-                alwaysUseGlobalRuff -> globalRuffLspExecutablePath
-                else -> projectRuffLspExecutablePath ?: globalRuffLspExecutablePath
-            }
-        }
     companion object {
         fun getInstance(project: Project): RuffConfigService {
             return project.getService(RuffConfigService::class.java)

diff --git a/src/com/koxudaxi/ruff/RuffPackageManagerListener.kt b/src/com/koxudaxi/ruff/RuffPackageManagerListener.kt
@@ -15,8 +15,8 @@ class RuffPackageManagerListener(private val project: Project) : PyPackageManage
         val ruffConfigService = RuffConfigService.getInstance(project)
         val ruffCacheService = RuffCacheService.getInstance(project)
         val ruffLspClientManager = RuffLspClientManager.getInstance(project)
-        ruffConfigService.projectRuffExecutablePath = findRuffExecutableInSDK(sdk, false)?.absolutePath
-        ruffConfigService.projectRuffLspExecutablePath = findRuffExecutableInSDK(sdk, true)?.absolutePath
+        ruffCacheService.setProjectRuffExecutablePath(findRuffExecutableInSDK(sdk, false)?.absolutePath)
+        ruffCacheService.setProjectRuffLspExecutablePath(findRuffExecutableInSDK(sdk, true)?.absolutePath)
         if (!lspSupported || !ruffConfigService.enableLsp) return
         ruffCacheService.setVersion {
             ApplicationManager.getApplication().invokeLater {

diff --git a/src/com/koxudaxi/ruff/lsp/intellij/RuffLspServerSupportProvider.kt b/src/com/koxudaxi/ruff/lsp/intellij/RuffLspServerSupportProvider.kt
@@ -27,7 +27,7 @@ class RuffLspServerSupportProvider : LspServerSupportProvider {
         if (ruffCacheService.getVersion() == null) return
         val descriptor = when {
             ruffConfigService.useRuffServer && ruffCacheService.hasLsp() == true -> {
-                getRuffExecutable(project, ruffConfigService, false)?.let {
+                getRuffExecutable(project, ruffConfigService, false, ruffCacheService)?.let {
                     RuffServerServerDescriptor(
                         project,
                         it,
@@ -36,7 +36,7 @@ class RuffLspServerSupportProvider : LspServerSupportProvider {
                 }
             }
 
-            else -> getRuffExecutable(project, ruffConfigService, true)?.let {
+            else -> getRuffExecutable(project, ruffConfigService, true, ruffCacheService)?.let {
                 RuffLspServerDescriptor(
                     project,
                     it,

diff --git a/src/com/koxudaxi/ruff/lsp/lsp4ij/RuffLanguageServer.kt b/src/com/koxudaxi/ruff/lsp/lsp4ij/RuffLanguageServer.kt
@@ -31,11 +31,11 @@ class RuffLanguageServer(project: Project) : ProcessStreamConnectionProvider() {
 
         val (ruffFile, args) = when {
                 ruffConfigService.useRuffServer && ruffCacheService.hasLsp() == true -> {
-                    val executable = getRuffExecutable(project, ruffConfigService, false) ?: return null
+                    val executable = getRuffExecutable(project, ruffConfigService, false, ruffCacheService) ?: return null
                     executable to project.LSP_ARGS + (getConfigArgs(ruffConfigService) ?: listOf())
                 }
                 else -> {
-                    val executable = getRuffExecutable(project, ruffConfigService, true) ?: return null
+                    val executable = getRuffExecutable(project, ruffConfigService, true, ruffCacheService) ?: return null
                     executable to listOf()
                 }
             }

diff --git a/src/com/koxudaxi/ruff/lsp/lsp4ij/RuffLanguageServerFactory.kt b/src/com/koxudaxi/ruff/lsp/lsp4ij/RuffLanguageServerFactory.kt
@@ -31,7 +31,7 @@ class RuffLanguageServerFactory : LanguageServerFactory, LanguageServerEnablemen
         val ruffCacheService = RuffCacheService.getInstance(project)
         if (ruffCacheService.getVersion() == null) return false
         if (ruffConfigService.useRuffServer && ruffCacheService.hasLsp() != true) return false
-        if (ruffConfigService.useRuffLsp && getRuffExecutable(project, ruffConfigService, true) == null ) return false
+        if (ruffConfigService.useRuffLsp && getRuffExecutable(project, ruffConfigService, true, ruffCacheService) == null ) return false
         return true
     }