Enhance SQL formatting by refining indentation logic and preventing unnecessary spaces in function parameters

xterao · xterao · commit 624d8064ec15 · 2025-08-22T10:58:18.000+09:00
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlBlock.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlBlock.kt
@@ -76,7 +76,7 @@ open class SqlBlock(
         private val SPACING_ONE_NO_KEEP = Spacing.createSpacing(1, 1, 0, false, 0)
     }
 
-    fun getChildrenTextLen(): Int = childBlocks.sumOf { child -> calculateChildTextLength(child) }
+    fun getChildrenTextLen(): Int = childBlocks.sumOf { child -> calculateChildTextLength(child).plus(1) }
 
     private fun calculateChildTextLength(child: SqlBlock): Int {
         val nonCommentChildren = child.childBlocks.filterNot { it is SqlDefaultCommentBlock }
@@ -139,7 +139,7 @@ open class SqlBlock(
         val firstConditionBlock = (prevChildren?.firstOrNull() as? SqlElConditionLoopCommentBlock)
         val endBlock = firstConditionBlock?.conditionEnd
         if (endBlock == null) return false
-        val lastBlock = prevChildren.lastOrNull()
+        val lastBlock = prevBlocks.lastOrNull()
 
         return endBlock.node.startOffset > (lastBlock?.node?.startOffset ?: 0)
     }
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlFileBlock.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlFileBlock.kt
@@ -26,6 +26,10 @@ import com.intellij.formatting.Wrap
 import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.formatter.common.AbstractBlock
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.psi.util.elementType
+import com.intellij.psi.util.nextLeaf
+import com.intellij.psi.util.nextLeafs
 import org.domaframework.doma.intellij.common.util.TypeUtil
 import org.domaframework.doma.intellij.formatter.block.comma.SqlCommaBlock
 import org.domaframework.doma.intellij.formatter.block.comment.SqlCommentBlock
@@ -221,8 +225,23 @@ open class SqlFileBlock(
                 }
             }
 
