Server::getSourcePath() - Code Metrics - thephpleague/glide - Measure and Improve Code Quality continuously with Scrutinizer

Server::getSourcePath() A
last analyzed 2020-10-31 16:19 UTC

↳ Parent: Server

Complexity

Conditions	4
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
dl	0
loc	20
ccs	0
cts	15
cp	0
rs	9.6
c	0
b	0
f	0
cc	4
nc	6
nop	1
crap	20

<?php

namespace League\Glide;

use InvalidArgumentException;
use League\Flysystem\FileExistsException;
use League\Flysystem\FilesystemInterface;
use League\Glide\Api\ApiInterface;
use League\Glide\Filesystem\FileNotFoundException;
use League\Glide\Filesystem\FilesystemException;
use League\Glide\Responses\ResponseFactoryInterface;

class Server
{
    /**
     * Source file system.
     * @var FilesystemInterface
     */
    protected $source;

    /**
     * Source path prefix.
     * @var string
     */
    protected $sourcePathPrefix;

    /**
     * Cache file system.
     * @var FilesystemInterface
     */
    protected $cache;

    /**
     * Cache path prefix.
     * @var string
     */
    protected $cachePathPrefix;

    /**
     * Whether to group cache in folders.
     * @var bool
     */
    protected $groupCacheInFolders = true;

    /**
     * Whether to cache with file extensions.
     * @var bool
     */
    protected $cacheWithFileExtensions = false;

    /**
     * Image manipulation API.
     * @var ApiInterface
     */
    protected $api;

    /**
     * Response factory.
     * @var ResponseFactoryInterface|null
     */
    protected $responseFactory;

    /**
     * Base URL.
     * @var string
     */
    protected $baseUrl;

    /**
     * Default image manipulations.
     * @var array
     */
    protected $defaults = [];

    /**
     * Preset image manipulations.
     * @var array
     */
    protected $presets = [];

    /**
     * Create Server instance.
     * @param FilesystemInterface $source Source file system.
     * @param FilesystemInterface $cache  Cache file system.
     * @param ApiInterface        $api    Image manipulation API.
     */
    public function __construct(FilesystemInterface $source, FilesystemInterface $cache, ApiInterface $api)
    {
        $this->setSource($source);
        $this->setCache($cache);
        $this->setApi($api);
    }

    /**
     * Set source file system.
     * @param FilesystemInterface $source Source file system.
     */
    public function setSource(FilesystemInterface $source)
    {
        $this->source = $source;
    }

    /**
     * Get source file system.
     * @return FilesystemInterface Source file system.
     */
    public function getSource()
    {
        return $this->source;
    }

    /**
     * Set source path prefix.
     * @param string $sourcePathPrefix Source path prefix.
     */
    public function setSourcePathPrefix($sourcePathPrefix)
    {
        $this->sourcePathPrefix = trim($sourcePathPrefix, '/');
    }

    /**
     * Get source path prefix.
     * @return string Source path prefix.
     */
    public function getSourcePathPrefix()
    {
        return $this->sourcePathPrefix;
    }

    /**
     * Get source path.
     * @param  string                $path Image path.
     * @return string                The source path.
     * @throws FileNotFoundException
     */
    public function getSourcePath($path)
    {
        $path = trim($path, '/');
        
        $baseUrl = $this->baseUrl.'/';

        if (substr($path, 0, strlen($baseUrl)) === $baseUrl) {
            $path = trim(substr($path, strlen($baseUrl)), '/');
        }

        if ($path === '') {
            throw new FileNotFoundException('Image path missing.');
        }

        if ($this->sourcePathPrefix) {
            $path = $this->sourcePathPrefix.'/'.$path;
        }

        return rawurldecode($path);
    }

    /**
     * Check if a source file exists.
     * @param  string $path Image path.
     * @return bool   Whether the source file exists.
     */
    public function sourceFileExists($path)
    {
        return $this->source->has($this->getSourcePath($path));
    }

