Merge branch 'master' into feature/more-prefixes-boolean-methods(#417)

# Conflicts:
#	diktat-analysis.yml
#	diktat-rules/src/main/resources/diktat-analysis-huawei.yml
#	diktat-rules/src/main/resources/diktat-analysis.yml

diktat-analysis.yml

@@ -1,187 +1,278 @@
+# Common configuration
 - name: DIKTAT_COMMON
   enabled: true
   configuration:
+    # put your package name here - it will be autofixed and checked
     domainName: org.cqfn.diktat
+    # testDirs: test
+# Checks that the Class/Enum/Interface name does not match Pascal case
 - name: CLASS_NAME_INCORRECT
   enabled: true
+# Checks that CONSTANT (treated as const val from companion object or class level) is in non UPPER_SNAKE_CASE
 - name: CONSTANT_UPPERCASE
   enabled: true
+# Checks that enum value is in non UPPER_SNAKE_CASE or non PascalCase depending on the config, UPPER_SNAKE_CASE by default
 - name: ENUM_VALUE
   enabled: true
   configuration:
+    # Two options: snakeCase(default), PascalCase
     enumStyle: snakeCase
+# Checks that class which extends any Exception class has Exception suffix
 - name: EXCEPTION_SUFFIX
   enabled: true
+# Checks that file name has extension
 - name: FILE_NAME_INCORRECT
   enabled: true
+# Checks that file name matches class name, if it is only one class in file
 - name: FILE_NAME_MATCH_CLASS
   enabled: true
+# Checks that functions/methods which return boolean have special prefix like "is/should/e.t.c"
 - name: FUNCTION_BOOLEAN_PREFIX
   enabled: true
-  configuration:
-    allowedPrefixes: "" # A list of functions that return boolean and are allowed to use. Input is in a form "foo, bar".
+# Checks that function/method name is in lowerCamelCase
 - name: FUNCTION_NAME_INCORRECT_CASE
   enabled: true
+# Checks that generic name doesn't contain more than 1 letter (capital). It can be followed by numbers, example: T12, T
 - name: GENERIC_NAME
   enabled: true
+# Identifier length should be in range [2,64] except names that used in industry like {i, j} and 'e' for catching exceptions
 - name: IDENTIFIER_LENGTH
   enabled: true
+# Checks that the object matches PascalCase
 - name: OBJECT_NAME_INCORRECT
   enabled: true
+# Checks that package name is in correct (lower) case
 - name: PACKAGE_NAME_INCORRECT_CASE
   enabled: true
+# Checks that package name starts with the company's domain
 - name: PACKAGE_NAME_INCORRECT_PREFIX
   enabled: true
+# Checks that package name does not have incorrect symbols like underscore or non-ASCII letters/digits
 - name: PACKAGE_NAME_INCORRECT_SYMBOLS
   enabled: true
+# Checks that the path for a file matches with a package name
 - name: PACKAGE_NAME_INCORRECT_PATH
   enabled: true
+# Checks that package name is in the file
 - name: PACKAGE_NAME_MISSING
   enabled: true
+# Checks that variable does not have prefix (like mVariable or M_VARIABLE)
 - name: VARIABLE_HAS_PREFIX
   enabled: true
+# Checks that variable does not contain one single letter, only exceptions are fixed names that used in industry like {i, j}
 - name: VARIABLE_NAME_INCORRECT
   enabled: true
+# Checks that the name of variable is in lowerCamelCase and contains only ASCII letters
 - name: VARIABLE_NAME_INCORRECT_FORMAT
   enabled: true
+# Checks that functions have kdoc
 - name: MISSING_KDOC_ON_FUNCTION
   enabled: true
+# Checks that on file level internal or public class or function has missing KDoc
 - name: MISSING_KDOC_TOP_LEVEL
   enabled: true
+# Checks that accessible internal elements (protected, public, internal) in a class are documented
 - name: MISSING_KDOC_CLASS_ELEMENTS
   enabled: true
+# Checks that accessible method parameters are documented in KDoc
 - name: KDOC_WITHOUT_PARAM_TAG
   enabled: true
+# Checks that accessible method explicit return type is documented in KDoc
 - name: KDOC_WITHOUT_RETURN_TAG
   enabled: true
+# Checks that accessible method throw keyword is documented in KDoc
 - name: KDOC_WITHOUT_THROWS_TAG
   enabled: true
+# Checks that KDoc is not empty
 - name: KDOC_EMPTY_KDOC
   enabled: true
+# Checks that underscore is correctly used to split package naming
 - name: INCORRECT_PACKAGE_SEPARATOR
   enabled: true
+# Checks that there is no @deprecated tag in kdoc
 - name: KDOC_NO_DEPRECATED_TAG
   enabled: true
+# Checks that there is no empty content in kdoc tags
 - name: KDOC_NO_EMPTY_TAGS
   enabled: true
+# Checks that there is only one space after kdoc tag
 - name: KDOC_WRONG_SPACES_AFTER_TAG
   enabled: true
+# Checks tags order in kDoc. `@param`, `@return`, `@throws`
 - name: KDOC_WRONG_TAGS_ORDER
   enabled: true
+# Checks that there is no newline of empty KDoc line (with leading asterisk) between `@param`, `@return`, `@throws` tags
 - name: KDOC_NO_NEWLINES_BETWEEN_BASIC_TAGS
   enabled: true
+# Checks that block of tags @param, @return, @throws is separated from previous part of KDoc by exactly one empty line
 - name: KDOC_NEWLINES_BEFORE_BASIC_TAGS
   enabled: true
+# Checks that special tags `@apiNote`, `@implNote`, `@implSpec` have exactly one empty line after
 - name: KDOC_NO_NEWLINE_AFTER_SPECIAL_TAGS
   enabled: true
+# Checks that KDoc does not contain single line with words 'return', 'get' or 'set'
 - name: KDOC_TRIVIAL_KDOC_ON_FUNCTION
-  enabled: 'true'
+  enabled: true
+# Checks that there is newline after header KDoc
 - name: HEADER_WRONG_FORMAT
   enabled: true
+# Checks that file with zero or >1 classes has header KDoc
 - name: HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE
   enabled: true
+# Checks that copyright exists on top of file and is properly formatted (as a block comment)
 - name: HEADER_MISSING_OR_WRONG_COPYRIGHT
   enabled: true
   configuration:
     isCopyrightMandatory: false
     copyrightText: ''
+# Checks that header kdoc is located before package directive
 - name: HEADER_NOT_BEFORE_PACKAGE
   enabled: true
+# Checks that header kdoc does not contain @author tag ar date
 - name: HEADER_CONTAINS_DATE_OR_AUTHOR
   enabled: true
+# Checks that file does not contain lines > maxSize
 - name: FILE_IS_TOO_LONG
   enabled: true
   configuration:
+    # number of lines
     maxSize: '2000'
     ignoreFolders: ''
+# Checks that file does not contain commented out code
 - name: COMMENTED_OUT_CODE
   enabled: true
+# Checks that file does not contain only comments, imports and package directive
 - name: FILE_CONTAINS_ONLY_COMMENTS
   enabled: true
-  # order imports alphabetically
+# Orders imports alphabetically
 - name: FILE_UNORDERED_IMPORTS
   enabled: true
   configuration:
     # use logical imports grouping with sorting inside of a group
     useRecommendedImportsOrder: true
+# Checks that general order of code parts is right
 - name: FILE_INCORRECT_BLOCKS_ORDER
   enabled: true
+# Checks that there is exactly one line between code blocks
 - name: FILE_NO_BLANK_LINE_BETWEEN_BLOCKS
   enabled: true
+# Checks that there is no wildcard imports. Exception: allowedWildcards
 - name: FILE_WILDCARD_IMPORTS
   enabled: true
   configuration:
+    # Allowed wildcards for imports (e.g. "import org.cqfn.diktat.*, import org.jetbrains.kotlin.*")
     allowedWildcards: "kotlinx.serialization.*,org.cqfn.diktat.ruleset.utils.*"
+# Checks that braces are used in if, else, when, for, do, and while statements. Exception: single line if statement
 - name: NO_BRACES_IN_CONDITIONALS_AND_LOOPS
   enabled: true
+# Checks that the declaration part of a class-like code structures (class/interface/etc.) is in the proper order
 - name: WRONG_ORDER_IN_CLASS_LIKE_STRUCTURES
   enabled: true
+# Checks that properties with comments are separated by a blank line
 - name: BLANK_LINE_BETWEEN_PROPERTIES
   enabled: true
+# Checks that non-empty code blocks with braces follow the K&R style (1TBS or OTBS style)
 - name: BRACES_BLOCK_STRUCTURE_ERROR
   enabled: true
   configuration:
     openBraceNewline: 'True'
     closeBraceNewline: 'True'
+# Checks that indentation is correct
 - name: WRONG_INDENTATION
   enabled: true
   configuration:
+    # Is newline at the end of a file needed
     newlineAtEnd: true
+    # If true: in parameter list when parameters are split by newline they are indented with two indentations instead of one
     extendedIndentOfParameters: false
+    # If true: if first parameter in parameter list is on the same line as opening parenthesis, then other parameters can be aligned with it
     alignedParameters: true
+    # If true: if expression is split by newline after operator like +/-/`*`, then the next line is indented with two indentations instead of one
     extendedIndentAfterOperators: true
+    # If true: when dot qualified expression starts on a new line, this line will be indented with two indentations instead of one
     extendedIndentBeforeDot: false
+    # The indentation size for each file
     indentationSize: 4
+# Checks that there is no empty blocks in a file.
+# If allowEmptyBlocks is true, checks that it follows correct style (have a newline)
 - name: EMPTY_BLOCK_STRUCTURE_ERROR
   enabled: true
   configuration:
+    # Whether a newline after `{` is required in an empty block
     styleEmptyBlockWithNewline: 'True'
     allowEmptyBlocks: 'False'
+# Checks that there is no more than one statement per line
 - name: MORE_THAN_ONE_STATEMENT_PER_LINE
   enabled: true
+# Checks that the line length is < lineLength parameter
 - name: LONG_LINE
   enabled: true
   configuration:
     lineLength: '180'
+# Checks that semicolons are not used at the end of a line
 - name: REDUNDANT_SEMICOLON
   enabled: true
+# Checks that line breaks follow code style guide: rule 3.6
 - name: WRONG_NEWLINES
   enabled: true
   configuration:
+    # If the number of parameters on one line is more than this threshold, all parameters will be placed on separate lines.
     maxParametersInOneLine: 2
+    # 3 by default.
+    # maxCallsInOneLine: 3
+# Checks that there are not too many consecutive spaces in line
 - name: TOO_MANY_CONSECUTIVE_SPACES
   enabled: true
   configuration:
-    max_spaces: '1'
+    # Maximum allowed number of consecutive spaces (not counting indentation)
+    maxSpaces: '1'
+    # Whether formatting for enums should be kept without checking
     saveInitialFormattingForEnums: false
+# Checks that blank lines are used correctly.
+# For example: triggers when there are too many blank lines between function declaration
 - name: TOO_MANY_BLANK_LINES
   enabled: true
+# Checks that usage of horizontal spaces doesn't violate code style guide
 - name: WRONG_WHITESPACE
   enabled: true
+# Checks that backticks (``) are not used in the identifier name, except the case when it is test method (marked with @Test annotation)
 - name: BACKTICKS_PROHIBITED
   enabled: true
+# Checks that a single line concatenation of strings is not used
 - name: STRING_CONCATENATION
   enabled: true
+# Checks that each when statement have else in the end
 - name: WHEN_WITHOUT_ELSE
   enabled: true
+# Checks that annotation is on a single line
 - name: ANNOTATION_NEW_LINE
   enabled: true
+# Checks that enum structure is correct: enum entries should be separated by comma and line break and last entry should have semicolon in the end.
 - name: ENUMS_SEPARATED
   enabled: true
+# Checks that value on integer or float constant is not too big
 - name: LONG_NUMERICAL_VALUES_SEPARATED
   enabled: true
   configuration:
+    # Maximum number of digits which are not split
     maxNumberLength: '5'
+    # Maximum number of digits between separators
     maxBlockLength: '3'
+# Checks that order of enum values or constant property inside companion is correct
 - name: WRONG_DECLARATIONS_ORDER
   enabled: true
   configuration:
+    # Whether enum members should be sorted alphabetically
     sortEnum: true
+    # Whether class properties should be sorted alphabetically
     sortProperty: true
+# Checks that multiple modifiers sequence is in the correct order
 - name: WRONG_MULTIPLE_MODIFIERS_ORDER
   enabled: true
+# Checks that identifier has appropriate name (See table of rule 1.2 part 6)
 - name: CONFUSING_IDENTIFIER_NAMING
   enabled: true
+# Checks year in the copyright
 - name: WRONG_COPYRIGHT_YEAR
   enabled: true
 # Inspection that checks if local variables are declared close to the first usage site
@@ -210,8 +301,10 @@
   enabled: true
   configuration:
     typeReferenceLength: '25' # max length of type reference
+# Checks if casting can be omitted
 - name: SMART_CAST_NEEDED
   enabled: true
+# Checks that variables of generic types have explicit type declaration
 - name: GENERIC_VARIABLE_WRONG_DECLARATION
   enabled: true
 # Inspection that checks if string template has redundant curly braces

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

@@ -79,7 +79,7 @@ class ConsecutiveSpacesRule(private val configRules: List<RulesConfig>) : Rule("
         /**
          * Maximum allowed number of consecutive spaces (not counting indentation)
          */
-        val numberOfSpaces = config["max_spaces"]?.toIntOrNull() ?: MAX_SPACES
+        val numberOfSpaces = config["maxSpaces"]?.toIntOrNull() ?: MAX_SPACES
 
         /**
          * Whether formatting for enums should be kept without checking

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

@@ -7,6 +7,7 @@ import org.cqfn.diktat.ruleset.constants.Warnings.FILE_NAME_MATCH_CLASS
 import org.cqfn.diktat.ruleset.utils.getAllChildrenWithType
 import org.cqfn.diktat.ruleset.utils.getFilePath
 import org.cqfn.diktat.ruleset.utils.getFirstChildWithType
+import org.cqfn.diktat.ruleset.utils.isKotlinScript
 import org.cqfn.diktat.ruleset.utils.isPascalCase
 
 import com.pinterest.ktlint.core.Rule
@@ -39,8 +40,10 @@ class FileNaming(private val configRules: List<RulesConfig>) : Rule("file-naming
 
         if (node.elementType == FILE) {
             filePath = node.getFilePath()
-            checkFileNaming(node)
-            checkClassNameMatchesWithFile(node)
+            if (!filePath.isKotlinScript()) {
+                checkFileNaming(node)
+                checkClassNameMatchesWithFile(node)
+            }
         }
     }
 

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

@@ -60,7 +60,7 @@ class PackageNaming(private val configRules: List<RulesConfig>) : Rule("package-
             val realPackageName = calculateRealPackageName(filePath)
 
             // if node isLeaf - this means that there is no package name declared
-            if (node.isLeaf()) {
+            if (node.isLeaf() && !filePath.isKotlinScript()) {
                 warnAndFixMissingPackageName(node, realPackageName, filePath)
                 return
             }
@@ -129,7 +129,7 @@ class PackageNaming(private val configRules: List<RulesConfig>) : Rule("package-
             }
 
         // package name should start from a company's domain name
-        if (!isDomainMatches(wordsInPackageName)) {
+        if (wordsInPackageName.isNotEmpty() && !isDomainMatches(wordsInPackageName)) {
             PACKAGE_NAME_INCORRECT_PREFIX.warnAndFix(configRules, emitWarn, isFixMode, domainName,
                 wordsInPackageName[0].startOffset, wordsInPackageName[0]) {
                 val oldPackageName = wordsInPackageName.joinToString(PACKAGE_SEPARATOR) { it.text }

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

@@ -17,6 +17,7 @@ import com.pinterest.ktlint.core.ast.ElementType.FUNCTION_LITERAL
 import com.pinterest.ktlint.core.ast.ElementType.LAMBDA_EXPRESSION
 import com.pinterest.ktlint.core.ast.ElementType.LBRACE
 import com.pinterest.ktlint.core.ast.ElementType.RBRACE
+import com.pinterest.ktlint.core.ast.ElementType.SCRIPT
 import com.pinterest.ktlint.core.ast.ElementType.WHITE_SPACE
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 
@@ -46,7 +47,11 @@ class BlankLinesRule(private val configRules: List<RulesConfig>) : Rule("blank-l
     }
 
     private fun handleBlankLine(node: ASTNode) {
-        if (node.treeParent.elementType.let { it == BLOCK || it == CLASS_BODY || it == FUNCTION_LITERAL }) {
+        if (node.treeParent.let {
+            // kts files are parsed as a SCRIPT node containing BLOCK, therefore WHITE_SPACEs from these BLOCKS shouldn't be checked
+            it.elementType == BLOCK && it.treeParent?.elementType != SCRIPT ||
+                    it.elementType == CLASS_BODY || it.elementType == FUNCTION_LITERAL
+        }) {
             if ((node.treeNext.elementType == RBRACE) xor (node.treePrev.elementType == LBRACE)) {
                 // if both are present, this is not beginning or end
                 // if both are null, then this block is empty and is handled in another rule

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

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