-            SqlTypes.FUNCTION_NAME ->
-                return SqlFunctionGroupBlock(child, defaultFormatCtx)
+            SqlTypes.FUNCTION_NAME -> {
+                val notWhiteSpaceElement =
+                    child.psi.nextLeafs
+                        .takeWhile { it is PsiWhiteSpace }
+                        .lastOrNull()
+                        ?.nextLeaf(true)
+                if (notWhiteSpaceElement?.elementType == SqlTypes.LEFT_PAREN ||
+                    PsiTreeUtil.nextLeaf(child.psi)?.elementType == SqlTypes.LEFT_PAREN
+                ) {
+                    return SqlFunctionGroupBlock(child, defaultFormatCtx)
+                }
+                return SqlKeywordBlock(
+                    child,
+                    IndentType.ATTACHED,
+                    defaultFormatCtx,
+                )
+            }
 
             SqlTypes.WORD -> {
                 return if (lastGroup is SqlWithQueryGroupBlock) {
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/block/group/subgroup/SqlFunctionParamBlock.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/block/group/subgroup/SqlFunctionParamBlock.kt
@@ -19,6 +19,9 @@ import com.intellij.lang.ASTNode
 import org.domaframework.doma.intellij.formatter.block.SqlBlock
 import org.domaframework.doma.intellij.formatter.block.comment.SqlDefaultCommentBlock
 import org.domaframework.doma.intellij.formatter.block.comment.SqlElConditionLoopCommentBlock
+import org.domaframework.doma.intellij.formatter.block.expr.SqlElAtSignBlock
+import org.domaframework.doma.intellij.formatter.block.expr.SqlElSymbolBlock
+import org.domaframework.doma.intellij.formatter.block.other.SqlOtherBlock
 import org.domaframework.doma.intellij.formatter.block.word.SqlFunctionGroupBlock
 import org.domaframework.doma.intellij.formatter.util.IndentType
 import org.domaframework.doma.intellij.formatter.util.SqlBlockFormattingContext
@@ -79,22 +82,51 @@ class SqlFunctionParamBlock(
     }
 
     override fun createGroupIndentLen(): Int {
-        val parentFunctionName = parentBlock as? SqlFunctionGroupBlock
-        parentFunctionName?.let { parent ->
-            return parent.indent.groupIndentLen
-                .plus(getNodeText().length)
-        }
-
+        val parentGroupIndent = parentBlock?.indent?.groupIndentLen ?: 0
         val prevChildrenDropLast =
             prevChildren?.dropLast(1)?.filter {
                 it !is SqlDefaultCommentBlock &&
                     it.node.elementType != SqlTypes.DOT
             }
                 ?: emptyList()
+        val parentText =
+            if (parentBlock is SqlElConditionLoopCommentBlock) {
+                val grand = parentBlock?.parentBlock
+                grand?.getNodeText() ?: ""
+            } else {
+                ""
+            }
         val prevLength =
             prevChildrenDropLast
-                .sumOf { it.getNodeText().length }
-                .plus(getNodeText().length)
-        return prevLength.plus(prevChildrenDropLast.count()).plus(1)
+                .sumOf {
+                    it.getChildrenTextLen().plus(it.getNodeText().length)
+                }.plus(getNodeText().length)
+
+        // Avoid unnecessary spaces when operators are consecutive
+        val consecutiveSymbolCount =
+            calculateConsecutiveSymbolCount(prevChildrenDropLast)
+        val spaces = prevChildrenDropLast.count().minus(consecutiveSymbolCount)
+
+//        parentFunctionName?.let { parent ->
+//            return parentGroupIndent
+//                .plus(prevLength)
+//        }
+
+        return prevLength.plus(spaces).plus(parentText.length).plus(parentGroupIndent)
+    }
+
+    private fun calculateConsecutiveSymbolCount(prevChildrenDropLast: List<SqlBlock>): Int {
+        var count = 0
+        var total = 0
+        for (block in prevChildrenDropLast) {
+            if (block is SqlOtherBlock || block is SqlElAtSignBlock || block is SqlElSymbolBlock) {
+                count++
+            } else {
+                if (count > 1) total++
+                count = 0
+            }
+        }
+        if (count > 1) total += count
+        return total
     }
 }
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/block/word/SqlFunctionGroupBlock.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/block/word/SqlFunctionGroupBlock.kt
@@ -37,7 +37,10 @@ class SqlFunctionGroupBlock(
         indent.groupIndentLen = createGroupIndentLen()
     }
 
-    override fun createBlockIndentLen(): Int {
+    override fun createBlockIndentLen(): Int = parentBlock?.indent?.groupIndentLen ?: 0
+
+    override fun createGroupIndentLen(): Int {
+        var baseIndent = 0
         parentBlock?.let { parent ->
             val children = prevChildren.dropLast(1).filter { it !is SqlDefaultCommentBlock }
             val prevBlocksLength =
@@ -55,15 +58,14 @@ class SqlFunctionGroupBlock(
                                 },
                             )
                     }.plus(parent.indent.groupIndentLen)
-            return if (parent is SqlSubGroupBlock) {
-                // parent.indent.groupIndentLen
-                prevBlocksLength
-            } else {
-                prevBlocksLength.plus(1)
-            }
+            baseIndent =
+                if (parent is SqlSubGroupBlock) {
+                    // parent.indent.groupIndentLen
+                    prevBlocksLength
+                } else {
+                    prevBlocksLength.plus(1)
+                }
         }
-        return 0
+        return baseIndent.plus(getNodeText().length)
     }
