26407566224

Committed 25 May 2026 03:18PM UTC coverage: 82.54%. First build

Build # 26407566224

Build Type

Pull #2383

github

Committed by

web-flow

Commit Message

Merge ddfaf03b1 into 88004e568

Pull Request Pull Request #2383: refactor: asset handling and add renderer extensions

Coverage Stats

282 of 358 new or added lines in 10 files covered. (78.77%)

3503 of 4244 relevant lines covered (82.54%)

0.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.93

/src/Asset.php

<?php

/**
 * This file is part of Cecil.
 *
 * (c) Arnaud Ligny <arnaud@ligny.fr>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Cecil;

use Cecil\Asset\Compiler as AssetCompiler;
use Cecil\Asset\Image;
use Cecil\Asset\Locator;
use Cecil\Asset\Optimizer as AssetOptimizer;
use Cecil\Builder;
use Cecil\Cache;
use Cecil\Config;
use Cecil\Exception\RuntimeException;
use Cecil\Url;
use Cecil\Util;
use wapmorgan\Mp3Info\Mp3Info;

/**
 * Asset class.
 *
 * Represents an asset (file) in the Cecil project.
 * Handles file locating, content reading, compiling, minifying, fingerprinting,
 * resizing images, and more.
 */
class Asset implements \ArrayAccess
{
    public const IMAGE_THUMB = 'thumbnails';

    /** @var Builder */
    protected $builder;

    /** @var Config */
    protected $config;

    /** @var array */
    protected $data = [];

    /** @var array Cache tags */
    protected $cacheTags = [];

