Support kotlin multiplatform project layout in PackageNaming rule (#516)

### What's done:
* Added logic with list of allowed targets
* Added tests

diktat-common/src/main/kotlin/org/cqfn/diktat/common/config/rules/RulesConfigReader.kt

@@ -115,6 +115,11 @@ data class CommonConfiguration(private val configuration: Map<String, String>?)
     val domainName: String by lazy {
         (configuration ?: mapOf()).getOrDefault("domainName", "")
     }
+
+    /**
+     * False if configuration has been read from config file, true if defaults are used
+     */
+    val isDefault = configuration == null
 }
 
 // ================== utils for List<RulesConfig> from yml config
@@ -130,7 +135,7 @@ fun List<RulesConfig>.getRuleConfig(rule: Rule): RulesConfig? = this.find { it.n
 /**
  * Get [RulesConfig] representing common configuration part that can be used in any rule
  */
-fun List<RulesConfig>.getCommonConfig() = find { it.name == DIKTAT_COMMON }
+private fun List<RulesConfig>.getCommonConfig() = find { it.name == DIKTAT_COMMON }
 
 /**
  * checking if in yml config particular rule is enabled or disabled

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

@@ -7,15 +7,16 @@ import com.pinterest.ktlint.core.ast.ElementType.PACKAGE_DIRECTIVE
 import com.pinterest.ktlint.core.ast.ElementType.REFERENCE_EXPRESSION
 import com.pinterest.ktlint.core.ast.isLeaf
 import org.cqfn.diktat.common.config.rules.RulesConfig
-import org.cqfn.diktat.common.config.rules.getCommonConfig
 import org.cqfn.diktat.common.config.rules.getCommonConfiguration
+import org.cqfn.diktat.ruleset.constants.EmitType
 import org.cqfn.diktat.ruleset.constants.Warnings.INCORRECT_PACKAGE_SEPARATOR
 import org.cqfn.diktat.ruleset.constants.Warnings.PACKAGE_NAME_INCORRECT_CASE
 import org.cqfn.diktat.ruleset.constants.Warnings.PACKAGE_NAME_INCORRECT_PATH
 import org.cqfn.diktat.ruleset.constants.Warnings.PACKAGE_NAME_INCORRECT_PREFIX
 import org.cqfn.diktat.ruleset.constants.Warnings.PACKAGE_NAME_INCORRECT_SYMBOLS
 import org.cqfn.diktat.ruleset.constants.Warnings.PACKAGE_NAME_MISSING
 import org.cqfn.diktat.ruleset.utils.*
+import org.jetbrains.kotlin.backend.common.onlyIf
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.PsiWhiteSpaceImpl
@@ -32,29 +33,21 @@ import org.slf4j.LoggerFactory
  */
 @Suppress("ForbiddenComment")
 class PackageNaming(private val configRules: List<RulesConfig>) : Rule("package-naming") {
-    companion object {
-        const val PACKAGE_SEPARATOR = "."
-        const val PACKAGE_PATH_ANCHOR = "src"
-        val LANGUAGE_DIR_NAMES = listOf("src", "main", "test", "java", "kotlin")
-        private val log = LoggerFactory.getLogger(PackageNaming::class.java)
-    }
-
-    private lateinit var emitWarn: ((offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit)
     private var isFixMode: Boolean = false
+    private lateinit var emitWarn: EmitType
     private lateinit var domainName: String
 
     override fun visit(node: ASTNode,
                        autoCorrect: Boolean,
-                       emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit) {
+                       emit: EmitType) {
         isFixMode = autoCorrect
         emitWarn = emit
 
-        val domainNameConfiguration = configRules.getCommonConfig()?.configuration
-        if (domainNameConfiguration == null) {
+        val configuration by configRules.getCommonConfiguration()
+        domainName = configuration.onlyIf({ isDefault }) {
             log.error("Not able to find an external configuration for domain name in the common configuration (is it missing in yml config?)")
         }
-        val configuration by configRules.getCommonConfiguration()
-        domainName = configuration.domainName
+            .domainName
 
         if (node.elementType == PACKAGE_DIRECTIVE) {
             val fileName = node.getRootNode().getFileName()
@@ -93,7 +86,7 @@ class PackageNaming(private val configRules: List<RulesConfig>) : Rule("package-
 
     /**
      * calculating real package name based on the directory path where the file is stored
-     * @return - list with words that are parts of package name like [org, diktat, name]
+     * @return list with words that are parts of package name like [org, diktat, name]
      */
     private fun calculateRealPackageName(fileName: String): List<String> {
         val filePathParts = fileName.splitPathToDirs()
@@ -129,7 +122,7 @@ class PackageNaming(private val configRules: List<RulesConfig>) : Rule("package-
         if (!isDomainMatches(wordsInPackageName)) {
             PACKAGE_NAME_INCORRECT_PREFIX.warnAndFix(configRules, emitWarn, isFixMode, domainName,
                     wordsInPackageName[0].startOffset, wordsInPackageName[0]) {
-                val oldPackageName = wordsInPackageName.map { it.text }.joinToString(PACKAGE_SEPARATOR)
+                val oldPackageName = wordsInPackageName.joinToString(PACKAGE_SEPARATOR) { it.text }
                 val newPackageName = "$domainName$PACKAGE_SEPARATOR$oldPackageName"
                 insertNewPackageName(packageDirectiveNode, newPackageName)
             }
@@ -231,4 +224,31 @@ class PackageNaming(private val configRules: List<RulesConfig>) : Rule("package-
             }
         }
     }
+
+    companion object {
+        /**
+         * Symbol that is used to separate parts in package name
+         */
+        const val PACKAGE_SEPARATOR = "."
+
+        /**
+         * Directory which is considered the start of sources file tree
+         */
+        const val PACKAGE_PATH_ANCHOR = "src"
+
+        /**
+         * Targets described in [KMM documentation](https://kotlinlang.org/docs/reference/mpp-supported-platforms.html)
+         */
+        private val kmmTargets = listOf("common", "jvm", "js", "android", "ios", "androidNativeArm32", "androidNativeArm64", "iosArm32", "iosArm64", "iosX64",
+            "watchosArm32", "watchosArm64", "watchosX86", "tvosArm64", "tvosX64", "macosX64", "linuxArm64", "linuxArm32Hfp", "linuxMips32", "linuxMipsel32", "linuxX64",
+            "mingwX64", "mingwX86", "wasm32")
+
+        /**
+         * Directories that are supposed to be first in sources file paths, relative to [PACKAGE_PATH_ANCHOR].
+         * For kotlin multiplatform projects directories for targets from [kmmTargets] are supported.
+         */
+        val LANGUAGE_DIR_NAMES = listOf("src", "main", "test", "java", "kotlin") + kmmTargets.flatMap { listOf("${it}Main", "${it}Test") }
+
+        private val log = LoggerFactory.getLogger(PackageNaming::class.java)
+    }
 }

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter1/PackageNamingWarnTest.kt

@@ -182,4 +182,46 @@ class PackageNamingWarnTest : LintTestBase(::PackageNaming) {
                 )
         )
     }
+
+    @Test
+    @Tag(WarningNames.PACKAGE_NAME_INCORRECT_PATH)
+    fun `should respect KMP project structure - positive example`() {
+        listOf("main", "test", "jvmMain", "jvmTest", "androidMain", "androidTest", "iosMain", "iosTest", "jsMain", "jsTest", "commonMain", "commonTest").forEach {
+            lintMethod(
+                """
+                    |package org.cqfn.diktat
+                """.trimMargin(),
+                fileName = "/home/testu/project/src/$it/kotlin/org/cqfn/diktat/Example.kt",
+                rulesConfigList = rulesConfigList
+            )
+        }
+    }
+
+    @Test
+    @Tag(WarningNames.PACKAGE_NAME_INCORRECT_PATH)
+    fun `should respect KMP project structure`() {
+        listOf("main", "test", "jvmMain", "jvmTest", "androidMain", "androidTest", "iosMain", "iosTest", "jsMain", "jsTest", "commonMain", "commonTest").forEach {
+            lintMethod(
+                """
+                    |package org.cqfn.diktat
+                """.trimMargin(),
+                LintError(1, 9, ruleId, "${PACKAGE_NAME_INCORRECT_PATH.warnText()} org.cqfn.diktat.example", true),
+                fileName = "/home/testu/project/src/$it/kotlin/org/cqfn/diktat/example/Example.kt",
+                rulesConfigList = rulesConfigList
+            )
+        }
+    }
+
+    @Test
+    @Tag(WarningNames.PACKAGE_NAME_INCORRECT_PATH)
+    fun `should respect KMP project structure - illegal source set name`() {
+        lintMethod(
+            """
+                |package org.cqfn.diktat
+            """.trimMargin(),
+            LintError(1, 9, ruleId, "${PACKAGE_NAME_INCORRECT_PATH.warnText()} org.cqfn.diktat.myProjectMain.kotlin.org.cqfn.diktat.example", true),
+            fileName = "/home/testu/project/src/myProjectMain/kotlin/org/cqfn/diktat/example/Example.kt",
+            rulesConfigList = rulesConfigList
+        )
+    }
 }

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/smoke/DiktatSmokeTest.kt

@@ -103,6 +103,13 @@ class DiktatSmokeTest : FixTestBase("test/smoke/src/main/kotlin",
         fixAndCompare("DefaultPackageExpected.kt", "DefaultPackageTest.kt")
     }
 
+    @Test
+    @Tag("DiktatRuleSetProvider")
+    fun `smoke test with multiplatform project layout`() {
+        fixAndCompare("../../jsMain/kotlin/org/cqfn/diktat/scripts/ScriptExpected.kt",
+        "../../jsMain/kotlin/org/cqfn/diktat/scripts/ScriptTest.kt")
+    }
+
     @AfterEach
     fun `revert configuration file to default`() {
         configFilePath = DEFAULT_CONFIG_PATH

diktat-rules/src/test/resources/test/smoke/src/jsMain/kotlin/org/cqfn/diktat/scripts/ScriptExpected.kt

@@ -0,0 +1,8 @@
+package org.cqfn.diktat.scripts
+
+import kotlinx.browser.document
+
+fun main() {
+    (document.getElementById("myId") as HTMLElement).click()
+}
+

diktat-rules/src/test/resources/test/smoke/src/jsMain/kotlin/org/cqfn/diktat/scripts/ScriptTest.kt

@@ -0,0 +1,7 @@
+package org.cqfn.diktat.js
+
+import kotlinx.browser.document
+
+fun main() {
+    (document.getElementById("myId") as HTMLElement).click()
+}