feat: add run configuration for project and single contract build

Fixes #79

Author: i582

gradle.properties

@@ -10,7 +10,7 @@ platformType = IC
 platformVersion = 2024.3.2
 
 platformPlugins =
-platformBundledPlugins =
+platformBundledPlugins = com.intellij.modules.json
 
 gradleVersion = 8.10.2
 

src/main/kotlin/org/tonstudio/tact/ide/build/TactBuildLineMarkerProvider.kt

@@ -0,0 +1,26 @@
+package org.tonstudio.tact.ide.build
+
+import com.intellij.execution.lineMarker.ExecutorAction
+import com.intellij.execution.lineMarker.RunLineMarkerContributor
+import com.intellij.icons.AllIcons
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.elementType
+import org.tonstudio.tact.lang.TactTypes
+import org.tonstudio.tact.lang.psi.TactContractType
+
+class TactBuildLineMarkerProvider : RunLineMarkerContributor() {
+    private val contextActions = ExecutorAction.Companion.getActions(0)
+
+    override fun getInfo(element: PsiElement): Info? {
+        if (element.elementType == TactTypes.IDENTIFIER) {
+            val parent = element.parent
+            if (parent is TactContractType) {
+                return Info(AllIcons.Toolwindows.ToolWindowBuild, contextActions)
+            }
+
+            return null
+        }
+
+        return null
+    }
+}

src/main/kotlin/org/tonstudio/tact/ide/build/TactBuildProjectLineMarkerProvider.kt

@@ -0,0 +1,32 @@
+package org.tonstudio.tact.ide.build
+
+import com.intellij.execution.lineMarker.ExecutorAction
+import com.intellij.execution.lineMarker.RunLineMarkerContributor
+import com.intellij.icons.AllIcons
+import com.intellij.json.JsonElementTypes
+import com.intellij.json.psi.JsonProperty
+import com.intellij.json.psi.JsonStringLiteral
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.elementType
+
+class TactBuildProjectLineMarkerProvider : RunLineMarkerContributor() {
+    private val contextActions = ExecutorAction.Companion.getActions(0)
+
+    override fun getInfo(element: PsiElement): Info? {
+        if (element.elementType != JsonElementTypes.DOUBLE_QUOTED_STRING && element.elementType != JsonElementTypes.SINGLE_QUOTED_STRING)
+            return null
+
+        val elementContent = element.text.slice(1..element.text.lastIndex - 1)
+        if (elementContent != "name") return null
+
+        val parent = element.parent.parent
+        if (parent is JsonProperty) {
+            if (parent.name == "name") {
+                val projectName = parent.value as? JsonStringLiteral ?: return null
+                return Info(AllIcons.Toolwindows.ToolWindowBuild, contextActions) { "Build project \"${projectName.value}\"" }
+            }
+        }
+
+        return null
+    }
+}

src/main/kotlin/org/tonstudio/tact/ide/build/TactProcessHandler.kt

@@ -0,0 +1,39 @@
+package org.tonstudio.tact.ide.build
+
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.execution.configurations.PtyCommandLine
+import com.intellij.execution.process.AnsiEscapeDecoder
+import com.intellij.execution.process.KillableProcessHandler
+import com.intellij.openapi.util.Key
+import com.intellij.util.io.BaseDataReader
+import com.intellij.util.io.BaseOutputReader
+
+class TactProcessHandler(commandLine: GeneralCommandLine) : KillableProcessHandler(commandLine), AnsiEscapeDecoder.ColoredTextAcceptor {
+    private val decoder: AnsiEscapeDecoder?
+
+    init {
+        setHasPty(commandLine is PtyCommandLine)
+        setShouldDestroyProcessRecursively(!hasPty())
+        decoder = null // if (!hasPty()) AnsiEscapeDecoder() else null
+    }
+
+    override fun notifyTextAvailable(text: String, outputType: Key<*>) {
+        decoder?.escapeText(text, outputType, this) ?: super.notifyTextAvailable(text, outputType)
+    }
+
+    override fun coloredTextAvailable(text: String, attributes: Key<*>) {
+        super.notifyTextAvailable(text, attributes)
+    }
+
+    override fun readerOptions(): BaseOutputReader.Options = object : BaseOutputReader.Options() {
+        override fun policy(): BaseDataReader.SleepingPolicy =
+            if (hasPty() || java.lang.Boolean.getBoolean("output.reader.blocking.mode")) {
+                BaseDataReader.SleepingPolicy.BLOCKING
+            } else {
+                BaseDataReader.SleepingPolicy.NON_BLOCKING
+            }
+
+        override fun splitToLines(): Boolean = !hasPty()
+    }
+}
+

src/main/kotlin/org/tonstudio/tact/ide/build/project/TactBuildConfiguration.kt