    /**
     * Set base URL.
     * @param string $baseUrl Base URL.
     */
    public function setBaseUrl($baseUrl)
    {
        $this->baseUrl = trim($baseUrl, '/');
    }

    /**
     * Get base URL.
     * @return string Base URL.
     */
    public function getBaseUrl()
    {
        return $this->baseUrl;
    }

    /**
     * Set cache file system.
     * @param FilesystemInterface $cache Cache file system.
     */
    public function setCache(FilesystemInterface $cache)
    {
        $this->cache = $cache;
    }

    /**
     * Get cache file system.
     * @return FilesystemInterface Cache file system.
     */
    public function getCache()
    {
        return $this->cache;
    }

    /**
     * Set cache path prefix.
     * @param string $cachePathPrefix Cache path prefix.
     */
    public function setCachePathPrefix($cachePathPrefix)
    {
        $this->cachePathPrefix = trim($cachePathPrefix, '/');
    }

    /**
     * Get cache path prefix.
     * @return string Cache path prefix.
     */
    public function getCachePathPrefix()
    {
        return $this->cachePathPrefix;
    }

    /**
     * Set the group cache in folders setting.
     * @param bool $groupCacheInFolders Whether to group cache in folders.
     */
    public function setGroupCacheInFolders($groupCacheInFolders)
    {
        $this->groupCacheInFolders = $groupCacheInFolders;
    }

    /**
     * Get the group cache in folders setting.
     * @return bool Whether to group cache in folders.
     */
    public function getGroupCacheInFolders()
    {
        return $this->groupCacheInFolders;
    }

    /**
     * Set the cache with file extensions setting.
     * @param bool $cacheWithFileExtensions Whether to cache with file extensions.
     */
    public function setCacheWithFileExtensions($cacheWithFileExtensions)
    {
        $this->cacheWithFileExtensions = $cacheWithFileExtensions;
    }

    /**
     * Get the cache with file extensions setting.
     * @return bool Whether to cache with file extensions.
     */
    public function getCacheWithFileExtensions()
    {
        return $this->cacheWithFileExtensions;
    }

    /**
     * Get cache path.
     * @param  string $path   Image path.
     * @param  array  $params Image manipulation params.
     * @return string Cache path.
     */
    public function getCachePath($path, array $params = [])
    {
        $sourcePath = $this->getSourcePath($path);

        if ($this->sourcePathPrefix) {
            $sourcePath = substr($sourcePath, strlen($this->sourcePathPrefix) + 1);
        }

        $params = $this->getAllParams($params);
        unset($params['s'], $params['p']);
        ksort($params);

        $md5 = md5($sourcePath.'?'.http_build_query($params));

        $cachedPath = $this->groupCacheInFolders ? $sourcePath.'/'.$md5 : $md5;

        if ($this->cachePathPrefix) {
            $cachedPath = $this->cachePathPrefix.'/'.$cachedPath;
        }
        
        if ($this->cacheWithFileExtensions) {
            $ext = (isset($params['fm']) ? $params['fm'] : pathinfo($path)['extension']);
            $ext = ($ext === 'pjpg') ? 'jpg' : $ext;
            $cachedPath .= '.'.$ext;
        }

        return $cachedPath;
    }

    /**
     * Check if a cache file exists.
     * @param  string $path   Image path.
     * @param  array  $params Image manipulation params.
     * @return bool   Whether the cache file exists.
     */
    public function cacheFileExists($path, array $params)
    {
        return $this->cache->has(
            $this->getCachePath($path, $params)
        );
    }

    /**
     * Delete cached manipulations for an image.
     * @param  string $path Image path.
     * @return bool   Whether the delete succeeded.
     */
    public function deleteCache($path)
    {
        if (!$this->groupCacheInFolders) {
            throw new InvalidArgumentException(
                'Deleting cached image manipulations is not possible when grouping cache into folders is disabled.'
            );
        }

        return $this->cache->deleteDir(
            dirname($this->getCachePath($path))
        );
    }

