MediaTrait::getRatio() - Code Metrics - Inspection of "Simplify Static" - PiedWeb/CMS - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 97dd58...4109cd )

by Dev
created 2020-12-13 10:31 UTC
MediaTrait::getRatio() A

↳ Parent: MediaTrait
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0
<?php

namespace PiedWeb\CMSBundle\Entity;

use Cocur\Slugify\Slugify;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;
use InvertColor\Color;
use Symfony\Component\HttpFoundation\File\File;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
use Symfony\Component\Yaml\Yaml;
use Vich\UploaderBundle\Mapping\Annotation as Vich;

trait MediaTrait
{
    use TimestampableTrait;

    /**
     * @ORM\Column(type="string", length=50)
     */
    protected $mimeType;

    /**
     * @ORM\Column(type="string", length=255)
     */
    protected $relativeDir;

    /**
     * @ORM\Column(type="integer")
     */
    protected $size;

    /**
     * @ORM\Column(type="integer", nullable=true)
     */
    protected $height;

    /**
     * @ORM\Column(type="integer", nullable=true)
     */
    protected $width;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    protected $mainColor;

    /**
     * @ORM\Column(type="string", length=255)
     */
    protected $media;

    /**
     * NOTE : this is used only for media renaming.
     *
     * @var string
     */
    protected $mediaBeforeUpdate;

    /**
     * NOTE: This is not a mapped field of entity metadata, just a simple property.
     *
     * @Vich\UploadableField(
     *     mapping="media_media",
     *     fileNameProperty="slug",
     *     mimeType="mimeType",
     *     size="size",
     *     dimensions="dimensions"
     * )
     *
     * @var File
     */
    protected $mediaFile;

    /**
     * @ORM\Column(type="string", length=100, unique=true)
     */
    protected $name;

    /**
     * @ORM\Column(type="text", nullable=true)
     */
    protected $names;

    protected $slug;

    /**
     * @ORM\OneToMany(
     *     targetEntity="PiedWeb\CMSBundle\Entity\PageHasMediaInterface",
     *     mappedBy="media",
     *     cascade={"all"},
     *     orphanRemoval=true
     * )
     */
    protected $pageHasMedias;

    /**
     * @ORM\OneToMany(
     *      targetEntity="PiedWeb\CMSBundle\Entity\PageInterface",
     *      mappedBy="mainImage"
     * )
     */
    protected $mainImagePages;

    public function __toString()
    {
        return $this->name.' ';
    }

    protected function getExtension($string)
    {
        return preg_replace('/.*(\\.[^.\\s]{3,4})$/', '$1', $string);
    }

    protected function slugifyPreservingExtension($string)
    {
        $extension = $this->getExtension($string);
        $stringSlugify = (new Slugify())->slugify($this->removeExtension($string));

        return $stringSlugify.$extension;
    }

    public function getSlugForce()
    {
        return $this->slug;
    }

    /**
     * Used by MediaAdmin.
     */
    public function setSlugForce($slug)
    {
        if (!$slug) {
            return $this;
        }

        $this->slug = (new Slugify(['regexp' => '/([^A-Za-z0-9\.]|-)+/']))->slugify($slug);

        if ($this->media) {
            $this->setMedia($this->slug.$this->getExtension($this->media));
        }

        return $this;
    }

    /**
     * Used by VichUploader.
     */
    public function setSlug($slug)
    {
        if (!$slug) {
            return $this;
        }

        $slugSlugify = $this->slugifyPreservingExtension($slug);

        if ($this->getExtension($this->media) != $this->getExtension($slugSlugify)) { // 1;
            // TODO manage problem URL move... quick validation impossible before file upload, and impossible after from
            // here

            //$this->media ? $this->removeExtension($slugSlugify).$this->getExtension($this->media) :
            $this->setMedia($slugSlugify);
        }

        return $this;
    }

    /**
     * @Assert\Callback
     */
    public function validate(ExecutionContextInterface $context, $payload)
    public function validate(ExecutionContextInterface $context, /** @scrutinizer ignore-unused */ $payload)
    {
        if ($this->getMimeType() && $this->mediaFile && $this->mediaFile->getMimeType() != $this->getMimeType()) {
            $context
                ->buildViolation('Attention ! Vous essayez de remplacer un fichier d\'un type ('
                    .$this->getMimeType().') par un fichier d\'une autre type ('.$this->mediaFile->getMimeType().')')
                ->atPath('fileName')
                ->addViolation()
            ;
        }
    }

    protected function removeExtension($string)
    {
        return preg_replace('/\\.[^.\\s]{3,4}$/', '', $string);
    }

    public function getSlug(): string
    {
        if ($this->slug) {
            return $this->slug;
        }

        if ($this->media) {
            return $this->slug = $this->removeExtension($this->media);
        }

        $this->slug = (new Slugify())->slugify($this->getName()); //Urlizer::urlize($this->getName());

        return $this->slug;
    }

