CssUrls.php

Go to the documentation of this file.

<?php
namespace Magento\Deploy\Package\Processor\PostProcessor;

use Magento\Deploy\Console\DeployStaticOptions;
use Magento\Deploy\Package\Package;
use Magento\Deploy\Package\PackageFile;
use Magento\Deploy\Package\Processor\ProcessorInterface;
use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\Exception\NotFoundException;
use Magento\Framework\Filesystem;
use Magento\Framework\View\Url\CssResolver;
use Magento\Framework\View\Asset\Minification;

class CssUrls implements ProcessorInterface
{
    private $staticDir;

    private $minification;

    private $options = [];

    public function __construct(Filesystem $filesystem, Minification $minification)
    {
        $this->staticDir = $filesystem->getDirectoryWrite(DirectoryList::STATIC_VIEW);
        $this->minification = $minification;
    }

    public function process(Package $package, array $options)
    {
        $this->options = $options;
        if ($this->options[DeployStaticOptions::NO_CSS] === true) {
            return false;
        }
        $urlMap = [];
        foreach (array_keys($package->getMap()) as $fileId) {
            $filePath = str_replace(\Magento\Framework\View\Asset\Repository::FILE_ID_SEPARATOR, '/', $fileId);
            if (strtolower(pathinfo($fileId, PATHINFO_EXTENSION)) == 'css') {
                $urlMap = $this->parseCss(
                    $urlMap,
                    $filePath,
                    $package->getPath(),
                    $this->staticDir->readFile(
                        $this->minification->addMinifiedSign($package->getPath() . '/' . $filePath)
                    ),
                    $package
                );
            }
        }
        $this->updateCssUrls($urlMap);
        return true;
    }

    private function parseCss(array $urlMap, $cssFilePath, $packagePath, $cssContent, Package $package)
    {
        $cssFilePath = $this->minification->addMinifiedSign($cssFilePath);

        $cssFileBasePath = pathinfo($cssFilePath, PATHINFO_DIRNAME);
        $urls = $this->getCssUrls($cssContent);
        foreach ($urls as $url) {
            if ($this->isExternalUrl($url)) {
                $urlMap[$url][] = [
                    'filePath' => $this->minification->addMinifiedSign($packagePath . '/' . $cssFilePath),
                    'replace' => $this->getValidExternalUrl($url, $package)
                ];
                continue;
            }
            $filePath = $this->getNormalizedFilePath($packagePath . '/' . $cssFileBasePath . '/' . $url);
            if ($this->staticDir->isReadable($this->minification->addMinifiedSign($filePath))) {
                continue;
            }
            $lookupFileId = $this->getNormalizedFilePath($cssFileBasePath . '/' . $url);
            $matchedFile = $this->getFileFromParent($lookupFileId, $package);
            if ($matchedFile) {
                $urlMap[$url][] = [
                    'filePath' => $this->minification->addMinifiedSign($packagePath . '/' . $cssFilePath),
                    'replace' => '../../../../' // base path is always of four chunks size
                        . str_repeat('../', count(explode('/', $cssFileBasePath)))
                        . $this->minification->addMinifiedSign($matchedFile->getDeployedFilePath())
                ];
            }
        }
        return $urlMap;
    }

    private function updateCssUrls(array $urlMap)
    {
        foreach ($urlMap as $ref => $targetFiles) {
            foreach ($targetFiles as $matchedFileData) {
                $filePath = $matchedFileData['filePath'];
                $oldCss = $this->staticDir->readFile($filePath);
                $newCss = str_replace($ref, $matchedFileData['replace'], $oldCss);
                if ($oldCss !== $newCss) {
                    $this->staticDir->writeFile($filePath, $newCss);
                }
            }
        }
    }

    private function getCssUrls($cssContent)
    {
        $urls = [];
        preg_match_all(CssResolver::REGEX_CSS_RELATIVE_URLS, $cssContent, $matches);
        if (!empty($matches[0]) && !empty($matches[1])) {
            $urls = array_combine($matches[0], $matches[1]);
        }
        return $urls;
    }

    private function getNormalizedFilePath($url)
    {
        $urlParts = explode('/', $url);
        $result = [];
        if (preg_match('/{{.*}}/', $url)) {
            foreach (array_reverse($urlParts) as $index => $part) {
                if (!preg_match('/^{{.*}}$/', $part)) {
                    $result[] = $part;
                } else {
                    break;
                }
            }
            return implode('/', array_reverse($result));
        }
        $prevIndex = 0;
        foreach ($urlParts as $index => $part) {
            if ($part == '..') {
                unset($urlParts[$index]);
                unset($urlParts[$prevIndex]);
                --$prevIndex;
            } else {
                $prevIndex = $index;
            }
        }
        return implode('/', $urlParts);
    }

    private function getValidExternalUrl($url, Package $package)
    {
        $url = $this->minification->removeMinifiedSign($url);
        $filePath = $this->getNormalizedFilePath($url);
        if (!$this->isFileExistsInPackage($filePath, $package)) {
            $matchedFile = $this->getFileFromParent($filePath, $package);
            $package = $matchedFile->getPackage();
        }
        return preg_replace(
            '/(?<=}})(.*)(?=\/{{)/',
            $package->getArea() . '/' . $package->getTheme(),
            $this->minification->addMinifiedSign($url)
        );
    }

    private function getFileFromParent($fileName, Package $currentPackage)
    {
        foreach (array_reverse($currentPackage->getParentPackages()) as $package) {
            foreach ($package->getFiles() as $file) {
                if ($file->getDeployedFileName() === $fileName) {
                    return $file;
                }
            }
        }
        return null;
    }

    private function isExternalUrl($url)
    {
        return preg_match('/{{.*}}/', $url);
    }

    private function isFileExistsInPackage($filePath, Package $package)
    {
        foreach ($package->getFiles() as $file) {
            if ($file->getDeployedFileName() === $filePath) {
                return true;
            }
        }
        return false;
    }
}