    /**
     * Set image manipulation API.
     * @param ApiInterface $api Image manipulation API.
     */
    public function setApi(ApiInterface $api)
    {
        $this->api = $api;
    }

    /**
     * Get image manipulation API.
     * @return ApiInterface Image manipulation API.
     */
    public function getApi()
    {
        return $this->api;
    }

    /**
     * Set default image manipulations.
     * @param array $defaults Default image manipulations.
     */
    public function setDefaults(array $defaults)
    {
        $this->defaults = $defaults;
    }

    /**
     * Get default image manipulations.
     * @return array Default image manipulations.
     */
    public function getDefaults()
    {
        return $this->defaults;
    }

    /**
     * Set preset image manipulations.
     * @param array $presets Preset image manipulations.
     */
    public function setPresets(array $presets)
    {
        $this->presets = $presets;
    }

    /**
     * Get preset image manipulations.
     * @return array Preset image manipulations.
     */
    public function getPresets()
    {
        return $this->presets;
    }

    /**
     * Get all image manipulations params, including defaults and presets.
     * @param  array $params Image manipulation params.
     * @return array All image manipulation params.
     */
    public function getAllParams(array $params)
    {
        $all = $this->defaults;

        if (isset($params['p'])) {
            foreach (explode(',', $params['p']) as $preset) {
                if (isset($this->presets[$preset])) {
                    $all = array_merge($all, $this->presets[$preset]);
                }
            }
        }

        return array_merge($all, $params);
    }

    /**
     * Set response factory.
     * @param ResponseFactoryInterface|null $responseFactory Response factory.
     */
    public function setResponseFactory(ResponseFactoryInterface $responseFactory = null)
    {
        $this->responseFactory = $responseFactory;
    }

    /**
     * Get response factory.
     * @return ResponseFactoryInterface Response factory.
     */
    public function getResponseFactory()
    {
        return $this->responseFactory;
    }

    /**
     * Generate and return image response.
     * @param  string                   $path   Image path.
     * @param  array                    $params Image manipulation params.
     * @return mixed                    Image response.
     * @throws InvalidArgumentException
     */
    public function getImageResponse($path, array $params)
    {
        if (is_null($this->responseFactory)) {
            throw new InvalidArgumentException(
                'Unable to get image response, no response factory defined.'
            );
        }

        $path = $this->makeImage($path, $params);

        return $this->responseFactory->create($this->cache, $path);
    }

    /**
     * Generate and return Base64 encoded image.
     * @param  string              $path   Image path.
     * @param  array               $params Image manipulation params.
     * @return string              Base64 encoded image.
     * @throws FilesystemException
     */
    public function getImageAsBase64($path, array $params)
    {
        $path = $this->makeImage($path, $params);

        $source = $this->cache->read($path);

        if ($source === false) {
            throw new FilesystemException(
                'Could not read the image `'.$path.'`.'
            );
        }

        return 'data:'.$this->cache->getMimetype($path).';base64,'.base64_encode($source);
    }

    /**
     * Generate and output image.
     * @param  string                   $path   Image path.
     * @param  array                    $params Image manipulation params.
     * @throws InvalidArgumentException
     */
    public function outputImage($path, array $params)
    {
        $path = $this->makeImage($path, $params);

        header('Content-Type:'.$this->cache->getMimetype($path));
        header('Content-Length:'.$this->cache->getSize($path));
        header('Cache-Control:'.'max-age=31536000, public');
        header('Expires:'.date_create('+1 years')->format('D, d M Y H:i:s').' GMT');

        $stream = $this->cache->readStream($path);

        if (ftell($stream) !== 0) {
            rewind($stream);
        }
        fpassthru($stream);
        fclose($stream);
    }

