Rename error codes and use proper messages. Also allow specifying patterns for member and string variables

simPod · simPod · commit 44073277d473 · 2022-02-03T14:29:24.000+01:00
diff --git a/src/Cdn77/Sniffs/NamingConventions/ValidVariableNameSniff.php b/src/Cdn77/Sniffs/NamingConventions/ValidVariableNameSniff.php
@@ -22,7 +22,14 @@
 
 class ValidVariableNameSniff extends AbstractVariableSniff
 {
-    public string $pattern = '\b(([a-zA-Z][a-zA-Z0-9]*?([A-Z][a-zA-Z0-9]*?)*?)|_+)\b';
+    public const CODE_DOES_NOT_MATCH_PATTERN = 'DoesNotMatchPattern';
+    public const CODE_MEMBER_DOES_NOT_MATCH_PATTERN = 'MemberDoesNotMatchPattern';
+    public const CODE_STRING_DOES_NOT_MATCH_PATTERN = 'StringDoesNotMatchPattern';
+    private const PATTERN_CAMEL_CASE_OR_UNUSED = '\b(([a-zA-Z][a-zA-Z0-9]*?([A-Z][a-zA-Z0-9]*?)*?)|_+)\b';
+
+    public string $pattern = self::PATTERN_CAMEL_CASE_OR_UNUSED;
+    public string $memberPattern = self::PATTERN_CAMEL_CASE_OR_UNUSED;
+    public string $stringPattern = self::PATTERN_CAMEL_CASE_OR_UNUSED;
 
     /**
      * Processes this test, when one of its tokens is encountered.
@@ -59,33 +66,33 @@ protected function processVariable(File $phpcsFile, $stackPtr): void
                 if ($tokens[$bracket]['code'] !== T_OPEN_PARENTHESIS) {
                     $objVarName = $tokens[$var]['content'];
 
-                    if (! $this->matchesRegex($objVarName)) {
-                        $error = 'Member variable "%s" is not in valid camel caps format';
+                    if (! $this->matchesRegex($objVarName, $this->memberPattern)) {
+                        $error = sprintf('Member variable "%%s" does not match pattern "%s"', $this->memberPattern);
                         $data = [$objVarName];
-                        $phpcsFile->addError($error, $var, 'MemberNotCamelCaps', $data);
+                        $phpcsFile->addError($error, $var, self::CODE_MEMBER_DOES_NOT_MATCH_PATTERN, $data);
                     }
                 }
             }
         }
 
         $objOperator = $phpcsFile->findPrevious(T_WHITESPACE, $stackPtr - 1, null, true);
         if ($tokens[$objOperator]['code'] === T_DOUBLE_COLON) {
-            if (! $this->matchesRegex($varName)) {
-                $error = 'Member variable "%s" is not in valid camel caps format';
+            if (! $this->matchesRegex($varName, $this->memberPattern)) {
+                $error = sprintf('Member variable "%%s" does not match pattern "%s"', $this->memberPattern);
                 $data = [$tokens[$stackPtr]['content']];
-                $phpcsFile->addError($error, $stackPtr, 'MemberNotCamelCaps', $data);
+                $phpcsFile->addError($error, $stackPtr, self::CODE_MEMBER_DOES_NOT_MATCH_PATTERN, $data);
             }
 
             return;
         }
 
-        if ($this->matchesRegex($varName)) {
+        if ($this->matchesRegex($varName, $this->pattern)) {
             return;
         }
 
-        $error = 'Variable "%s" is not in valid camel caps format';
+        $error = sprintf('Variable "%%s" does not match pattern "%s"', $this->pattern);
         $data = [$varName];
-        $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $data);
+        $phpcsFile->addError($error, $stackPtr, self::CODE_DOES_NOT_MATCH_PATTERN, $data);
     }
 
     /**
@@ -113,12 +120,12 @@ protected function processMemberVar(File $phpcsFile, $stackPtr): void
 
         $errorData = [$varName];
 
-        if ($this->matchesRegex($varName)) {
+        if ($this->matchesRegex($varName, $this->memberPattern)) {
             return;
         }
 
-        $error = 'Member variable "%s" is not in valid camel caps format';
-        $phpcsFile->addError($error, $stackPtr, 'MemberNotCamelCaps', $errorData);
+        $error = sprintf('Member variable "%%s" does not match pattern "%s"', $this->memberPattern);
+        $phpcsFile->addError($error, $stackPtr, self::CODE_MEMBER_DOES_NOT_MATCH_PATTERN, $errorData);
     }
 
     /**
@@ -150,18 +157,18 @@ protected function processVariableInString(File $phpcsFile, $stackPtr): void
                 continue;
             }
 
-            if ($this->matchesRegex($varName)) {
+            if ($this->matchesRegex($varName, $this->stringPattern)) {
                 continue;
             }
 
-            $error = 'Variable "%s" is not in valid camel caps format';
+            $error = sprintf('Variable "%%s" does not match pattern "%s"', $this->stringPattern);
             $data = [$varName];
-            $phpcsFile->addError($error, $stackPtr, 'StringNotCamelCaps', $data);
+            $phpcsFile->addError($error, $stackPtr, self::CODE_STRING_DOES_NOT_MATCH_PATTERN, $data);
         }
     }
 
-    private function matchesRegex(string $varName): bool
+    private function matchesRegex(string $varName, string $pattern): bool
     {
-        return preg_match(sprintf('~%s~', $this->pattern), $varName) === 1;
+        return preg_match(sprintf('~%s~', $pattern), $varName) === 1;
     }
 }
diff --git a/tests/Sniffs/NamingConventions/ValidVariableNameSniffTest.php b/tests/Sniffs/NamingConventions/ValidVariableNameSniffTest.php
@@ -14,56 +14,54 @@
 
 class ValidVariableNameSniffTest extends TestCase
 {
-    public const CODE_NOT_CAMEL_CAPS = 'NotCamelCaps';
-    public const CODE_MEMBER_NOT_CAMEL_CAPS = 'MemberNotCamelCaps';
-    public const CODE_PUBLIC_HAS_UNDERSCORE = 'PublicHasUnderscore';
-    public const CODE_STRING_NOT_CAMEL_CAPS = 'StringNotCamelCaps';
-
     public function testErrors(): void
     {
         $file = self::checkFile(__DIR__ . '/data/ValidVariableNameSniffTest.inc');
 
         $errorTypesPerLine = [
-            3 => self::CODE_NOT_CAMEL_CAPS,
-            5 => self::CODE_NOT_CAMEL_CAPS,
-            10 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            12 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            15 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            17 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            20 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            22 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            24 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            25 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            26 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            31 => self::CODE_NOT_CAMEL_CAPS,
-            33 => self::CODE_NOT_CAMEL_CAPS,
-            36 => self::CODE_STRING_NOT_CAMEL_CAPS,
-            37 => self::CODE_STRING_NOT_CAMEL_CAPS,
-            39 => self::CODE_STRING_NOT_CAMEL_CAPS,
-            42 => self::CODE_NOT_CAMEL_CAPS,
-            44 => self::CODE_NOT_CAMEL_CAPS,
-            53 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            55 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            58 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            60 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            62 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            63 => self::CODE_NOT_CAMEL_CAPS,
-            64 => self::CODE_NOT_CAMEL_CAPS,
-            67 => self::CODE_NOT_CAMEL_CAPS,
-            81 => self::CODE_STRING_NOT_CAMEL_CAPS,
-            106 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            107 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            108 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            123 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            124 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            134 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            138 => self::CODE_NOT_CAMEL_CAPS,
-            140 => self::CODE_NOT_CAMEL_CAPS,
-            141 => self::CODE_NOT_CAMEL_CAPS,
-            146 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            148 => self::CODE_MEMBER_NOT_CAMEL_CAPS,
-            150 => [self::CODE_NOT_CAMEL_CAPS, self::CODE_NOT_CAMEL_CAPS],
-            152 => self::CODE_NOT_CAMEL_CAPS,
+            3 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            5 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            10 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            12 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            15 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            17 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            20 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            22 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            24 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            25 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            26 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            31 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            33 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            36 => ValidVariableNameSniff::CODE_STRING_DOES_NOT_MATCH_PATTERN,
+            37 => ValidVariableNameSniff::CODE_STRING_DOES_NOT_MATCH_PATTERN,
+            39 => ValidVariableNameSniff::CODE_STRING_DOES_NOT_MATCH_PATTERN,
+            42 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            44 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            53 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            55 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            58 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            60 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            62 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            63 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            64 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            67 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            81 => ValidVariableNameSniff::CODE_STRING_DOES_NOT_MATCH_PATTERN,
+            106 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            107 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            108 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            123 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            124 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            134 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            138 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            140 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            141 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            146 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            148 => ValidVariableNameSniff::CODE_MEMBER_DOES_NOT_MATCH_PATTERN,
+            150 => [
+                ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+                ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
+            ],
+            152 => ValidVariableNameSniff::CODE_DOES_NOT_MATCH_PATTERN,
         ];
         $possibleLines = array_keys($errorTypesPerLine);
 

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,14 @@`
`22`	`22`
`23`	`23`	`class ValidVariableNameSniff extends AbstractVariableSniff`
`24`	`24`	`{`
`25`		`- public string $pattern = '\b(([a-zA-Z][a-zA-Z0-9]?([A-Z][a-zA-Z0-9]?)*?)\|_+)\b';`
	`25`	`+ public const CODE_DOES_NOT_MATCH_PATTERN = 'DoesNotMatchPattern';`
	`26`	`+ public const CODE_MEMBER_DOES_NOT_MATCH_PATTERN = 'MemberDoesNotMatchPattern';`
	`27`	`+ public const CODE_STRING_DOES_NOT_MATCH_PATTERN = 'StringDoesNotMatchPattern';`
	`28`	`+ private const PATTERN_CAMEL_CASE_OR_UNUSED = '\b(([a-zA-Z][a-zA-Z0-9]?([A-Z][a-zA-Z0-9]?)*?)\|_+)\b';`
	`29`	`+`
	`30`	`+ public string $pattern = self::PATTERN_CAMEL_CASE_OR_UNUSED;`
	`31`	`+ public string $memberPattern = self::PATTERN_CAMEL_CASE_OR_UNUSED;`
	`32`	`+ public string $stringPattern = self::PATTERN_CAMEL_CASE_OR_UNUSED;`
`26`	`33`
`27`	`34`	`/**`
`28`	`35`	`* Processes this test, when one of its tokens is encountered.`
`@@ -59,33 +66,33 @@ protected function processVariable(File $phpcsFile, $stackPtr): void`
`59`	`66`	`if ($tokens[$bracket]['code'] !== T_OPEN_PARENTHESIS) {`
`60`	`67`	`$objVarName = $tokens[$var]['content'];`
`61`	`68`
`62`		`- if (! $this->matchesRegex($objVarName)) {`
`63`		`- $error = 'Member variable "%s" is not in valid camel caps format';`
	`69`	`+ if (! $this->matchesRegex($objVarName, $this->memberPattern)) {`
	`70`	`+ $error = sprintf('Member variable "%%s" does not match pattern "%s"', $this->memberPattern);`
`64`	`71`	`$data = [$objVarName];`
`65`		`- $phpcsFile->addError($error, $var, 'MemberNotCamelCaps', $data);`
	`72`	`+ $phpcsFile->addError($error, $var, self::CODE_MEMBER_DOES_NOT_MATCH_PATTERN, $data);`
`66`	`73`	`}`
`67`	`74`	`}`
`68`	`75`	`}`
`69`	`76`	`}`
`70`	`77`
`71`	`78`	`$objOperator = $phpcsFile->findPrevious(T_WHITESPACE, $stackPtr - 1, null, true);`
`72`	`79`	`if ($tokens[$objOperator]['code'] === T_DOUBLE_COLON) {`
`73`		`- if (! $this->matchesRegex($varName)) {`
`74`		`- $error = 'Member variable "%s" is not in valid camel caps format';`
	`80`	`+ if (! $this->matchesRegex($varName, $this->memberPattern)) {`
	`81`	`+ $error = sprintf('Member variable "%%s" does not match pattern "%s"', $this->memberPattern);`
`75`	`82`	`$data = [$tokens[$stackPtr]['content']];`
`76`		`- $phpcsFile->addError($error, $stackPtr, 'MemberNotCamelCaps', $data);`
	`83`	`+ $phpcsFile->addError($error, $stackPtr, self::CODE_MEMBER_DOES_NOT_MATCH_PATTERN, $data);`
`77`	`84`	`}`
`78`	`85`
`79`	`86`	`return;`
`80`	`87`	`}`
`81`	`88`
`82`		`- if ($this->matchesRegex($varName)) {`
	`89`	`+ if ($this->matchesRegex($varName, $this->pattern)) {`
`83`	`90`	`return;`
`84`	`91`	`}`
`85`	`92`
`86`		`- $error = 'Variable "%s" is not in valid camel caps format';`
	`93`	`+ $error = sprintf('Variable "%%s" does not match pattern "%s"', $this->pattern);`
`87`	`94`	`$data = [$varName];`
`88`		`- $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $data);`
	`95`	`+ $phpcsFile->addError($error, $stackPtr, self::CODE_DOES_NOT_MATCH_PATTERN, $data);`
`89`	`96`	`}`
`90`	`97`
`91`	`98`	`/**`
`@@ -113,12 +120,12 @@ protected function processMemberVar(File $phpcsFile, $stackPtr): void`
`113`	`120`
`114`	`121`	`$errorData = [$varName];`
`115`	`122`
`116`		`- if ($this->matchesRegex($varName)) {`
	`123`	`+ if ($this->matchesRegex($varName, $this->memberPattern)) {`
`117`	`124`	`return;`
`118`	`125`	`}`
`119`	`126`
`120`		`- $error = 'Member variable "%s" is not in valid camel caps format';`
`121`		`- $phpcsFile->addError($error, $stackPtr, 'MemberNotCamelCaps', $errorData);`
	`127`	`+ $error = sprintf('Member variable "%%s" does not match pattern "%s"', $this->memberPattern);`
	`128`	`+ $phpcsFile->addError($error, $stackPtr, self::CODE_MEMBER_DOES_NOT_MATCH_PATTERN, $errorData);`
`122`	`129`	`}`
`123`	`130`
`124`	`131`	`/**`
`@@ -150,18 +157,18 @@ protected function processVariableInString(File $phpcsFile, $stackPtr): void`
`150`	`157`	`continue;`
`151`	`158`	`}`
`152`	`159`
`153`		`- if ($this->matchesRegex($varName)) {`
	`160`	`+ if ($this->matchesRegex($varName, $this->stringPattern)) {`
`154`	`161`	`continue;`
`155`	`162`	`}`
`156`	`163`
`157`		`- $error = 'Variable "%s" is not in valid camel caps format';`
	`164`	`+ $error = sprintf('Variable "%%s" does not match pattern "%s"', $this->stringPattern);`
`158`	`165`	`$data = [$varName];`
`159`		`- $phpcsFile->addError($error, $stackPtr, 'StringNotCamelCaps', $data);`
	`166`	`+ $phpcsFile->addError($error, $stackPtr, self::CODE_STRING_DOES_NOT_MATCH_PATTERN, $data);`
`160`	`167`	`}`
`161`	`168`	`}`
`162`	`169`
`163`		`- private function matchesRegex(string $varName): bool`
	`170`	`+ private function matchesRegex(string $varName, string $pattern): bool`
`164`	`171`	`{`
`165`		`- return preg_match(sprintf('~%s~', $this->pattern), $varName) === 1;`
	`172`	`+ return preg_match(sprintf('~%s~', $pattern), $varName) === 1;`
`166`	`173`	`}`
`167`	`174`	`}`