    /**
     * Creates an Asset from a file path, an array of files path or an URL.
     * Options:
     * [
     *     'filename' => <string>,
     *     'ignore_missing' => <bool>,
     *     'fingerprint' => <bool>,
     *     'minify' => <bool>,
     *     'optimize' => <bool>,
     *     'fallback' => <string>,
     *     'useragent' => <string>,
     *     'language' => <string|null>,
     * ]
     *
     * @param Builder      $builder
     * @param string|array $paths
     * @param array|null   $options
     *
     * @throws RuntimeException
     */
    public function __construct(Builder $builder, string|array $paths, array|null $options = null)
    {
        $this->builder = $builder;
        $this->config = $builder->getConfig();
        $paths = \is_array($paths) ? $paths : [$paths];
        // checks path(s)
        array_walk($paths, function ($path) {
            // must be a string
            if (!\is_string($path)) {
                throw new RuntimeException(\sprintf('The path of an asset must be a string ("%s" given).', \gettype($path)));
            }
            // can't be empty
            if (empty($path)) {
                throw new RuntimeException('The path of an asset can\'t be empty.');
            }
            // can't be relative
            if (substr($path, 0, 2) == '..') {
                throw new RuntimeException(\sprintf('The path of asset "%s" is wrong: it must be directly relative to `assets` or `static` directory, or a remote URL.', $path));
            }
        });
        $this->data = [
            'file'     => '',    // absolute file path
            'files'    => [],    // array of absolute files path
            'missing'  => false, // if file not found but missing allowed: 'missing' is true
            '_path'    => '',    // original path
            'path'     => '',    // public path
            'url'      => null,  // URL if it's a remote file
            'ext'      => '',    // file extension
            'type'     => '',    // file type (e.g.: image, audio, video, etc.)
            'subtype'  => '',    // file media type (e.g.: image/png, audio/mp3, etc.)
            'size'     => 0,     // file size (in bytes)
            'width'    => null,  // width (in pixels)
            'height'   => null,  // height (in pixels)
            'exif'     => [],    // image exif data
            'duration' => null,  // audio or video duration
            'content'  => '',    // file content
            'hash'     => '',    // file content hash
        ];

        // handles options
        $options = array_merge(
            [
                'filename'       => '',
                'ignore_missing' => false,
                'fingerprint'    => $this->config->isEnabled('assets.fingerprint'),
                'minify'         => $this->config->isEnabled('assets.minify'),
                'optimize'       => $this->config->isEnabled('assets.images.optimize'),
                'fallback'       => '',
                'useragent'      => (string) $this->config->get('assets.remote.useragent.default'),
                'language'       => null,
            ],
            \is_array($options) ? $options : []
        );
        $language = null;
        if (isset($options['language']) && \is_scalar($options['language'])) {
            $language = (string) $options['language'];
            $language = $language === '' ? null : $language;
        }
        unset($options['language']);

        // cache for "locate file(s)"
        $cache = new Cache($this->builder, 'assets');
        $locateCacheKey = \sprintf(
            '%s_locate%s__%s__%s',
            $options['filename'] ?: implode('_', $paths),
            $language ? '_' . $language : '',
            Builder::getBuildId(),
            Builder::getVersion()
        );

        // locate file(s) and get content
        if (!$cache->has($locateCacheKey)) {
            $pathsCount = \count($paths);
            for ($i = 0; $i < $pathsCount; $i++) {
                try {
                    $this->data['missing'] = false;
                    $locate = (new Locator($this->builder))->locate(
                        $paths[$i],
                        $options['fallback'],
                        $options['useragent'],
                        $language
                    );
                    $file = $locate['file'];
                    $path = $locate['path'];
                    $type = Util\File::getMediaType($file)[0];
                    if ($i > 0) { // bundle
                        if ($type != $this->data['type']) {
                            throw new RuntimeException(\sprintf('Asset bundle type error (%s != %s).', $type, $this->data['type']));
                        }
                    }
                    $this->data['file'] = $file;
                    $this->data['files'][] = $file;
                    $this->data['path'] = $path;
                    $this->data['url'] = Util\File::isRemote($paths[$i]) ? $paths[$i] : null;
                    $this->data['ext'] = Util\File::getExtension($file);
                    $this->data['type'] = $type;
                    $this->data['subtype'] = Util\File::getMediaType($file)[1];
                    $this->data['size'] += filesize($file) ?: 0;
                    $this->data['content'] .= Util\File::fileGetContents($file);
                    $this->data['hash'] = hash('xxh128', $this->data['content']);
                    // bundle default filename
                    $filename = $options['filename'];
                    if ($pathsCount > 1 && empty($filename)) {
                        switch ($this->data['ext']) {
                            case 'scss':
                            case 'css':
                                $filename = 'styles.css';
                                break;
                            case 'js':
                                $filename = 'scripts.js';
                                break;
                            default:
                                throw new RuntimeException(\sprintf('Asset bundle supports %s files only.', '.scss, .css and .js'));
                        }
                    }
                    // apply bundle filename to path
                    if (!empty($filename)) {
                        $this->data['path'] = $filename;
                    }
                    // add leading slash
                    $this->data['path'] = '/' . ltrim($this->data['path'], '/');
                    $this->data['_path'] = $this->data['path'];
                } catch (RuntimeException $e) {
                    if ($options['ignore_missing']) {
                        $this->data['missing'] = true;
                        continue;
                    }
                    throw new RuntimeException(\sprintf('Unable to handle asset "%s".', $paths[$i]), previous: $e);
                }
            }
            $cache->set($locateCacheKey, $this->data);
        }
        $this->data = $cache->get($locateCacheKey);

        // missing
        if ($this->isMissing()) {
            return;
        }

        // cache for "process asset"
        $cache = new Cache($this->builder, 'assets');
        // create cache tags from options
        $this->cacheTags = $options;
        // remove unnecessary cache tags
        unset($this->cacheTags['optimize'], $this->cacheTags['ignore_missing'], $this->cacheTags['fallback'], $this->cacheTags['useragent']);
        if (!\in_array($this->data['ext'], ['css', 'js', 'scss'])) {
            unset($this->cacheTags['minify']);
        }
        // optimize image?
        $optimize = false;
        if ($options['optimize'] && $this->data['type'] == 'image' && !$this->isImageInCdn()) {
            $optimize = true;
            $quality = (int) $this->config->get('assets.images.quality');
            $this->cacheTags['quality'] = $quality;
        }
        $cacheKey = $cache->createKey($this, tags: $this->cacheTags);
        if (!$cache->has($cacheKey)) {
            // fingerprinting
            if ($options['fingerprint']) {
                $this->doFingerprint();
            }
            // compiling Sass files
            $this->doCompile();
            // minifying (CSS and JavaScript files)
            if ($options['minify']) {
                $this->doMinify();
            }
            // get width and height
            $this->data['width'] = $this->getWidth();
            $this->data['height'] = $this->getHeight();
            // get image exif
            if ($this->data['subtype'] == 'image/jpeg') {
                $this->data['exif'] = Util\File::readExif($this->data['file']);
            }
            // get duration
            if ($this->data['type'] == 'audio') {
                $this->data['duration'] = $this->getAudio()['duration'];
            }
            if ($this->data['type'] == 'video') {
                $this->data['duration'] = $this->getVideo()['duration'];
            }
            $cache->set($cacheKey, $this->data, $this->config->get('cache.assets.ttl'));
            $this->builder->getLogger()->debug(\sprintf('Asset cached: "%s"', $this->data['path']));
            // optimizing images files (in cache directory)
            if ($optimize) {
                $this->optimizeImage($cache->getContentFile($this->data['path']), $this->data['path'], $quality);
            }
        }
        $this->data = $cache->get($cacheKey);
    }

