Allow to switch off script definitions

^KT-24465 Fixed
2018-07-16 15:30:58 +03:00
parent 7826f44180
commit 6596a6ba75
5 changed files with 102 additions and 32 deletions
@@ -108,7 +108,7 @@ class ScriptDefinitionsManager(private val project: Project) : LazyScriptDefinit
            (definitions ?: kotlin.run {
                reloadScriptDefinitions()
                definitions!!
-            }).asSequence()
+            }).asSequence().filter { KotlinScriptingSettings.getInstance(project).isScriptDefinitionEnabled(it) }

    private fun getContributors(): List<ScriptDefinitionContributor> {
        @Suppress("DEPRECATION")
@@ -133,7 +133,12 @@ class ScriptDefinitionsManager(private val project: Project) : LazyScriptDefinit
        updateDefinitions()
    }

-    fun getAllDefinitions() = currentDefinitions.toList()
+    fun getAllDefinitions(): List<KotlinScriptDefinition> {
+        return definitions ?: kotlin.run {
+            reloadScriptDefinitions()
+            definitions!!
+        }
+    }

    override fun getDefaultScriptDefinition(): KotlinScriptDefinition {
        return StandardIdeScriptDefinition(project)
@@ -29,7 +29,7 @@ class KotlinScriptingSettings : PersistentStateComponent<Element> {
     */
    var suppressDefinitionsCheck = false

-    private var scriptDefinitions = linkedMapOf<KotlinScriptDefinitionKey, Int>()
+    private var scriptDefinitions = linkedMapOf<KotlinScriptDefinitionKey, KotlinScriptDefinitionValue>()

    override fun getState(): Element {
        val definitionsRootElement = Element("KotlinScriptingSettings")
@@ -67,21 +67,31 @@ class KotlinScriptingSettings : PersistentStateComponent<Element> {

        val scriptDefinitionsList = state.getChildren(SCRIPT_DEFINITION_TAG)
        for (scriptDefinitionElement in scriptDefinitionsList) {
-            scriptDefinitions[scriptDefinitionElement.toKey()] = scriptDefinitionElement.getOrderTag()
+            scriptDefinitions[scriptDefinitionElement.toKey()] = scriptDefinitionElement.toValue()
        }
    }

-    fun saveScriptDefinitionsOrder(newScriptDefinitions: List<KotlinScriptDefinition>) {
-        for ((index, scriptDefinition) in newScriptDefinitions.withIndex()) {
-            scriptDefinitions[scriptDefinition.toKey()] = index
-        }
+    fun setOrder(scriptDefinition: KotlinScriptDefinition, order: Int) {
+        scriptDefinitions[scriptDefinition.toKey()] = scriptDefinitions[scriptDefinition.toKey()]?.copy(order = order) ?:
+                KotlinScriptDefinitionValue(order)
+    }
+
+
+    fun setEnabled(scriptDefinition: KotlinScriptDefinition, isEnabled: Boolean) {
+        scriptDefinitions[scriptDefinition.toKey()] = scriptDefinitions[scriptDefinition.toKey()]?.copy(isEnabled = isEnabled) ?:
+                KotlinScriptDefinitionValue(scriptDefinitions.size, isEnabled)
    }

    fun getScriptDefinitionOrder(scriptDefinition: KotlinScriptDefinition): Int {
-        return scriptDefinitions[scriptDefinition.toKey()] ?: Integer.MAX_VALUE
+        return scriptDefinitions[scriptDefinition.toKey()]?.order ?: Integer.MAX_VALUE
+    }
+
+    fun isScriptDefinitionEnabled(scriptDefinition: KotlinScriptDefinition): Boolean {
+        return scriptDefinitions[scriptDefinition.toKey()]?.isEnabled ?: true
    }

    private data class KotlinScriptDefinitionKey(val definitionName: String, val className: String)
+    private data class KotlinScriptDefinitionValue(val order: Int, val isEnabled: Boolean = true)

    private fun Element.toKey() = KotlinScriptDefinitionKey(
        getAttributeValue(KotlinScriptDefinitionKey::definitionName.name),
@@ -91,19 +101,28 @@ class KotlinScriptingSettings : PersistentStateComponent<Element> {
    private fun KotlinScriptDefinition.toKey() =
        KotlinScriptDefinitionKey(this.name, this::class.qualifiedName ?: "unknown")

-    private fun Element.addScriptDefinitionContentElement(definition: KotlinScriptDefinitionKey, order: Int) {
+    private fun Element.addScriptDefinitionContentElement(definition: KotlinScriptDefinitionKey, settings: KotlinScriptDefinitionValue) {
        element(SCRIPT_DEFINITION_TAG).apply {
            attribute(KotlinScriptDefinitionKey::className.name, definition.className)
            attribute(KotlinScriptDefinitionKey::definitionName.name, definition.definitionName)

-            element(SCRIPT_DEFINITION_ORDER_TAG).apply {
-                text = order.toString()
+            element(KotlinScriptDefinitionValue::order.name).apply {
+                text = settings.order.toString()
+            }
+
+            if (!settings.isEnabled) {
+                element(KotlinScriptDefinitionValue::isEnabled.name).apply {
+                    text = settings.isEnabled.toString()
+                }
            }
        }
    }

-    private fun Element.getOrderTag(): Int {
-        return getChildText(SCRIPT_DEFINITION_ORDER_TAG)?.toInt() ?: Integer.MAX_VALUE
+    private fun Element.toValue(): KotlinScriptDefinitionValue {
+        val order = getChildText(KotlinScriptDefinitionValue::order.name)?.toInt() ?: Integer.MAX_VALUE
+        val isEnabled = getChildText(KotlinScriptDefinitionValue::isEnabled.name)?.toBoolean() ?: true
+
+        return KotlinScriptDefinitionValue(order, isEnabled)
    }

    companion object {
@@ -111,7 +130,6 @@ class KotlinScriptingSettings : PersistentStateComponent<Element> {
            ServiceManager.getService(project, KotlinScriptingSettings::class.java)

        private const val SCRIPT_DEFINITION_TAG = "scriptDefinition"
-        private const val SCRIPT_DEFINITION_ORDER_TAG = "order"

    }
 }
@@ -5,36 +5,70 @@

 package org.jetbrains.kotlin.idea.script.configuration

+import com.intellij.ui.BooleanTableCellEditor
+import com.intellij.ui.BooleanTableCellRenderer
 import com.intellij.util.ui.ColumnInfo
 import com.intellij.util.ui.ListTableModel
 import org.jetbrains.kotlin.idea.core.script.StandardIdeScriptDefinition
+import org.jetbrains.kotlin.idea.core.script.settings.KotlinScriptingSettings
 import org.jetbrains.kotlin.parsing.KotlinParserDefinition
 import org.jetbrains.kotlin.script.KotlinScriptDefinition
 import org.jetbrains.kotlin.script.KotlinScriptDefinitionFromAnnotatedTemplate
 import org.jetbrains.kotlin.scripting.compiler.plugin.KotlinScriptDefinitionAdapterFromNewAPIBase

-class KotlinScriptDefinitionsModel(definitions: MutableList<KotlinScriptDefinition>) :
-    ListTableModel<KotlinScriptDefinition>(
+class KotlinScriptDefinitionsModelDescriptor(val definition: KotlinScriptDefinition, var isEnabled: Boolean)
+
+class KotlinScriptDefinitionsModel private constructor(definitions: MutableList<KotlinScriptDefinitionsModelDescriptor>) :
+    ListTableModel<KotlinScriptDefinitionsModelDescriptor>(
        arrayOf(
            ScriptDefinitionName(),
-            ScriptDefinitionPattern()
+            ScriptDefinitionPattern(),
+            ScriptDefinitionIsEnabled()
        ),
        definitions,
        0
    ) {

-    private class ScriptDefinitionName : ColumnInfo<KotlinScriptDefinition, String>("Name") {
-        override fun valueOf(item: KotlinScriptDefinition) = item.name
+    fun getDefinitions() = items.map { it.definition }
+    fun setDefinitions(definitions: List<KotlinScriptDefinition>, settings: KotlinScriptingSettings) {
+        items = definitions.mapTo(arrayListOf()) { KotlinScriptDefinitionsModelDescriptor(it, settings.isScriptDefinitionEnabled(it)) }
    }

-    private class ScriptDefinitionPattern : ColumnInfo<KotlinScriptDefinition, String>("Pattern/Extension") {
-        override fun valueOf(item: KotlinScriptDefinition): String {
-            return when (item) {
-                is KotlinScriptDefinitionFromAnnotatedTemplate -> item.scriptFilePattern.pattern
-                is KotlinScriptDefinitionAdapterFromNewAPIBase -> item.fileExtension
+    private class ScriptDefinitionName : ColumnInfo<KotlinScriptDefinitionsModelDescriptor, String>("Name") {
+        override fun valueOf(item: KotlinScriptDefinitionsModelDescriptor) = item.definition.name
+    }
+
+    private class ScriptDefinitionPattern : ColumnInfo<KotlinScriptDefinitionsModelDescriptor, String>("Pattern/Extension") {
+        override fun valueOf(item: KotlinScriptDefinitionsModelDescriptor): String {
+            val definition = item.definition
+            return when (definition) {
+                is KotlinScriptDefinitionFromAnnotatedTemplate -> definition.scriptFilePattern.pattern
+                is KotlinScriptDefinitionAdapterFromNewAPIBase -> definition.fileExtension
                is StandardIdeScriptDefinition -> KotlinParserDefinition.STD_SCRIPT_EXT
                else -> ""
            }
        }
    }
+
+    private class ScriptDefinitionIsEnabled : ColumnInfo<KotlinScriptDefinitionsModelDescriptor, Boolean>("Is Enabled") {
+        override fun valueOf(item: KotlinScriptDefinitionsModelDescriptor): Boolean = item.isEnabled
+        override fun setValue(item: KotlinScriptDefinitionsModelDescriptor, value: Boolean) {
+            item.isEnabled = value
+        }
+
+        override fun getEditor(item: KotlinScriptDefinitionsModelDescriptor?) = BooleanTableCellEditor()
+        override fun getRenderer(item: KotlinScriptDefinitionsModelDescriptor?) = BooleanTableCellRenderer()
+        override fun isCellEditable(item: KotlinScriptDefinitionsModelDescriptor) = item.definition !is StandardIdeScriptDefinition
+    }
+
+    companion object {
+        fun createModel(definitions: List<KotlinScriptDefinition>, settings: KotlinScriptingSettings): KotlinScriptDefinitionsModel {
+            return KotlinScriptDefinitionsModel(definitions.mapTo(arrayListOf()) {
+                KotlinScriptDefinitionsModelDescriptor(
+                    it,
+                    settings.isScriptDefinitionEnabled(it)
+                )
+            })
+        }
+    }
 }
@@ -4,7 +4,6 @@
 */
 package org.jetbrains.kotlin.idea.script.configuration;

-import com.google.common.collect.Lists;
 import com.intellij.openapi.options.Configurable;
 import com.intellij.openapi.options.SearchableConfigurable;
 import com.intellij.openapi.project.Project;
@@ -15,10 +14,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.core.script.ScriptDefinitionsManager;
 import org.jetbrains.kotlin.idea.core.script.settings.KotlinScriptingSettings;
+import org.jetbrains.kotlin.script.KotlinScriptDefinition;

 import javax.swing.*;
 import java.awt.*;
-import java.util.Collections;

 public class KotlinScriptingSettingsConfigurable implements SearchableConfigurable, Configurable.NoScroll {
    private JPanel root;
@@ -38,7 +37,7 @@ public class KotlinScriptingSettingsConfigurable implements SearchableConfigurab
    @Nullable
    @Override
    public JComponent createComponent() {
-        model = new KotlinScriptDefinitionsModel(Lists.newArrayList(manager.getAllDefinitions()));
+        model = KotlinScriptDefinitionsModel.Companion.createModel(manager.getAllDefinitions(), settings);

        panelScriptDefinitionsChooser.setLayout(new BorderLayout());
        panelScriptDefinitionsChooser.add(
@@ -62,7 +61,12 @@ public class KotlinScriptingSettingsConfigurable implements SearchableConfigurab
        settings.setAutoReloadEnabled(scriptDependenciesAutoReload.isSelected());

        if (isScriptDefinitionsChanged()) {
-            settings.saveScriptDefinitionsOrder(Collections.unmodifiableList(model.getItems()));
+            for (KotlinScriptDefinitionsModelDescriptor item : model.getItems()) {
+                KotlinScriptDefinition definition = item.getDefinition();
+                settings.setOrder(definition, model.getItems().indexOf(item));
+                settings.setEnabled(definition, item.isEnabled());
+            }
+
            manager.reorderScriptDefinitions();
        }
    }
@@ -71,11 +75,16 @@ public class KotlinScriptingSettingsConfigurable implements SearchableConfigurab
    public void reset() {
        scriptDependenciesAutoReload.setSelected(settings.isAutoReloadEnabled());

-        model.setItems(Lists.newArrayList(manager.getAllDefinitions()));
+        model.setDefinitions(manager.getAllDefinitions(), settings);
    }

    private boolean isScriptDefinitionsChanged() {
-        return !model.getItems().equals(manager.getAllDefinitions());
+        for (KotlinScriptDefinitionsModelDescriptor item : model.getItems()) {
+            if (settings.isScriptDefinitionEnabled(item.getDefinition()) != item.isEnabled()) {
+                return true;
+            }
+        }
+        return !model.getDefinitions().equals(manager.getAllDefinitions());
    }


@@ -41,7 +41,11 @@ class MultipleScriptDefinitionsChecker(private val project: Project) : EditorNot

        val allApplicableDefinitions = ScriptDefinitionsManager.getInstance(project)
            .getAllDefinitions()
-            .filter { it !is StandardIdeScriptDefinition && it.isScript(ktFile.name) }
+            .filter {
+                it !is StandardIdeScriptDefinition &&
+                        it.isScript(ktFile.name) &&
+                        KotlinScriptingSettings.getInstance(project).isScriptDefinitionEnabled(it)
+            }
            .toList()
        if (allApplicableDefinitions.size < 2) return null