Spatie\Image\GlideConversion

Complexity

Total Complexity

28

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	4	1
A	setTemporaryDirectory()	0	20	5
A	getTemporaryDirectory()	0	4	1
A	isValidTemporaryDirectoryLocation()	0	4	3
A	__construct()	0	4	1
A	useImageDriver()	0	6	1
A	performManipulations()	0	19	2
A	extractWatermarkPath()	0	10	2
A	createGlideServer()	0	14	2
A	save()	0	18	4
A	prepareManipulations()	0	12	3
A	convertToGlideParameter()	0	38	2
A	directoryIsEmpty()	0	6	1

<?php

namespace Spatie\Image;

use FilesystemIterator;
use League\Glide\Server;
use League\Glide\ServerFactory;
use Spatie\Image\Exceptions\CouldNotConvert;
use Spatie\Image\Exceptions\DefectiveConfiguration;

final class GlideConversion
{
    /** @var string */
    private $inputImage;

    /** @var string */
    private $imageDriver = 'gd';

    /** @var string */
    private $conversionResult = null;

    /** @var string */
    private $temporaryDirectory = null;

    public static function create(string $inputImage, $config = []): self
    {
        return new self($inputImage, $config);

The call to GlideConversion::__construct() has too many arguments starting with $config.

    }

    public function setTemporaryDirectory($tempDir)
    {
        if (isset($tempDir)) {
            if (! is_dir($tempDir)) {
                try {
                    mkdir($tempDir);
                } catch (\Exception $e) {
                    throw DefectiveConfiguration::invalidTemporaryDirectory($tempDir);
                }
            }

            if (! self::isValidTemporaryDirectoryLocation($tempDir)) {
                throw DefectiveConfiguration::invalidTemporaryDirectory($tempDir);
            }

            $this->temporaryDirectory = $tempDir;
        }

        return $this;
    }

    public function getTemporaryDirectory(): string
    {
        return $this->temporaryDirectory;
    }

    private static function isValidTemporaryDirectoryLocation($dir): bool
    {
        return isset($dir) && is_dir($dir) && is_writable($dir);
    }

    public function __construct(string $inputImage)
    {
        $this->inputImage = $inputImage;
    }

    public function useImageDriver(string $imageDriver): self
    {
        $this->imageDriver = $imageDriver;

        return $this;
    }

    public function performManipulations(Manipulations $manipulations)
    {
        foreach ($manipulations->getManipulationSequence() as $manipulationGroup) {
            $inputFile = $this->conversionResult ?? $this->inputImage;

            $watermarkPath = $this->extractWatermarkPath($manipulationGroup);

            $glideServer = $this->createGlideServer($inputFile, $watermarkPath);

            $glideServer->setGroupCacheInFolders(false);

            $this->conversionResult = $this->temporaryDirectory.DIRECTORY_SEPARATOR.$glideServer->makeImage(
                    pathinfo($inputFile, PATHINFO_BASENAME),
                    $this->prepareManipulations($manipulationGroup)
                );
        }

        return $this;
    }

    /**
     * Removes the watermark path from the manipulationGroup and returns it. This way it can be injected into the Glide
     * server as the `watermarks` path.
     *
     * @param $manipulationGroup
     *
     * @return null|string
     */
    private function extractWatermarkPath(&$manipulationGroup)
    {
        if (array_key_exists('watermark', $manipulationGroup)) {
            $watermarkPath = dirname($manipulationGroup['watermark']);

            $manipulationGroup['watermark'] = basename($manipulationGroup['watermark']);

            return $watermarkPath;
        }
    }

    private function createGlideServer($inputFile, string $watermarkPath = null): Server
    {
        $config = [
            'source' => dirname($inputFile),
            'cache' => $this->temporaryDirectory,
            'driver' => $this->imageDriver,
        ];

        if ($watermarkPath) {

The expression $watermarkPath of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $config['watermarks'] = $watermarkPath;
        }

        return ServerFactory::create($config);
    }

    public function save(string $outputFile)
    {
        if ($this->conversionResult == '') {
            copy($this->inputImage, $outputFile);

            return;
        }

        $conversionResultDirectory = pathinfo($this->conversionResult, PATHINFO_DIRNAME);

        copy($this->conversionResult, $outputFile);

        unlink($this->conversionResult);

        if ($this->directoryIsEmpty($conversionResultDirectory) && $conversionResultDirectory !== '/tmp') {
            rmdir($conversionResultDirectory);
        }
    }

    private function prepareManipulations(array $manipulationGroup): array
    {
        $glideManipulations = [];

        foreach ($manipulationGroup as $name => $argument) {
            if ($name !== 'optimize') {
                $glideManipulations[$this->convertToGlideParameter($name)] = $argument;
            }
        }

        return $glideManipulations;
    }

    private function convertToGlideParameter(string $manipulationName): string
    {
        $conversions = [
            'width' => 'w',
            'height' => 'h',
            'blur' => 'blur',
            'pixelate' => 'pixel',
            'crop' => 'fit',
            'manualCrop' => 'crop',
            'orientation' => 'or',
            'flip' => 'flip',
            'fit' => 'fit',
            'devicePixelRatio' => 'dpr',
            'brightness' => 'bri',
            'contrast' => 'con',
            'gamma' => 'gam',
            'sharpen' => 'sharp',
            'filter' => 'filt',
            'background' => 'bg',
            'border' => 'border',
            'quality' => 'q',
            'format' => 'fm',
            'watermark' => 'mark',
            'watermarkWidth' => 'markw',
            'watermarkHeight' => 'markh',
            'watermarkFit' => 'markfit',
            'watermarkPaddingX' => 'markx',
            'watermarkPaddingY' => 'marky',
            'watermarkPosition' => 'markpos',
            'watermarkOpacity' => 'markalpha',
        ];

        if (! isset($conversions[$manipulationName])) {
            throw CouldNotConvert::unknownManipulation($manipulationName);
        }

        return $conversions[$manipulationName];
    }

    private function directoryIsEmpty(string $directory): bool
    {
        $iterator = new FilesystemIterator($directory);

        return ! $iterator->valid();
    }
}