    /**
     * Returns path.
     */
    public function __toString(): string
    {
        $this->save();

        if ($this->isImageInCdn()) {
            return $this->buildImageCdnUrl();
        }

        if ($this->builder->getConfig()->isEnabled('canonicalurl')) {
            return (string) new Url($this->builder, $this->data['path'], ['canonical' => true]);
        }

        return $this->data['path'];
    }

    /**
     * Implements \ArrayAccess.
     */
    #[\ReturnTypeWillChange]
    public function offsetSet($offset, $value): void
    {
        if (!\is_null($offset)) {
            $this->data[$offset] = $value;
        }
    }

    /**
     * Implements \ArrayAccess.
     */
    #[\ReturnTypeWillChange]
    public function offsetExists($offset): bool
    {
        return isset($this->data[$offset]);
    }

    /**
     * Implements \ArrayAccess.
     */
    #[\ReturnTypeWillChange]
    public function offsetUnset($offset): void
    {
        unset($this->data[$offset]);
    }

    /**
     * Implements \ArrayAccess.
     */
    #[\ReturnTypeWillChange]
    public function offsetGet($offset)
    {
        return isset($this->data[$offset]) ? $this->data[$offset] : null;
    }

    /**
     * Saves the asset by adding its path to the build assets list.
     * Skips assets marked as missing and validates that the asset file exists in cache before adding it.
     *
     * @throws RuntimeException
     */
    public function save(): void
    {
        if ($this->isMissing()) {
            return;
        }

        $cache = new Cache($this->builder, 'assets');
        if (empty($this->data['path']) || !Util\File::getFS()->exists($cache->getContentFile($this->data['path']))) {
            throw new RuntimeException(\sprintf('Unable to add "%s" to assets list. Please clear cache and retry.', $this->data['path']));
        }

        $this->builder->addToAssetsList($this->data['path']);
    }

    /**
     * Checks if the asset is missing.
     */
    public function isMissing(): bool
    {
        return $this->data['missing'];
    }

    /**
     * Add hash to the file name + cache.
     */
    public function fingerprint(): self
    {
        $this->cacheTags['fingerprint'] = true;
        $cache = new Cache($this->builder, 'assets');
        $cacheKey = $cache->createKey($this, tags: $this->cacheTags);
        if (!$cache->has($cacheKey)) {
            $this->doFingerprint();
            $cache->set($cacheKey, $this->data, $this->config->get('cache.assets.ttl'));
        }
        $this->data = $cache->get($cacheKey);

        return $this;
    }

    /**
     * Compiles a SCSS + cache.
     *
     * @throws RuntimeException
     */
    public function compile(): self
    {
        $this->cacheTags['compile'] = true;
        $cache = new Cache($this->builder, 'assets');
        $cacheKey = $cache->createKey($this, tags: $this->cacheTags);
        if (!$cache->has($cacheKey)) {
            $this->doCompile();
            $cache->set($cacheKey, $this->data, $this->config->get('cache.assets.ttl'));
        }
        $this->data = $cache->get($cacheKey);

        return $this;
    }

    /**
     * Minifying a CSS or a JS.
     */
    public function minify(): self
    {
        $this->cacheTags['minify'] = true;
        $cache = new Cache($this->builder, 'assets');
        $cacheKey = $cache->createKey($this, tags: $this->cacheTags);
        if (!$cache->has($cacheKey)) {
            $this->doMinify();
            $cache->set($cacheKey, $this->data, $this->config->get('cache.assets.ttl'));
        }
        $this->data = $cache->get($cacheKey);

        return $this;
    }

    /**
     * Returns the Data URL (encoded in Base64).
     *
     * @throws RuntimeException
     */
    public function dataurl(): string
    {
        if ($this->data['type'] == 'image' && !Image::isSVG($this)) {
            return Image::getDataUrl($this, (int) $this->config->get('assets.images.quality'));
        }

        return \sprintf('data:%s;base64,%s', $this->data['subtype'], base64_encode($this->data['content']));
    }

