Separate className validator and namespace validator.

Author: SerkanYildiz

src/Generator.php

@@ -141,6 +141,7 @@ public function createClassNameDetails(string $name, string $namespacePrefix, st
             $className = rtrim($fullNamespacePrefix, '\\').'\\'.Str::asClassName($name, $suffix);
         }
 
+        Validator::validateNamespace($className);
         Validator::validateClassName($className, $validationErrorMessage);
 
         // if this is a custom class, we may be completely different than the namespace prefix

src/Str.php

@@ -210,14 +210,12 @@ public static function isValidPhpClassName(string $className): bool
             'list', 'namespace', 'new', 'or', 'print', 'private',
             'protected', 'public', 'require', 'require_once', 'return',
             'static', 'switch', 'throw', 'trait', 'try', 'unset',
-            'use', 'var', 'while', 'xor', '__CLASS__', '__DIR__', '__FILE__',
-            '__FUNCTION__', '__LINE__', '__METHOD__', '__NAMESPACE__', '__TRAIT__',
+            'use', 'var', 'while', 'xor',
             'int', 'float', 'bool', 'string', 'true', 'false', 'null', 'void',
             'iterable', 'object',
         ];
 
-        return !\in_array(strtolower($className), $reservedKeywords, true) &&
-            preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $className);
+        return !\in_array(strtolower(self::getShortClassName($className)), $reservedKeywords, true);
     }
 
     public static function areClassesAlphabetical(string $class1, string $class2)
@@ -233,4 +231,22 @@ public static function asHumanWords(string $variableName): string
     {
         return implode(' ', preg_split('/(?=[A-Z])/', $variableName));
     }
+
+    public static function isValidPhpNamespace(string $className): bool
+    {
+        $predefinedConstants = ['__CLASS__', '__DIR__', '__FILE__', '__FUNCTION__',
+            '__LINE__', '__METHOD__', '__NAMESPACE__', '__TRAIT__',
+        ];
+
+        $namespace = self::getNamespace($className);
+        $pieces = explode('\\', $namespace);
+
+        foreach ($pieces as $piece) {
+            if (\in_array(strtoupper($piece), $predefinedConstants, true)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }

src/Validator.php

@@ -29,13 +29,17 @@ public static function validateClassName(string $className, string $errorMessage
         $pieces = explode('\\', ltrim($className, '\\'));
 
         foreach ($pieces as $piece) {
-            if (!Str::isValidPhpClassName($piece)) {
+            if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $piece)) {
                 $errorMessage = $errorMessage ?: sprintf('"%s" is not valid as a PHP class name (it must start with a letter or underscore, followed by any number of letters, numbers, or underscores)', $className);
 
                 throw new RuntimeCommandException($errorMessage);
             }
         }
 
+        if (!Str::isValidPhpClassName($className)) {
+            throw new RuntimeCommandException(sprintf('"%s" is a reserved keyword and thus cannot be used as class name in PHP.', $className));
+        }
+
         // return original class name
         return $className;
     }
@@ -207,4 +211,13 @@ public static function classIsUserInterface($userClassName): string
 
         return $userClassName;
     }
+
+    public static function validateNamespace(string $className): string
+    {
+        if (!Str::isValidPhpNamespace($className)) {
+            throw new RuntimeCommandException(sprintf('"%s" is a predefined constant and thus cannot be used as part of a namespace.', $className));
+        }
+
+        return $className;
+    }
 }

tests/StrTest.php

@@ -37,6 +37,12 @@ public function testAsTwigVariable($value, $expectedResult)
         $this->assertSame($expectedResult, Str::asTwigVariable($value));
     }
 
+    /** @dataProvider provideIsValidPhpClassName */
+    public function testIsValidPhpClassName($expected, $className)
+    {
+        $this->assertSame($expected, Str::isValidPhpClassName($className));
+    }
+
     public function provideHasSuffix()
     {
         yield ['', '', true];
@@ -175,4 +181,12 @@ public function getShortClassNameCaseTests()
         yield ['App\\Entity\\Foo', 'Foo'];
         yield ['Foo', 'Foo'];
     }
+
+    public function provideIsValidPhpClassName()
+    {
+        yield [false, 'App\\Entity\\Class'];
+        yield [true, 'App\\Class\\Service'];
+        yield [false, 'App\\Entity\\Object'];
+        yield [true, 'App\\Foo\\Bar'];
+    }
 }

tests/ValidatorTest.php

@@ -59,7 +59,20 @@ public function testValidateClassName()
     public function testInvalidClassName()
     {
         $this->expectException(RuntimeCommandException::class);
-        $this->expectExceptionMessage('"class" is not valid as a PHP class name (it must start with a letter or underscore, followed by any number of letters, numbers, or underscores)');
+        $this->expectExceptionMessage('"class" is a reserved keyword and thus cannot be used as class name in PHP.');
         Validator::validateClassName('class');
     }
+
+    public function testInvalidNamespace()
+    {
+        $this->expectException(RuntimeCommandException::class);
+        $this->expectExceptionMessage('"App\__CLASS__\FooBar" is a predefined constant and thus cannot be used as part of a namespace.');
+        Validator::validateNamespace('App\__CLASS__\FooBar');
+    }
+
+    public function testValidNamespaceInvalidClassName()
+    {
+        $this->assertSame('\App\object\Foo', Validator::validateClassName('\App\object\Foo'));
+        $this->assertSame('\App\class\Foo', Validator::validateClassName('\App\class\Foo'));
+    }
 }