Update the logic for formatting injected SQL so that it aligns at the specified indentation level, offset downward by the configured indent amount.

Author: xterao

src/main/kotlin/org/domaframework/doma/intellij/formatter/processor/SqlFormatPostProcessor.kt

@@ -43,7 +43,7 @@ class SqlFormatPostProcessor : SqlPostProcessor() {
         }
 
         val document = getDocument(source) ?: return rangeToReformat
-        val processedText = processDocumentText(document.text, true)
+        val processedText = processDocumentText(document.text)
 
         if (document.text == processedText) {
             return rangeToReformat

src/main/kotlin/org/domaframework/doma/intellij/formatter/processor/SqlInjectionPostProcessor.kt

@@ -46,7 +46,7 @@ class SqlInjectionPostProcessor : SqlPostProcessor() {
         val visitor = DaoInjectionSqlVisitor(element, project)
         element.accept(visitor)
         visitor.processAll { text, skipFinalLineBreak ->
-            processDocumentText(text, skipFinalLineBreak)
+            processDocumentText(text)
         }
     }
 }

src/main/kotlin/org/domaframework/doma/intellij/formatter/processor/SqlPostProcessor.kt

@@ -36,20 +36,12 @@ abstract class SqlPostProcessor : PostFormatProcessor {
         settings: CodeStyleSettings,
     ): TextRange = rangeToReformat
 
-    protected fun processDocumentText(
-        originalText: String,
-        existsOriginalDocument: Boolean,
-    ): String {
+    protected fun processDocumentText(originalText: String): String {
         val withoutTrailingSpaces = removeTrailingSpaces(originalText)
-        return ensureProperFileEnding(withoutTrailingSpaces, existsOriginalDocument)
+        return ensureProperFileEnding(withoutTrailingSpaces)
     }
 
     private fun removeTrailingSpaces(text: String): String = text.replace(trailingSpacesRegex, "$1")
 
-    private fun ensureProperFileEnding(
-        text: String,
-        isEndSpace: Boolean,
-    ): String =
-        text.trimEnd() +
-            if (isEndSpace) StringUtil.LINE_SEPARATE else ""
+    private fun ensureProperFileEnding(text: String): String = text.trimEnd() + StringUtil.LINE_SEPARATE
 }

src/main/kotlin/org/domaframework/doma/intellij/formatter/visitor/DaoInjectionSqlVisitor.kt