    /**
     * Hashing content of an asset with the specified algo, sha384 by default.
     * Used for SRI (Subresource Integrity).
     *
     * @see https://developer.mozilla.org/fr/docs/Web/Security/Subresource_Integrity
     */
    public function integrity(string $algo = 'sha384'): string
    {
        return \sprintf('%s-%s', $algo, base64_encode(hash($algo, $this->data['content'], true)));
    }

    /**
     * Resizes an image to the given width or/and height.
     *
     * - If only the width is specified, the height is calculated to preserve the aspect ratio
     * - If only the height is specified, the width is calculated to preserve the aspect ratio
     * - If both width and height are specified, the image is resized to fit within the given dimensions, image is cropped and centered if necessary
     * - If rmAnimation is true, any animation in the image (e.g., GIF) will be removed.
     *
     * @throws RuntimeException
     */
    public function resize(?int $width = null, ?int $height = null, bool $rmAnimation = false): self
    {
        $this->checkImage();

        // if no width and no height, return the original image
        if ($width === null && $height === null) {
            return $this;
        }

        // if equal with and height, return the original image
        if ($width == $this->data['width'] && $height == $this->data['height']) {
            return $this;
        }

        // if the image width or height is already smaller, return the original image
        if ($width !== null && $this->data['width'] <= $width && $height === null) {
            return $this;
        }
        if ($height !== null && $this->data['height'] <= $height && $width === null) {
            return $this;
        }

        $assetResized = clone $this;
        $assetResized->data['width'] = $width ?? $this->data['width'];
        $assetResized->data['height'] = $height ?? $this->data['height'];

        if ($this->isImageInCdn()) {
            if ($width === null) {
                $assetResized->data['width'] = round($this->data['width'] / ($this->data['height'] / $height));
            }
            if ($height === null) {
                $assetResized->data['height'] = round($this->data['height'] / ($this->data['width'] / $width));
            }

            return $assetResized; // returns asset with the new dimensions only: CDN do the rest of the job
        }

        $quality = (int) $this->config->get('assets.images.quality');

        $cache = new Cache($this->builder, 'assets');
        $assetResized->cacheTags['quality'] = $quality;
        $assetResized->cacheTags['width'] = $width;
        $assetResized->cacheTags['height'] = $height;
        $cacheKey = $cache->createKey($assetResized, tags: $assetResized->cacheTags);
        if (!$cache->has($cacheKey)) {
            $assetResized->data['content'] = Image::resize($assetResized, $width, $height, $quality, $rmAnimation);
            $assetResized->data['path'] = '/' . Util::joinPath(
                (string) $this->config->get('assets.target'),
                self::IMAGE_THUMB,
                (string) $width . 'x' . (string) $height,
                $assetResized->data['path']
            );
            $assetResized->data['path'] = $this->deduplicateThumbPath($assetResized->data['path']);
            $assetResized->data['width'] = $assetResized->getWidth();
            $assetResized->data['height'] = $assetResized->getHeight();
            $assetResized->data['size'] = \strlen($assetResized->data['content']);

            $cache->set($cacheKey, $assetResized->data, $this->config->get('cache.assets.ttl'));
            $this->builder->getLogger()->debug(\sprintf('Asset resized: "%s" (%sx%s)', $assetResized->data['path'], $width, $height));
        }
        $assetResized->data = $cache->get($cacheKey);

        return $assetResized;
    }

    /**
     * Creates a maskable image (with a padding = 20%).
     *
     * @throws RuntimeException
     */
    public function maskable(?int $padding = null): self
    {
        $this->checkImage();

        if ($padding === null) {
            $padding = 20; // default padding
        }

        $assetMaskable = clone $this;

        $quality = (int) $this->config->get('assets.images.quality');

        $cache = new Cache($this->builder, 'assets');
        $assetMaskable->cacheTags['maskable'] = true;
        $cacheKey = $cache->createKey($assetMaskable, tags: $assetMaskable->cacheTags);
        if (!$cache->has($cacheKey)) {
            $assetMaskable->data['content'] = Image::maskable($assetMaskable, $quality, $padding);
            $assetMaskable->data['path'] = '/' . Util::joinPath(
                (string) $this->config->get('assets.target'),
                'maskable',
                $assetMaskable->data['path']
            );
            $assetMaskable->data['size'] = \strlen($assetMaskable->data['content']);

            $cache->set($cacheKey, $assetMaskable->data, $this->config->get('cache.assets.ttl'));
            $this->builder->getLogger()->debug(\sprintf('Asset maskabled: "%s"', $assetMaskable->data['path']));
        }
        $assetMaskable->data = $cache->get($cacheKey);

        return $assetMaskable;
    }

