GNAHotelSolutions\ImageCacher\Cacher

Complexity

Total Complexity

34

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	resize()	0	4	1
A	crop()	0	4	1
B	manipulate()	0	41	6
A	isSmallerThanRequested()	0	4	3
A	isAlreadyCached()	0	5	2
A	cachedImageIsTheSame()	0	7	1
A	getCachedImageFullName()	0	8	2
A	getCachedImagePathName()	0	4	1
A	getCachedImageName()	0	4	1
A	getCacheImagePath()	0	4	1
A	isAlpha()	0	4	1
A	getImageResource()	0	16	4
A	getCutEdges()	0	14	2
A	saveImage()	0	18	4
A	createCacheDirectoryIfNotExists()	0	12	3

<?php

namespace GNAHotelSolutions\ImageCacher;

class Cacher
{
    /** @var string  */
    protected $cachePath;
    
    /** @var string  */
    protected $cacheRootPath;

    /** @var string */
    protected $imagesRootPath;

    public function __construct(string $cachePath = 'cache/images', string $cacheRootPath = '', string $imagesRootPath = '')
    {
        $this->cachePath = $cachePath;
        $this->cacheRootPath = rtrim($cacheRootPath, '/');
        $this->imagesRootPath = rtrim($imagesRootPath, '/');
    }

    public function resize($image, $width = null, $height = null): Image
    {
        return $this->manipulate($image, $width, $height, false);
    }

    public function crop($image, $width = null, $height = null): Image
    {
        return $this->manipulate($image, $width, $height, true);
    }

    protected function manipulate($image, $width = null, $height = null, bool $cropImage = false): Image
    {
        if (is_string($image)) {
            $image = new Image($image, $this->imagesRootPath);
        }

        if ($this->isSmallerThanRequested($image, $width, $height)) {
            return $image;
        }

        $resizedWidth = $width ?? round($height * $image->getAspectRatio());
        $resizedHeight = $height ?? round($width / $image->getAspectRatio());

        if ($this->isAlreadyCached($image, $resizedWidth, $resizedHeight)) {
            return new Image($this->getCachedImagePathName($image, $resizedWidth, $resizedHeight), $this->cacheRootPath);
        }

        $layout = imagecreatetruecolor($resizedWidth, $resizedHeight);

        if ($this->isAlpha($image)) {
            imagealphablending($layout, false);
            imagesavealpha($layout, true);
        }

        if ($cropImage) {
            [$cutWidth, $cutHeight] = $this->getCutEdges($image, $resizedWidth, $resizedHeight);

The variable $cutWidth seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

The variable $cutHeight seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

            $cutX = ($image->getWidth() - $cutWidth) / 2;

The variable $cutWidth seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

            $cutY = ($image->getHeight() - $cutHeight) / 2;

The variable $cutHeight seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

        } else {
            $cutWidth = $image->getWidth();
            $cutHeight = $image->getHeight();
            $cutX = 0;
            $cutY = 0;
        }

        imagecopyresampled($layout, $this->getImageResource($image), 0, 0, $cutX, $cutY, $resizedWidth, $resizedHeight, $cutWidth, $cutHeight);

The variable $cutWidth does not seem to be defined for all execution paths leading up to this point.

The variable $cutHeight does not seem to be defined for all execution paths leading up to this point.

        $this->saveImage($image, $layout, $resizedWidth, $resizedHeight);

        return new Image($this->getCachedImagePathName($image, $resizedWidth, $resizedHeight), $this->cacheRootPath);
    }

    protected function isSmallerThanRequested(Image $image, $width, $height): bool
    {
        return (! $width && ! $height) || $image->isSmallerThan($width, $height);
    }

    protected function isAlreadyCached(Image $image, $width, $height): bool
    {
        return file_exists($this->getCachedImageFullName($image, $width, $height)) 
            && $this->cachedImageIsTheSame($image, $width, $height);
    }

    protected function cachedImageIsTheSame(Image $image, $width, $height): bool
    {
        $cachedImageUpdatedAt = filemtime($this->getCachedImageFullName($image, $width, $height));
        $imageUpdatedAt = filemtime($image->getOriginalFullPath());
        
        return $cachedImageUpdatedAt >= $imageUpdatedAt;
    }

    protected function getCachedImageFullName(Image $image, $width, $height): string
    {
        if ($this->cacheRootPath === '') {
            return $this->getCachedImagePathName($image, $width, $height);
        }

        return "{$this->cacheRootPath}/{$this->getCachedImagePathName($image, $width, $height)}";
    }

    protected function getCachedImagePathName(Image $image, $width, $height): string
    {
        return "{$this->cachePath}/{$this->getCachedImageName($image, $width, $height)}";
    }

    protected function getCachedImageName(Image $image, $width, $height): string
    {
        return "{$this->getCacheImagePath($image->getPath(), $width, $height)}/{$image->getName()}";
    }

    protected function getCacheImagePath(string $path, $width, $height): string
    {
        return ltrim("{$path}/{$width}x{$height}", '/');
    }

    protected function isAlpha(Image $image): bool
    {
        return in_array($image->getType(), ['gif', 'png']);
    }

    protected function getImageResource(Image $image)
    {
        if ($image->getType() === 'jpeg') {
            return imagecreatefromjpeg($image->getOriginalFullPath());
        }

        if ($image->getType() === 'png') {
            return imagecreatefrompng($image->getOriginalFullPath());
        }

        if ($image->getType() === 'gif') {
            return imagecreatefromgif($image->getOriginalFullPath());
        }

        throw new \Exception("Image type [{$image->getType()}] not supported.");
    }

    protected function getCutEdges(Image $image, int $width, int $height): array
    {
        $aspectRatio = $width / $height;

        $cutEdgeWidth = round($image->getHeight() * $aspectRatio);

        if ($cutEdgeWidth > $image->getWidth()) {
            $cutEdgeWidth = $image->getWidth();
        }

        $cutEdgeHeight = round($cutEdgeWidth / $aspectRatio);

        return [$cutEdgeWidth, $cutEdgeHeight];
    }

    protected function saveImage(Image $image, $layout, $width, $height): string
    {
        $this->createCacheDirectoryIfNotExists($image, $width, $height);

        if ($image->getType() === 'jpeg') {
            return imagejpeg($layout, $this->getCachedImageFullName($image, $width, $height));
        }

        if ($image->getType() === 'png') {
            return imagepng($layout, $this->getCachedImageFullName($image, $width, $height));
        }

        if ($image->getType() === 'gif') {
            return imagegif($layout, $this->getCachedImageFullName($image, $width, $height));
        }

        throw new \Exception("Image type [{$image->getType()}] not supported.");
    }

    protected function createCacheDirectoryIfNotExists(Image $image, $width, $height): void
    {
        $cachePath = "{$this->cacheRootPath}/{$this->cachePath}/{$this->getCacheImagePath($image->getPath(), $width, $height)}";

        if (substr($cachePath, 0, 1) !== '') {
            $cachePath = "/{$cachePath}";
        }

        if (! file_exists($cachePath)) {
            mkdir($cachePath, 0777, true);
        }
    }
}