Import and modify Validator class from MakerBundle (#4)

* Import and modify Validator class from MakerBundle

* Trim $ from field name

* Trim spaces from field name

Author: GromNaN

src/Maker/MakeDocument.php

@@ -7,6 +7,7 @@
 use Doctrine\Bundle\MongoDBBundle\DoctrineMongoDBBundle;
 use Doctrine\Bundle\MongoDBMakerBundle\MongoDB\DocumentClassGenerator;
 use Doctrine\Bundle\MongoDBMakerBundle\MongoDB\MongoDBHelper;
+use Doctrine\Bundle\MongoDBMakerBundle\MongoDB\Validator;
 use Doctrine\ODM\MongoDB\Types\Type;
 use InvalidArgumentException;
 use ReflectionClass;
@@ -23,7 +24,6 @@
 use Symfony\Bundle\MakerBundle\Util\ClassDetails;
 use Symfony\Bundle\MakerBundle\Util\ClassSource\Model\ClassProperty;
 use Symfony\Bundle\MakerBundle\Util\ClassSourceManipulator;
-use Symfony\Bundle\MakerBundle\Validator;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
@@ -195,7 +195,7 @@ private function askForNextField(ConsoleStyle $io, array $fields, string $docume
             $questionText = 'Add another property? Enter the property name (or press <return> to stop adding fields)';
         }
 
-        $fieldName = $io->ask($questionText, null, function ($name) use ($fields) {
+        $fieldName = $io->ask($questionText, null, static function ($name) use ($fields) {
             // allow it to be empty
             if (! $name) {
                 return $name;
@@ -205,7 +205,7 @@ private function askForNextField(ConsoleStyle $io, array $fields, string $docume
                 throw new InvalidArgumentException(sprintf('The "%s" property already exists.', $name));
             }
 
-            return Validator::validateDoctrineFieldName($name, $this->mongoDBHelper->getRegistry());
+            return Validator::validateFieldName($name);
         });
 
         if (! $fieldName) {

src/MongoDB/Validator.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Bundle\MongoDBMakerBundle\MongoDB;
+
+use Symfony\Bundle\MakerBundle\Exception\RuntimeCommandException;
+
+use function preg_match;
+use function sprintf;
+use function str_contains;
+use function trim;
+
+final class Validator
+{
+    /**
+     * Validates that a value is not blank.
+     */
+    public static function notBlank(string|null $value = null): string
+    {
+        if ($value === null || $value === '') {
+            throw new RuntimeCommandException('This value cannot be blank.');
+        }
+
+        return $value;
+    }
+
+    /**
+     * Validates a MongoDB document field name.
+     *
+     * MongoDB field names:
+     * - Cannot be empty
+     * - $ prefix is trimmed (reserved for operators)
+     * - Cannot contain null character
+     * - Cannot contain dots (used for nested documents)
+     * - Should be valid PHP property names
+     */
+    public static function validateFieldName(string $name): string
+    {
+        // Trim $ prefix (reserved for MongoDB operators) and spaces
+        $name = trim($name, '$ ');
+
+        if ($name === '') {
+            throw new RuntimeCommandException('Field name cannot be empty.');
+        }
+
+        // MongoDB-specific restrictions
+        if (str_contains($name, '.')) {
+            throw new RuntimeCommandException(sprintf('Field name "%s" cannot contain a dot (used for nested documents).', $name));
+        }
+
+        if (str_contains($name, "\0")) {
+            throw new RuntimeCommandException(sprintf('Field name "%s" cannot contain null characters.', $name));
+        }
+
+        // Check for valid PHP property name (starts with letter or underscore, followed by letters, numbers, or underscores)
+        if (! preg_match('/^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$/', $name)) {
+            throw new RuntimeCommandException(sprintf('"%s" is not a valid PHP property name.', $name));
+        }
+
+        return $name;
+    }
+}

tests/MongoDB/ValidatorTest.php

@@ -0,0 +1,120 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Bundle\MongoDBMakerBundle\Tests\MongoDB;
+
+use Doctrine\Bundle\MongoDBMakerBundle\MongoDB\Validator;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\MakerBundle\Exception\RuntimeCommandException;
+
+class ValidatorTest extends TestCase
+{
+    #[DataProvider('validNotBlankProvider')]
+    public function testNotBlankWithValidValue(string $value): void
+    {
+        $result = Validator::notBlank($value);
+
+        $this->assertSame($value, $result);
+    }
+
+    /** @return Generator<string, array{0: string}> */
+    public static function validNotBlankProvider(): Generator
+    {
+        yield 'simple string' => ['valid'];
+        yield 'string with spaces' => ['hello world'];
+        yield 'single character' => ['a'];
+        yield 'whitespace only' => [' '];
+    }
+
+    #[DataProvider('invalidNotBlankProvider')]
+    public function testNotBlankWithInvalidValue(string|null $value): void
+    {
+        $this->expectException(RuntimeCommandException::class);
+        $this->expectExceptionMessage('This value cannot be blank.');
+
+        Validator::notBlank($value);
+    }
+
+    /** @return Generator<string, array{0: string|null}> */
+    public static function invalidNotBlankProvider(): Generator
+    {
+        yield 'null' => [null];
+        yield 'empty string' => [''];
+    }
+
+    #[DataProvider('validFieldNameProvider')]
+    public function testValidateFieldNameWithValidNames(string $fieldName, string $expected): void
+    {
+        $result = Validator::validateFieldName($fieldName);
+
+        $this->assertSame($expected, $result);
+    }
+
+    /** @return Generator<string, array{0: string, 1: string}> */
+    public static function validFieldNameProvider(): Generator
+    {
+        yield 'simple name' => ['name', 'name'];
+        yield 'camelCase' => ['firstName', 'firstName'];
+        yield 'with underscore prefix' => ['_private', '_private'];
+        yield 'with numbers' => ['field1', 'field1'];
+        yield 'snake_case' => ['user_name', 'user_name'];
+        yield 'uppercase' => ['CONSTANT', 'CONSTANT'];
+        yield 'mixed case with numbers' => ['myField2Test', 'myField2Test'];
+        yield 'dollar prefix is trimmed' => ['$field', 'field'];
+        yield 'multiple dollar prefix is trimmed' => ['$$field', 'field'];
+    }
+
+    #[DataProvider('emptyFieldNameProvider')]
+    public function testValidateFieldNameWithEmptyValue(string $fieldName): void
+    {
+        $this->expectException(RuntimeCommandException::class);
+        $this->expectExceptionMessage('Field name cannot be empty.');
+
+        Validator::validateFieldName($fieldName);
+    }
+
+    /** @return Generator<string, array{0: string|null}> */
+    public static function emptyFieldNameProvider(): Generator
+    {
+        yield 'empty string' => [''];
+        yield 'dollar only' => ['$'];
+        yield 'multiple dollars only' => ['$$$'];
+    }
+
+    #[DataProvider('invalidPhpPropertyNameProvider')]
+    public function testValidateFieldNameWithInvalidPhpPropertyNames(string $fieldName): void
+    {
+        $this->expectException(RuntimeCommandException::class);
+        $this->expectExceptionMessageMatches('/is not a valid PHP property name/');
+
+        Validator::validateFieldName($fieldName);
+    }
+
+    /** @return Generator<string, array{0: string}> */
+    public static function invalidPhpPropertyNameProvider(): Generator
+    {
+        yield 'starts with number' => ['1field'];
+        yield 'contains dash' => ['field-name'];
+        yield 'contains space' => ['field name'];
+        yield 'contains special char' => ['field@name'];
+    }
+
+    #[DataProvider('mongoDbRestrictedFieldNameProvider')]
+    public function testValidateFieldNameWithMongoDbRestrictions(string $fieldName, string $expectedMessagePattern): void
+    {
+        $this->expectException(RuntimeCommandException::class);
+        $this->expectExceptionMessageMatches($expectedMessagePattern);
+
+        Validator::validateFieldName($fieldName);
+    }
+
+    /** @return Generator<string, array{0: string, 1: string}> */
+    public static function mongoDbRestrictedFieldNameProvider(): Generator
+    {
+        yield 'contains dot' => ['field.name', '/cannot contain a dot/'];
+        yield 'null character' => ["field\0name", '/cannot contain null characters/'];
+    }
+}