Wrapper in kts file (#735)

* Wrapper in kts file

### What's done:
   Created new rule, added tests and documentation

diktat-analysis.yml

@@ -467,4 +467,7 @@
   enabled: true
 # If file contains class, then it can't contain extension functions for the same class
 - name: EXTENSION_FUNCTION_WITH_CLASS
+  enabled: true
+# Check if kts script contains other functions except run code
+- name: RUN_IN_SCRIPT
   enabled: true

diktat-rules/src/main/kotlin/generated/WarningNames.kt

@@ -249,4 +249,6 @@ public object WarningNames {
     public const val INLINE_CLASS_CAN_BE_USED: String = "INLINE_CLASS_CAN_BE_USED"
 
     public const val EXTENSION_FUNCTION_WITH_CLASS: String = "EXTENSION_FUNCTION_WITH_CLASS"
+
+    public const val RUN_IN_SCRIPT: String = "RUN_IN_SCRIPT"
 }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/constants/Warnings.kt

@@ -165,6 +165,7 @@ enum class Warnings(
     OBJECT_IS_PREFERRED(true, "6.4.2", "it is better to use object for stateless classes"),
     INLINE_CLASS_CAN_BE_USED(true, "6.1.12", "inline class can be used"),
     EXTENSION_FUNCTION_WITH_CLASS(false, "6.2.3", "do not use extension functions for the class defined in the same file"),
+    RUN_IN_SCRIPT(true, "6.5.1", "wrap blocks of code in top-level scope functions like `run`"),
     ;
 
     /**

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/DiktatRuleSetProvider.kt

@@ -61,6 +61,7 @@ import org.cqfn.diktat.ruleset.rules.chapter6.ExtensionFunctionsInFileRule
 import org.cqfn.diktat.ruleset.rules.chapter6.ExtensionFunctionsSameNameRule
 import org.cqfn.diktat.ruleset.rules.chapter6.ImplicitBackingPropertyRule
 import org.cqfn.diktat.ruleset.rules.chapter6.PropertyAccessorFields
+import org.cqfn.diktat.ruleset.rules.chapter6.RunInScript
 import org.cqfn.diktat.ruleset.rules.chapter6.TrivialPropertyAccessors
 import org.cqfn.diktat.ruleset.rules.chapter6.UselessSupertype
 import org.cqfn.diktat.ruleset.rules.chapter6.classes.AbstractClassesRule
@@ -181,6 +182,7 @@ class DiktatRuleSetProvider(private var diktatConfigFile: String = DIKTAT_ANALYS
             ::StringConcatenationRule,
             ::AccurateCalculationsRule,
             ::LineLength,
+            ::RunInScript,
             ::TypeAliasRule,
             ::OverloadingArgumentsFunction,
             ::FunctionLength,

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/chapter6/RunInScript.kt

@@ -0,0 +1,80 @@
+package org.cqfn.diktat.ruleset.rules.chapter6
+
+import org.cqfn.diktat.common.config.rules.RulesConfig
+import org.cqfn.diktat.ruleset.constants.EmitType
+import org.cqfn.diktat.ruleset.constants.Warnings.RUN_IN_SCRIPT
+import org.cqfn.diktat.ruleset.utils.*
+
+import com.pinterest.ktlint.core.Rule
+import com.pinterest.ktlint.core.ast.ElementType.CALL_EXPRESSION
+import com.pinterest.ktlint.core.ast.ElementType.DOT_QUALIFIED_EXPRESSION
+import com.pinterest.ktlint.core.ast.ElementType.LAMBDA_ARGUMENT
+import com.pinterest.ktlint.core.ast.ElementType.LAMBDA_EXPRESSION
+import com.pinterest.ktlint.core.ast.ElementType.PARENTHESIZED
+import com.pinterest.ktlint.core.ast.ElementType.SCRIPT_INITIALIZER
+import com.pinterest.ktlint.core.ast.ElementType.VALUE_ARGUMENT
+import com.pinterest.ktlint.core.ast.ElementType.VALUE_ARGUMENT_LIST
+import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.CompositeElement
+
+/**
+ * Rule that checks if kts script contains other functions except run code
+ * In .kts files allow use only property declaration, function, classes, and code inside `run` block
+ * In gradle.kts files allow to call expression and dot qualified expression in addition to everything used in .kts files
+ */
+class RunInScript(private val configRules: List<RulesConfig>) : Rule("run-script") {
+    private var isFixMode: Boolean = false
+    private lateinit var emitWarn: EmitType
+
+    override fun visit(
+        node: ASTNode,
+        autoCorrect: Boolean,
+        emit: EmitType
+    ) {
+        isFixMode = autoCorrect
+        emitWarn = emit
+
+        if (node.elementType == SCRIPT_INITIALIZER && node.getRootNode().getFilePath().isKotlinScript()) {
+            if (node.getRootNode().getFilePath().isGradleScript()) {
+                checkGradleNode(node)
+            } else {
+                checkScript(node)
+            }
+        }
+    }
+
+    private fun checkGradleNode(node: ASTNode) {
+        val astNode = if (node.firstChildNode.elementType == PARENTHESIZED) {
+            node.firstChildNode
+        } else {
+            node
+        }
+        if (!astNode.hasChildOfType(CALL_EXPRESSION) && !astNode.hasChildOfType(DOT_QUALIFIED_EXPRESSION)) {
+            RUN_IN_SCRIPT.warnAndFix(configRules, emitWarn, isFixMode, astNode.text, astNode.startOffset, astNode) {
+                val parent = astNode.treeParent
+                val newNode = KotlinParser().createNode("run {\n ${astNode.text}\n} \n")
+                val newScript = CompositeElement(SCRIPT_INITIALIZER)
+                parent.addChild(newScript, astNode)
+                newScript.addChild(newNode)
+                parent.removeChild(astNode)
+            }
+        }
+    }
+
+    private fun checkScript(node: ASTNode) {
+        val isLambdaArgument = node.firstChildNode.hasChildOfType(LAMBDA_ARGUMENT)
+        val isLambdaInsideValueArgument = node.firstChildNode.findChildByType(VALUE_ARGUMENT_LIST)?.findChildByType(VALUE_ARGUMENT)?.findChildByType(LAMBDA_EXPRESSION) != null
+        if (!(isLambdaArgument || isLambdaInsideValueArgument)) {
+            RUN_IN_SCRIPT.warnAndFix(configRules, emitWarn, isFixMode, node.text, node.startOffset, node) {
+                if (node.firstChildNode.elementType != DOT_QUALIFIED_EXPRESSION) {
+                    val parent = node.treeParent
+                    val newNode = KotlinParser().createNode("run {\n ${node.text}\n} \n")
+                    val newScript = CompositeElement(SCRIPT_INITIALIZER)
+                    parent.addChild(newScript, node)
+                    newScript.addChild(newNode)
+                    parent.removeChild(node)
+                }
+            }
+        }
+    }
+}

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/utils/StringUtils.kt

@@ -118,3 +118,10 @@ fun String.removePrefix(): String {
  * @return true if this is a kotlin script file name, false otherwise
  */
 fun String.isKotlinScript() = endsWith(".kts")
+
+/**
+ * Checks if [this] String is a name of a gradle kotlin script file by checking whether file extension equals 'gradle.kts'
+ *
+ * @return true if this is a gradle kotlin script file name, false otherwise
+ */
+fun String.isGradleScript() = endsWith("gradle.kts")

diktat-rules/src/main/resources/diktat-analysis-huawei.yml

@@ -467,4 +467,7 @@
   enabled: true
 # If file contains class, then it can't contain extension functions for the same class
 - name: EXTENSION_FUNCTION_WITH_CLASS
+  enabled: true
+# Check if kts script contains other functions except run code
+- name: RUN_IN_SCRIPT
   enabled: true

diktat-rules/src/main/resources/diktat-analysis.yml

@@ -463,4 +463,7 @@
   enabled: true
 # If file contains class, then it can't contain extension functions for the same class
 - name: EXTENSION_FUNCTION_WITH_CLASS
+  enabled: true
+# Check if kts script contains other functions except run code
+- name: RUN_IN_SCRIPT
   enabled: true

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter6/RunInScriptFixTest.kt

@@ -0,0 +1,16 @@
+package org.cqfn.diktat.ruleset.chapter6
+
+import org.cqfn.diktat.ruleset.rules.chapter6.RunInScript
+import org.cqfn.diktat.util.FixTestBase
+
+import generated.WarningNames
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+
+class RunInScriptFixTest : FixTestBase("test/chapter6/script", ::RunInScript) {
+    @Test
+    @Tag(WarningNames.RUN_IN_SCRIPT)
+    fun `should wrap into run`() {
+        fixAndCompare("SimpleRunInScriptExpected.kts", "SimpleRunInScriptTest.kts")
+    }
+}

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter6/RunInScriptWarnTest.kt

@@ -0,0 +1,133 @@
+package org.cqfn.diktat.ruleset.chapter6
+
+import org.cqfn.diktat.ruleset.constants.Warnings.RUN_IN_SCRIPT
+import org.cqfn.diktat.ruleset.rules.DIKTAT_RULE_SET_ID
+import org.cqfn.diktat.ruleset.rules.chapter6.RunInScript
+import org.cqfn.diktat.util.LintTestBase
+
+import com.pinterest.ktlint.core.LintError
+import generated.WarningNames
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+
+class RunInScriptWarnTest : LintTestBase(::RunInScript) {
+    private val ruleId: String = "$DIKTAT_RULE_SET_ID:run-script"
+
+    @Test
+    @Tag(WarningNames.RUN_IN_SCRIPT)
+    fun `check simple example`() {
+        lintMethod(
+            """
+                class A {}
+                
+                fun foo() {
+                }
+                
+                diktat {}
+                
+                diktat({})
+
+                foo/*df*/()
+
+                foo( //dfdg
+                    10
+                )
+                println("hello")
+                
+                w.map { it -> it }
+                
+                tasks.register("a") {
+                    dependsOn("b")
+                    doFirst {
+                        generateCodeStyle(file("rootDir/guide"), file("rootDir/../wp"))
+                    }
+                }
+                
+            """.trimMargin(),
+            LintError(10, 17, ruleId, "${RUN_IN_SCRIPT.warnText()} foo/*df*/()", true),
+            LintError(12, 17, ruleId, "${RUN_IN_SCRIPT.warnText()} foo( //dfdg...", true),
+            LintError(15, 17, ruleId, "${RUN_IN_SCRIPT.warnText()} println(\"hello\")", true),
+            LintError(17, 17, ruleId, "${RUN_IN_SCRIPT.warnText()} w.map { it -> it }", true),
+            LintError(19, 17, ruleId, "${RUN_IN_SCRIPT.warnText()} tasks.register(\"a\") {...", true),
+            fileName = "src/main/kotlin/org/cqfn/diktat/Example.kts"
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.RUN_IN_SCRIPT)
+    fun `check correct examples`() {
+        lintMethod(
+            """
+                run {
+                    println("hello")
+                }
+                
+                run{println("hello")}
+                
+                val task = tasks.register("a") {
+                }
+                
+            """.trimMargin(),
+            fileName = "src/main/kotlin/org/cqfn/diktat/Example.kts"
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.RUN_IN_SCRIPT)
+    fun `check correct with custom wrapper`() {
+        lintMethod(
+            """
+                custom {
+                    println("hello")
+                }
+                
+                oneMore{println("hello")}
+                
+                another {
+                    println("hello")
+                }
+            """.trimMargin(),
+            fileName = "src/main/kotlin/org/cqfn/diktat/Example.kts"
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.RUN_IN_SCRIPT)
+    fun `check gradle file`() {
+        lintMethod(
+            """
+                class A {}
+                
+                fun foo() {
+                }
+                
+                if(true) {
+                    goo()
+                }
+                
+                diktat {}
+                
+                diktat({})
+
+                foo/*df*/()
+
+                foo( //dfdg
+                    10
+                )
+                println("hello")
+                
+                w.map { it -> it }
+                
+                (tasks.register("a") {
+                    dependsOn("b")
+                    doFirst {
+                        generateCodeStyle(file("rootDir/guide"), file("rootDir/../wp"))
+                    }
+                })
+                
+            """.trimMargin(),
+            LintError(6, 17, ruleId, "${RUN_IN_SCRIPT.warnText()} if(true) {...", true),
+            fileName = "src/main/kotlin/org/cqfn/diktat/builds.gradle.kts"
+        )
+    }
+}

diktat-rules/src/test/resources/test/chapter6/script/SimpleRunInScriptExpected.kts

@@ -0,0 +1,18 @@
+
+run {
+ println("hello world!")
+}
+
+fun foo() {
+    println()
+}
+
+val q = Config()
+
+run {
+    println("a")
+}
+
+also {
+    println("a")
+}

diktat-rules/src/test/resources/test/chapter6/script/SimpleRunInScriptTest.kts

@@ -0,0 +1,16 @@
+
+println("hello world!")
+
+fun foo() {
+    println()
+}
+
+val q = Config()
+
+run {
+    println("a")
+}
+
+also {
+    println("a")
+}

diktat-rules/src/test/resources/test/smoke/build.gradle_.kts

@@ -11,14 +11,14 @@ repositories {
     maven { url = uri("https://example.com") }
 }
 
-tasks.register("generateAvailableRules") {
+val generateAvailableRules by tasks.register("generateAvailableRules") {
     dependsOn("generateRulesMapping")
     doFirst {
         generateAvailableRules(rootDir, file("$rootDir/../wp"))
     }
 }
 
-tasks.register("updateDocumentation") {
+val updateDocumentation = tasks.register("updateDocumentation") {
     dependsOn(
         "generateRulesMapping",
         "generateAvailableRules",

info/available-rules.md

@@ -117,4 +117,5 @@
 |    6  |     6.2.2  |  EXTENSION_FUNCTION_SAME_SIGNATURE       |  Checks if extension function has the same signature as another extension function and their classes are related                                                               |  no  |  no  |  + |
 |    6  |     6.4.1  |  AVOID_USING_UTILITY_CLASS               | Checks if there is class/object that can be replace with extension function                                                                                                  | no  | no | - |
 |    6  |     6.4.2  |  OBJECT_IS_PREFERRED                     | Checks: if class is stateless it is preferred to use `object`                                                                                                                | yes | no | + |
-|    6  |     6.2.3  | EXTENSION_FUNCTION_WITH_CLASS            | Check: if file contains class, then it can not have extension functions for the same class                                                                                                     | no | no | - |
+|    6  |     6.2.3  | EXTENSION_FUNCTION_WITH_CLASS            | Check: if file contains class, then it can not have extension functions for the same class                                                                                                     | no | no | - |
+|    6  |     6.5.1  |  RUN_IN_SCRIPT                           | Checks : if kts script contains other functions except run code                                                                                                              | yes | no | - |

info/guide/guide-chapter-6.md

@@ -468,3 +468,18 @@ object O: I {
     override fun foo() {}
 }
 ```
+
+#### <a name="r6.5.1"></a> 6.5.1 kts files should wrap logic into top-level scope
+It is still recommended wrapping logic inside functions and avoid using top-level statements for function calls or wrapping blocks of code
+in top-level scope functions like `run`.
+
+**Valid example**:
+```
+run {
+    // some code
+}
+
+fun foo() {
+
+}
+```