Add condition to treat function names as regular word blocks

Author: xterao

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlFileBlock.kt

@@ -236,11 +236,12 @@ open class SqlFileBlock(
                 ) {
                     return SqlFunctionGroupBlock(child, defaultFormatCtx)
                 }
-                return SqlKeywordBlock(
-                    child,
-                    IndentType.ATTACHED,
-                    defaultFormatCtx,
-                )
+                // If it is not followed by a left parenthesis, treat it as a word block
+                return if (lastGroup is SqlWithQueryGroupBlock) {
+                    SqlWithCommonTableGroupBlock(child, defaultFormatCtx)
+                } else {
+                    blockUtil.getWordBlock(lastGroup, child)
+                }
             }
 
             SqlTypes.WORD -> {

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/other/SqlEscapeBlock.kt

@@ -17,7 +17,9 @@ package org.domaframework.doma.intellij.formatter.block.other
 
 import com.intellij.lang.ASTNode
 import org.domaframework.doma.intellij.formatter.block.SqlBlock
+import org.domaframework.doma.intellij.formatter.block.comment.SqlElConditionLoopCommentBlock
 import org.domaframework.doma.intellij.formatter.block.group.subgroup.SqlArrayListGroupBlock
+import org.domaframework.doma.intellij.formatter.block.group.subgroup.SqlSubQueryGroupBlock
 import org.domaframework.doma.intellij.formatter.util.SqlBlockFormattingContext
 
 class SqlEscapeBlock(
@@ -34,12 +36,53 @@ class SqlEscapeBlock(
     }
 
     override fun createBlockIndentLen(): Int {
-        val hasEvenEscapeBlocks = parentBlock?.childBlocks?.count { it is SqlEscapeBlock }?.let { it % 2 == 0 } == true
+        val parentEscapeBlock =
+            if (parentBlock is SqlElConditionLoopCommentBlock) {
+                if (parentBlock?.parentBlock is SqlEscapeBlock)1 else 0
+            } else {
+                0
+            }
+        val prevBlocks = parentBlock?.childBlocks?.count { it is SqlEscapeBlock }?.plus(parentEscapeBlock) ?: 0
+
+        val hasEvenEscapeBlocks = prevBlocks.let { it % 2 == 0 } == true
         isEndEscape = hasEvenEscapeBlocks || getNodeText() == "]"
         return if (isEndEscape) {
             0
         } else {
-            1
+            calculateIndentLen()
         }
     }
+
+    private fun calculateIndentLen(): Int {
+        parentBlock?.let { parent ->
+            when (parent) {
+                is SqlSubQueryGroupBlock -> {
+                    val parentIndentLen = parent.indent.groupIndentLen
+                    val grand = parent.parentBlock
+                    if (grand != null && grand.getNodeText().lowercase() == "create") {
+                        val grandIndentLen = grand.indent.groupIndentLen
+                        return grandIndentLen.plus(parentIndentLen).plus(1)
+                    }
+                    return parentIndentLen.plus(1)
+                }
+
+                is SqlElConditionLoopCommentBlock -> {
+                    return parent.indent.groupIndentLen
+                }
+
+                else -> {
+                    if (isSaveSpace(parentBlock))return parentBlock?.indent?.groupIndentLen ?: 1
+                    return 1
+                }
+            }
+        }
+        return 1
+    }
+
+    override fun isSaveSpace(lastGroup: SqlBlock?): Boolean =
+        if (isEndEscape) {
+            false
+        } else {
+            super.isSaveSpace(lastGroup)
+        }
 }

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/word/SqlFunctionGroupBlock.kt

@@ -40,32 +40,48 @@ class SqlFunctionGroupBlock(
     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 =
-                children
-                    .sumOf { prev ->
-                        prev
-                            .getChildrenTextLen()
-                            .plus(
-                                if (prev.node.elementType == SqlTypes.DOT ||
-                                    prev.node.elementType == SqlTypes.RIGHT_PAREN
-                                ) {
-                                    0
-                                } else {
-                                    prev.getNodeText().length.plus(1)
-                                },
-                            )
-                    }.plus(parent.indent.groupIndentLen)
-            baseIndent =
-                if (parent is SqlSubGroupBlock) {
-                    // parent.indent.groupIndentLen
-                    prevBlocksLength
-                } else {
-                    prevBlocksLength.plus(1)
-                }
-        }
+        val baseIndent =
+            parentBlock?.let { parent ->
+                val children = prevChildren.dropLast(1).filter { it !is SqlDefaultCommentBlock }
+                val prevBlocksLength = calculatePrevBlocksLength(children, parent)
+                calculateBaseIndent(parent, prevBlocksLength)
+            } ?: 0
         return baseIndent.plus(getNodeText().length)
     }
+
+    private fun calculatePrevBlocksLength(
+        children: List<SqlBlock>,
+        parent: SqlBlock,
+    ): Int =
+        children
+            .sumOf { prev ->
+                prev
+                    .getChildrenTextLen()
+                    .plus(
+                        if (prev.node.elementType == SqlTypes.DOT ||
+                            prev.node.elementType == SqlTypes.RIGHT_PAREN
+                        ) {
+                            0
+                        } else {
+                            prev.getNodeText().length.plus(1)
+                        },
+                    )
+            }.plus(parent.indent.groupIndentLen)
+
+    private fun calculateBaseIndent(
+        parent: SqlBlock,
+        prevBlocksLength: Int,
+    ): Int =
+        when (parent) {
+            is SqlSubGroupBlock ->
+                prevBlocksLength
+
+            is SqlElConditionLoopCommentBlock -> {
+                val directiveParent = parentBlock?.parentBlock
+                val directiveParentLen = directiveParent?.getNodeText()?.length?.plus(1) ?: 1
+                prevBlocksLength.plus(directiveParentLen)
+            }
+
+            else -> prevBlocksLength.plus(1)
+        }
 }