    /**
     * Generate manipulated image.
     * @param  string                $path   Image path.
     * @param  array                 $params Image manipulation params.
     * @return string                Cache path.
     * @throws FileNotFoundException
     * @throws FilesystemException
     */
    public function makeImage($path, array $params)
    {
        $sourcePath = $this->getSourcePath($path);
        $cachedPath = $this->getCachePath($path, $params);

        if ($this->cacheFileExists($path, $params) === true) {
            return $cachedPath;
        }

        if ($this->sourceFileExists($path) === false) {
            throw new FileNotFoundException(
                'Could not find the image `'.$sourcePath.'`.'
            );
        }

        $source = $this->source->read(
            $sourcePath
        );

        if ($source === false) {
            throw new FilesystemException(
                'Could not read the image `'.$sourcePath.'`.'
            );
        }

        // We need to write the image to the local disk before
        // doing any manipulations. This is because EXIF data
        // can only be read from an actual file.
        $tmp = tempnam(sys_get_temp_dir(), 'Glide');

        if (file_put_contents($tmp, $source) === false) {
            throw new FilesystemException(
                'Unable to write temp file for `'.$sourcePath.'`.'
            );
        }

        try {
            $write = $this->cache->write(
                $cachedPath,
                $this->api->run($tmp, $this->getAllParams($params))
            );

            if ($write === false) {
                throw new FilesystemException(
                    'Could not write the image `'.$cachedPath.'`.'
                );
            }
        } catch (FileExistsException $exception) {
            // This edge case occurs when the target already exists
            // because it's currently be written to disk in another
            // request. It's best to just fail silently.
        } finally {
            unlink($tmp);
        }

        return $cachedPath;
    }
}


