ByTIC\MediaLibrary\Validation\Validators\FileValidator

Complexity

Total Complexity

19

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Test Coverage

Coverage

25.58%

Importance

Changes	2
Bugs	1	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	contraintNeedsValidation()	0	9	3
A	validateMimeType()	0	18	6
A	determineMime()	0	5	2
A	doValidation()	0	3	1
B	validateOrientation()	0	23	7

<?php

namespace ByTIC\MediaLibrary\Validation\Validators;

use ByTIC\MediaLibrary\Validation\Constraints\FileConstraint;
use ByTIC\MediaLibrary\Validation\Constraints\ImageConstraint;
use Nip\Logger\Exception;
use Symfony\Component\HttpFoundation\File\UploadedFile;

/**
 * Class FileValidator.
 */
class FileValidator extends AbstractValidator
{
    public const KB_BYTES = 1000;
    public const MB_BYTES = 1000000;
    public const KIB_BYTES = 1024;
    public const MIB_BYTES = 1048576;

    private static $suffices = [

The private property $suffices is not used, and could be removed.

        1               => 'bytes',
        self::KB_BYTES  => 'kB',
        self::MB_BYTES  => 'MB',
        self::KIB_BYTES => 'KiB',
        self::MIB_BYTES => 'MiB',
    ];

    /**
     * @return bool
     */
    protected function contraintNeedsValidation(): bool
    {
        $constraint = $this->getConstraint();

        if (null === $constraint->mimeTypes && null === $constraint->maxSize) {
            return false;
        }

        return true;
    }

    /**
     * @throws Exception
     */
    protected function doValidation()
    {
        $this->validateMimeType();
    }

    /**
     * @return void
     */
    protected function validateMimeType()
    {
        $constraint = $this->getConstraint();

        if ($constraint->mimeTypes) {
            $mimeTypes = (array) $constraint->mimeTypes;
            $mime = $this->determineMime();

Are you sure the assignment to $mime is correct as $this->determineMime() targeting ByTIC\MediaLibrary\Validation\Validators\FileValidator::determineMime() seems to always return null.

            foreach ($mimeTypes as $mimeType) {
                if ($mimeType === $mime) {
                    return;
                }
                if ($discrete = strstr($mimeType, '/*', true)) {
                    if (strstr($mime, '/', true) === $discrete) {

$mime of type null is incompatible with the type string expected by parameter $haystack of strstr().

                        return;
                    }
                }
            }
            $this->addViolation($constraint, FileConstraint::INVALID_MIME_TYPE_ERROR, []);
        }
    }

    /**
     * @return string|null
     */
    protected function determineMime()
    {
        $file = $this->getValue();
        if ($file instanceof UploadedFile) {

$file is never a sub-type of Symfony\Component\HttpFoundation\File\UploadedFile.

            return $file->getClientMimeType();
        }
    }

    /**
     * @param $width
     * @param $height
     */
    protected function validateOrientation($width, $height)
    {
        $constraint = $this->getConstraint();

        if (!$constraint->allowSquare && $width == $height) {
            $this->addViolation(
                $constraint,
                ImageConstraint::SQUARE_NOT_ALLOWED_ERROR,
                ['width' => $width, 'height' => $height]
            );
        }
        if (!$constraint->allowLandscape && $width > $height) {
            $this->addViolation(
                $constraint,
                ImageConstraint::LANDSCAPE_NOT_ALLOWED_ERROR,
                ['width' => $width, 'height' => $height]
            );
        }
        if (!$constraint->allowPortrait && $width < $height) {
            $this->addViolation(
                $constraint,
                ImageConstraint::PORTRAIT_NOT_ALLOWED_ERROR,
                ['width' => $width, 'height' => $height]
            );
        }
    }
}