MediaMonks\SonataMediaBundle\Generator\ImageGenerator

Complexity

Total Complexity

22

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

95.31%

Importance

Changes	2
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	1
A	generate()	0	15	3
B	generateImage()	0	24	5
A	getImageData()	0	12	3
A	doGenerateImage()	0	8	1
A	getTemporaryFile()	0	15	3
A	getServer()	0	4	1
A	getFilenameGenerator()	0	4	1
A	getDefaultImageParameters()	0	4	1
A	getTmpPath()	0	4	1
A	getTmpPrefix()	0	4	1
A	getFallbackImage()	0	4	1

<?php

namespace MediaMonks\SonataMediaBundle\Generator;

use League\Glide\Filesystem\FilesystemException;
use League\Glide\Server;
use MediaMonks\SonataMediaBundle\ErrorHandlerTrait;
use MediaMonks\SonataMediaBundle\ParameterBag\ImageParameterBag;
use MediaMonks\SonataMediaBundle\Model\MediaInterface;

class ImageGenerator
{
    use ErrorHandlerTrait;

    /**
     * @var Server
     */
    private $server;

    /**
     * @var FilenameGeneratorInterface
     */
    private $filenameGenerator;

    /**
     * @var array
     */
    private $defaultImageParameters;

    /**
     * @var string
     */
    private $tmpPath;

    /**
     * @var string
     */
    private $tmpPrefix;

    /**
     * @var string
     */
    private $fallbackImage;

    /**
     * @param Server $server
     * @param FilenameGeneratorInterface $filenameGenerator
     * @param array $defaultImageParameters
     * @param null $fallbackImage
     * @param null $tmpPath
     * @param null $tmpPrefix
     */
    public function __construct(
        Server $server,
        FilenameGeneratorInterface $filenameGenerator,
        $defaultImageParameters = [],
        $fallbackImage = null,
        $tmpPath = null,
        $tmpPrefix = null
    ) {
        $this->server = $server;
        $this->filenameGenerator = $filenameGenerator;
        $this->defaultImageParameters = $defaultImageParameters;
        $this->fallbackImage = $fallbackImage;
        $this->tmpPath = $tmpPath;
        $this->tmpPrefix = $tmpPrefix;
    }

    /**
     * @param MediaInterface $media
     * @param ImageParameterBag $parameterBag
     * @return mixed
     */
    public function generate(MediaInterface $media, ImageParameterBag $parameterBag)
    {
        $parameterBag->setDefaults($this->defaultImageParameters);
        if (!$parameterBag->hasExtra('fit')) {
            $parameterBag->addExtra('fit', 'crop-'.$media->getFocalPoint());
        }

        $filename = $this->filenameGenerator->generate($media, $parameterBag);

        if (!$this->server->getCache()->has($filename)) {
            $this->generateImage($media, $parameterBag, $filename);
        }

        return $filename;
    }

    /**
     * @param MediaInterface $media
     * @param ImageParameterBag $parameterBag
     * @param $filename
     * @throws FilesystemException
     * @throws \Exception
     */
    protected function generateImage(MediaInterface $media, ImageParameterBag $parameterBag, $filename)
    {
        $tmp = $this->getTemporaryFile();
        $imageData = $this->getImageData($media);

        $this->disableErrorHandler();
        if (file_put_contents($tmp, $imageData) === false) {
            $this->restoreErrorHandler();
            throw new FilesystemException('Unable to write temporary file');
        }
        $this->restoreErrorHandler();

        try {
            $this->server->getCache()->put($filename, $this->doGenerateImage($media, $tmp, $parameterBag));
        } catch (\Exception $e) {
            throw new FilesystemException('Could not generate image', 0, $e);
        } finally {
            if (file_exists($tmp)) {
                if (!@unlink($tmp)) {
                    throw new FilesystemException('Unable to clean up temporary file');
                }
            }
        }
    }

    /**
     * @param MediaInterface $media
     * @return string
     * @throws FilesystemException
     */
    protected function getImageData(MediaInterface $media)
    {
        if ($this->server->getSource()->has($media->getImage())) {
            return $this->server->getSource()->read($media->getImage());
        }

        if (!is_null($this->fallbackImage)) {
            return file_get_contents($this->fallbackImage);
        }

        throw new FilesystemException('File not found');
    }

    /**
     * @param MediaInterface $media
     * @param string $tmp
     * @param ImageParameterBag $parameterBag
     * @return string
     */
    protected function doGenerateImage(MediaInterface $media, $tmp, ImageParameterBag $parameterBag)

The parameter $media is not used and could be removed.

    {
        $parameters = $parameterBag->getExtra();
        $parameters['w'] = $parameterBag->getWidth();
        $parameters['h'] = $parameterBag->getHeight();

        return $this->server->getApi()->run($tmp, $parameters);
    }

    /**
     * @return string
     */
    protected function getTemporaryFile()
    {
        if (empty($this->tmpPath)) {
            $this->tmpPath = sys_get_temp_dir();
        }
        if (empty($this->tmpPrefix)) {
            $this->tmpPrefix = 'media';
        }

        $this->disableErrorHandler();
        $tempFile = tempnam($this->tmpPath, $this->tmpPrefix);
        $this->restoreErrorHandler();

        return $tempFile;
    }

    /**
     * @return Server
     */
    public function getServer()
    {
        return $this->server;
    }

    /**
     * @return FilenameGeneratorInterface
     */
    public function getFilenameGenerator()
    {
        return $this->filenameGenerator;
    }

    /**
     * @return array
     */
    public function getDefaultImageParameters()
    {
        return $this->defaultImageParameters;
    }

    /**
     * @return string
     */
    public function getTmpPath()
    {
        return $this->tmpPath;
    }

    /**
     * @return string
     */
    public function getTmpPrefix()
    {
        return $this->tmpPrefix;
    }

    /**
     * @return string
     */
    public function getFallbackImage()
    {
        return $this->fallbackImage;
    }
}