    /**
     * Converts an image asset to $format format.
     *
     * @throws RuntimeException
     */
    public function convert(string $format, ?int $quality = null): self
    {
        if ($this->data['type'] != 'image') {
            throw new RuntimeException(\sprintf('Unable to convert "%s" (%s) to %s: not an image.', $this->data['path'], $this->data['type'], $format));
        }

        if ($quality === null) {
            $quality = (int) $this->config->get('assets.images.quality');
        }

        $asset = clone $this;
        $asset['ext'] = $format;
        $asset->data['subtype'] = "image/$format";

        if ($this->isImageInCdn()) {
            return $asset; // returns the asset with the new extension only: CDN do the rest of the job
        }

        $cache = new Cache($this->builder, 'assets');
        $this->cacheTags['quality'] = $quality;
        if ($this->data['width']) {
            $this->cacheTags['width'] = $this->data['width'];
        }
        $cacheKey = $cache->createKey($asset, tags: $this->cacheTags);
        if (!$cache->has($cacheKey)) {
            $asset->data['content'] = Image::convert($asset, $format, $quality);
            $asset->data['path'] = preg_replace('/\.' . $this->data['ext'] . '$/m', ".$format", $this->data['path']);
            $asset->data['size'] = \strlen($asset->data['content']);
            $cache->set($cacheKey, $asset->data, $this->config->get('cache.assets.ttl'));
            $this->builder->getLogger()->debug(\sprintf('Asset converted: "%s" (%s -> %s)', $asset->data['path'], $this->data['ext'], $format));
        }
        $asset->data = $cache->get($cacheKey);

        return $asset;
    }

    /**
     * Converts an image asset to WebP format.
     *
     * @throws RuntimeException
     */
    public function webp(?int $quality = null): self
    {
        return $this->convert('webp', $quality);
    }

    /**
     * Converts an image asset to AVIF format.
     *
     * @throws RuntimeException
     */
    public function avif(?int $quality = null): self
    {
        return $this->convert('avif', $quality);
    }

    /**
     * Is the asset an image and is it in CDN?
     */
    public function isImageInCdn(): bool
    {
        if (
            $this->data['type'] == 'image'
            && $this->config->isEnabled('assets.images.cdn')
            && $this->data['ext'] != 'ico'
            && (Image::isSVG($this) && $this->config->isEnabled('assets.images.cdn.svg'))
        ) {
            return true;
        }
        // handle remote image?
        if ($this->data['url'] !== null && $this->config->isEnabled('assets.images.cdn.remote')) {
            return true;
        }

        return false;
    }

    /**
     * Returns the width of an image/SVG or a video.
     *
     * @throws RuntimeException
     */
    public function getWidth(): ?int
    {
        switch ($this->data['type']) {
            case 'image':
                if (Image::isSVG($this) && false !== $svg = Image::getSvgAttributes($this)) {
                    return (int) $svg->width;
                }
                if (false === $size = $this->getImageSize()) {
                    throw new RuntimeException(\sprintf('Unable to get width of "%s".', $this->data['path']));
                }

                return $size[0];
            case 'video':
                return $this->getVideo()['width'];
        }

        return null;
    }

    /**
     * Returns the height of an image/SVG or a video.
     *
     * @throws RuntimeException
     */
    public function getHeight(): ?int
    {
        switch ($this->data['type']) {
            case 'image':
                if (Image::isSVG($this) && false !== $svg = Image::getSvgAttributes($this)) {
                    return (int) $svg->height;
                }
                if (false === $size = $this->getImageSize()) {
                    throw new RuntimeException(\sprintf('Unable to get height of "%s".', $this->data['path']));
                }

                return $size[1];
            case 'video':
                return $this->getVideo()['height'];
        }

        return null;
    }

    /**
     * Returns audio file infos:
     * - duration (in seconds.microseconds)
     * - bitrate (in bps)
     * - channel ('stereo', 'dual_mono', 'joint_stereo' or 'mono')
     *
     * @see https://github.com/wapmorgan/Mp3Info
     */
    public function getAudio(): array
    {
        $audio = new Mp3Info($this->data['file']);

        return [
            'duration' => $audio->duration,
            'bitrate'  => $audio->bitRate,
            'channel'  => $audio->channel,
        ];
    }