@@ -0,0 +1,71 @@
+package org.tonstudio.tact.ide.build.project
+
+import com.intellij.execution.Executor
+import com.intellij.execution.configurations.ConfigurationFactory
+import com.intellij.execution.configurations.LocatableConfiguration
+import com.intellij.execution.configurations.RunConfigurationBase
+import com.intellij.execution.configurations.RunProfileState
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.intellij.openapi.project.Project
+import org.jdom.Element
+
+open class TactBuildConfiguration(project: Project, factory: ConfigurationFactory?, name: String?) :
+    RunConfigurationBase<TactBuildConfigurationOptions>(project, factory, name),
+    LocatableConfiguration {
+
+    override fun getOptions() = super.getOptions() as TactBuildConfigurationOptions
+
+    var fileName: String
+        get() = options.fileName
+        set(value) {
+            options.fileName = value
+        }
+
+    var projectName: String
+        get() = options.projectName
+        set(value) {
+            options.projectName = value
+        }
+
+    override fun writeExternal(element: Element) {
+        super<RunConfigurationBase>.writeExternal(element)
+
+        with(element) {
+            writeString("fileName", fileName)
+            writeString("projectName", projectName)
+        }
+    }
+
+    override fun isGeneratedName(): Boolean {
+        return false
+    }
+
+    override fun readExternal(element: Element) {
+        super<RunConfigurationBase>.readExternal(element)
+
+        with(element) {
+            readString("fileName")?.let { fileName = it }
+            readString("projectName")?.let { projectName = it }
+        }
+    }
+
+    override fun getConfigurationEditor() = TactBuildConfigurationEditor(project)
+
+    override fun checkConfiguration() {}
+
+    override fun getState(executor: Executor, executionEnvironment: ExecutionEnvironment): RunProfileState? {
+        return TactBuildConfigurationRunState(executionEnvironment, this)
+    }
+
+    private fun Element.writeString(name: String, value: String) {
+        val opt = Element("option")
+        opt.setAttribute("name", name)
+        opt.setAttribute("value", value)
+        addContent(opt)
+    }
+
+    private fun Element.readString(name: String): String? =
+        children
+            .find { it.name == "option" && it.getAttributeValue("name") == name }
+            ?.getAttributeValue("value")
+}

src/main/kotlin/org/tonstudio/tact/ide/build/project/TactBuildConfigurationEditor.kt

@@ -0,0 +1,66 @@
+package org.tonstudio.tact.ide.build.project
+
+import com.intellij.execution.configuration.EnvironmentVariablesComponent
+import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory
+import com.intellij.openapi.options.SettingsEditor
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.ui.DialogPanel
+import com.intellij.ui.dsl.builder.*
+import javax.swing.JComponent
+import javax.swing.JPanel
+
+open class TactBuildConfigurationEditor(private val project: Project) : SettingsEditor<TactBuildConfiguration>() {
+    data class Model(
+        var fileName: String = "",
+        var projectName: String = "",
+    )
+
+    private val environmentVariables = EnvironmentVariablesComponent()
+    private lateinit var mainPanel: DialogPanel
+    private val model = Model()
+
+    init {
+        environmentVariables.label.text = "Environment:"
+    }
+
+    override fun resetEditorFrom(demoRunConfiguration: TactBuildConfiguration) {
+        with(model) {
+            fileName = demoRunConfiguration.fileName
+            projectName = demoRunConfiguration.projectName
+        }
+
+        mainPanel.reset()
+    }
+
+    override fun applyEditorTo(demoRunConfiguration: TactBuildConfiguration) {
+        mainPanel.apply()
+
+        with(demoRunConfiguration) {
+            fileName = model.fileName
+            projectName = model.projectName
+        }
+    }
+
+    override fun createEditor(): JComponent = component()
+
+    private fun component(): JPanel {
+        mainPanel = panel {
+            row("Config File:") {
+                textFieldWithBrowseButton(
+                    FileChooserDescriptorFactory.createSingleFileDescriptor("tact.config.json").withTitle("Select Tact Config File"),
+                    project,
+                )
+                    .align(AlignX.FILL)
+                    .bindText(model::fileName)
+            }.bottomGap(BottomGap.NONE)
+
+            row("Project name:") {
+                textField()
+                    .align(AlignX.FILL)
+                    .bindText(model::projectName)
+                    .comment("Project name to build")
+            }.bottomGap(BottomGap.NONE)
+        }
+        return mainPanel
+    }
+}

src/main/kotlin/org/tonstudio/tact/ide/build/project/TactBuildConfigurationOptions.kt

@@ -0,0 +1,20 @@
+package org.tonstudio.tact.ide.build.project
+
+import com.intellij.execution.configurations.RunConfigurationOptions
+
+class TactBuildConfigurationOptions : RunConfigurationOptions() {
+    private var _fileName = string("").provideDelegate(this, "fileNameRunConfiguration")
+    private var _projectName = string("").provideDelegate(this, "projectNameRunConfiguration")
+
+    var fileName: String
+        get() = _fileName.getValue(this) ?: ""
+        set(value) {
+            _fileName.setValue(this, value)
+        }
+
+    var projectName: String
+        get() = _projectName.getValue(this) ?: ""
+        set(value) {
+            _projectName.setValue(this, value)
+        }
+}

