feat(intellij): implemented support for 4 spaces tab

- this is enabled by default for robot files

Author: d-biehl

intellij-client/README.md

@@ -6,29 +6,37 @@
 
 <!-- Plugin description -->
 
-**RobotCode** is a PyCharm/IntelliJ Plugin that enhances your workflow with [Robot Framework](https://robotframework.org/).
-It provides a rich set of features to help you write, run, and debug your Robot Framework tests directly within your IDE.
-
+**RobotCode** is a PyCharm/IntelliJ Plugin that enhances your workflow
+with [Robot Framework](https://robotframework.org/).
+It provides a rich set of features to help you write, run, and debug your Robot Framework tests directly within your
+IDE.
 
 ⚠️ **Important Notice** ⚠️
-This plugin is currently under active development and is not yet ready for production use. Please note that it may contain bugs or lack certain features.
+This plugin is currently under active development and is not yet ready for production use. Please note that it may
+contain bugs or lack certain features.
 
-We invite you to join the Robot Framework and RobotCode community by reporting issues, suggesting features, and helping us improve the plugin.
+We invite you to join the Robot Framework and RobotCode community by reporting issues, suggesting features, and helping
+us improve the plugin.
 
 Your feedback is greatly appreciated! 🙂
 
-
 ## Why RobotCode?
 
 **Built on Robot Framework Core**
-RobotCode is based on the Robot Framework Core and uses its parser, ensuring complete compatibility and consistency. This means you get the same syntax validation, error messages, and behavior as if you were running Robot Framework directly.
+RobotCode is based on the Robot Framework Core and uses its parser, ensuring complete compatibility and consistency.
+This means you get the same syntax validation, error messages, and behavior as if you were running Robot Framework
+directly.
 
 **Powered by the Language Server Protocol**
-RobotCode is built on the Language Server Protocol (LSP), a modern standard for implementing language support across multiple editors and IDEs. This ensures a seamless and responsive user experience, while making it easier to maintain compatibility with evolving IDE features.
+RobotCode is built on the Language Server Protocol (LSP), a modern standard for implementing language support across
+multiple editors and IDEs. This ensures a seamless and responsive user experience, while making it easier to maintain
+compatibility with evolving IDE features.
 
 **Powerful Command Line Tools**
-RobotCode extends the Robot Framework CLI with enhanced tools for test execution, analysis, and debugging. It supports [`robot.toml`](https://robotcode.io/03_reference/) configurations, integrates a Debug Adapter Protocol (DAP) compatible debugger, and provides an interactive REPL environment for experimenting with Robot Framework commands. Modular and flexible, these tools streamline your workflow for both development and production.
-
+RobotCode extends the Robot Framework CLI with enhanced tools for test execution, analysis, and debugging. It supports [
+`robot.toml`](https://robotcode.io/03_reference/) configurations, integrates a Debug Adapter Protocol (DAP) compatible
+debugger, and provides an interactive REPL environment for experimenting with Robot Framework commands. Modular and
+flexible, these tools streamline your workflow for both development and production.
 
 ## Key Features
 
@@ -37,31 +45,30 @@ RobotCode extends the Robot Framework CLI with enhanced tools for test execution
 - **Integrated Debugging**: Debug Robot Framework tests directly within the IDE.
 - **Test Management**: Discover, run, and monitor Robot Framework tests without leaving your IDE.
 - **Rich Test Reports**: View detailed test results and logs directly in the IDE.
-- **Code Analysis**: Leverage tools like [Robocop](https://robocop.readthedocs.io/) for linting and static code analysis.
+- **Code Analysis**: Leverage tools like [Robocop](https://robocop.readthedocs.io/) for linting and static code
+  analysis.
 - **Formatting Made Easy**: Use [Robotidy](https://robotidy.readthedocs.io/) for consistent code formatting.
 - **Support for `robot.toml`**: Manage your Robot Framework projects with ease.
 - **More Features Coming Soon!**
 
-
 ## Requirements
 
 - Python 3.8 or newer
 - Robot Framework 4.1 or newer
 - PyCharm 2024.3.1 or newer
 
-
 ## Getting Started
 
 1. Install the [RobotCode Plugin](https://plugins.jetbrains.com/plugin/26216) from the JETBRAINS Marketplace.
 2. Configure your Robot Framework Python environment
 3. Start writing and running your Robot Framework tests!
 
 (Comming soon...)
-For a more detailed guide, check out the [Let's get started](https://robotcode.io/02_get_started/) Guide on the [RobotCode](https://robotcode.io) website.
+For a more detailed guide, check out the [Let's get started](https://robotcode.io/02_get_started/) Guide on
+the [RobotCode](https://robotcode.io) website.
 
 <!-- Plugin description end -->
 
-
 ## Installation
 
 - Using the IDE built-in plugin system:
@@ -71,9 +78,11 @@ For a more detailed guide, check out the [Let's get started](https://robotcode.i
 
 - Using JetBrains Marketplace:
 
-  Go to [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/26216) and install it by clicking the <kbd>Install to ...</kbd> button in case your IDE is running.
+  Go to [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/26216) and install it by clicking the <kbd>Install
+  to ...</kbd> button in case your IDE is running.
 
-  You can also download the [latest release](https://plugins.jetbrains.com/plugin/26216/versions) from JetBrains Marketplace and install it manually using
+  You can also download the [latest release](https://plugins.jetbrains.com/plugin/26216/versions) from JetBrains
+  Marketplace and install it manually using
   <kbd>Settings/Preferences</kbd> > <kbd>Plugins</kbd> > <kbd>⚙️</kbd> > <kbd>Install plugin from disk...</kbd>
 
 - Manually:

intellij-client/gradle.properties

@@ -34,5 +34,5 @@ org.gradle.configuration-cache = true
 org.gradle.caching = true
 
 
-kotlin.daemon.jvmargs=-Xmx4096m
-kotlin.code.style=official
+kotlin.daemon.jvmargs = -Xmx4096m
+kotlin.code.style = official

intellij-client/gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,7 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
+distributionBase = GRADLE_USER_HOME
+distributionPath = wrapper/dists
+distributionUrl = https\://services.gradle.org/distributions/gradle-8.12-bin.zip
+networkTimeout = 10000
+validateDistributionUrl = true
+zipStoreBase = GRADLE_USER_HOME
+zipStorePath = wrapper/dists

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/RobotIcons.kt

@@ -1,13 +1,13 @@
 package dev.robotcode.robotcode4ij
 
 import com.intellij.openapi.util.IconLoader
-import javax.swing.Icon
 
 class RobotIcons {
     companion object {
-        val Resource: Icon? = IconLoader.findIcon("/images/robot.svg", Companion::class.java)
-        val Suite: Icon? = IconLoader.findIcon("/images/robot.svg", Companion::class.java)
-        val RobotCode: Icon? = IconLoader.findIcon("/images/robotcode.svg", Companion::class.java)
+        val Resource = IconLoader.findIcon("/images/resource.svg", Companion::class.java)!!
+        val Suite = IconLoader.findIcon("/images/suite.svg", Companion::class.java)!!
+        val RobotCode = IconLoader.findIcon("/images/robotcode.svg", Companion::class.java)!!
+        val Robot = IconLoader.findIcon("/images/suite.robot", Companion::class.java)!!
     }
 
 }

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/configuration/RobotCodeCodeStyleSettings.kt

@@ -0,0 +1,10 @@
+package dev.robotcode.robotcode4ij.configuration
+
+import com.intellij.psi.codeStyle.CodeStyleSettings
+import com.intellij.psi.codeStyle.CustomCodeStyleSettings
+
+class RobotCodeCodeStyleSettings(container: CodeStyleSettings) :
+    CustomCodeStyleSettings(RobotCodeCodeStyleSettings::class.java.simpleName, container) {
+    @JvmField
+    var use4SpacesIndentation: Boolean = true
+}

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/settings/RobotCodeCodeStyleSettingsProvider.kt renamed to intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/configuration/RobotCodeCodeStyleSettingsProvider.kt

@@ -1,4 +1,4 @@
-package dev.robotcode.robotcode4ij.settings
+package dev.robotcode.robotcode4ij.configuration
 
 import com.intellij.application.options.CodeStyleAbstractConfigurable
 import com.intellij.application.options.CodeStyleAbstractPanel
@@ -28,6 +28,9 @@ class RobotCodeCodeStyleSettingsProvider : CodeStyleSettingsProvider() {
     }
 
     private class CodeStyleMainPanel(currentSettings: CodeStyleSettings, settings: CodeStyleSettings) :
-        TabbedLanguageCodeStylePanel(RobotFrameworkLanguage, currentSettings, settings)
-    
+        TabbedLanguageCodeStylePanel(RobotFrameworkLanguage, currentSettings, settings) {
+        override fun initTabs(settings: CodeStyleSettings?) {
+            addIndentOptionsTab(settings)
+        }
+    }
 }

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/settings/RobotCodeColorSettingsPage.kt renamed to intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/configuration/RobotCodeColorSettingsPage.kt

@@ -1,4 +1,4 @@
-package dev.robotcode.robotcode4ij.settings
+package dev.robotcode.robotcode4ij.configuration
 
 import com.intellij.openapi.editor.colors.TextAttributesKey
 import com.intellij.openapi.fileTypes.SyntaxHighlighter
@@ -22,6 +22,7 @@ class RobotCodeColorSettingsPage : ColorSettingsPage {
         AttributesDescriptor("Control flow", Colors.CONTROL_FLOW),
         AttributesDescriptor("Argument", Colors.ARGUMENT),
         AttributesDescriptor("Embedded argument", Colors.EMBEDDED_ARGUMENT),
+        AttributesDescriptor("Named argument", Colors.NAMED_ARGUMENT),
         AttributesDescriptor("Variable", Colors.VARIABLE),
         AttributesDescriptor("Variable expression", Colors.VARIABLE_EXPRESSION),
         AttributesDescriptor("Variable begin", Colors.VARIABLE_BEGIN),

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/configuration/RobotCodeLanguageCodeStyleSettingsProvider.kt

@@ -0,0 +1,115 @@
+package dev.robotcode.robotcode4ij.configuration
+
+import com.intellij.application.options.IndentOptionsEditor
+import com.intellij.application.options.SmartIndentOptionsEditor
+import com.intellij.lang.Language
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiFileFactory
+import com.intellij.psi.codeStyle.CodeStyleSettings
+import com.intellij.psi.codeStyle.CommonCodeStyleSettings
+import com.intellij.psi.codeStyle.CustomCodeStyleSettings
+import com.intellij.psi.codeStyle.LanguageCodeStyleSettingsProvider
+import dev.robotcode.robotcode4ij.RobotFrameworkLanguage
+import dev.robotcode.robotcode4ij.RobotSuiteFileType
+import javax.swing.JCheckBox
+
+class RobotCodeLanguageCodeStyleSettingsProvider : LanguageCodeStyleSettingsProvider() {
+    override fun getLanguage(): Language {
+        return RobotFrameworkLanguage
+    }
+    
+    override fun getFileExt(): String {
+        return "robot"
+    }
+    
+    override fun getIndentOptionsEditor(): IndentOptionsEditor {
+        return object : SmartIndentOptionsEditor(this) {
+            private lateinit var use4SpacesTabCheckBox: JCheckBox
+            
+            override fun addComponents() {
+                super.addComponents()
+                use4SpacesTabCheckBox = JCheckBox("Use 4 spaces indentation")
+                @Suppress("removal")
+                add(use4SpacesTabCheckBox)
+            }
+            
+            override fun setEnabled(enabled: Boolean) {
+                super.setEnabled(enabled)
+                use4SpacesTabCheckBox.isEnabled = enabled
+            }
+            
+            override fun isModified(
+                settings: CodeStyleSettings,
+                options: CommonCodeStyleSettings.IndentOptions
+            ): Boolean {
+                var result = super.isModified(settings, options)
+                val settings = settings.getCustomSettings(RobotCodeCodeStyleSettings::class.java)
+                result = result || isFieldModified(use4SpacesTabCheckBox, settings.use4SpacesIndentation)
+                return result
+            }
+            
+            override fun apply(settings: CodeStyleSettings, options: CommonCodeStyleSettings.IndentOptions?) {
+                super.apply(settings, options)
+                settings.getCustomSettings(RobotCodeCodeStyleSettings::class.java).use4SpacesIndentation =
+                    use4SpacesTabCheckBox.isSelected
+            }
+            
+            override fun reset(settings: CodeStyleSettings, options: CommonCodeStyleSettings.IndentOptions) {
+                super.reset(settings, options)
+                val customSettings = settings.getCustomSettings(RobotCodeCodeStyleSettings::class.java)
+                use4SpacesTabCheckBox.isSelected = customSettings.use4SpacesIndentation
+            }
+        }
+    }
+    
+    override fun createCustomSettings(settings: CodeStyleSettings): CustomCodeStyleSettings {
+        return RobotCodeCodeStyleSettings(settings)
+    }
+    
+    override fun createFileFromText(project: Project, text: String): PsiFile? {
+        return PsiFileFactory.getInstance(project).createFileFromText("dummy.robot", RobotSuiteFileType, text)
+    }
+    
+    override fun getCodeSample(settingsType: SettingsType): String {
+        return """
+        *** Settings ***
+        Library  SeleniumLibrary
+        
+        *** Variables ***
+        ${'$'}{URL}  http://example.com    # a comment
+        
+        *** Test Cases ***
+        Example Test
+            Open Application  ${'$'}{URL}
+            Log  %{APP_DATA:unknown}
+            Close Application
+            
+        BDD Example Test
+            Given application is open
+            When I enter something into the Search Field
+            Then Something Should Happen
+            
+        *** Keywords ***
+        Open Application
+            [Arguments]  ${'$'}{url}
+            Open Browser  ${'$'}{url}
+            
+        Close Application
+            Close Browser
+            
+        *** Comments ***
+        this is a comment block
+        with multiple lines
+        """.trimIndent()
+    }
+    
+    override fun customizeDefaults(
+        commonSettings: CommonCodeStyleSettings,
+        indentOptions: CommonCodeStyleSettings.IndentOptions
+    ) {
+        indentOptions.INDENT_SIZE = 4
+        indentOptions.USE_TAB_CHARACTER = false
+        indentOptions.CONTINUATION_INDENT_SIZE = 4
+    }
+}

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/settings/ProjectSettingsConfigurableProvider.kt renamed to intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/configuration/RobotCodeProjectSettingsConfigurableProvider.kt

@@ -1,4 +1,4 @@
-package dev.robotcode.robotcode4ij.settings
+package dev.robotcode.robotcode4ij.configuration
 
 import com.google.gson.GsonBuilder
 import com.google.gson.JsonElement
@@ -8,7 +8,7 @@ import com.intellij.openapi.components.SimplePersistentStateComponent
 import com.intellij.openapi.components.State
 import com.intellij.openapi.components.Storage
 import com.intellij.openapi.components.service
-import com.intellij.openapi.options.BoundSearchableConfigurable
+import com.intellij.openapi.options.BoundConfigurable
 import com.intellij.openapi.options.Configurable
 import com.intellij.openapi.options.ConfigurableProvider
 import com.intellij.openapi.project.Project
@@ -17,24 +17,21 @@ import com.intellij.ui.dsl.builder.AlignX
 import com.intellij.ui.dsl.builder.bindSelected
 import com.intellij.ui.dsl.builder.bindText
 import com.intellij.ui.dsl.builder.panel
+import dev.robotcode.robotcode4ij.configuration.SimplePersistentStateComponentHelper.delegate
+import dev.robotcode.robotcode4ij.configuration.SimplePersistentStateComponentHelper.stringDelegate
 import dev.robotcode.robotcode4ij.lsp.langServerManager
-import dev.robotcode.robotcode4ij.settings.SimplePersistentStateComponentHelper.delegate
-import dev.robotcode.robotcode4ij.settings.SimplePersistentStateComponentHelper.stringDelegate
 
 
-class ProjectSettingsConfigurableProvider(private val project: Project) : ConfigurableProvider() {
+class RobotCodeProjectSettingsConfigurableProvider(private val project: Project) : ConfigurableProvider() {
     override fun createConfigurable(): Configurable {
-        return ProjectSettingsConfigurable(project)
+        return RobotCodeProjectSettingsConfigurable(project)
     }
-    
 }
 
 
-class ProjectSettingsConfigurable(private val project: Project) : BoundSearchableConfigurable(
-    "Robot Framework", "robotcode.robotframework.settings"
-) {
+class RobotCodeProjectSettingsConfigurable(private val project: Project) : BoundConfigurable("RobotCode") {
 
-    private val settings = ProjectSettings.getInstance(project)
+    private val settings = RobotCodeProjectConfiguration.getInstance(project)
 
     override fun createPanel(): DialogPanel {
         return panel {
@@ -49,8 +46,7 @@ class ProjectSettingsConfigurable(private val project: Project) : BoundSearchabl
                     comboBox(listOf("default", "rpa", "norpa")).label("Mode")
                 }.rowComment("Specifies robot execution mode. Corresponds to the `--rpa` or `--norpa` option of __robot__.")
             }
-            group("Editing") {
-                // TODO: not supported in IntelliJ
+            group("Editing") { // TODO: not supported in IntelliJ
                 // group("Editor") {
                 //     row {
                 //         checkBox("4 Spaces Tab").bindSelected(settings::editor4SpacesTab)
@@ -87,9 +83,10 @@ class ProjectSettingsConfigurable(private val project: Project) : BoundSearchabl
 }
 
 @Service(Service.Level.PROJECT) @State(name = "ProjectSettings", storages = [Storage("robotcodeSettings.xml")])
-class ProjectSettings : SimplePersistentStateComponent<ProjectSettings.ProjectState>(ProjectState()) {
+class RobotCodeProjectConfiguration :
+    SimplePersistentStateComponent<RobotCodeProjectConfiguration.ProjectState>(ProjectState()) {
     companion object {
-        fun getInstance(project: Project): ProjectSettings = project.service()
+        fun getInstance(project: Project): RobotCodeProjectConfiguration = project.service()
     }
 
     fun asJson(): JsonElement {
@@ -123,13 +120,11 @@ data class InlayHints(
 )
 
 data class Completion(
-    var filterDefaultLanguage: Boolean = false,
-    var headerStyle: String? = null
+    var filterDefaultLanguage: Boolean = false, var headerStyle: String? = null
 )
 
 data class All(
-    var completion: Completion = Completion(),
-    var inlayHints: InlayHints = InlayHints()
+    var completion: Completion = Completion(), var inlayHints: InlayHints = InlayHints()
 )
 
 data class RobotCodeSettings(

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/settings/SimplePersistentStateComponentHelper.kt renamed to intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/configuration/SimplePersistentStateComponentHelper.kt

@@ -1,4 +1,4 @@
-package dev.robotcode.robotcode4ij.settings
+package dev.robotcode.robotcode4ij.configuration
 
 import com.intellij.openapi.components.BaseState
 import com.intellij.openapi.components.SimplePersistentStateComponent