Add Format Enable Setting

xterao · xterao · commit 67f9bf41c272 · 2025-04-04T14:45:23.000+09:00
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/SqlFormatPreProcessor.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/SqlFormatPreProcessor.kt
@@ -32,6 +32,7 @@ import com.intellij.psi.util.prevLeafs
 import org.domaframework.doma.intellij.psi.SqlBlockComment
 import org.domaframework.doma.intellij.psi.SqlTypes
 import org.domaframework.doma.intellij.setting.SqlLanguage
+import org.domaframework.doma.intellij.state.DomaToolsFunctionEnableSettings
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 class SqlFormatPreProcessor : PreFormatProcessor {
@@ -44,6 +45,7 @@ class SqlFormatPreProcessor : PreFormatProcessor {
         source: PsiFile,
         rangeToReformat: TextRange,
     ): TextRange {
+        if (!isEnableFormat()) return rangeToReformat
         if (source.language != SqlLanguage.INSTANCE) return rangeToReformat
 
         val visitor = SqlFormatVisitor()
@@ -61,13 +63,17 @@ class SqlFormatPreProcessor : PreFormatProcessor {
         val documentLastElement = visitor.lastElement
         val documentLastRange = visitor.lastElement?.textRange
         if (documentLastElement != null && documentLastRange != null && documentLastRange.endOffset <= rangeToReformat.endOffset) {
-            if (documentLastElement !is PsiWhiteSpace) {
-                val textEnd = documentLastElement.endOffset
-                document.insertString(textEnd, " \n")
-            } else {
+            if (documentLastElement is PsiWhiteSpace) {
                 val textStart = documentLastElement.startOffset
                 val textEnd = documentLastElement.endOffset
                 document.replaceString(textStart, textEnd, " \n")
+            } else if (documentLastElement.elementType == SqlTypes.LINE_COMMENT) {
+                val textStart = documentLastElement.startOffset
+                val textEnd = documentLastElement.endOffset
+                document.replaceString(textStart, textEnd, "${documentLastElement.text} \n")
+            } else {
+                val textEnd = documentLastElement.endOffset
+                document.insertString(textEnd, " \n")
             }
         }
 
@@ -111,9 +117,7 @@ class SqlFormatPreProcessor : PreFormatProcessor {
             } else {
                 // Remove spaces after newlines to reset indentation
                 val nextSibling = it.nextSibling
-                if (nextSibling.elementType == SqlTypes.LINE_COMMENT) {
-                    document.replaceString(textRangeStart, textRangeEnd, "")
-                } else if (nextSibling.elementType == SqlTypes.BLOCK_COMMENT) {
+                if (nextSibling.elementType == SqlTypes.BLOCK_COMMENT) {
                     removeSpacesAroundNewline(document, it.textRange)
                 } else if (keywordIndex < replaceKeywordList.size) {
                     val nextElement = replaceKeywordList[keywordIndex]
@@ -150,6 +154,12 @@ class SqlFormatPreProcessor : PreFormatProcessor {
         return rangeToReformat.grown(visitor.replaces.size)
     }
 
+    private fun isEnableFormat(): Boolean {
+        val setting = DomaToolsFunctionEnableSettings.getInstance()
+        val isEnableFormat = setting.state.isEnableSqlFormat
+        return isEnableFormat
+    }
+
     private fun removeSpacesAroundNewline(
         document: Document,
         range: TextRange,
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/formatter/SqlFormattingModelBuilder.kt b/src/main/kotlin/org/domaframework/doma/intellij/formatter/SqlFormattingModelBuilder.kt
@@ -28,20 +28,33 @@ import com.intellij.psi.codeStyle.CodeStyleSettings
 import org.domaframework.doma.intellij.formatter.block.SqlBlock
 import org.domaframework.doma.intellij.psi.SqlTypes
 import org.domaframework.doma.intellij.setting.SqlLanguage
+import org.domaframework.doma.intellij.state.DomaToolsFunctionEnableSettings
 
-@Suppress("ktlint:standard:no-consecutive-comments")
 class SqlFormattingModelBuilder : FormattingModelBuilder {
     override fun createModel(formattingContext: FormattingContext): FormattingModel {
         val codeStyleSettings = formattingContext.codeStyleSettings
+        val setting = DomaToolsFunctionEnableSettings.getInstance()
+        val isEnableFormat = setting.state.isEnableSqlFormat
+
+        val spacingBuilder =
+            if (!isEnableFormat) {
+                SpacingBuilder(codeStyleSettings, SqlLanguage.INSTANCE)
+            } else {
+                createSpaceBuilder(codeStyleSettings)
+            }
+        val customSpacingBuilder =
+            if (!isEnableFormat) null else createCustomSpacingBuilder()
+
         return FormattingModelProvider
             .createFormattingModelForPsiFile(
                 formattingContext.containingFile,
                 SqlBlock(
                     formattingContext.node,
                     Wrap.createWrap(WrapType.NONE, false),
                     Alignment.createAlignment(),
-                    createCustomSpacingBuilder(),
-                    createSpaceBuilder(codeStyleSettings),
+                    customSpacingBuilder,
+                    spacingBuilder,
+                    isEnableFormat,
                 ),
                 codeStyleSettings,
             )
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
@@ -56,24 +56,21 @@ open class SqlBlock(
     alignment: Alignment?,
     private val customSpacingBuilder: SqlCustomSpacingBuilder?,
     internal val spacingBuilder: SpacingBuilder,
+    private val enableFormat: Boolean = false,
 ) : AbstractBlock(
         node,
         wrap,
         alignment,
     ) {
+    data class ElementIndent(
+        var indentLevel: IndentType,
+        var indentLen: Int,
+        var groupIndentLen: Int,
+    )
+
     val blocks = mutableListOf<AbstractBlock>()
     open var parentBlock: SqlBlock? = null
     open val childBlocks = mutableListOf<SqlBlock>()
-
-    open fun setParentGroupBlock(block: SqlBlock?) {
-        parentBlock = block
-        parentBlock?.addChildBlock(this)
-    }
-
-    open fun addChildBlock(childBlock: SqlBlock) {
-        childBlocks.add(childBlock)
-    }
-
     open val indent: ElementIndent =
         ElementIndent(
             IndentType.FILE,
@@ -85,8 +82,19 @@ open class SqlBlock(
 
     protected open val pendingCommentBlocks = mutableListOf<SqlBlock>()
 
+    protected fun isEnableFormat(): Boolean = enableFormat
+
+    open fun setParentGroupBlock(block: SqlBlock?) {
+        parentBlock = block
+        parentBlock?.addChildBlock(this)
+    }
+
+    open fun addChildBlock(childBlock: SqlBlock) {
+        childBlocks.add(childBlock)
+    }
+
     public override fun buildChildren(): MutableList<AbstractBlock> {
-        if (isLeaf) return mutableListOf()
+        if (isLeaf || !isEnableFormat()) return mutableListOf()
 
         var child = node.firstChildNode
         var prevNonWhiteSpaceNode: ASTNode? = null
@@ -142,14 +150,14 @@ open class SqlBlock(
             childBlock is SqlColumnDefinitionRawGroupBlock ||
             childBlock is SqlColumnDefinitionGroupBlock ||
             (childBlock is SqlRightPatternBlock && childBlock.isNeedBeforeWhiteSpace(lastGroup)) ||
-            // 改行があれば残す。無ければ残さない
             (
                 (
                     childBlock is SqlLineCommentBlock ||
                         childBlock is SqlBlockCommentBlock
                 ) &&
                     child.treePrev.text.contains("\n")
-            )
+            ) ||
+            (childBlock is SqlElBlockCommentBlock && childBlock.isConditionLoopBlock)
 
     private fun setRightSpace(lastBlock: SqlBlock?) {
         val rightBlock = lastBlock as? SqlRightPatternBlock
@@ -665,6 +673,8 @@ open class SqlBlock(
         child1: Block?,
         child2: Block,
     ): Spacing? {
+        if (!isEnableFormat()) return null
+
         // The end of a line comment element is a newline, so just add a space for the indent.
         if (child1 is SqlLineCommentBlock) {
             if (child2 is SqlBlock) {
@@ -673,12 +683,24 @@ open class SqlBlock(
         }
 
         // Do not leave a space after the comment block of the bind variable
-        if (child1 is SqlElBlockCommentBlock) {
+        if (child1 is SqlElBlockCommentBlock && child2 !is SqlCommentBlock) {
             return Spacing.createSpacing(0, 0, 0, false, 0)
         }
-        // Put a space before the comment block of the bind variable
+
         if (child2 is SqlElBlockCommentBlock) {
-            return Spacing.createSpacing(1, 1, 1, false, 1)
+            when (child1) {
+                is SqlElBlockCommentBlock -> {
+                    val indentLen = child2.indent.indentLen
+                    return Spacing.createSpacing(indentLen, indentLen, 1, false, 0)
+                }
+
+                is SqlWhitespaceBlock -> {
+                    val indentLen = child2.indent.indentLen
+                    return Spacing.createSpacing(indentLen, indentLen, 0, false, 0)
+                }
+
+                else -> return SqlCustomSpacingBuilder.normalSpacing
+            }
         }
 
         if (child1 is SqlWhitespaceBlock) {
@@ -748,6 +770,8 @@ open class SqlBlock(
     }
 
     override fun getChildAttributes(newChildIndex: Int): ChildAttributes {
+        if (!isEnableFormat()) return ChildAttributes(Indent.getNoneIndent(), null)
+
         blocks
             .getOrNull(newChildIndex)
             ?.let {
@@ -761,13 +785,12 @@ open class SqlBlock(
         return ChildAttributes(Indent.getNoneIndent(), null)
     }
 
-    override fun getChildIndent(): Indent? = Indent.getSpaceIndent(4)
+    override fun getChildIndent(): Indent? =
+        if (!isEnableFormat()) {
+            Indent.getSpaceIndent(4)
+        } else {
+            Indent.getSpaceIndent(0)
+        }
 
     override fun isLeaf(): Boolean = myNode.firstChildNode == null
-
-    data class ElementIndent(
-        var indentLevel: IndentType,
-        var indentLen: Int,
-        var groupIndentLen: Int,
-    )
 }
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/setting/DomaToolsConfigurable.kt b/src/main/kotlin/org/domaframework/doma/intellij/setting/DomaToolsConfigurable.kt
@@ -0,0 +1,53 @@
+/*
+ * Copyright Doma Tools Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.domaframework.doma.intellij.setting
+
+import com.intellij.openapi.options.Configurable
+import com.intellij.openapi.options.ConfigurationException
+import org.domaframework.doma.intellij.state.DomaToolsFunctionEnableSettings
+import java.util.Objects
+import javax.swing.JComponent
+
+class DomaToolsConfigurable : Configurable {
+    private var mySettingsComponent: SettingComponent? = SettingComponent()
+
+    override fun getDisplayName(): String = "Doma Tools"
+
+    override fun createComponent(): JComponent? = mySettingsComponent?.panel
+
+    override fun isModified(): Boolean {
+        val state: DomaToolsFunctionEnableSettings.State =
+            Objects.requireNonNull(DomaToolsFunctionEnableSettings.getInstance().getState())
+        return mySettingsComponent?.enableFormat != state.isEnableSqlFormat
+    }
+
+    @Throws(ConfigurationException::class)
+    override fun apply() {
+        val state: DomaToolsFunctionEnableSettings.State =
+            Objects.requireNonNull(DomaToolsFunctionEnableSettings.getInstance().getState())
+        state.isEnableSqlFormat = mySettingsComponent?.enableFormat == true
+    }
+
+    override fun reset() {
+        val state: DomaToolsFunctionEnableSettings.State =
+            Objects.requireNonNull(DomaToolsFunctionEnableSettings.getInstance().getState())
+        mySettingsComponent?.enableFormat = state.isEnableSqlFormat
+    }
+
+    override fun disposeUIResources() {
+        mySettingsComponent = null
+    }
+}
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/setting/SettingComponent.kt b/src/main/kotlin/org/domaframework/doma/intellij/setting/SettingComponent.kt
@@ -0,0 +1,42 @@
+/*
+ * Copyright Doma Tools Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.domaframework.doma.intellij.setting
+
+import com.intellij.ui.components.JBCheckBox
+import com.intellij.ui.components.JBLabel
+import com.intellij.util.ui.FormBuilder
+import org.domaframework.doma.intellij.bundle.MessageBundle
+import javax.swing.JPanel
+
+class SettingComponent {
+    val panel: JPanel?
+    private val enableFormatCheckBox = JBCheckBox()
+
+    init {
+        this.panel =
+            FormBuilder
+                .createFormBuilder()
+                .addLabeledComponent(JBLabel(MessageBundle.message("config.enable.sql.format")), enableFormatCheckBox, 1, false)
+                .addComponentFillVertically(JPanel(), 0)
+                .panel
+    }
+
+    var enableFormat: Boolean
+        get() = enableFormatCheckBox.isSelected
+        set(enabled) {
+            enableFormatCheckBox.isSelected = enabled
+        }
+}
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/state/DomaToolsFunctionEnableSettings.kt b/src/main/kotlin/org/domaframework/doma/intellij/state/DomaToolsFunctionEnableSettings.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright Doma Tools Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.domaframework.doma.intellij.state
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.components.BaseState
+import com.intellij.openapi.components.PersistentStateComponent
+import com.intellij.openapi.components.State
+import com.intellij.openapi.components.Storage
+import com.intellij.openapi.components.StoragePathMacros
+
+@State(
+    name = "org.domaframework.doma",
+    reloadable = true,
+    storages = [Storage(StoragePathMacros.WORKSPACE_FILE)],
+)
+class DomaToolsFunctionEnableSettings : PersistentStateComponent<DomaToolsFunctionEnableSettings.State> {
+    class State : BaseState() {
+        var isEnableSqlFormat = false
+    }
+
+    var myState: State = State()
+
+    override fun getState(): State = myState
+
+    override fun loadState(state: DomaToolsFunctionEnableSettings.State) {
+        myState = state
+    }
+
+    companion object {
+        fun getInstance(): DomaToolsFunctionEnableSettings =
+            ApplicationManager.getApplication().getService(DomaToolsFunctionEnableSettings::class.java)
+    }
+}
diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml
@@ -18,6 +18,12 @@
   <extensions defaultExtensionNs="com.intellij">
     <postStartupActivity implementation="org.domaframework.doma.intellij.setting.DomaToolStartupActivity"/>
 
+    <applicationService
+      serviceImplementation="org.domaframework.doma.intellij.state.DomaToolsFunctionEnableSettings"/>
+      <applicationConfigurable groupId="org.domaframework.doma"
+        instance="org.domaframework.doma.intellij.setting.DomaToolsConfigurable"
+        displayName="Doma Tools" />
+
     <!-- Gutter -->
     <codeInsight.lineMarkerProvider language="JAVA"
       implementationClass="org.domaframework.doma.intellij.gutter.dao.DaoMethodProvider"/>
diff --git a/src/main/resources/messages/DomaToolsBundle.properties b/src/main/resources/messages/DomaToolsBundle.properties
diff --git a/src/main/resources/messages/DomaToolsBundle_ja.properties b/src/main/resources/messages/DomaToolsBundle_ja.properties
