7.3

* Add the`filenameCharset` and`filenameCountUnit` options to the`File` constraint

* Deprecate defining custom constraints not supporting named arguments

* Deprecate passing an array of options to the constructors of the constraint classes, pass each option as a dedicated argument instead

* Add support for ratio checks for SVG files to the`Image` constraint

useSymfony\Component\Validator\Attribute\HasNamedArguments;

useSymfony\Component\Validator\Constraint;

useSymfony\Component\Validator\Exception\ConstraintDefinitionException;

useSymfony\Component\Validator\Exception\InvalidArgumentException;

publicconstINVALID_MIME_TYPE_ERROR ='744f00bc-4389-4c74-92de-9a43cde55534';

publicconstINVALID_EXTENSION_ERROR ='c8c7315c-6186-4719-8b71-5659e16bdcb7';

publicconstFILENAME_TOO_LONG ='e5706483-91a8-49d8-9a59-5e81a3c634a8';

publicconstFILENAME_INVALID_CHARACTERS ='04ee58e1-42b4-45c7-8423-8a4a145fedd9';

publicconstFILENAME_COUNT_BYTES ='bytes';

publicconstFILENAME_COUNT_CODEPOINTS ='codepoints';

publicconstFILENAME_COUNT_GRAPHEMES ='graphemes';

privateconstFILENAME_VALID_COUNT_UNITS = [

self::FILENAME_COUNT_BYTES,

self::FILENAME_COUNT_CODEPOINTS,

self::FILENAME_COUNT_GRAPHEMES,

];

protectedconstERROR_NAMES = [

self::NOT_FOUND_ERROR =>'NOT_FOUND_ERROR',

self::INVALID_MIME_TYPE_ERROR =>'INVALID_MIME_TYPE_ERROR',

self::INVALID_EXTENSION_ERROR =>'INVALID_EXTENSION_ERROR',

self::FILENAME_TOO_LONG =>'FILENAME_TOO_LONG',

self::FILENAME_INVALID_CHARACTERS =>'FILENAME_INVALID_CHARACTERS',

];

public ?bool$binaryFormat =null;

publicarray|string$mimeTypes = [];

public ?int$filenameMaxLength =null;

publicarray|string$extensions = [];

public ?string$filenameCharset =null;

publicstring$filenameCountUnit =self::FILENAME_COUNT_BYTES;

publicstring$notFoundMessage ='The file could not be found.';

publicstring$notReadableMessage ='The file is not readable.';

publicstring$maxSizeMessage ='The file is too large ({{ size }} {{ suffix }}). Allowed maximum size is {{ limit }} {{ suffix }}.';

publicstring$mimeTypesMessage ='The mime type of the file is invalid ({{ type }}). Allowed mime types are {{ types }}.';

publicstring$extensionsMessage ='The extension of the file is invalid ({{ extension }}). Allowed extensions are {{ extensions }}.';

publicstring$disallowEmptyMessage ='An empty file is not allowed.';

publicstring$filenameTooLongMessage ='The filename is too long. It should have {{ filename_max_length }} character or less.|The filename is too long. It should have {{ filename_max_length }} characters or less.';

publicstring$filenameCharsetMessage ='This filename does not match the expected charset.';

publicstring$uploadIniSizeErrorMessage ='The file is too large. Allowed maximum size is {{ limit }} {{ suffix }}.';

publicstring$uploadFormSizeErrorMessage ='The file is too large.';

?string$uploadErrorMessage =null,

?array$groups =null,

mixed$payload =null,

array|string|null$extensions =null,

?string$extensionsMessage =null,

?string$filenameCharset =null,

?string$filenameCountUnit =null,

?string$filenameCharsetMessage =null,

) {

if (\is_array($options)) {

trigger_deprecation('symfony/validator','7.3','Passing an array of options to configure the "%s" constraint is deprecated, use named arguments instead.',static::class);

$this->binaryFormat =$binaryFormat ??$this->binaryFormat;

$this->mimeTypes =$mimeTypes ??$this->mimeTypes;

$this->filenameMaxLength =$filenameMaxLength ??$this->filenameMaxLength;

$this->filenameCharset =$filenameCharset ??$this->filenameCharset;

$this->filenameCountUnit =$filenameCountUnit ??$this->filenameCountUnit;

$this->extensions =$extensions ??$this->extensions;

$this->notFoundMessage =$notFoundMessage ??$this->notFoundMessage;

$this->notReadableMessage =$notReadableMessage ??$this->notReadableMessage;

$this->extensionsMessage =$extensionsMessage ??$this->extensionsMessage;

$this->disallowEmptyMessage =$disallowEmptyMessage ??$this->disallowEmptyMessage;

$this->filenameTooLongMessage =$filenameTooLongMessage ??$this->filenameTooLongMessage;

$this->filenameCharsetMessage =$filenameCharsetMessage ??$this->filenameCharsetMessage;

$this->uploadIniSizeErrorMessage =$uploadIniSizeErrorMessage ??$this->uploadIniSizeErrorMessage;

$this->uploadFormSizeErrorMessage =$uploadFormSizeErrorMessage ??$this->uploadFormSizeErrorMessage;

$this->uploadPartialErrorMessage =$uploadPartialErrorMessage ??$this->uploadPartialErrorMessage;

if (null !==$this->maxSize) {

$this->normalizeBinaryFormat($this->maxSize);

}

if (!\in_array($this->filenameCountUnit,self::FILENAME_VALID_COUNT_UNITS,true)) {

thrownewInvalidArgumentException(\sprintf('The "filenameCountUnit" option must be one of the "%s::FILENAME_COUNT_*" constants ("%s" given).',__CLASS__,$this->filenameCountUnit));

}

}

publicfunction__set(string$option,mixed$value):void

return;

}