1			<?php
2
3			namespace League\Glide;
4
5			use InvalidArgumentException;
6			use League\Flysystem\FileExistsException;
7			use League\Flysystem\FilesystemInterface;
8			use League\Glide\Api\ApiInterface;
9			use League\Glide\Filesystem\FileNotFoundException;
10			use League\Glide\Filesystem\FilesystemException;
11			use League\Glide\Responses\ResponseFactoryInterface;
12
13			class Server
14			{
15			/**
16			* Source file system.
17			* @var FilesystemInterface
18			*/
19			protected $source;
20
21			/**
22			* Source path prefix.
23			* @var string
24			*/
25			protected $sourcePathPrefix;
26
27			/**
28			* Cache file system.
29			* @var FilesystemInterface
30			*/
31			protected $cache;
32
33			/**
34			* Cache path prefix.
35			* @var string
36			*/
37			protected $cachePathPrefix;
38
39			/**
40			* Whether to group cache in folders.
41			* @var bool
42			*/
43			protected $groupCacheInFolders = true;
44
45			/**
46			* Whether to cache with file extensions.
47			* @var bool
48			*/
49			protected $cacheWithFileExtensions = false;
50
51			/**
52			* Image manipulation API.
53			* @var ApiInterface
54			*/
55			protected $api;
56
57			/**
58			* Response factory.
59			* @var ResponseFactoryInterface\|null
60			*/
61			protected $responseFactory;
62
63			/**
64			* Base URL.
65			* @var string
66			*/
67			protected $baseUrl;
68
69			/**
70			* Default image manipulations.
71			* @var array
72			*/
73			protected $defaults = [];
74
75			/**
76			* Preset image manipulations.
77			* @var array
78			*/
79			protected $presets = [];
80
81			/**
82			* Create Server instance.
83			* @param FilesystemInterface $source Source file system.
84			* @param FilesystemInterface $cache Cache file system.
85			* @param ApiInterface $api Image manipulation API.
86			*/
87			public function __construct(FilesystemInterface $source, FilesystemInterface $cache, ApiInterface $api)
88			{
89			$this->setSource($source);
90			$this->setCache($cache);
91			$this->setApi($api);
92			}
93
94			/**
95			* Set source file system.
96			* @param FilesystemInterface $source Source file system.
97			*/
98			public function setSource(FilesystemInterface $source)
99			{
100			$this->source = $source;
101			}
102
103			/**
104			* Get source file system.
105			* @return FilesystemInterface Source file system.
106			*/
107			public function getSource()
108			{
109			return $this->source;
110			}
111
112			/**
113			* Set source path prefix.
114			* @param string $sourcePathPrefix Source path prefix.
115			*/
116			public function setSourcePathPrefix($sourcePathPrefix)
117			{
118			$this->sourcePathPrefix = trim($sourcePathPrefix, '/');
119			}
120
121			/**
122			* Get source path prefix.
123			* @return string Source path prefix.
124			*/
125			public function getSourcePathPrefix()
126			{
127			return $this->sourcePathPrefix;
128			}
129
130			/**
131			* Get source path.
132			* @param string $path Image path.
133			* @return string The source path.
134			* @throws FileNotFoundException
135			*/
136			public function getSourcePath($path)
137			{
138			$path = trim($path, '/');
139
140			$baseUrl = $this->baseUrl.'/';
141
142			if (substr($path, 0, strlen($baseUrl)) === $baseUrl) {
143			$path = trim(substr($path, strlen($baseUrl)), '/');
144			}
145
146			if ($path === '') {
147			throw new FileNotFoundException('Image path missing.');
148			}
149
150			if ($this->sourcePathPrefix) {
151			$path = $this->sourcePathPrefix.'/'.$path;
152			}
153
154			return rawurldecode($path);
155			}
156
157			/**
158			* Check if a source file exists.
159			* @param string $path Image path.
160			* @return bool Whether the source file exists.
161			*/
162			public function sourceFileExists($path)
163			{
164			return $this->source->has($this->getSourcePath($path));
165			}
166
167			/**
168			* Set base URL.
169			* @param string $baseUrl Base URL.
170			*/
171			public function setBaseUrl($baseUrl)
172			{
173			$this->baseUrl = trim($baseUrl, '/');
174			}
175
176			/**
177			* Get base URL.
178			* @return string Base URL.
179			*/
180			public function getBaseUrl()
181			{
182			return $this->baseUrl;
183			}
184
185			/**
186			* Set cache file system.
187			* @param FilesystemInterface $cache Cache file system.
188			*/
189			public function setCache(FilesystemInterface $cache)
190			{
191			$this->cache = $cache;
192			}
193
194			/**
195			* Get cache file system.
196			* @return FilesystemInterface Cache file system.
197			*/
198			public function getCache()
199			{
200			return $this->cache;
201			}
202
203			/**
204			* Set cache path prefix.
205			* @param string $cachePathPrefix Cache path prefix.
206			*/
207			public function setCachePathPrefix($cachePathPrefix)
208			{
209			$this->cachePathPrefix = trim($cachePathPrefix, '/');
210			}
211
212			/**
213			* Get cache path prefix.
214			* @return string Cache path prefix.
215			*/
216			public function getCachePathPrefix()
217			{
218			return $this->cachePathPrefix;
219			}
220
221			/**
222			* Set the group cache in folders setting.
223			* @param bool $groupCacheInFolders Whether to group cache in folders.
224			*/
225			public function setGroupCacheInFolders($groupCacheInFolders)
226			{
227			$this->groupCacheInFolders = $groupCacheInFolders;
228			}
229
230			/**
231			* Get the group cache in folders setting.
232			* @return bool Whether to group cache in folders.
233			*/
234			public function getGroupCacheInFolders()
235			{
236			return $this->groupCacheInFolders;
237			}
238
239			/**
240			* Set the cache with file extensions setting.
241			* @param bool $cacheWithFileExtensions Whether to cache with file extensions.
242			*/
243			public function setCacheWithFileExtensions($cacheWithFileExtensions)
244			{
245			$this->cacheWithFileExtensions = $cacheWithFileExtensions;
246			}
247
248			/**
249			* Get the cache with file extensions setting.
250			* @return bool Whether to cache with file extensions.
251			*/
252			public function getCacheWithFileExtensions()
253			{
254			return $this->cacheWithFileExtensions;
255			}
256
257			/**
258			* Get cache path.
259			* @param string $path Image path.
260			* @param array $params Image manipulation params.
261			* @return string Cache path.
262			*/
263			public function getCachePath($path, array $params = [])
264			{
265			$sourcePath = $this->getSourcePath($path);
266
267			if ($this->sourcePathPrefix) {
268			$sourcePath = substr($sourcePath, strlen($this->sourcePathPrefix) + 1);
269			}
270
271			$params = $this->getAllParams($params);
272			unset($params['s'], $params['p']);
273			ksort($params);
274
275			$md5 = md5($sourcePath.'?'.http_build_query($params));
276
277			$cachedPath = $this->groupCacheInFolders ? $sourcePath.'/'.$md5 : $md5;
278
279			if ($this->cachePathPrefix) {
280			$cachedPath = $this->cachePathPrefix.'/'.$cachedPath;
281			}
282
283			if ($this->cacheWithFileExtensions) {
284			$ext = (isset($params['fm']) ? $params['fm'] : pathinfo($path)['extension']);
285			$ext = ($ext === 'pjpg') ? 'jpg' : $ext;
286			$cachedPath .= '.'.$ext;
287			}
288
289			return $cachedPath;
290			}
291
292			/**
293			* Check if a cache file exists.
294			* @param string $path Image path.
295			* @param array $params Image manipulation params.
296			* @return bool Whether the cache file exists.
297			*/
298			public function cacheFileExists($path, array $params)
299			{
300			return $this->cache->has(
301			$this->getCachePath($path, $params)
302			);
303			}
304
305			/**
306			* Delete cached manipulations for an image.
307			* @param string $path Image path.
308			* @return bool Whether the delete succeeded.
309			*/
310			public function deleteCache($path)
311			{
312			if (!$this->groupCacheInFolders) {
313			throw new InvalidArgumentException(
314			'Deleting cached image manipulations is not possible when grouping cache into folders is disabled.'
315			);
316			}
317
318			return $this->cache->deleteDir(
319			dirname($this->getCachePath($path))
320			);
321			}
322
323			/**
324			* Set image manipulation API.
325			* @param ApiInterface $api Image manipulation API.
326			*/
327			public function setApi(ApiInterface $api)
328			{
329			$this->api = $api;
330			}
331
332			/**
333			* Get image manipulation API.
334			* @return ApiInterface Image manipulation API.
335			*/
336			public function getApi()
337			{
338			return $this->api;
339			}
340
341			/**
342			* Set default image manipulations.
343			* @param array $defaults Default image manipulations.
344			*/
345			public function setDefaults(array $defaults)
346			{
347			$this->defaults = $defaults;
348			}
349
350			/**
351			* Get default image manipulations.
352			* @return array Default image manipulations.
353			*/
354			public function getDefaults()
355			{
356			return $this->defaults;
357			}
358
359			/**
360			* Set preset image manipulations.
361			* @param array $presets Preset image manipulations.
362			*/
363			public function setPresets(array $presets)
364			{
365			$this->presets = $presets;
366			}
367
368			/**
369			* Get preset image manipulations.
370			* @return array Preset image manipulations.
371			*/
372			public function getPresets()
373			{
374			return $this->presets;
375			}
376
377			/**
378			* Get all image manipulations params, including defaults and presets.
379			* @param array $params Image manipulation params.
380			* @return array All image manipulation params.
381			*/
382			public function getAllParams(array $params)
383			{
384			$all = $this->defaults;
385
386			if (isset($params['p'])) {
387			foreach (explode(',', $params['p']) as $preset) {
388			if (isset($this->presets[$preset])) {
389			$all = array_merge($all, $this->presets[$preset]);
390			}
391			}
392			}
393
394			return array_merge($all, $params);
395			}
396
397			/**
398			* Set response factory.
399			* @param ResponseFactoryInterface\|null $responseFactory Response factory.
400			*/
401			public function setResponseFactory(ResponseFactoryInterface $responseFactory = null)
402			{
403			$this->responseFactory = $responseFactory;
404			}
405
406			/**
407			* Get response factory.
408			* @return ResponseFactoryInterface Response factory.
409			*/
410			public function getResponseFactory()
411			{
412			return $this->responseFactory;
413			}
414
415			/**
416			* Generate and return image response.
417			* @param string $path Image path.
418			* @param array $params Image manipulation params.
419			* @return mixed Image response.
420			* @throws InvalidArgumentException
421			*/
422			public function getImageResponse($path, array $params)
423			{
424			if (is_null($this->responseFactory)) {
425			throw new InvalidArgumentException(
426			'Unable to get image response, no response factory defined.'
427			);
428			}
429
430			$path = $this->makeImage($path, $params);
431
432			return $this->responseFactory->create($this->cache, $path);
433			}
434
435			/**
436			* Generate and return Base64 encoded image.
437			* @param string $path Image path.
438			* @param array $params Image manipulation params.
439			* @return string Base64 encoded image.
440			* @throws FilesystemException
441			*/
442			public function getImageAsBase64($path, array $params)
443			{
444			$path = $this->makeImage($path, $params);
445
446			$source = $this->cache->read($path);
447
448			if ($source === false) {
449			throw new FilesystemException(
450			'Could not read the image `'.$path.'`.'
451			);
452			}
453
454			return 'data:'.$this->cache->getMimetype($path).';base64,'.base64_encode($source);
455			}
456
457			/**
458			* Generate and output image.
459			* @param string $path Image path.
460			* @param array $params Image manipulation params.
461			* @throws InvalidArgumentException
462			*/
463			public function outputImage($path, array $params)
464			{
465			$path = $this->makeImage($path, $params);
466
467			header('Content-Type:'.$this->cache->getMimetype($path));
468			header('Content-Length:'.$this->cache->getSize($path));
469			header('Cache-Control:'.'max-age=31536000, public');
470			header('Expires:'.date_create('+1 years')->format('D, d M Y H:i:s').' GMT');
471
472			$stream = $this->cache->readStream($path);
473
474			if (ftell($stream) !== 0) {
475			rewind($stream);
476			}
477			fpassthru($stream);
478			fclose($stream);
479			}
480
481			/**
482			* Generate manipulated image.
483			* @param string $path Image path.
484			* @param array $params Image manipulation params.
485			* @return string Cache path.
486			* @throws FileNotFoundException
487			* @throws FilesystemException
488			*/
489			public function makeImage($path, array $params)
490			{
491			$sourcePath = $this->getSourcePath($path);
492			$cachedPath = $this->getCachePath($path, $params);
493
494			if ($this->cacheFileExists($path, $params) === true) {
495			return $cachedPath;
496			}
497
498			if ($this->sourceFileExists($path) === false) {
499			throw new FileNotFoundException(
500			'Could not find the image `'.$sourcePath.'`.'
501			);
502			}
503
504			$source = $this->source->read(
505			$sourcePath
506			);
507
508			if ($source === false) {
509			throw new FilesystemException(
510			'Could not read the image `'.$sourcePath.'`.'
511			);
512			}
513
514			// We need to write the image to the local disk before
515			// doing any manipulations. This is because EXIF data
516			// can only be read from an actual file.
517			$tmp = tempnam(sys_get_temp_dir(), 'Glide');
518
519			if (file_put_contents($tmp, $source) === false) {
520			throw new FilesystemException(
521			'Unable to write temp file for `'.$sourcePath.'`.'
522			);
523			}
524
525			try {
526			$write = $this->cache->write(
527			$cachedPath,
528			$this->api->run($tmp, $this->getAllParams($params))
529			);
530
531			if ($write === false) {
532			throw new FilesystemException(
533			'Could not write the image `'.$cachedPath.'`.'
534			);
535			}
536			} catch (FileExistsException $exception) {
537			// This edge case occurs when the target already exists
538			// because it's currently be written to disk in another
539			// request. It's best to just fail silently.
540			} finally {
541			unlink($tmp);
542			}
543
544			return $cachedPath;
545			}
546			}
547

thephpleague / glide

Server::getSourcePath() A last analyzed 2020-10-31 16:19 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Server::getSourcePath() A
last analyzed 2020-10-31 16:19 UTC