    public function setMediaFile(?File $media = null): void
    {
        $this->mediaFile = $media;

        if (null !== $media) {
            $this->updatedAt = new \DateTimeImmutable();
        }
    }

    public function getMediaFile(): ?File
    {
        return $this->mediaFile;
    }

    public function getMedia(): ?string
    {
        return $this->media;
    }

    public function setMedia($media): self
    {
        if (!$media) {
            return $this;
        }

        if (null !== $this->media) {
            $this->setMediaBeforeUpdate($this->media);
            //$this->media = $this->removeExtension($media).$this->getExtension($this->media);
        } //else

        $this->media = $media;

        return $this;
    }

    public function getName($getLocalized = null, $onlyLocalized = false): ?string
    {
        $names = $this->getNames(true);

        return $getLocalized ?
            (isset($names[$getLocalized]) ? $names[$getLocalized] : ($onlyLocalized ? null : $this->name))
            : $this->name;
    }

    public function getNames($yaml = false)
    {
        return true === $yaml && null !== $this->names ? Yaml::parse($this->names) : $this->names;
    }

    public function setNames(?string $names): self
    {
        $this->name = $names;

        return $this;
    }

    public function getNameByLocale($locale)
    {
        $names = $this->getNames(true);

        return $names[$locale] ?? $this->getName();
    }

    public function setName(?string $name): self
    {
        $this->name = $name;

        return $this;
    }

    public function getRelativeDir(): ?string
    {
        return rtrim($this->relativeDir, '/');
    }

    public function setRelativeDir($relativeDir): self
    {
        $this->relativeDir = rtrim($relativeDir, '/');

        return $this;
    }

    public function getMimeType(): ?string
    {
        return $this->mimeType;
    }

    protected function getPreviousMimeType()
    {
        return $this->previousMimeType ?? null;
    }

    public function setMimeType($mimeType): self
    {
        $this->mimeType = $mimeType;

        return $this;
    }

    public function getSize()
    {
        return $this->size;
    }

    public function setSize($size): self
    {
        $this->size = $size;

        return $this;
    }

    public function setDimensions($dimensions): self
    {
        if (isset($dimensions[0])) {
            $this->width = (int) $dimensions[0];
        }

        if (isset($dimensions[1])) {
            $this->height = (int) $dimensions[1];
        }

        return $this;
    }

    public function getDimensions(): array
    {
        return [$this->width, $this->height];
    }

    public function getRatio(): float
    {
        return $this->height / $this->width;
    }

    public function getWidth()
    {
        return $this->width;
    }

    public function getHeight()
    {
        return $this->height;
    }

    public function getMainColor(): ?string
    {
        return $this->mainColor;
    }

    public function getMainColorOpposite()
    {
        if (null === $this->getMainColor()) {
            return;
        }

        return Color::fromHex($this->getMainColor())->invert(true);
    }

    public function setMainColor(?string $mainColor): self
    {
        $this->mainColor = $mainColor;

        return $this;
    }

    public function setPageHasMedias($pageHasMedias)
    {
        $this->pageHasMedias = new ArrayCollection();
        foreach ($pageHasMedias as $pageHasMedia) {
            $this->addPageHasMedia($pageHasMedia);
        }
    }

    public function getPageHasMedias()
    {
        return $this->pageHasMedias;
    }

    public function addPageHasMedia(PageHasMedia $pageHasMedia)
    {
        $pageHasMedia->setMedia($this);
        $this->pageHasMedias[] = $pageHasMedia;
    }

    public function removePageHasMedia(PageHasMedia $pageHasMedia)
    {
        $this->pageHasMedias->removeElement($pageHasMedia);
    }

    public function getMainImagePages()
    {
        return $this->mainImagePages;
    }

    /**
     * @ORM\PreRemove
     */
    public function removeMainImageFromPages()
    {
        foreach ($this->mainImagePages as $page) {
            $page->setMainImage(null);
        }
    }

    public function getPath(): ?string
    {
        return $this->getFullPath();
    }

    public function getFullPath(): ?string
    {
        return null !== $this->media
            ? '/'.$this->getRelativeDir().($this->getMedia() ? '/'.$this->getMedia() : '')
            : null;
    }

    public function getFullPathWebP(): ?string
    {
        return null !== $this->media
            ? '/'.$this->getRelativeDir().($this->getSlug() ? '/'.$this->getSlug().'.webp' : '')
            : null;
    }

    /**
     * Get nOTE : this is used only for media renaming.
     *
     * @return string
     */
    public function getMediaBeforeUpdate()
    {
        return $this->mediaBeforeUpdate;
    }

    /**
     * Set nOTE : this is used only for media renaming.
     *
     * @param string $mediaBeforeUpdate NOTE : this is used only for media renaming
     *
     * @return self
     */
    public function setMediaBeforeUpdate(string $mediaBeforeUpdate)
    {
        $this->mediaBeforeUpdate = $mediaBeforeUpdate;

        return $this;
    }
}

PiedWeb / CMS

Push — master ( 97dd58...4109cd )

MediaTrait::getRatio() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