$sizeInBytes =filesize($path);

$basename =$valueinstanceof UploadedFile ?$value->getClientOriginalName() :basename($path);

$filenameCharset =$constraint->filenameCharset ?? (File::FILENAME_COUNT_BYTES !==$constraint->filenameCountUnit ?'UTF-8' :null);

if ($invalidFilenameCharset =null !==$filenameCharset) {

try {

$invalidFilenameCharset = !@mb_check_encoding($basename,$constraint->filenameCharset);

}catch (\ValueError$e) {

if (!str_starts_with($e->getMessage(),'mb_check_encoding(): Argument #2 ($encoding) must be a valid encoding')) {

throw$e;

}

}

}

$filenameLength =$invalidFilenameCharset ?0 :match ($constraint->filenameCountUnit) {

File::FILENAME_COUNT_BYTES =>\strlen($basename),

File::FILENAME_COUNT_CODEPOINTS =>mb_strlen($basename,$filenameCharset),

File::FILENAME_COUNT_GRAPHEMES =>grapheme_strlen($basename),

};

if ($invalidFilenameCharset ||false === ($filenameLength ??false)) {

$this->context->buildViolation($constraint->filenameCharsetMessage)

->setParameter('{{ name }}',$this->formatValue($basename))

->setParameter('{{ charset }}',$filenameCharset)

->setCode(File::FILENAME_INVALID_CHARACTERS)

->addViolation();

return;

}

if ($constraint->filenameMaxLength &&$constraint->filenameMaxLength <$filenameLength =\strlen($basename)) {

if ($constraint->filenameMaxLength &&$constraint->filenameMaxLength <$filenameLength) {

$this->context->buildViolation($constraint->filenameTooLongMessage)

->setParameter('{{ filename_max_length }}',$this->formatValue($constraint->filenameMaxLength))

->setCode(File::FILENAME_TOO_LONG)

return;

}

if (0 ===$sizeInBytes) {

if (!$sizeInBytes =filesize($path)) {

$this->context->buildViolation($constraint->disallowEmptyMessage)

->setParameter('{{ file }}',$this->formatValue($path))

->setParameter('{{ name }}',$this->formatValue($basename))

?string$corruptedMessage =null,

?array$groups =null,

mixed$payload =null,

?string$filenameCharset =null,

?string$filenameCountUnit =null,

?string$filenameCharsetMessage =null,

) {

parent::__construct(

$options,

$uploadExtensionErrorMessage,

$uploadErrorMessage,

$groups,

$payload,

$filenameCharset,

$filenameCountUnit,

$filenameCharsetMessage,

);

$this->minWidth =$minWidth ??$this->minWidth;

usePHPUnit\Framework\TestCase;

useSymfony\Component\Validator\Constraints\File;

useSymfony\Component\Validator\Exception\ConstraintDefinitionException;

useSymfony\Component\Validator\Exception\InvalidArgumentException;

useSymfony\Component\Validator\Mapping\ClassMetadata;

useSymfony\Component\Validator\Mapping\Loader\AttributeLoader;

$this->assertSame(1000,$file->maxSize);

}

publicfunctiontestFilenameMaxLength()

{

$file =newFile(filenameMaxLength:30);

$this->assertSame(30,$file->filenameMaxLength);

}

publicfunctiontestDefaultFilenameCountUnitIsUsed()

{

$file =newFile();

self::assertSame(File::FILENAME_COUNT_BYTES,$file->filenameCountUnit);

}

publicfunctiontestFilenameCharsetDefaultsToNull()

{

$file =newFile();

self::assertNull($file->filenameCharset);

}

publicfunctiontestInvalidFilenameCountUnitThrowsException()

{

self::expectException(InvalidArgumentException::class);

self::expectExceptionMessage(\sprintf('The "filenameCountUnit" option must be one of the "%s::FILENAME_COUNT_*" constants ("%s" given).', File::class,'nonExistentCountUnit'));

$file =newFile(filenameCountUnit:'nonExistentCountUnit');

}

self::assertSame(100000,$cConstraint->maxSize);

self::assertSame(['my_group'],$cConstraint->groups);

self::assertSame('some attached data',$cConstraint->payload);

self::assertSame(30,$cConstraint->filenameMaxLength);

self::assertSame('ISO-8859-15',$cConstraint->filenameCharset);

self::assertSame(File::FILENAME_COUNT_CODEPOINTS,$cConstraint->filenameCountUnit);

}

}