-
-    override fun createGroupIndentLen(): Int = indent.indentLen.plus(getNodeText().length)
 }
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/processor/SqlFormatPreProcessor.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/processor/SqlFormatPreProcessor.kt
@@ -111,7 +111,7 @@ class SqlFormatPreProcessor : PreFormatProcessor {
                     }
 
                     SqlTypes.LEFT_PAREN -> {
-                        newKeyword = getNewLineString(it.prevSibling, getUpperText(it))
+                        newKeyword = getNewLineLeftParenString(it.prevSibling, getUpperText(it))
                     }
 
                     SqlTypes.RIGHT_PAREN -> {
@@ -233,6 +233,22 @@ class SqlFormatPreProcessor : PreFormatProcessor {
         }
     }
 
+    private fun getNewLineLeftParenString(
+        prevElement: PsiElement?,
+        text: String,
+    ): String =
+        if (prevElement?.elementType == SqlTypes.BLOCK_COMMENT ||
+            (
+                prevElement?.text?.contains(LINE_SEPARATE) == false &&
+                    prevElement.prevSibling != null &&
+                    prevElement.elementType != SqlTypes.FUNCTION_NAME
+            )
+        ) {
+            "$LINE_SEPARATE$text"
+        } else {
+            text
+        }
+
     private fun getNewLineString(
         prevElement: PsiElement?,
         text: String,
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/util/SqlBlockGenerator.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/util/SqlBlockGenerator.kt
@@ -220,10 +220,18 @@ class SqlBlockGenerator(
                         }
                     }
                     "from" -> {
-                        SqlFromGroupBlock(
-                            child,
-                            sqlBlockFormattingCtx,
-                        )
+                        if (lastGroupBlock is SqlSubGroupBlock) {
+                            SqlKeywordBlock(
+                                child,
+                                IndentType.ATTACHED,
+                                sqlBlockFormattingCtx,
+                            )
+                        } else {
+                            SqlFromGroupBlock(
+                                child,
+                                sqlBlockFormattingCtx,
+                            )
+                        }
                     }
                     "where" -> {
                         SqlWhereGroupBlock(
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/util/SqlKeywordUtil.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/util/SqlKeywordUtil.kt
@@ -304,7 +304,7 @@ class SqlKeywordUtil {
         private val SET_LINE_KEYWORDS =
             mapOf(
                 "into" to setOf("insert"),
-                "from" to setOf("delete", "distinct"),
+                "from" to setOf("delete", "distinct", "year"),
                 "distinct" to setOf("select"),
                 "table" to setOf("create", "alter", "rename", "truncate", "drop"),
                 "index" to setOf("create", "alter", "rename", "truncate", "drop"),

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ open class SqlBlock(`
`76`	`76`	`private val SPACING_ONE_NO_KEEP = Spacing.createSpacing(1, 1, 0, false, 0)`
`77`	`77`	`}`
`78`	`78`
`79`		`- fun getChildrenTextLen(): Int = childBlocks.sumOf { child -> calculateChildTextLength(child) }`
	`79`	`+ fun getChildrenTextLen(): Int = childBlocks.sumOf { child -> calculateChildTextLength(child).plus(1) }`
`80`	`80`
`81`	`81`	`private fun calculateChildTextLength(child: SqlBlock): Int {`
`82`	`82`	`val nonCommentChildren = child.childBlocks.filterNot { it is SqlDefaultCommentBlock }`
`@@ -139,7 +139,7 @@ open class SqlBlock(`
`139`	`139`	`val firstConditionBlock = (prevChildren?.firstOrNull() as? SqlElConditionLoopCommentBlock)`
`140`	`140`	`val endBlock = firstConditionBlock?.conditionEnd`
`141`	`141`	`if (endBlock == null) return false`
`142`		`- val lastBlock = prevChildren.lastOrNull()`
	`142`	`+ val lastBlock = prevBlocks.lastOrNull()`
`143`	`143`
`144`	`144`	`return endBlock.node.startOffset > (lastBlock?.node?.startOffset ?: 0)`
`145`	`145`	`}`