fix settings (#367)

* Fix: settings are not persisted, swap run icons

- when in Configurable we used: project.settings.storedSettings
it would return some instance of state. And because state
can change, writes to that instance were not saved and
so settings were not persisted
- Fixed a bug with test run icons, "Run all tests" was
swapped with "Run test"

* Do not use projectPath, use project.path

* fix: verbose mode enabling/disabling doesn't work

* show wizard on project open

* fix test dir setting

* remove custome target, persist selected target

* Little suggested changes

* Some improvements to targets

* fix: connectionSettingsChangedNotFired after settings changed

Co-authored-by: Egor Kulikov <[email protected]>

Author: vol0n

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/UTBotStartupActivity.kt

@@ -1,12 +1,11 @@
 package org.utbot.cpp.clion.plugin
 
 import com.intellij.ide.util.RunOnceUtil
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.startup.StartupActivity
-import org.utbot.cpp.clion.plugin.client.Client
 import org.utbot.cpp.clion.plugin.client.ClientManager
-import org.utbot.cpp.clion.plugin.settings.pluginSettings
 import org.utbot.cpp.clion.plugin.settings.settings
 import org.utbot.cpp.clion.plugin.ui.wizard.UTBotWizard
 import org.utbot.cpp.clion.plugin.utils.invokeOnEdt
@@ -27,10 +26,11 @@ class UTBotStartupActivity : StartupActivity {
 
 
     private fun showWizardOnFirstOpen(project: Project) {
-        if (pluginSettings.isFirstLaunch && !Client.IS_TEST_MODE) {
-            pluginSettings.isFirstLaunch = false
+        if (!ApplicationManager.getApplication().isUnitTestMode) {
             invokeOnEdt {
-                UTBotWizard(project).showAndGet()
+                RunOnceUtil.runOnceForProject(project, "Show UTBot quick-start wizard to configure project") {
+                    UTBotWizard(project).showAndGet()
+                }
             }
         }
     }

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/client/Client.kt

@@ -201,7 +201,6 @@ class Client(
     }
 
     companion object {
-        var IS_TEST_MODE = false
         const val HEARTBEAT_INTERVAL: Long = 500L
         const val SERVER_TIMEOUT: Long = 300000L
         const val DELAY_TIME: Long = 500L

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/settings/SettingsProvider.kt

@@ -7,7 +7,4 @@ val Project.settings: UTBotAllProjectSettings
     get() = this.service()
 
 val projectIndependentSettings: UTBotProjectIndependentSettings.State
-    get() = service<UTBotProjectIndependentSettings>().state
-
-val pluginSettings: UTBotPluginSpecificSettings
-    get() = service()
+    get() = service<UTBotProjectIndependentSettings>().state

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/settings/UTBotAllProjectSettings.kt

@@ -9,6 +9,7 @@ import org.utbot.cpp.clion.plugin.ui.targetsToolWindow.UTBotTarget
 import org.utbot.cpp.clion.plugin.utils.convertToRemotePathIfNeeded
 import org.utbot.cpp.clion.plugin.utils.isWindows
 import org.utbot.cpp.clion.plugin.utils.notifyWarning
+import org.utbot.cpp.clion.plugin.utils.path
 import java.io.File
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -18,29 +19,23 @@ class UTBotAllProjectSettings(val project: Project) {
     val storedSettings: UTBotProjectStoredSettings.State
         get() = project.service<UTBotProjectStoredSettings>().state
 
-    // todo: maybe remove this property and access directly
-    var projectPath: String
-        get() {
-            return storedSettings.projectPath
-        }
-        set(value) {
-            storedSettings.projectPath = value
-        }
-
     val buildDirPath: Path
-        get() = Paths.get(projectPath).resolve(storedSettings.buildDirRelativePath)
+        get() = Paths.get(project.path).resolve(storedSettings.buildDirRelativePath)
+
+    val testsDirPath: Path
+        get() = Paths.get(project.path).resolve(storedSettings.testsDirRelativePath)
 
     val convertedSourcePaths: List<String>
         get() = storedSettings.sourceDirs.map { it.convertToRemotePathIfNeeded(project) }
 
     val convertedTestDirPath: String
-        get() = storedSettings.testDirPath.convertToRemotePathIfNeeded(project)
+        get() = testsDirPath.toString().convertToRemotePathIfNeeded(project)
 
     val convertedTargetPath: String
         get() = if (storedSettings.targetPath == UTBotTarget.autoTarget.path) storedSettings.targetPath
         else storedSettings.targetPath.convertToRemotePathIfNeeded(project)
 
-    val convertedProjectPath: String get() = projectPath.convertToRemotePathIfNeeded(project)
+    val convertedProjectPath: String get() = project.path.convertToRemotePathIfNeeded(project)
 
     /**
      * If this property returns true, plugin must convert path sent and returned from server.
@@ -52,7 +47,7 @@ class UTBotAllProjectSettings(val project: Project) {
         get() {
             val isLocalHost =
                 projectIndependentSettings.serverName == "localhost" || projectIndependentSettings.serverName == "127.0.0.01"
-            return !(storedSettings.remotePath == projectPath && isLocalHost) || isWindows
+            return !(storedSettings.remotePath == UTBotProjectStoredSettings.REMOTE_PATH_VALUE_FOR_LOCAL_SCENARIO && isLocalHost) || isWindows
         }
 
     fun fireUTBotSettingsChanged() {
@@ -66,13 +61,6 @@ class UTBotAllProjectSettings(val project: Project) {
         storedSettings.buildDirRelativePath = UTBotProjectStoredSettings.DEFAULT_RELATIVE_PATH_TO_BUILD_DIR
         storedSettings.targetPath = UTBotTarget.autoTarget.path
 
-        try {
-            storedSettings.testDirPath =
-                Paths.get(projectPath, UTBotProjectStoredSettings.DEFAULT_RELATIVE_PATH_TO_TEST_DIR).toString()
-        } catch (e: IllegalStateException) {
-            notifyWarning("Guessing settings failed: could not guess project path! Please specify it in settings!")
-        }
-
         val cmakeRunConfiguration = CMakeAppRunConfiguration.getSelectedConfigurationAndTarget(project)?.first
         val buildConfigurationSources = cmakeRunConfiguration?.cMakeTarget?.buildConfigurations?.map { it.sources }
         //TODO: why do we use firstOrNull here?

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/settings/UTBotConfigurable.kt

@@ -2,11 +2,13 @@
 
 package org.utbot.cpp.clion.plugin.settings
 
+import com.intellij.openapi.components.service
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory
 import com.intellij.openapi.options.BoundConfigurable
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.DialogPanel
+import com.intellij.ui.components.JBTextField
 import com.intellij.ui.dsl.builder.BottomGap
 import com.intellij.ui.dsl.builder.COLUMNS_LARGE
 import com.intellij.ui.dsl.builder.LabelPosition
@@ -24,19 +26,23 @@ import org.utbot.cpp.clion.plugin.UTBot
 import org.utbot.cpp.clion.plugin.listeners.UTBotSettingsChangedListener
 import org.utbot.cpp.clion.plugin.ui.ObservableValue
 import org.utbot.cpp.clion.plugin.ui.sourceFoldersView.UTBotProjectViewPaneForSettings
+import org.utbot.cpp.clion.plugin.ui.targetsToolWindow.UTBotTarget
 import org.utbot.cpp.clion.plugin.utils.commandLineEditor
 import org.utbot.cpp.clion.plugin.utils.isWindows
+import org.utbot.cpp.clion.plugin.utils.path
 import org.utbot.cpp.clion.plugin.utils.toWslFormat
 import java.awt.Dimension
+import java.nio.file.Paths
 
 class UTBotConfigurable(private val myProject: Project) : BoundConfigurable(
     "Project Settings to Generate Tests"
 ) {
     private val logger = Logger.getInstance("ProjectConfigurable")
     private val panel by lazy { createMainPanel() }
 
-    private val settings: UTBotProjectStoredSettings.State
-        get() = myProject.settings.storedSettings
+    private val settings: UTBotProjectStoredSettings = myProject.service()
+    private lateinit var portTextfield: JBTextField
+    private lateinit var serverNameTextField: JBTextField
 
     private val isLocalOrWsl = ObservableValue(settings.isLocalOrWslScenario)
 
@@ -62,16 +68,17 @@ class UTBotConfigurable(private val myProject: Project) : BoundConfigurable(
     private fun createMainPanel(): DialogPanel {
         logger.trace("createPanel was called")
         return panel {
-            group("Connection Settings") { this.createConnectionSettings() }
-            group("Paths") { this.createPathsSettings() }
-            group("CMake") { this.createCMakeSettings() }
-            group("Generator Settings") { this.createGeneratorSettings() }
+            group("Connection Settings") { createConnectionSettings() }
+            group("Paths") { createPathsSettings() }
+            group("CMake") { createCMakeSettings() }
+            group("Generator Settings") { createGeneratorSettings() }
         }
     }
 
     private fun Panel.createConnectionSettings() {
         row(UTBot.message("settings.project.port")) {
             intTextField().bindIntText(projectIndependentSettings::port).applyToComponent {
+                portTextfield = this
                 maximumSize = TEXT_FIELD_MAX_SIZE
             }
         }.rowComment(UTBot.message("deployment.utbotPort.description"))
@@ -94,6 +101,7 @@ class UTBotConfigurable(private val myProject: Project) : BoundConfigurable(
 
         row(UTBot.message("settings.project.serverName")) {
             textField().bindText(projectIndependentSettings::serverName).applyToComponent {
+                serverNameTextField = this
                 isLocalOrWsl.addOnChangeListener { newValue ->
                     if (newValue)
                         this.text = "localhost"
@@ -106,38 +114,31 @@ class UTBotConfigurable(private val myProject: Project) : BoundConfigurable(
                 .applyToComponent {
                     isLocalOrWsl.addOnChangeListener { newValue ->
                         if (newValue)
-                            this.text = if (isWindows) myProject.settings.projectPath.toWslFormat() else ""
+                            this.text = if (isWindows) myProject.path.toWslFormat() else ""
                     }
                 }.enabledIf(enabledIfNotLocalOrWslScenario)
         }.rowComment(UTBot.message("deployment.remotePath.description"))
     }
 
     private fun Panel.createPathsSettings() {
-        row(UTBot.message("settings.project.projectPath")) {
-            textFieldWithBrowseButton(
-                UTBot.message("settings.project.projectPath.title"),
-                myProject,
-                FileChooserDescriptorFactory.createSingleFileDescriptor()
-            ).bindText(
-                getter = { myProject.settings.projectPath },
-                setter = { value -> myProject.settings.projectPath = value })
-                .columns(COLUMNS_LARGE)
-        }.rowComment(UTBot.message("settings.project.projectPath.info"))
         createPathChooser(
             settings::buildDirRelativePath,
             UTBot.message("settings.project.buildDir"),
             UTBot.message("settings.project.buildDir.browse.title")
         ).rowComment(UTBot.message("paths.buildDirectory.description"))
-        createPathChooser(
-            settings::targetPath,
-            UTBot.message("settings.project.target"),
-            UTBot.message("settings.project.target.browse.title")
-        ).rowComment(UTBot.message("paths.target.description"))
-        createPathChooser(
-            settings::testDirPath,
-            UTBot.message("settings.project.testsDir"),
-            UTBot.message("settings.project.testsDir.browse.title")
-        ).rowComment(UTBot.message("paths.testsDirectory.description"))
+
+        row(UTBot.message("settings.project.target")) {
+            textField().bindText(
+                getter = {
+                    settings.uiTargetPath
+                },
+                setter = {}
+            ).columns(COLUMNS_LARGE).enabled(false)
+        }.rowComment(UTBot.message("paths.target.description"))
+
+        row(UTBot.message("settings.project.testsDir")) {
+            textField().bindText(settings::testDirRelativePath).columns(COLUMNS_LARGE)
+        }.rowComment(UTBot.message("paths.testsDir.description"))
 
         row {
             val pane = UTBotProjectViewPaneForSettings(myProject)
@@ -221,7 +222,7 @@ class UTBotConfigurable(private val myProject: Project) : BoundConfigurable(
             spinner(
                 UTBotProjectStoredSettings.TIMEOUT_PER_TEST_MIN_VALUE..
                         UTBotProjectStoredSettings.TIMEOUT_PER_TEST_MAX_VALUE
-            ).bindIntValue(settings::timeoutPerFunction).applyToComponent {
+            ).bindIntValue(settings::timeoutPerTest).applyToComponent {
                 maximumSize = TEXT_FIELD_MAX_SIZE
             }
         }.rowComment(UTBot.message("advanced.timeoutPerTest.description"))
@@ -232,8 +233,12 @@ class UTBotConfigurable(private val myProject: Project) : BoundConfigurable(
     }
 
     override fun apply() {
+        val wereConnectionSettingsModified =
+            portTextfield.text != projectIndependentSettings.port.toString() || serverNameTextField.text != projectIndependentSettings.serverName
         panel.apply()
         myProject.settings.fireUTBotSettingsChanged()
+        if (wereConnectionSettingsModified)
+            projectIndependentSettings.fireConnectionSettingsChanged()
     }
 
     override fun reset() {