#[File(maxSize:100, notFoundMessage:'myMessage')]

private$b;

#[File(maxSize:'100K', groups: ['my_group'], payload:'some attached data')]

#[File(maxSize:'100K',filenameMaxLength:30, filenameCharset:'ISO-8859-15', filenameCountUnit: File::FILENAME_COUNT_CODEPOINTS,groups: ['my_group'], payload:'some attached data')]

private$c;

}

publicfunctiontestFilenameMaxLengthIsTooLong(File$constraintFile,string$messageViolation)

publicfunctiontestFilenameMaxLengthIsTooLong(File$constraintFile,string$filename,string$messageViolation)

{

file_put_contents($this->path,'1');

$file =newUploadedFile($this->path,'myFileWithATooLongOriginalFileName',null,null,true);

$file =newUploadedFile($this->path,$filename,null,null,true);

$this->validator->validate($file,$constraintFile);

$this->buildViolation($messageViolation)

publicstaticfunctionprovideFilenameMaxLengthIsTooLong():\Generator

{

yield'Simple case with only the parameter "filenameMaxLength"' => [

yield'Codepoints and UTF-8 : default' => [

newFile(filenameMaxLength:30),

'myFileWithATooLongOriginalFileName',

'The filename is too long. It should have {{ filename_max_length }} character or less.|The filename is too long. It should have {{ filename_max_length }} characters or less.',

];

yield'Case with the parameter "filenameMaxLength" and a custom error message' => [

newFile(filenameMaxLength:20, filenameTooLongMessage:'Your filename is too long. Please use at maximum {{ filename_max_length }} characters'),

'Your filename is too long. Please use at maximum {{ filename_max_length }} characters',

yield'Codepoints and UTF-8: custom error message' => [

newFile(filenameMaxLength:20, filenameTooLongMessage:'myMessage'),

'myFileWithATooLongOriginalFileName',

'myMessage',

];

yield'Graphemes' => [

newFile(filenameMaxLength:1, filenameCountUnit: File::FILENAME_COUNT_GRAPHEMES, filenameTooLongMessage:'myMessage'),

"A\u{0300}A\u{0300}",

'myMessage',

];

yield'Bytes' => [

newFile(filenameMaxLength:5, filenameCountUnit: File::FILENAME_COUNT_BYTES, filenameTooLongMessage:'myMessage'),

"A\u{0300}A\u{0300}",

'myMessage',

];

}

publicfunctiontestFilenameMaxLength()

publicfunctiontestValidCountUnitFilenameMaxLength(int$maxLength,string$countUnit)

{

file_put_contents($this->path,'1');

$file =newUploadedFile($this->path,'tinyOriginalFileName',null,null,true);

$this->validator->validate($file,newFile(filenameMaxLength:20));

$file =newUploadedFile($this->path,"A\u{0300}",null,null,true);

$this->validator->validate($file,newFile(filenameMaxLength:$maxLength, filenameCountUnit:$countUnit));

$this->assertNoViolation();

}

publicfunctiontestFilenameCharset(string$filename,string$charset,bool$isValid)

{

file_put_contents($this->path,'1');

$file =newUploadedFile($this->path,$filename,null,null,true);

$this->validator->validate($file,newFile(filenameCharset:$charset, filenameCharsetMessage:'myMessage'));

if ($isValid) {

$this->assertNoViolation();

}else {

$this->buildViolation('myMessage')

->setParameter('{{ name }}','"'.$filename.'"')

->setParameter('{{ charset }}',$charset)

->setCode(File::FILENAME_INVALID_CHARACTERS)

->assertRaised();

}

}

publicstaticfunctionprovideFilenameCountUnit():array

{

return [

'graphemes' => [1, File::FILENAME_COUNT_GRAPHEMES],

'codepoints' => [2, File::FILENAME_COUNT_CODEPOINTS],

'bytes' => [3, File::FILENAME_COUNT_BYTES],

];

}

publicstaticfunctionprovideFilenameCharset():array

{

return [

['é','utf8',true],

["\xE9",'CP1252',true],

["\xE9",'XXX',false],

["\xE9",'utf8',false],

];

}

abstractprotectedfunctiongetFile($filename);

}