@@ -40,15 +40,14 @@ class DaoInjectionSqlVisitor(
     private data class FormattingTask(
         val expression: PsiLiteralExpression,
         val formattedText: String,
-        val baseIndent: String,
     )
 
     companion object {
         private const val TEMP_FILE_PREFIX = "temp_format"
         private const val SQL_FILE_EXTENSION = ".sql"
-        private const val SQL_COMMENT_PATTERN = "^[ \\t]*/\\*"
         private const val TRIPLE_QUOTE = "\"\"\""
         private const val WRITE_COMMAND_NAME = "Format Injected SQL"
+        private const val BASE_INDENT = "\t\t\t" // getBaseIndent(formattedSql)
     }
 
     private val formattingTasks = mutableListOf<FormattingTask>()
@@ -58,36 +57,39 @@ class DaoInjectionSqlVisitor(
         val injected: PsiFile? = InjectionSqlUtil.initInjectionElement(element, project, expression)
         if (injected != null) {
             // Format SQL and store the task
-            val originalSqlText = injected.text
-            val formattedSql = formatAsTemporarySqlFile(originalSqlText)
-            // Keep the current top line indent
-            val baseIndent = getBaseIndent(formattedSql)
             val originalText = expression.value?.toString() ?: return
-
-            if (formattedSql != originalText) {
-                formattingTasks.add(FormattingTask(expression, formattedSql, baseIndent))
-            }
+            val removeIndent = removeIndentLines(originalText)
+            formattingTasks.add(FormattingTask(expression, removeIndent))
         }
     }
 
-    /**
-     * Extracts the base indentation from the first non-blank, non-comment line.
-     */
-    private fun getBaseIndent(string: String): String {
-        val lines = string.lines()
-        val commentRegex = Regex(SQL_COMMENT_PATTERN)
-
-        // Skip blank lines and comment lines
-        val firstContentLineIndex =
-            lines.indexOfFirst { line ->
-                line.isNotBlank() && !commentRegex.matches(line)
+    private fun removeIndentLines(sqlText: String): String {
+        val lines = sqlText.lines()
+        val commentStartRegex = Regex("^[ \t]*/[*][ \t]*\\*")
+        val commentEndRegex = Regex("\\*/.*$")
+        var blockComment = false
+        val removeIndentLines =
+            lines.map { line ->
+                if (blockComment) {
+                    if (commentEndRegex.containsMatchIn(line)) {
+                        blockComment = false
+                    }
+                    SINGLE_SPACE.plus(line.dropWhile { it.isWhitespace() })
+                } else {
+                    val baseLine =
+                        if (commentStartRegex.containsMatchIn(line)) {
+                            blockComment = true
+                            // Exclude spaces between `/*` and the comment content element,
+                            // as IntelliJ IDEA's Java formatter may insert a space there during formatting.
+                            line.replace(commentStartRegex, "/**")
+                        } else {
+                            line
+                        }
+                    baseLine.dropWhile { it.isWhitespace() }
+                }
             }
 
-        return if (firstContentLineIndex >= 0) {
-            lines[firstContentLineIndex].takeWhile { it.isWhitespace() }
-        } else {
-            ""
-        }
+        return removeIndentLines.joinToString(StringUtil.LINE_SEPARATE)
     }
 
     /**
@@ -138,10 +140,11 @@ class DaoInjectionSqlVisitor(
      */
     private fun replaceHostStringLiteral(
         task: FormattingTask,
-        removeSpace: (String, Boolean) -> String,
+        sqlPostProcessorProcess: (String, Boolean) -> String,
     ) {
         try {
-            val formattedLiteral = createFormattedLiteral(task, removeSpace)
+            // Keep the current top line indent
+            val formattedLiteral = createFormattedLiteral(task, sqlPostProcessorProcess)
             replaceInDocument(task.expression, formattedLiteral)
         } catch (_: Exception) {
             // Silently ignore formatting failures
@@ -150,16 +153,19 @@ class DaoInjectionSqlVisitor(
 
     private fun createFormattedLiteral(
         task: FormattingTask,
-        removeSpace: (String, Boolean) -> String,
+        sqlPostProcessorProcess: (String, Boolean) -> String,
     ): String {
-        val newLiteralText = createFormattedLiteralText(task.formattedText)
-        val normalizedText = normalizeIndentation(newLiteralText, task.baseIndent)
-        val cleanedText = removeSpace(normalizedText, false)
+        // Retrieve the same formatted string as when formatting a regular SQL file.
+        val formattedSql = formatAsTemporarySqlFile(task.formattedText)
+        val cleanedText = sqlPostProcessorProcess(formattedSql, false)
+        // Generate text aligned with the literal element using the formatted string.
+        val newLiteralText = createFormattedLiteralText(cleanedText)
+        val normalizedText = normalizeIndentation(newLiteralText)
 
         val elementFactory =
             com.intellij.psi.JavaPsiFacade
                 .getElementFactory(project)
-        val newLiteral = elementFactory.createExpressionFromText(cleanedText, task.expression)
+        val newLiteral = elementFactory.createExpressionFromText(normalizedText, task.expression)
         return newLiteral.text
     }
 
@@ -192,10 +198,7 @@ class DaoInjectionSqlVisitor(
     /**
      * Normalizes indentation by removing base indent and reapplying it consistently.
      */
-    private fun normalizeIndentation(
-        sqlText: String,
-        baseIndent: String,
-    ): String {
+    private fun normalizeIndentation(sqlText: String): String {
         val lines = sqlText.lines()
         if (lines.isEmpty()) return sqlText
 
@@ -206,8 +209,8 @@ class DaoInjectionSqlVisitor(
             contentLines.map { line ->
                 when {
                     line.isBlank() -> line
-                    line.startsWith(baseIndent) -> baseIndent + line.removePrefix(baseIndent)
-                    else -> baseIndent + line
+                    line.startsWith(BASE_INDENT) -> BASE_INDENT + line.removePrefix(BASE_INDENT)
+                    else -> BASE_INDENT + line
                 }
             }