src/main/kotlin/org/tonstudio/tact/ide/build/project/TactBuildConfigurationProducer.kt

@@ -0,0 +1,67 @@
+package org.tonstudio.tact.ide.build.project
+
+import com.intellij.execution.actions.ConfigurationContext
+import com.intellij.execution.actions.LazyRunConfigurationProducer
+import com.intellij.execution.configurations.ConfigurationFactory
+import com.intellij.execution.configurations.ConfigurationTypeUtil
+import com.intellij.json.psi.JsonFile
+import com.intellij.json.psi.JsonProperty
+import com.intellij.json.psi.JsonStringLiteral
+import com.intellij.openapi.roots.TestSourcesFilter
+import com.intellij.openapi.util.Ref
+import com.intellij.psi.PsiElement
+
+class TactBuildConfigurationProducer : LazyRunConfigurationProducer<TactBuildConfiguration>() {
+    override fun getConfigurationFactory(): ConfigurationFactory =
+        ConfigurationTypeUtil.findConfigurationType(TactBuildConfigurationType.ID)!!
+            .configurationFactories[0]
+
+    override fun isConfigurationFromContext(
+        configuration: TactBuildConfiguration,
+        context: ConfigurationContext,
+    ): Boolean {
+        val element = context.location?.psiElement ?: return false
+        val containingFile = element.containingFile ?: return false
+        if (TestSourcesFilter.isTestSources(containingFile.virtualFile, element.project)) {
+            return false
+        }
+
+        if (containingFile !is JsonFile || containingFile.name != "tact.config.json") {
+            return false
+        }
+
+        val projectName = getProjectName(element) ?: return false
+
+        return configuration.fileName == containingFile.virtualFile.path && configuration.projectName == projectName
+    }
+
+    override fun setupConfigurationFromContext(
+        configuration: TactBuildConfiguration,
+        context: ConfigurationContext,
+        sourceElement: Ref<PsiElement>,
+    ): Boolean {
+        val element = sourceElement.get()
+        val containingFile = element.containingFile ?: return false
+        if (TestSourcesFilter.isTestSources(containingFile.virtualFile, element.project)) {
+            return false
+        }
+
+        if (containingFile !is JsonFile || containingFile.name != "tact.config.json") {
+            return false
+        }
+
+        val configPath = containingFile.virtualFile.path
+        val projectName = getProjectName(element) ?: return false
+
+        configuration.name = "Build project \"$projectName\""
+        configuration.fileName = configPath
+        configuration.projectName = projectName
+        return true
+    }
+
+    private fun getProjectName(element: PsiElement?): String?{
+        val jsonProperty = element?.parent?.parent as? JsonProperty
+        val projectName = jsonProperty?.value as? JsonStringLiteral ?: return null
+        return projectName.value
+    }
+}

src/main/kotlin/org/tonstudio/tact/ide/build/project/TactBuildConfigurationRunState.kt

@@ -0,0 +1,52 @@
+package org.tonstudio.tact.ide.build.project
+
+import com.intellij.execution.ExecutionResult
+import com.intellij.execution.Executor
+import com.intellij.execution.configurations.CommandLineState
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.execution.configurations.RunProfileState
+import com.intellij.execution.process.ProcessHandler
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.intellij.execution.runners.ProgramRunner
+import org.tonstudio.tact.configurations.TactConfigurationUtil
+import org.tonstudio.tact.ide.build.TactProcessHandler
+import org.tonstudio.tact.ide.build.tryRelativizePath
+import org.tonstudio.tact.toolchain.TactToolchainService.Companion.toolchainSettings
+
+class TactBuildConfigurationRunState(
+    val env: ExecutionEnvironment,
+    val conf: TactBuildConfiguration,
+) : RunProfileState {
+
+    override fun execute(executor: Executor, runner: ProgramRunner<*>): ExecutionResult? {
+        val state = object : CommandLineState(env) {
+            override fun startProcess(): ProcessHandler {
+                val project = env.project
+
+                val root = project.toolchainSettings.toolchain().rootDir()
+                if (root == null) {
+                    throw Error("Can't build: ${TactConfigurationUtil.TOOLCHAIN_NOT_SETUP}")
+                }
+
+                val tactCompiler = root.findChild("bin")?.findChild("tact.js")
+                if (tactCompiler == null) {
+                    throw Error("Can't build: Cannot find Tact compiler executable")
+                }
+
+                val (configPath, projectRoot) = tryRelativizePath(project, conf.fileName)
+
+                val commandLine = GeneralCommandLine()
+                    .withExePath(tactCompiler.path)
+                    .withWorkDirectory(projectRoot)
+                    .withCharset(Charsets.UTF_8)
+                    .withParameters("--config", configPath)
+                    .withParameters("--project", conf.projectName)
+                    .withRedirectErrorStream(true)
+
+                return TactProcessHandler(commandLine)
+            }
+        }
+
+        return state.execute(executor, runner)
+    }
+}