Improve codes

SerafimArts · SerafimArts · commit a56885ef7d97 · 2024-01-26T04:33:29.000+03:00
diff --git a/src/Exception/InvalidTagNameException.php b/src/Exception/InvalidTagNameException.php
@@ -9,13 +9,13 @@
  */
 class InvalidTagNameException extends InvalidTagException implements DocBlockExceptionInterface
 {
-    final public const CODE_EMPTY = 0x01 + parent::CODE_LAST;
+    final public const ERROR_CODE_EMPTY = 0x01 + parent::CODE_LAST;
 
-    final public const CODE_EMPTY_NAME = 0x02 + parent::CODE_LAST;
+    final public const ERROR_CODE_EMPTY_NAME = 0x02 + parent::CODE_LAST;
 
-    final public const CODE_INVALID_PREFIX = 0x03 + parent::CODE_LAST;
+    final public const ERROR_CODE_INVALID_PREFIX = 0x03 + parent::CODE_LAST;
 
-    protected const CODE_LAST = self::CODE_INVALID_PREFIX;
+    protected const CODE_LAST = self::ERROR_CODE_INVALID_PREFIX;
 
     /**
      * Occurs when a tag name is empty.
@@ -24,7 +24,7 @@ public static function fromEmptyTag(): self
     {
         $message = 'Can not read tag name from empty value';
 
-        return new self($message, self::CODE_EMPTY);
+        return new self($message, self::ERROR_CODE_EMPTY);
     }
 
     /**
@@ -34,7 +34,7 @@ public static function fromEmptyTagName(): self
     {
         $message = 'Tag name cannot be empty';
 
-        return new self($message, self::CODE_EMPTY_NAME);
+        return new self($message, self::ERROR_CODE_EMPTY_NAME);
     }
 
     /**
@@ -44,6 +44,6 @@ public static function fromInvalidTagPrefix(): self
     {
         $message = 'The tag name must starts with the "@" character';
 
-        return new self($message, self::CODE_INVALID_PREFIX);
+        return new self($message, self::ERROR_CODE_INVALID_PREFIX);
     }
 }
diff --git a/src/Exception/InvalidTypeException.php b/src/Exception/InvalidTypeException.php
@@ -6,12 +6,13 @@
 
 /**
  * @psalm-consistent-constructor
+ * @phpstan-consistent-constructor
  */
 class InvalidTypeException extends InvalidTagException implements DocBlockExceptionInterface
 {
-    final public const CODE_WITHOUT_TYPE = 0x01 + parent::CODE_LAST;
+    final public const ERROR_CODE_WITHOUT_TYPE = 0x01 + parent::CODE_LAST;
 
-    protected const CODE_LAST = self::CODE_WITHOUT_TYPE;
+    protected const CODE_LAST = self::ERROR_CODE_WITHOUT_TYPE;
 
     public function __construct(string $message, int $code = 0, ?\Throwable $previous = null)
     {
@@ -22,6 +23,6 @@ public static function fromInvalidType(\Throwable $e = null): self
     {
         $message = 'Could not parse tag type';
 
-        return new static($message, self::CODE_WITHOUT_TYPE, $e);
+        return new static($message, self::ERROR_CODE_WITHOUT_TYPE, $e);
     }
 }
diff --git a/src/Exception/InvalidVariableNameException.php b/src/Exception/InvalidVariableNameException.php
@@ -8,20 +8,21 @@
 
 /**
  * @psalm-consistent-constructor
+ * @phpstan-consistent-constructor
  */
 class InvalidVariableNameException extends InvalidTagException implements InvalidTypedTagExceptionInterface
 {
-    final public const CODE_WITH_TYPE = 0x01 + parent::CODE_LAST;
+    final public const ERROR_CODE_WITH_TYPE = 0x01 + parent::CODE_LAST;
 
-    final public const CODE_WITHOUT_TYPE = 0x02 + parent::CODE_LAST;
+    final public const ERROR_CODE_WITHOUT_TYPE = 0x02 + parent::CODE_LAST;
 
-    final public const CODE_EMPTY = 0x03 + parent::CODE_LAST;
+    final public const ERROR_CODE_EMPTY = 0x03 + parent::CODE_LAST;
 
-    final public const CODE_EMPTY_NAME = 0x04 + parent::CODE_LAST;
+    final public const ERROR_CODE_EMPTY_NAME = 0x04 + parent::CODE_LAST;
 
-    final public const CODE_INVALID_PREFIX = 0x05 + parent::CODE_LAST;
+    final public const ERROR_CODE_INVALID_PREFIX = 0x05 + parent::CODE_LAST;
 
-    protected const CODE_LAST = self::CODE_INVALID_PREFIX;
+    protected const CODE_LAST = self::ERROR_CODE_INVALID_PREFIX;
 
     /**
      * @param int<0, max> $offset
@@ -53,7 +54,7 @@ public static function fromNonTyped(\Throwable $e = null): self
     {
         $message = 'Could not parse tag variable name, expected "<@tag> <$name> [<description>]"';
 
-        return new static($message, self::CODE_WITHOUT_TYPE, $e);
+        return new static($message, self::ERROR_CODE_WITHOUT_TYPE, $e);
     }
 
     /**
@@ -63,7 +64,7 @@ public static function fromTyped(TypeStatement $type, int $offset, \Throwable $e
     {
         $message = 'Could not parse typed tag variable name, expected "<@tag> <type> <$name> [<description>]"';
 
-        return new static($message, self::CODE_WITH_TYPE, $e, $type, $offset);
+        return new static($message, self::ERROR_CODE_WITH_TYPE, $e, $type, $offset);
     }
 
     /**
@@ -73,7 +74,7 @@ public static function fromEmptyVariable(): self
     {
         $message = 'Can not read variable name from empty value';
 
-        return new self($message, self::CODE_EMPTY);
+        return new self($message, self::ERROR_CODE_EMPTY);
     }
 
     /**
@@ -83,7 +84,7 @@ public static function fromEmptyVariableName(): self
     {
         $message = 'Variable name cannot be empty';
 
-        return new self($message, self::CODE_EMPTY_NAME);
+        return new self($message, self::ERROR_CODE_EMPTY_NAME);
     }
 
     /**
@@ -93,6 +94,6 @@ public static function fromInvalidVariablePrefix(): self
     {
         $message = 'The variable name must starts with the "$" character';
 
-        return new self($message, self::CODE_INVALID_PREFIX);
+        return new self($message, self::ERROR_CODE_INVALID_PREFIX);
     }
 }
diff --git a/tests/Unit/Reader/TagNameReaderTest.php b/tests/Unit/Reader/TagNameReaderTest.php
@@ -70,7 +70,7 @@ public function testTagStartsWithAsciiChars(string $char, int $code): void
 
         if (!$allowed) {
             self::expectException(InvalidTagNameException::class);
-            self::expectExceptionCode(InvalidTagNameException::CODE_EMPTY_NAME);
+            self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_EMPTY_NAME);
         }
 
         $sequence = $this->read($tag = "@{$char}suffix");
@@ -84,31 +84,31 @@ public function testTagStartsWithAsciiChars(string $char, int $code): void
     public function testWithoutName(): void
     {
         self::expectException(InvalidTagNameException::class);
-        self::expectExceptionCode(InvalidTagNameException::CODE_EMPTY_NAME);
+        self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_EMPTY_NAME);
 
         $this->read('@ description');
     }
 
     public function testWithoutNameAndDescription(): void
     {
         self::expectException(InvalidTagNameException::class);
-        self::expectExceptionCode(InvalidTagNameException::CODE_EMPTY_NAME);
+        self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_EMPTY_NAME);
 
         $this->read('@');
     }
 
     public function testEmptyTag(): void
     {
         self::expectException(InvalidTagNameException::class);
-        self::expectExceptionCode(InvalidTagNameException::CODE_EMPTY);
+        self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_EMPTY);
 
         $this->read('');
     }
 
     public function testWithoutTag(): void
     {
         self::expectException(InvalidTagNameException::class);
-        self::expectExceptionCode(InvalidTagNameException::CODE_INVALID_PREFIX);
+        self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_INVALID_PREFIX);
 
         $this->read('description');
     }
diff --git a/tests/Unit/Reader/TypeReaderTest.php b/tests/Unit/Reader/TypeReaderTest.php
@@ -43,15 +43,15 @@ public function testWithDescription(): void
     public function testSyntaxError(): void
     {
         self::expectException(InvalidTypeException::class);
-        self::expectExceptionCode(InvalidTypeException::CODE_WITHOUT_TYPE);
+        self::expectExceptionCode(InvalidTypeException::ERROR_CODE_WITHOUT_TYPE);
 
         $this->read(':type');
     }
 
     public function testEmpty(): void
     {
         self::expectException(InvalidTypeException::class);
-        self::expectExceptionCode(InvalidTypeException::CODE_WITHOUT_TYPE);
+        self::expectExceptionCode(InvalidTypeException::ERROR_CODE_WITHOUT_TYPE);
 
         $this->read('');
     }
diff --git a/tests/Unit/Reader/VariableNameReaderTest.php b/tests/Unit/Reader/VariableNameReaderTest.php
@@ -70,7 +70,7 @@ public function testTagStartsWithAsciiChars(string $char, int $code): void
 
         if (!$allowed) {
             self::expectException(InvalidVariableNameException::class);
-            self::expectExceptionCode(InvalidVariableNameException::CODE_EMPTY_NAME);
+            self::expectExceptionCode(InvalidVariableNameException::ERROR_CODE_EMPTY_NAME);
         }
 
         $sequence = $this->read($tag = "\${$char}suffix");
@@ -84,31 +84,31 @@ public function testTagStartsWithAsciiChars(string $char, int $code): void
     public function testWithoutName(): void
     {
         self::expectException(InvalidVariableNameException::class);
-        self::expectExceptionCode(InvalidVariableNameException::CODE_EMPTY_NAME);
+        self::expectExceptionCode(InvalidVariableNameException::ERROR_CODE_EMPTY_NAME);
 
         $this->read('$ description');
     }
 
     public function testWithoutNameAndDescription(): void
     {
         self::expectException(InvalidVariableNameException::class);
-        self::expectExceptionCode(InvalidVariableNameException::CODE_EMPTY_NAME);
+        self::expectExceptionCode(InvalidVariableNameException::ERROR_CODE_EMPTY_NAME);
 
         $this->read('$');
     }
 
     public function testEmptyTag(): void
     {
         self::expectException(InvalidVariableNameException::class);
-        self::expectExceptionCode(InvalidVariableNameException::CODE_EMPTY);
+        self::expectExceptionCode(InvalidVariableNameException::ERROR_CODE_EMPTY);
 
         $this->read('');
     }
 
     public function testWithoutTag(): void
     {
         self::expectException(InvalidVariableNameException::class);
-        self::expectExceptionCode(InvalidVariableNameException::CODE_INVALID_PREFIX);
+        self::expectExceptionCode(InvalidVariableNameException::ERROR_CODE_INVALID_PREFIX);
 
         $this->read('description');
     }

Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,13 @@`
`9`	`9`	`*/`
`10`	`10`	`class InvalidTagNameException extends InvalidTagException implements DocBlockExceptionInterface`
`11`	`11`	`{`
`12`		`- final public const CODE_EMPTY = 0x01 + parent::CODE_LAST;`
	`12`	`+ final public const ERROR_CODE_EMPTY = 0x01 + parent::CODE_LAST;`
`13`	`13`
`14`		`- final public const CODE_EMPTY_NAME = 0x02 + parent::CODE_LAST;`
	`14`	`+ final public const ERROR_CODE_EMPTY_NAME = 0x02 + parent::CODE_LAST;`
`15`	`15`
`16`		`- final public const CODE_INVALID_PREFIX = 0x03 + parent::CODE_LAST;`
	`16`	`+ final public const ERROR_CODE_INVALID_PREFIX = 0x03 + parent::CODE_LAST;`
`17`	`17`
`18`		`- protected const CODE_LAST = self::CODE_INVALID_PREFIX;`
	`18`	`+ protected const CODE_LAST = self::ERROR_CODE_INVALID_PREFIX;`
`19`	`19`
`20`	`20`	`/**`
`21`	`21`	`* Occurs when a tag name is empty.`
`@@ -24,7 +24,7 @@ public static function fromEmptyTag(): self`
`24`	`24`	`{`
`25`	`25`	`$message = 'Can not read tag name from empty value';`
`26`	`26`
`27`		`- return new self($message, self::CODE_EMPTY);`
	`27`	`+ return new self($message, self::ERROR_CODE_EMPTY);`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`/**`
`@@ -34,7 +34,7 @@ public static function fromEmptyTagName(): self`
`34`	`34`	`{`
`35`	`35`	`$message = 'Tag name cannot be empty';`
`36`	`36`
`37`		`- return new self($message, self::CODE_EMPTY_NAME);`
	`37`	`+ return new self($message, self::ERROR_CODE_EMPTY_NAME);`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`/**`
`@@ -44,6 +44,6 @@ public static function fromInvalidTagPrefix(): self`
`44`	`44`	`{`
`45`	`45`	`$message = 'The tag name must starts with the "@" character';`
`46`	`46`
`47`		`- return new self($message, self::CODE_INVALID_PREFIX);`
	`47`	`+ return new self($message, self::ERROR_CODE_INVALID_PREFIX);`
`48`	`48`	`}`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,12 +6,13 @@`
`6`	`6`
`7`	`7`	`/**`
`8`	`8`	`* @psalm-consistent-constructor`
	`9`	`+ * @phpstan-consistent-constructor`
`9`	`10`	`*/`
`10`	`11`	`class InvalidTypeException extends InvalidTagException implements DocBlockExceptionInterface`
`11`	`12`	`{`
`12`		`- final public const CODE_WITHOUT_TYPE = 0x01 + parent::CODE_LAST;`
	`13`	`+ final public const ERROR_CODE_WITHOUT_TYPE = 0x01 + parent::CODE_LAST;`
`13`	`14`
`14`		`- protected const CODE_LAST = self::CODE_WITHOUT_TYPE;`
	`15`	`+ protected const CODE_LAST = self::ERROR_CODE_WITHOUT_TYPE;`
`15`	`16`
`16`	`17`	`public function __construct(string $message, int $code = 0, ?\Throwable $previous = null)`
`17`	`18`	`{`
`@@ -22,6 +23,6 @@ public static function fromInvalidType(\Throwable $e = null): self`
`22`	`23`	`{`
`23`	`24`	`$message = 'Could not parse tag type';`
`24`	`25`
`25`		`- return new static($message, self::CODE_WITHOUT_TYPE, $e);`
	`26`	`+ return new static($message, self::ERROR_CODE_WITHOUT_TYPE, $e);`
`26`	`27`	`}`
`27`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,20 +8,21 @@`
`8`	`8`
`9`	`9`	`/**`
`10`	`10`	`* @psalm-consistent-constructor`
	`11`	`+ * @phpstan-consistent-constructor`
`11`	`12`	`*/`
`12`	`13`	`class InvalidVariableNameException extends InvalidTagException implements InvalidTypedTagExceptionInterface`
`13`	`14`	`{`
`14`		`- final public const CODE_WITH_TYPE = 0x01 + parent::CODE_LAST;`
	`15`	`+ final public const ERROR_CODE_WITH_TYPE = 0x01 + parent::CODE_LAST;`
`15`	`16`
`16`		`- final public const CODE_WITHOUT_TYPE = 0x02 + parent::CODE_LAST;`
	`17`	`+ final public const ERROR_CODE_WITHOUT_TYPE = 0x02 + parent::CODE_LAST;`
`17`	`18`
`18`		`- final public const CODE_EMPTY = 0x03 + parent::CODE_LAST;`
	`19`	`+ final public const ERROR_CODE_EMPTY = 0x03 + parent::CODE_LAST;`
`19`	`20`
`20`		`- final public const CODE_EMPTY_NAME = 0x04 + parent::CODE_LAST;`
	`21`	`+ final public const ERROR_CODE_EMPTY_NAME = 0x04 + parent::CODE_LAST;`
`21`	`22`
`22`		`- final public const CODE_INVALID_PREFIX = 0x05 + parent::CODE_LAST;`
	`23`	`+ final public const ERROR_CODE_INVALID_PREFIX = 0x05 + parent::CODE_LAST;`
`23`	`24`
`24`		`- protected const CODE_LAST = self::CODE_INVALID_PREFIX;`
	`25`	`+ protected const CODE_LAST = self::ERROR_CODE_INVALID_PREFIX;`
`25`	`26`
`26`	`27`	`/**`
`27`	`28`	`* @param int<0, max> $offset`
`@@ -53,7 +54,7 @@ public static function fromNonTyped(\Throwable $e = null): self`
`53`	`54`	`{`
`54`	`55`	`$message = 'Could not parse tag variable name, expected "<@tag> <$name> [<description>]"';`
`55`	`56`
`56`		`- return new static($message, self::CODE_WITHOUT_TYPE, $e);`
	`57`	`+ return new static($message, self::ERROR_CODE_WITHOUT_TYPE, $e);`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`/**`
`@@ -63,7 +64,7 @@ public static function fromTyped(TypeStatement $type, int $offset, \Throwable $e`
`63`	`64`	`{`
`64`	`65`	`$message = 'Could not parse typed tag variable name, expected "<@tag> <type> <$name> [<description>]"';`
`65`	`66`
`66`		`- return new static($message, self::CODE_WITH_TYPE, $e, $type, $offset);`
	`67`	`+ return new static($message, self::ERROR_CODE_WITH_TYPE, $e, $type, $offset);`
`67`	`68`	`}`
`68`	`69`
`69`	`70`	`/**`
`@@ -73,7 +74,7 @@ public static function fromEmptyVariable(): self`
`73`	`74`	`{`
`74`	`75`	`$message = 'Can not read variable name from empty value';`
`75`	`76`
`76`		`- return new self($message, self::CODE_EMPTY);`
	`77`	`+ return new self($message, self::ERROR_CODE_EMPTY);`
`77`	`78`	`}`
`78`	`79`
`79`	`80`	`/**`
`@@ -83,7 +84,7 @@ public static function fromEmptyVariableName(): self`
`83`	`84`	`{`
`84`	`85`	`$message = 'Variable name cannot be empty';`
`85`	`86`
`86`		`- return new self($message, self::CODE_EMPTY_NAME);`
	`87`	`+ return new self($message, self::ERROR_CODE_EMPTY_NAME);`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`/**`
`@@ -93,6 +94,6 @@ public static function fromInvalidVariablePrefix(): self`
`93`	`94`	`{`
`94`	`95`	`$message = 'The variable name must starts with the "$" character';`
`95`	`96`
`96`		`- return new self($message, self::CODE_INVALID_PREFIX);`
	`97`	`+ return new self($message, self::ERROR_CODE_INVALID_PREFIX);`
`97`	`98`	`}`
`98`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ public function testTagStartsWithAsciiChars(string $char, int $code): void`
`70`	`70`
`71`	`71`	`if (!$allowed) {`
`72`	`72`	`self::expectException(InvalidTagNameException::class);`
`73`		`- self::expectExceptionCode(InvalidTagNameException::CODE_EMPTY_NAME);`
	`73`	`+ self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_EMPTY_NAME);`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`$sequence = $this->read($tag = "@{$char}suffix");`
`@@ -84,31 +84,31 @@ public function testTagStartsWithAsciiChars(string $char, int $code): void`
`84`	`84`	`public function testWithoutName(): void`
`85`	`85`	`{`
`86`	`86`	`self::expectException(InvalidTagNameException::class);`
`87`		`- self::expectExceptionCode(InvalidTagNameException::CODE_EMPTY_NAME);`
	`87`	`+ self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_EMPTY_NAME);`
`88`	`88`
`89`	`89`	`$this->read('@ description');`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`public function testWithoutNameAndDescription(): void`
`93`	`93`	`{`
`94`	`94`	`self::expectException(InvalidTagNameException::class);`
`95`		`- self::expectExceptionCode(InvalidTagNameException::CODE_EMPTY_NAME);`
	`95`	`+ self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_EMPTY_NAME);`
`96`	`96`
`97`	`97`	`$this->read('@');`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`public function testEmptyTag(): void`
`101`	`101`	`{`
`102`	`102`	`self::expectException(InvalidTagNameException::class);`
`103`		`- self::expectExceptionCode(InvalidTagNameException::CODE_EMPTY);`
	`103`	`+ self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_EMPTY);`
`104`	`104`
`105`	`105`	`$this->read('');`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`public function testWithoutTag(): void`
`109`	`109`	`{`
`110`	`110`	`self::expectException(InvalidTagNameException::class);`
`111`		`- self::expectExceptionCode(InvalidTagNameException::CODE_INVALID_PREFIX);`
	`111`	`+ self::expectExceptionCode(InvalidTagNameException::ERROR_CODE_INVALID_PREFIX);`
`112`	`112`
`113`	`113`	`$this->read('description');`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,15 +43,15 @@ public function testWithDescription(): void`
`43`	`43`	`public function testSyntaxError(): void`
`44`	`44`	`{`
`45`	`45`	`self::expectException(InvalidTypeException::class);`
`46`		`- self::expectExceptionCode(InvalidTypeException::CODE_WITHOUT_TYPE);`
	`46`	`+ self::expectExceptionCode(InvalidTypeException::ERROR_CODE_WITHOUT_TYPE);`
`47`	`47`
`48`	`48`	`$this->read(':type');`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`public function testEmpty(): void`
`52`	`52`	`{`
`53`	`53`	`self::expectException(InvalidTypeException::class);`
`54`		`- self::expectExceptionCode(InvalidTypeException::CODE_WITHOUT_TYPE);`
	`54`	`+ self::expectExceptionCode(InvalidTypeException::ERROR_CODE_WITHOUT_TYPE);`
`55`	`55`
`56`	`56`	`$this->read('');`
`57`	`57`	`}`