Support formatting using ktlint (#52)

* Support formatting using ktlint

* use ktlint binary for now

* detekt

* Default to none

* Update config

* Make ktlint default

* Log error

Author: smocherla-brex

server/build.gradle.kts

@@ -69,7 +69,9 @@ dependencies {
     annotationProcessor(libs.org.openjdk.jmh.generator.annprocess)
 }
 
-configurations.forEach { config -> config.resolutionStrategy { preferProjectModules() } }
+configurations.forEach { config -> config.resolutionStrategy {
+    preferProjectModules()
+} }
 
 tasks.startScripts { applicationName = "kotlin-language-server" }
 

server/src/main/kotlin/org/javacs/kt/Configuration.kt

@@ -72,9 +72,15 @@ data class KtfmtConfiguration(
     var removeUnusedImports: Boolean = true,
 )
 
+data class KtlintConfiguration(
+    var editorConfigPath: String? = null,
+    var ktlintPath: String? = "ktlint",
+)
+
 data class FormattingConfiguration(
-    var formatter: String = "ktfmt",
-    var ktfmt: KtfmtConfiguration = KtfmtConfiguration()
+    var formatter: String = "ktlint",
+    var ktfmt: KtfmtConfiguration = KtfmtConfiguration(),
+    var ktlint: KtlintConfiguration = KtlintConfiguration(),
 )
 
 fun getInitializationOptions(params: InitializeParams): InitializationOptions? {
@@ -95,6 +101,8 @@ data class InitializationOptions(
     val lazyCompilation: Boolean = false,
     // The JVM configuration, which encapsulates the Java version used by the Kotlin compiler
     val jvmConfiguration: JVMConfiguration? = JVMConfiguration(),
+    // The formatting configuration
+    val formattingConfiguration: FormattingConfiguration? = FormattingConfiguration(),
 )
 
 class GsonPathConverter : JsonDeserializer<Path?> {

server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt

@@ -73,6 +73,7 @@ class KotlinLanguageServer(
     @JsonDelegate
     fun getProtocolExtensionService(): KotlinProtocolExtensions = protocolExtensions
 
+    @Suppress("CyclomaticComplexMethod", "LongMethod")
     override fun initialize(params: InitializeParams): CompletableFuture<InitializeResult> = async.compute {
         val serverCapabilities = ServerCapabilities()
         serverCapabilities.setTextDocumentSync(TextDocumentSyncKind.Incremental)
@@ -107,6 +108,15 @@ class KotlinLanguageServer(
                 LOG.info("JVM Target - ${jvmConfig.target}")
                 config.compiler.jvm.target = jvmConfig.target
             }
+            it.formattingConfiguration?.let { formattingConfig ->
+                config.formatting.formatter = formattingConfig.formatter
+                formattingConfig.ktlint.ktlintPath?.let { ktlintPath ->
+                    config.formatting.ktlint.ktlintPath = ktlintPath
+                }
+                formattingConfig.ktlint.editorConfigPath?.let { editorConfigPath ->
+                    config.formatting.ktlint.editorConfigPath = editorConfigPath
+                }
+            }
         }
 
 

server/src/main/kotlin/org/javacs/kt/KotlinWorkspaceService.kt

@@ -134,6 +134,11 @@ class KotlinWorkspaceService(
                         get("continuationIndent")?.asInt?.let { ktfmt.continuationIndent = it }
                         get("removeUnusedImports")?.asBoolean?.let { ktfmt.removeUnusedImports = it }
                     }
+                    get("ktlint")?.asJsonObject?.apply {
+                        val ktlint = formatting.ktlint
+                        get("ktlintPath")?.asString?.let { ktlint.ktlintPath = it }
+                        get("editorConfigPath")?.asString?.let { ktlint.editorConfigPath = it }
+                    }
                 }
 
                 // Update options for inlay hints

server/src/main/kotlin/org/javacs/kt/formatting/FormattingService.kt

@@ -10,6 +10,7 @@ class FormattingService(private val config: FormattingConfiguration) {
 
     private val formatter: Formatter get() = when (config.formatter) {
         "ktfmt" -> KtfmtFormatter(config.ktfmt)
+        "ktlint" -> KtlintFormatter(config.ktlint)
         "none" -> NopFormatter
         else -> KtfmtFormatter(config.ktfmt)
     }

server/src/main/kotlin/org/javacs/kt/formatting/KtlintFormatter.kt

@@ -0,0 +1,38 @@
+package org.javacs.kt.formatting
+
+import org.eclipse.lsp4j.FormattingOptions
+import org.javacs.kt.KtlintConfiguration
+
+/**
+ * KtlintFormatter formats the code using ktlint API
+ */
+class KtlintFormatter(private val ktlintConfig: KtlintConfiguration): Formatter {
+    override fun format(code: String, options: FormattingOptions): String {
+        requireNotNull(ktlintConfig.ktlintPath)
+        val ktlintArgs = mutableListOf<String>("--stdin", "--format", "--log-level=none")
+        ktlintConfig.editorConfigPath?.let {
+            ktlintArgs.add("--editorconfig=${ktlintConfig.editorConfigPath}")
+        }
+        val process = ProcessBuilder(listOf(ktlintConfig.ktlintPath) + ktlintArgs)
+            .start()
+
+        process.outputStream.bufferedWriter().use { writer ->
+            writer.write(code)
+            writer.flush()
+            writer.close()  // important: signal EOF to stdin
+        }
+
+        val exitCode = process.waitFor()
+        val formatted = process.inputStream.bufferedReader().readText()
+
+        if (exitCode != 0) {
+            val error = process.errorStream.bufferedReader().readText()
+            throw KtlintException("ktlint failed with exit code $exitCode. Output: $formatted, Error: $error")
+        }
+
+        return formatted
+    }
+}
+
+
+class KtlintException(message: String) : Exception(message)