Allow a single whitespace line in chained expressions

CHANGELOG.md

@@ -22,6 +22,7 @@ An AssertJ style API for testing KtLint rules ([#1444](https://github.com/pinter
 - Add experimental rule for consistent spacing before the start of the function body (`function-start-of-body-spacing`) ([#1341](https://github.com/pinterest/ktlint/issues/1341))
 
 ### Fixed
+- Allow a single whitespace line in chained expressions ([#1469](https://github.com/pinterest/ktlint/pull/1469))
 - Fix check of spacing in the receiver type of an anonymous function ([#1440](https://github.com/pinterest/ktlint/issues/1440))
 - Allow comment on same line as super class in class declaration `wrapping` ([#1457](https://github.com/pinterest/ktlint/pull/1457))
 

ktlint-ruleset-standard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/NoBlankLinesInChainedMethodCallsRule.kt

@@ -0,0 +1,24 @@
+package com.pinterest.ktlint.ruleset.standard
+
+import com.pinterest.ktlint.core.Rule
+import com.pinterest.ktlint.core.ast.ElementType.DOT_QUALIFIED_EXPRESSION
+import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+import org.jetbrains.kotlin.com.intellij.psi.PsiWhiteSpace
+import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement
+
+public class NoBlankLinesInChainedMethodCallsRule : Rule("no-blank-lines-in-chained-method-calls") {
+    override fun visit(
+        node: ASTNode,
+        autoCorrect: Boolean,
+        emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit
+    ) {
+        val isBlankLine = node is PsiWhiteSpace && node.getText().contains("\n\n")
+        if (isBlankLine && node.treeParent.elementType == DOT_QUALIFIED_EXPRESSION) {
+            emit(node.startOffset + 1, "Needless blank line(s)", true)
+
+            if (autoCorrect) {
+                (node as LeafPsiElement).rawReplaceWithText("\n" + node.getText().split("\n\n")[1])
+            }
+        }
+    }
+}

ktlint-ruleset-standard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/NoConsecutiveBlankLinesRule.kt

@@ -2,7 +2,6 @@ package com.pinterest.ktlint.ruleset.standard
 
 import com.pinterest.ktlint.core.Rule
 import com.pinterest.ktlint.core.ast.ElementType.CLASS
-import com.pinterest.ktlint.core.ast.ElementType.DOT_QUALIFIED_EXPRESSION
 import com.pinterest.ktlint.core.ast.ElementType.IDENTIFIER
 import com.pinterest.ktlint.core.ast.ElementType.PRIMARY_CONSTRUCTOR
 import com.pinterest.ktlint.core.ast.nextLeaf
@@ -25,20 +24,21 @@ public class NoConsecutiveBlankLinesRule : Rule("no-consecutive-blank-lines") {
             if (lfcount < 2) {
                 return
             }
+
             val eof = node.nextLeaf() == null
             val prevNode = node.treePrev
             val betweenClassAndPrimaryConstructor = prevNode.elementType == IDENTIFIER &&
                 prevNode.treeParent.elementType == CLASS &&
                 node.treeNext.elementType == PRIMARY_CONSTRUCTOR
-            val inDotQualifiedExpression = node.treeParent.elementType == DOT_QUALIFIED_EXPRESSION && lfcount > 1
-            if (lfcount > 2 || eof || betweenClassAndPrimaryConstructor || inDotQualifiedExpression) {
+
+            if (lfcount > 2 || eof || betweenClassAndPrimaryConstructor) {
                 val split = text.split("\n")
                 emit(node.startOffset + split[0].length + split[1].length + 2, "Needless blank line(s)", true)
                 if (autoCorrect) {
                     val newText = buildString {
                         append(split.first())
                         append("\n")
-                        if (!eof && !betweenClassAndPrimaryConstructor && !inDotQualifiedExpression) append("\n")
+                        if (!eof && !betweenClassAndPrimaryConstructor) append("\n")
                         append(split.last())
                     }
                     (node as LeafPsiElement).rawReplaceWithText(newText)

ktlint-ruleset-standard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/StandardRuleSetProvider.kt

@@ -18,6 +18,7 @@ public class StandardRuleSetProvider : RuleSetProvider {
         ModifierOrderRule(),
         NoBlankLineBeforeRbraceRule(),
         NoConsecutiveBlankLinesRule(),
+        NoBlankLinesInChainedMethodCallsRule(),
         NoEmptyClassBodyRule(),
         NoLineBreakAfterElseRule(),
         NoLineBreakBeforeAssignmentRule(),

ktlint-ruleset-standard/src/test/kotlin/com/pinterest/ktlint/ruleset/standard/NoBlankLinesInChainedMethodCallsRuleTest.kt

@@ -0,0 +1,47 @@
+package com.pinterest.ktlint.ruleset.standard
+
+import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat
+import com.pinterest.ktlint.test.LintViolation
+import org.junit.jupiter.api.Test
+
+class NoBlankLinesInChainedMethodCallsRuleTest {
+
+    private val noBlankLinesInChainedMethodCallsRuleAssertThat = NoBlankLinesInChainedMethodCallsRule().assertThat()
+
+    @Test
+    fun `single blank line in dot qualified expression returns lint error`() {
+        val code =
+            """
+            fun foo(inputText: String) {
+                inputText
+
+                    .toLowerCase()
+            }
+            """.trimIndent()
+
+        noBlankLinesInChainedMethodCallsRuleAssertThat(code)
+            .hasLintViolations(LintViolation(3, 1, "Needless blank line(s)"))
+            .isFormattedAs(
+                """
+                fun foo(inputText: String) {
+                    inputText
+                        .toLowerCase()
+                }
+                """.trimIndent()
+            )
+    }
+
+    @Test
+    fun `single blank line between statements does not return lint error`() {
+        val code =
+            """
+            fun foo(inputText: String) {
+                bar()
+
+                bar()
+            }
+            """.trimIndent()
+
+        noBlankLinesInChainedMethodCallsRuleAssertThat(code).hasNoLintViolations()
+    }
+}

ktlint-ruleset-standard/src/test/kotlin/com/pinterest/ktlint/ruleset/standard/NoConsecutiveBlankLinesRuleTest.kt

@@ -3,7 +3,6 @@ package com.pinterest.ktlint.ruleset.standard
 import com.pinterest.ktlint.test.KtLintAssertThat.Companion.assertThat
 import com.pinterest.ktlint.test.LintViolation
 import com.pinterest.ktlint.test.MULTILINE_STRING_QUOTE
-import com.pinterest.ktlint.test.format
 import com.pinterest.ktlint.test.lint
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Nested
@@ -176,25 +175,41 @@ class NoConsecutiveBlankLinesRuleTest {
     }
 
     @Test
-    fun `should remove line in dot qualified expression`() {
-        assertThat(
-            NoConsecutiveBlankLinesRule().format(
-                """
-                fun foo(inputText: String) {
-                    inputText
+    fun `Given single blank line in dot qualified expression should not return lint errors`() {
+        val code =
+            """
+            fun foo(inputText: String) {
+                inputText
 
+                    .toLowerCase()
+            }
+            """.trimIndent()
 
-                        .toLowerCase()
-                }
-                """.trimIndent()
-            )
-        ).isEqualTo(
+        noConsecutiveBlankLinesRuleAssertThat(code).hasNoLintViolations()
+    }
+
+    @Test
+    fun `Given multiple blank line in dot qualified expression should return lint error`() {
+        val code =
             """
             fun foo(inputText: String) {
                 inputText
+
+
                     .toLowerCase()
             }
             """.trimIndent()
-        )
+
+        noConsecutiveBlankLinesRuleAssertThat(code)
+            .hasLintViolations(LintViolation(4, 1, "Needless blank line(s)"))
+            .isFormattedAs(
+                """
+                fun foo(inputText: String) {
+                    inputText
+
+                        .toLowerCase()
+                }
+                """.trimIndent()
+            )
     }
 }