    /**
     * Returns video file infos:
     * - duration (in seconds)
     * - width (in pixels)
     * - height (in pixels)
     *
     * @see https://github.com/JamesHeinrich/getID3
     */
    public function getVideo(): array
    {
        if ($this->data['type'] !== 'video') {
            throw new RuntimeException(\sprintf('Unable to get video infos of "%s".', $this->data['path']));
        }

        $video = (new \getID3())->analyze($this->data['file']);

        return [
            'duration' => $video['playtime_seconds'],
            'width'    => $video['video']['resolution_x'],
            'height'   => $video['video']['resolution_y'],
        ];
    }

    /**
     * Builds a relative path from a URL.
     * Used for remote files.
     *
     * @deprecated Use Locator::buildPathFromUrl() instead.
     */
    public static function buildPathFromUrl(string $url): string
    {
        return Locator::buildPathFromUrl($url);
    }

    /**
     * Replaces some characters by '_'.
     *
     * @deprecated Use Locator::sanitize() instead.
     */
    public static function sanitize(string $string): string
    {
        return Locator::sanitize($string);
    }

    /**
     * Add hash to the file name.
     */
    protected function doFingerprint(): self
    {
        $hash = hash('xxh128', $this->data['content']);
        $this->data['path'] = preg_replace(
            '/\.' . $this->data['ext'] . '$/m',
            ".$hash." . $this->data['ext'],
            $this->data['path']
        );
        $this->builder->getLogger()->debug(\sprintf('Asset fingerprinted: "%s"', $this->data['path']));

        return $this;
    }

    /**
     * Compiles SCSS to CSS.
     */
    protected function doCompile(): self
    {
        $this->data = (new AssetCompiler($this->builder))->compile($this->data);

        return $this;
    }

    /**
     * Minifies a CSS or JS asset.
     */
    protected function doMinify(): self
    {
        // compile SCSS files first
        if ($this->data['ext'] === 'scss') {
            $this->doCompile();
        }
        $this->data = (new AssetOptimizer($this->builder))->minify($this->data);

        return $this;
    }

    /**
     * Optimizes an image file in-place.
     * Returns the new file size.
     */
    private function optimizeImage(string $filepath, string $path, int $quality): int
    {
        return (new AssetOptimizer($this->builder))->optimizeImage($filepath, $path, $quality);
    }

    /**
     * Returns image size informations.
     *
     * @see https://www.php.net/manual/function.getimagesize.php
     *
     * @throws RuntimeException
     */
    private function getImageSize(): array|false
    {
        if (!$this->data['type'] == 'image') {
            return false;
        }

        try {
            if (false === $size = getimagesizefromstring($this->data['content'])) {
                return false;
            }
        } catch (\Exception $e) {
            throw new RuntimeException(\sprintf('Handling asset "%s" failed: "%s".', $this->data['path'], $e->getMessage()));
        }

        return $size;
    }

    /**
     * Builds CDN image URL.
     */
    private function buildImageCdnUrl(): string
    {
        return str_replace(
            [
                '%account%',
                '%image_url%',
                '%width%',
                '%quality%',
                '%format%',
            ],
            [
                $this->config->get('assets.images.cdn.account') ?? '',
                ltrim($this->data['url'] ?? (string) new Url($this->builder, $this->data['path'], ['canonical' => $this->config->get('assets.images.cdn.canonical') ?? true]), '/'),
                $this->data['width'],
                (int) $this->config->get('assets.images.quality'),
                $this->data['ext'],
            ],
            (string) $this->config->get('assets.images.cdn.url')
        );
    }

    /**
     * Checks if the asset is not missing and is typed as an image.
     *
     * @throws RuntimeException
     */
    private function checkImage(): void
    {
        if ($this->isMissing()) {
            throw new RuntimeException(\sprintf('Unable to resize "%s": file not found.', $this->data['path']));
        }
        if ($this->data['type'] != 'image') {
            throw new RuntimeException(\sprintf('Unable to resize "%s": not an image.', $this->data['path']));
        }
    }

    /**
     * Remove redondant '/thumbnails/<width(xheight)>/' in the path.
     */
    private function deduplicateThumbPath(string $path): string
    {
        // https://regex101.com/r/0r7FMY/1
        $pattern = '/(' . self::IMAGE_THUMB . '\/(\d+){0,1}x(\d+){0,1}\/)(' . self::IMAGE_THUMB . '\/(\d+){0,1}x(\d+){0,1}\/)(.*)/i';

        if (null === $result = preg_replace($pattern, '$1$7', $path)) {
            return $path;
        }

        return $result;
    }
}

Cecilapp / Cecil / 26407566224

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous