ENUM_VALUE styles support: snakeCase/pascalCase (#408)

### What's done:
* added config parameter for ENUM_VALUE: enumStyle: snakeCase/pascalCase
* rule documentation updated with more info
* warnings&analysis updated
* warning test added

diktat-analysis.yml

@@ -10,7 +10,8 @@
   configuration: {}
 - name: ENUM_VALUE
   enabled: true
-  configuration: {}
+  configuration:
+    enumStyle: snakeCase
 - name: EXCEPTION_SUFFIX
   enabled: true
   configuration: {}

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

@@ -28,7 +28,7 @@ enum class Warnings(private val canBeAutoCorrected: Boolean, private val warn: S
     CONSTANT_UPPERCASE(true, "<val> properties from companion object or on file level mostly in all cases are constants - please use upper snake case for them"),
     VARIABLE_HAS_PREFIX(true, "variable has prefix (like mVariable or M_VARIABLE), generally it is a bad code style (Android - is the only exception)"),
     IDENTIFIER_LENGTH(false, "identifier's length is incorrect, it should be in range of [2, 64] symbols"),
-    ENUM_VALUE(true, "in the same way as constants, enum values should be in UPPER_CASE snake format"),
+    ENUM_VALUE(true, "enum values should be in selected UPPER_CASE snake/PascalCase format"),
     GENERIC_NAME(true, "generic name should contain only one single capital letter, it can be followed by a number"),
     FUNCTION_NAME_INCORRECT_CASE(true, "function/method name should be in lowerCamelCase"),
     FUNCTION_BOOLEAN_PREFIX(true, "functions that return the value of Boolean type should have <is> or <has> prefix"),

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

@@ -10,7 +10,9 @@ import com.pinterest.ktlint.core.ast.ElementType.FUNCTION_TYPE
 import com.pinterest.ktlint.core.ast.ElementType.TYPE_REFERENCE
 import com.pinterest.ktlint.core.ast.ElementType.VALUE_PARAMETER_LIST
 import com.pinterest.ktlint.core.ast.prevCodeSibling
+import org.cqfn.diktat.common.config.rules.RuleConfiguration
 import org.cqfn.diktat.common.config.rules.RulesConfig
+import org.cqfn.diktat.common.config.rules.getRuleConfig
 import org.cqfn.diktat.ruleset.constants.Warnings.BACKTICKS_PROHIBITED
 import org.cqfn.diktat.ruleset.constants.Warnings.CLASS_NAME_INCORRECT
 import org.cqfn.diktat.ruleset.constants.Warnings.CONSTANT_UPPERCASE
@@ -45,6 +47,7 @@ import org.cqfn.diktat.ruleset.utils.removePrefix
 import org.cqfn.diktat.ruleset.utils.toLowerCamelCase
 import org.cqfn.diktat.ruleset.utils.toPascalCase
 import org.cqfn.diktat.ruleset.utils.toUpperSnakeCase
+import org.cqfn.diktat.ruleset.utils.Style
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement
@@ -291,10 +294,20 @@ class IdentifierNaming(private val configRules: List<RulesConfig>) : Rule("ident
     private fun checkEnumValues(node: ASTNode): List<ASTNode> {
         val enumValues: List<ASTNode> = node.getChildren(null).filter { it.elementType == ElementType.IDENTIFIER }
         enumValues.forEach { value ->
-            if (!value.text.isUpperSnakeCase()) {
+            val configuration = IdentifierNamingConfiguration(configRules.getRuleConfig(ENUM_VALUE)?.configuration
+                    ?: mapOf())
+            val validator = when (configuration.enumStyle) {
+                Style.PASCAL_CASE -> String::isPascalCase
+                Style.SNAKE_CASE -> String::isUpperSnakeCase
+            }
+            val autofix = when (configuration.enumStyle) {
+                Style.PASCAL_CASE -> String::toPascalCase
+                Style.SNAKE_CASE -> String::toUpperSnakeCase
+            }
+            if (!validator(value.text)) {
                 ENUM_VALUE.warnAndFix(configRules, emitWarn, isFixMode, value.text, value.startOffset, value) {
                     // FixMe: add tests for this
-                    (value as LeafPsiElement).replaceWithText(value.text.toUpperSnakeCase())
+                    (value as LeafPsiElement).replaceWithText(autofix(value.text))
                 }
             }
 
@@ -378,4 +391,19 @@ class IdentifierNaming(private val configRules: List<RulesConfig>) : Rule("ident
         val prevCatchKeyWord = parentValueParamList?.prevCodeSibling()?.elementType == CATCH_KEYWORD
         return node.text == "e" && node.findParentNodeWithSpecificType(CATCH) != null && prevCatchKeyWord
     }
+
+    class IdentifierNamingConfiguration(config: Map<String, String>) : RuleConfiguration(config) {
+        private val Style.isEnumStyle: Boolean
+            get() = listOf(Style.PASCAL_CASE, Style.SNAKE_CASE).contains(this)
+
+        val enumStyle = config["enumStyle"]?.let { styleString ->
+            val style = Style.values().firstOrNull {
+                it.name == styleString.toUpperSnakeCase()
+            }
+            if (style == null || !style.isEnumStyle) {
+                error("$styleString is unsupported for enum style")
+            }
+            style
+        } ?: Style.SNAKE_CASE
+    }
 }

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

@@ -158,3 +158,8 @@ private fun convertUnknownCaseToUpperSnake(str: String): String {
 
 private fun String.getFirstLetterOrDigit() =
         indexOfFirst { it.isLetterOrDigit() }
+
+enum class Style {
+    PASCAL_CASE,
+    SNAKE_CASE,
+}

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

@@ -1,16 +1,51 @@
 package org.cqfn.diktat.ruleset.chapter1
 
 import generated.WarningNames
+import org.cqfn.diktat.common.config.rules.RulesConfig
+import org.cqfn.diktat.common.config.rules.getRuleConfig
+import org.cqfn.diktat.ruleset.constants.Warnings
 import org.cqfn.diktat.ruleset.rules.IdentifierNaming
 import org.cqfn.diktat.util.FixTestBase
 import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
 
 class EnumValueCaseTest : FixTestBase("test/paragraph1/naming", ::IdentifierNaming) {
+    private val rulesConfigSnakeCaseEnum: List<RulesConfig> = listOf(
+            RulesConfig(Warnings.ENUM_VALUE.name, true,
+                    mapOf("enumStyle" to "snakeCase"))
+    )
+
+    private val rulesConfigPascalCaseEnum: List<RulesConfig> = listOf(
+            RulesConfig(Warnings.ENUM_VALUE.name, true,
+                    mapOf("enumStyle" to "pascalCase"))
+    )
+
+    private val rulesConfigEnumUnknownStyle: List<RulesConfig> = listOf(
+            RulesConfig(Warnings.ENUM_VALUE.name, true,
+                    mapOf("enumStyle" to "otherCase"))
+    )
+
+    @Test
+    @Tag(WarningNames.ENUM_VALUE)
+    fun `incorrect enum snake case value fix`() {
+        fixAndCompare("enum_/EnumValueSnakeCaseExpected.kt", "enum_/EnumValueSnakeCaseTest.kt", rulesConfigSnakeCaseEnum)
+    }
+
+    @Test
+    @Tag(WarningNames.ENUM_VALUE)
+    fun `incorrect enum pascal case value fix`() {
+        fixAndCompare("enum_/EnumValuePascalCaseExpected.kt", "enum_/EnumValuePascalCaseTest.kt", rulesConfigPascalCaseEnum)
+    }
 
     @Test
     @Tag(WarningNames.ENUM_VALUE)
-    fun `incorrect enum value fix`() {
-        fixAndCompare("enum_/EnumValueCaseExpected.kt", "enum_/EnumValueCaseTest.kt")
+    fun `incorrect enum unknown style`() {
+        assertThrows<IllegalStateException> {
+            IdentifierNaming.IdentifierNamingConfiguration(
+                    rulesConfigEnumUnknownStyle.getRuleConfig(Warnings.ENUM_VALUE)
+                            ?.configuration ?: mapOf()
+            )
+        }
     }
 }

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

@@ -30,7 +30,7 @@ class IdentifierNamingFixTest : FixTestBase(
     @Test
     @Tag(WarningNames.ENUM_VALUE)
     fun `incorrect enum values case fix`() {
-        fixAndCompare("enum_/EnumValueCaseExpected.kt", "enum_/EnumValueCaseTest.kt")
+        fixAndCompare("enum_/EnumValueSnakeCaseExpected.kt", "enum_/EnumValueSnakeCaseTest.kt")
     }
 
     @Test

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

@@ -2,6 +2,7 @@ package org.cqfn.diktat.ruleset.chapter1
 
 import com.pinterest.ktlint.core.LintError
 import generated.WarningNames
+import org.cqfn.diktat.common.config.rules.RulesConfig
 import org.cqfn.diktat.ruleset.constants.Warnings
 import org.cqfn.diktat.ruleset.constants.Warnings.BACKTICKS_PROHIBITED
 import org.cqfn.diktat.ruleset.constants.Warnings.CLASS_NAME_INCORRECT
@@ -206,14 +207,38 @@ class IdentifierNamingWarnTest : LintTestBase(::IdentifierNaming) {
         val code =
                 """
                   enum class TEST_ONE {
-                    first_value, secondValue, thirdVALUE
+                    first_value, secondValue, thirdVALUE, FourthValue
                   }
                 """.trimIndent()
         lintMethod(code,
                 LintError(1, 12, ruleId, "${CLASS_NAME_INCORRECT.warnText()} TEST_ONE", true),
                 LintError(2, 3, ruleId, "${ENUM_VALUE.warnText()} first_value", true),
                 LintError(2, 16, ruleId, "${ENUM_VALUE.warnText()} secondValue", true),
-                LintError(2, 29, ruleId, "${ENUM_VALUE.warnText()} thirdVALUE", true)
+                LintError(2, 29, ruleId, "${ENUM_VALUE.warnText()} thirdVALUE", true),
+                LintError(2, 41, ruleId, "${ENUM_VALUE.warnText()} FourthValue", true)
+        )
+    }
+
+    @Test
+    @Tags(Tag(WarningNames.ENUM_VALUE), Tag(WarningNames.CLASS_NAME_INCORRECT))
+    fun `check case for pascal case enum values (check - negative)`() {
+        val code =
+                """
+                  enum class TEST_ONE {
+                    first_value, secondValue, thirdVALUE, FOURTH_VALUE
+                  }
+                """.trimIndent()
+        val rulesConfigPascalCaseEnum: List<RulesConfig> = listOf(
+                RulesConfig(ENUM_VALUE.name, true,
+                        mapOf("enumStyle" to "pascalCase"))
+        )
+        lintMethod(code,
+                LintError(1, 12, ruleId, "${CLASS_NAME_INCORRECT.warnText()} TEST_ONE", true),
+                LintError(2, 3, ruleId, "${ENUM_VALUE.warnText()} first_value", true),
+                LintError(2, 16, ruleId, "${ENUM_VALUE.warnText()} secondValue", true),
+                LintError(2, 29, ruleId, "${ENUM_VALUE.warnText()} thirdVALUE", true),
+                LintError(2, 41, ruleId, "${ENUM_VALUE.warnText()} FOURTH_VALUE", true),
+                rulesConfigList = rulesConfigPascalCaseEnum
         )
     }
 

diktat-rules/src/test/resources/test/paragraph1/naming/enum_/EnumValuePascalCaseExpected.kt

@@ -0,0 +1,10 @@
+package org.cqfn.diktat.test.resources.test.paragraph1.naming.enum_
+
+enum class EnumValuePascalCaseTest {
+    PaScSalL,
+    PascAslF,
+    StartPsaaaDfe,
+    NameMyaSayR,
+    NameMyaSayR
+}
+

diktat-rules/src/test/resources/test/paragraph1/naming/enum_/EnumValuePascalCaseTest.kt

@@ -0,0 +1,10 @@
+package org.cqfn.diktat.test.resources.test.paragraph1.naming.enum_
+
+enum class EnumValuePascalCaseTest {
+    paSC_SAl_l,
+    PascAsl_f,
+    START_PSaaa_DFE,
+    _NAme_MYa_sayR,
+    NAme_MYa_sayR_
+}
+

diktat-rules/src/test/resources/test/paragraph1/naming/enum_/EnumValueCaseExpected.kt → diktat-rules/src/test/resources/test/paragraph1/naming/enum_/EnumValueSnakeCaseExpected.kt

@@ -1,6 +1,6 @@
 package org.cqfn.diktat.test.resources.test.paragraph1.naming.enum_
 
-enum class EnumValueCaseTest {
+enum class EnumValueSnakeCaseTest {
     PA_SC_SAL_L,
     PASC_ASL_F,
     START_PSAAA_DFE,

diktat-rules/src/test/resources/test/paragraph1/naming/enum_/EnumValueCaseTest.kt → diktat-rules/src/test/resources/test/paragraph1/naming/enum_/EnumValueSnakeCaseTest.kt

@@ -1,6 +1,6 @@
 package org.cqfn.diktat.test.resources.test.paragraph1.naming.enum_
 
-enum class EnumValueCaseTest {
+enum class EnumValueSnakeCaseTest {
     paSC_SAl_l,
     PascAsl_f,
     START_PSaaa_DFE,

info/available-rules.md

@@ -15,7 +15,7 @@
 |    1 |      1.6 | CONSTANT_UPPERCASE                      | Check: warns if CONSTANT (treated as const val from companion object or class level) is in non UPPER_SNAKE_CASE<br>Fix: name is changed to UPPER_SNAKE_CASE| yes | no |Recursively update usages of this identifier in the project|
 |    1 |      1.5 | VARIABLE_HAS_PREFIX                     | Check: warns if variable has prefix (like mVariable or M_VARIABLE), generally it is a bad code style (Android - is the only exception<br>Fix: no fix as we are not able to imagine good name by machine| no | no |may be we can fix it, but I do not see any sense for it|
 |    1 |      1.2 | IDENTIFIER_LENGTH                       | Check: identifier length should be in range [2,64] except names that used in industry like {i, j} and 'e' for catching exceptions.<br>Fix: no fix as we are not able to imagine good name by machine          | no | no |May be make this rule configurable (length)|
-|    1 |      1.4 | ENUM_VALUE                              | Check:  warns if enum value is in non UPPER_SNAKE_CASE<br>Fix: automatically converting case to UPPER_SNAKE_CASE                                                             | yes | no |Recursively update usages of this identifier in the project|
+|    1 |      1.4 | ENUM_VALUE                              | Check: warns if enum value is in non UPPER_SNAKE_CASE or non PascalCase depending on the config, UPPER_SNAKE_CASE by default<br>Fix: automatically converting case to selected case| yes | enumStyle: snakeCase, pascalCase |Recursively update usages of this identifier in the project|
 |    1 |      1.2 | GENERIC_NAME                            | Check: warns if generic name contains more than 1 letter (capital). It can be followed by numbers, example: T12, T<br>Fix:                                                   | yes | no |Recursively update usages of this identifier in the project|
 |    1 |      1.5 | FUNCTION_NAME_INCORRECT_CASE            | Check: function/method name should be in lowerCamelCase:<br>Fix:                                                                                                             | yes | no |Recursively update usages of this function in the project|
 |    1 |      1.5 | FUNCTION_BOOLEAN_PREFIX                 | Check: functions/methods that return boolean should have special prefix like "is/should/e.t.c"<br>Fix:                                                                       | yes | no |Recursively update usages of this function in the projectAggressive fix - what if new name will not be valid|