feat(lsp): trim single trailing spaces on type

Author: iamgio

quarkdown-lsp/src/main/kotlin/com/quarkdown/lsp/QuarkdownLanguageServer.kt

@@ -6,9 +6,11 @@ import com.quarkdown.lsp.diagnostics.DiagnosticsSuppliersFactory
 import com.quarkdown.lsp.highlight.SemanticTokensSuppliersFactory
 import com.quarkdown.lsp.highlight.TokenType
 import com.quarkdown.lsp.hover.HoverSuppliersFactory
+import com.quarkdown.lsp.ontype.OnTypeFormattingSuppliersFactory
 import com.quarkdown.lsp.pattern.QuarkdownPatterns
 import org.eclipse.lsp4j.CompletionOptions
 import org.eclipse.lsp4j.Diagnostic
+import org.eclipse.lsp4j.DocumentOnTypeFormattingOptions
 import org.eclipse.lsp4j.InitializeParams
 import org.eclipse.lsp4j.InitializeResult
 import org.eclipse.lsp4j.MessageParams
@@ -44,6 +46,7 @@ class QuarkdownLanguageServer(
             SemanticTokensSuppliersFactory.default(),
             HoverSuppliersFactory.default(this),
             DiagnosticsSuppliersFactory.default(this),
+            OnTypeFormattingSuppliersFactory.default(),
         )
 
     private val completionTriggers =
@@ -55,6 +58,8 @@ class QuarkdownLanguageServer(
             )
         }
 
+    private val onTypeFormattingOptions = DocumentOnTypeFormattingOptions("\n")
+
     private val workspaceService: WorkspaceService = QuarkdownWorkspaceService(this)
 
     private lateinit var client: LanguageClient
@@ -85,6 +90,7 @@ class QuarkdownLanguageServer(
                 completionProvider = CompletionOptions(true, completionTriggers)
                 hoverProvider = Either.forLeft(true)
                 semanticTokensProvider = SemanticTokensWithRegistrationOptions(legend, true, null)
+                documentOnTypeFormattingProvider = onTypeFormattingOptions
             }
         val response = InitializeResult(serverCaps)
 

quarkdown-lsp/src/main/kotlin/com/quarkdown/lsp/QuarkdownTextDocumentService.kt

@@ -5,9 +5,11 @@ import com.quarkdown.lsp.completion.CompletionSupplier
 import com.quarkdown.lsp.diagnostics.DiagnosticsSupplier
 import com.quarkdown.lsp.highlight.SemanticTokensSupplier
 import com.quarkdown.lsp.hover.HoverSupplier
+import com.quarkdown.lsp.ontype.OnTypeFormattingEditSupplier
 import com.quarkdown.lsp.subservices.CompletionSubservice
 import com.quarkdown.lsp.subservices.DiagnosticsSubservice
 import com.quarkdown.lsp.subservices.HoverSubservice
+import com.quarkdown.lsp.subservices.OnTypeFormattingSubservice
 import com.quarkdown.lsp.subservices.SemanticTokensSubservice
 import org.eclipse.lsp4j.CompletionItem
 import org.eclipse.lsp4j.CompletionList
@@ -17,11 +19,13 @@ import org.eclipse.lsp4j.DidChangeTextDocumentParams
 import org.eclipse.lsp4j.DidCloseTextDocumentParams
 import org.eclipse.lsp4j.DidOpenTextDocumentParams
 import org.eclipse.lsp4j.DidSaveTextDocumentParams
+import org.eclipse.lsp4j.DocumentOnTypeFormattingParams
 import org.eclipse.lsp4j.Hover
 import org.eclipse.lsp4j.HoverParams
 import org.eclipse.lsp4j.SemanticTokens
 import org.eclipse.lsp4j.SemanticTokensParams
 import org.eclipse.lsp4j.TextDocumentIdentifier
+import org.eclipse.lsp4j.TextEdit
 import org.eclipse.lsp4j.jsonrpc.messages.Either
 import org.eclipse.lsp4j.services.TextDocumentService
 import java.util.concurrent.CompletableFuture
@@ -38,11 +42,13 @@ class QuarkdownTextDocumentService(
     tokensSuppliers: List<SemanticTokensSupplier>,
     hoverSuppliers: List<HoverSupplier>,
     diagnosticsSuppliers: List<DiagnosticsSupplier>,
+    formattingSuppliers: List<OnTypeFormattingEditSupplier>,
 ) : TextDocumentService {
     private val completionService = CompletionSubservice(completionSuppliers)
     private val semanticTokensService = SemanticTokensSubservice(tokensSuppliers)
     private val hoverService = HoverSubservice(hoverSuppliers)
     private val diagnosticsService = DiagnosticsSubservice(diagnosticsSuppliers)
+    private val onTypeFormattingService = OnTypeFormattingSubservice(formattingSuppliers)
 
     /**
      * Maps document URIs to their text content.
@@ -155,4 +161,11 @@ class QuarkdownTextDocumentService(
         val document = getDocument(params.textDocument)
         return CompletableFuture.completedFuture(hoverService.process(params, document))
     }
+
+    override fun onTypeFormatting(params: DocumentOnTypeFormattingParams): CompletableFuture<List<TextEdit?>?>? {
+        server.log("Operation 'text/onTypeFormatting'")
+
+        val document = getDocument(params.textDocument)
+        return CompletableFuture.completedFuture(onTypeFormattingService.process(params, document))
+    }
 }

quarkdown-lsp/src/main/kotlin/com/quarkdown/lsp/ontype/OnTypeFormattingEditSupplier.kt

@@ -0,0 +1,21 @@
+package com.quarkdown.lsp.ontype
+
+import com.quarkdown.lsp.TextDocument
+import org.eclipse.lsp4j.DocumentOnTypeFormattingParams
+import org.eclipse.lsp4j.TextEdit
+
+/**
+ * Supplier of text edits for on-type formatting.
+ */
+interface OnTypeFormattingEditSupplier {
+    /**
+     * Provides text edits for on-type formatting based on the given parameters and document.
+     * @param params the parameters for the on-type formatting request
+     * @param document the text document to format
+     * @return a list of text edits to apply to the document
+     */
+    fun getEdits(
+        params: DocumentOnTypeFormattingParams,
+        document: TextDocument,
+    ): List<TextEdit>
+}

quarkdown-lsp/src/main/kotlin/com/quarkdown/lsp/ontype/OnTypeFormattingSuppliersFactory.kt

@@ -0,0 +1,8 @@
+package com.quarkdown.lsp.ontype
+
+/**
+ * Factory for creating [OnTypeFormattingEditSupplier]s.
+ */
+object OnTypeFormattingSuppliersFactory {
+    fun default(): List<OnTypeFormattingEditSupplier> = listOf(TrailingSpacesRemoverOnTypeFormattingEditSupplier())
+}

quarkdown-lsp/src/main/kotlin/com/quarkdown/lsp/ontype/TrailingSpacesRemoverOnTypeFormattingEditSupplier.kt

@@ -0,0 +1,40 @@
+package com.quarkdown.lsp.ontype
+
+import com.quarkdown.lsp.TextDocument
+import com.quarkdown.lsp.util.getLine
+import org.eclipse.lsp4j.DocumentOnTypeFormattingParams
+import org.eclipse.lsp4j.Position
+import org.eclipse.lsp4j.Range
+import org.eclipse.lsp4j.TextEdit
+
+private const val TO_REMOVE = " "
+
+/**
+ * Formatter that removes a single trailing space at the end of the previous line when the user types a newline,
+ * but keeps double (or more) spaces which are significant in Markdown for hard line breaks.
+ */
+class TrailingSpacesRemoverOnTypeFormattingEditSupplier : OnTypeFormattingEditSupplier {
+    override fun getEdits(
+        params: DocumentOnTypeFormattingParams,
+        document: TextDocument,
+    ): List<TextEdit> {
+        val lineNum = params.position.line - 1 // Line before the newline.
+        val line =
+            document.text.getLine(lineNum)
+                ?: return emptyList() // No such line.
+
+        if (!line.endsWith(TO_REMOVE)) return emptyList() // No trailing space.
+        if (line.endsWith(TO_REMOVE + TO_REMOVE)) return emptyList() // More than one trailing space.
+
+        val edit =
+            TextEdit(
+                Range(
+                    Position(lineNum, line.length - TO_REMOVE.length),
+                    Position(lineNum, line.length),
+                ),
+                "",
+            )
+
+        return listOf(edit)
+    }
+}

quarkdown-lsp/src/main/kotlin/com/quarkdown/lsp/subservices/OnTypeFormattingSubservice.kt

@@ -0,0 +1,19 @@
+package com.quarkdown.lsp.subservices
+
+import com.quarkdown.lsp.TextDocument
+import com.quarkdown.lsp.ontype.OnTypeFormattingEditSupplier
+import org.eclipse.lsp4j.DocumentOnTypeFormattingParams
+import org.eclipse.lsp4j.TextEdit
+
+/**
+ * Subservice for handling on-type formatting requests.
+ * It aggregates edits from all suppliers and returns them as a single list.
+ */
+class OnTypeFormattingSubservice(
+    private val editSuppliers: List<OnTypeFormattingEditSupplier>,
+) : TextDocumentSubservice<DocumentOnTypeFormattingParams, List<TextEdit>> {
+    override fun process(
+        params: DocumentOnTypeFormattingParams,
+        document: TextDocument,
+    ): List<TextEdit> = editSuppliers.flatMap { it.getEdits(params, document) }
+}

quarkdown-lsp/src/main/kotlin/com/quarkdown/lsp/util/PositionUtils.kt

@@ -3,17 +3,23 @@ package com.quarkdown.lsp.util
 import com.quarkdown.core.util.substringWithinBounds
 import org.eclipse.lsp4j.Position
 
+/**
+ * @param line the line number (0-based)
+ * @return the line at the specified index, or null if the index is out of bounds
+ */
+fun String.getLine(line: Int): String? = lines().getOrNull(line)
+
 /**
  * @param text the text content to search in
  * @return the character at the specified position, or null if the position is out of bounds
  */
-fun Position.getChar(text: String): Char? = text.lines().getOrNull(line)?.getOrNull(character - 1)
+fun Position.getChar(text: String): Char? = text.getLine(line)?.getOrNull(character - 1)
 
 /**
  * @param text the text content to search in
  * @return the substring from the start of the line, up to the specified position, or `null` if the position is out of bounds
  */
-fun Position.getLineUntilPosition(text: String): String? = text.lines()[line].substringWithinBounds(0, character)
+fun Position.getLineUntilPosition(text: String): String? = text.getLine(line)?.substringWithinBounds(0, character)
 
 /**
  * @param text the text content to search in

quarkdown-lsp/src/test/kotlin/com/quarkdown/lsp/TrailingSpacesRemoverFormattingEditSupplierTest.kt

@@ -0,0 +1,67 @@
+package com.quarkdown.lsp
+
+import com.quarkdown.core.util.normalizeLineSeparators
+import com.quarkdown.lsp.ontype.TrailingSpacesRemoverOnTypeFormattingEditSupplier
+import org.eclipse.lsp4j.DocumentOnTypeFormattingParams
+import org.eclipse.lsp4j.FormattingOptions
+import org.eclipse.lsp4j.Position
+import org.eclipse.lsp4j.TextDocumentIdentifier
+import org.eclipse.lsp4j.TextEdit
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+/**
+ * Tests for [TrailingSpacesRemoverOnTypeFormattingEditSupplier].
+ */
+class TrailingSpacesRemoverFormattingEditSupplierTest {
+    private val supplier = TrailingSpacesRemoverOnTypeFormattingEditSupplier()
+
+    private fun getEdits(
+        text: String,
+        atLine: Int,
+    ): List<TextEdit> {
+        val doc = TextDocument(text.normalizeLineSeparators().toString())
+        val options = FormattingOptions(2, true)
+        val params =
+            DocumentOnTypeFormattingParams(TextDocumentIdentifier("mem://test.md"), options, Position(atLine, 0), "\n")
+        return supplier.getEdits(params, doc)
+    }
+
+    @Test
+    fun `removes single trailing space`() {
+        val text = "Hello \n"
+        val edits = getEdits(text, 1)
+        assertEquals(1, edits.size)
+        assertEquals(
+            5,
+            edits
+                .single()
+                .range.start.character,
+        )
+        assertEquals(
+            6,
+            edits
+                .single()
+                .range.end.character,
+        )
+    }
+
+    @Test
+    fun `removes single trailing spaces among multiple lines`() {
+        val text = "Hello \nWorld \nThis is a test \n"
+        val edits = getEdits(text, 3)
+        assertEquals(1, edits.size)
+    }
+
+    @Test
+    fun `keeps double trailing space`() {
+        val text = "Hello  \n"
+        assertEquals(0, getEdits(text, 1).size)
+    }
+
+    @Test
+    fun `no trailing space to remove`() {
+        val text = "Hello\n"
+        assertEquals(0, getEdits(text, 1).size)
+    }
+}