Merge.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\View\Model\Layout;

use Magento\Framework\App\State;
use Magento\Framework\Config\Dom\ValidationException;
use Magento\Framework\Filesystem\DriverPool;
use Magento\Framework\Filesystem\File\ReadFactory;
use Magento\Framework\View\Layout\LayoutCacheKeyInterface;
use Magento\Framework\View\Model\Layout\Update\Validator;

class Merge implements \Magento\Framework\View\Layout\ProcessorInterface
{
    const DESIGN_ABSTRACTION_CUSTOM = 'custom';

    const DESIGN_ABSTRACTION_PAGE_LAYOUT = 'page_layout';

    const XPATH_HANDLE_DECLARATION = '/layout[@design_abstraction]';

    const TYPE_ATTRIBUTE = 'xsi:type';

    const PAGE_LAYOUT_CACHE_SUFFIX = 'page_layout';

    private $theme;

    private $scope;

    protected $layoutUpdatesCache;

    protected $updates = [];

    protected $handles = [];

    protected $pageHandles = [];

    protected $subst = null;

    private $fileSource;

    private $pageLayoutFileSource;

    private $appState;

    private $layoutCacheKey;

    protected $cache;

    protected $layoutValidator;

    protected $logger;

    protected $pageLayout;

    protected $cacheSuffix;

    protected $allHandles = [];

    protected $handleProcessing = 1;

    protected $handleProcessed = 2;

    private $readFactory;

    public function __construct(
        \Magento\Framework\View\DesignInterface $design,
        \Magento\Framework\Url\ScopeResolverInterface $scopeResolver,
        \Magento\Framework\View\File\CollectorInterface $fileSource,
        \Magento\Framework\View\File\CollectorInterface $pageLayoutFileSource,
        \Magento\Framework\App\State $appState,
        \Magento\Framework\Cache\FrontendInterface $cache,
        \Magento\Framework\View\Model\Layout\Update\Validator $validator,
        \Psr\Log\LoggerInterface $logger,
        ReadFactory $readFactory,
        \Magento\Framework\View\Design\ThemeInterface $theme = null,
        $cacheSuffix = '',
        LayoutCacheKeyInterface $layoutCacheKey = null
    ) {
        $this->theme = $theme ?: $design->getDesignTheme();
        $this->scope = $scopeResolver->getScope();
        $this->fileSource = $fileSource;
        $this->pageLayoutFileSource = $pageLayoutFileSource;
        $this->appState = $appState;
        $this->cache = $cache;
        $this->layoutValidator = $validator;
        $this->logger = $logger;
        $this->readFactory = $readFactory;
        $this->cacheSuffix = $cacheSuffix;
        $this->layoutCacheKey = $layoutCacheKey
            ?: \Magento\Framework\App\ObjectManager::getInstance()->get(LayoutCacheKeyInterface::class);
    }

    public function addUpdate($update)
    {
        if (!in_array($update, $this->updates)) {
            $this->updates[] = $update;
        }
        return $this;
    }

    public function asArray()
    {
        return $this->updates;
    }

    public function asString()
    {
        return implode('', $this->updates);
    }

    public function addHandle($handleName)
    {
        if (is_array($handleName)) {
            foreach ($handleName as $name) {
                $this->handles[$name] = 1;
            }
        } else {
            $this->handles[$handleName] = 1;
        }
        return $this;
    }

    public function removeHandle($handleName)
    {
        unset($this->handles[$handleName]);
        return $this;
    }

    public function getHandles()
    {
        return array_keys($this->handles);
    }

    public function addPageHandles(array $handlesToTry)
    {
        $handlesAdded = false;
        foreach ($handlesToTry as $handleName) {
            if (!$this->pageHandleExists($handleName)) {
                continue;
            }
            $handles[] = $handleName;
            $this->pageHandles = $handles;
            $this->addHandle($handles);
            $handlesAdded = true;
        }
        return $handlesAdded;
    }

    public function pageHandleExists($handleName)
    {
        return (bool)$this->_getPageHandleNode($handleName);
    }

    public function getPageLayout()
    {
        return $this->pageLayout;
    }

    public function isLayoutDefined()
    {
        $fullLayoutXml = $this->getFileLayoutUpdatesXml();
        foreach ($this->getHandles() as $handle) {
            if ($fullLayoutXml->xpath("layout[@id='{$handle}']")) {
                return true;
            }
        }
        return false;
    }

    protected function _getPageHandleNode($handleName)
    {
        /* quick validation for non-existing page types */
        if (!$handleName) {
            return null;
        }
        $handles = $this->getFileLayoutUpdatesXml()->xpath("handle[@id='{$handleName}']");
        if (empty($handles)) {
            return null;
        }
        $nodes = $this->getFileLayoutUpdatesXml()->xpath("/layouts/handle[@id=\"{$handleName}\"]");
        return $nodes ? reset($nodes) : null;
    }

    public function getPageHandles()
    {
        return $this->pageHandles;
    }

    public function getAllDesignAbstractions()
    {
        $result = [];

        $conditions = [
            '(@design_abstraction="' . self::DESIGN_ABSTRACTION_PAGE_LAYOUT .
            '" or @design_abstraction="' . self::DESIGN_ABSTRACTION_CUSTOM . '")',
        ];
        $xpath = '/layouts/*[' . implode(' or ', $conditions) . ']';
        $nodes = $this->getFileLayoutUpdatesXml()->xpath($xpath) ?: [];
        foreach ($nodes as $node) {
            $name = $node->getAttribute('id');
            $info = [
                'name' => $name,
                'label' => (string)new \Magento\Framework\Phrase((string)$node->getAttribute('label')),
                'design_abstraction' => $node->getAttribute('design_abstraction'),
            ];
            $result[$name] = $info;
        }
        return $result;
    }

    public function getPageHandleType($handleName)
    {
        $node = $this->_getPageHandleNode($handleName);
        return $node ? $node->getAttribute('type') : null;
    }

    public function load($handles = [])
    {
        if (is_string($handles)) {
            $handles = [$handles];
        } elseif (!is_array($handles)) {
            throw new \Magento\Framework\Exception\LocalizedException(
                new \Magento\Framework\Phrase('Invalid layout update handle')
            );
        }

        $this->addHandle($handles);

        $cacheId = $this->getCacheId();
        $cacheIdPageLayout = $cacheId . '_' . self::PAGE_LAYOUT_CACHE_SUFFIX;
        $result = $this->_loadCache($cacheId);
        if ($result) {
            $this->addUpdate($result);
            $this->pageLayout = $this->_loadCache($cacheIdPageLayout);
            foreach ($this->getHandles() as $handle) {
                $this->allHandles[$handle] = $this->handleProcessed;
            }
            return $this;
        }

        foreach ($this->getHandles() as $handle) {
            $this->_merge($handle);
        }

        $layout = $this->asString();
        $this->_validateMergedLayout($cacheId, $layout);
        $this->_saveCache($layout, $cacheId, $this->getHandles());
        $this->_saveCache((string)$this->pageLayout, $cacheIdPageLayout, $this->getHandles());
        return $this;
    }

    protected function _validateMergedLayout($cacheId, $layout)
    {
        $layoutStr = '<handle id="handle">' . $layout . '</handle>';

        try {
            $this->layoutValidator->isValid($layoutStr, Validator::LAYOUT_SCHEMA_MERGED, false);
        } catch (\Exception $e) {
            $messages = $this->layoutValidator->getMessages();
            //Add first message to exception
            $message = reset($messages);
            $this->logger->info(
                'Cache file with merged layout: ' . $cacheId
                . ' and handles ' . implode(', ', (array)$this->getHandles()) . ': ' . $message
            );
            if ($this->appState->getMode() === \Magento\Framework\App\State::MODE_DEVELOPER) {
                throw $e;
            }
        }

        return $this;
    }

    public function asSimplexml()
    {
        $updates = trim($this->asString());
        $updates = '<?xml version="1.0"?>'
            . '<layout xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
            . $updates
            . '</layout>';
        return $this->_loadXmlString($updates);
    }

    protected function _loadXmlString($xmlString)
    {
        return simplexml_load_string($xmlString, \Magento\Framework\View\Layout\Element::class);
    }

    protected function _merge($handle)
    {
        if (!isset($this->allHandles[$handle])) {
            $this->allHandles[$handle] = $this->handleProcessing;
            $this->_fetchPackageLayoutUpdates($handle);
            $this->_fetchDbLayoutUpdates($handle);
            $this->allHandles[$handle] = $this->handleProcessed;
        } elseif ($this->allHandles[$handle] == $this->handleProcessing
            && $this->appState->getMode() === \Magento\Framework\App\State::MODE_DEVELOPER
        ) {
            $this->logger->info('Cyclic dependency in merged layout for handle: ' . $handle);
        }
        return $this;
    }

    protected function _fetchPackageLayoutUpdates($handle)
    {
        $_profilerKey = 'layout_package_update:' . $handle;
        \Magento\Framework\Profiler::start($_profilerKey);
        $layout = $this->getFileLayoutUpdatesXml();
        foreach ($layout->xpath("*[self::handle or self::layout][@id='{$handle}']") as $updateXml) {
            $this->_fetchRecursiveUpdates($updateXml);
            $updateInnerXml = $updateXml->innerXml();
            $this->validateUpdate($handle, $updateInnerXml);
            $this->addUpdate($updateInnerXml);
        }
        \Magento\Framework\Profiler::stop($_profilerKey);

        return true;
    }

    protected function _fetchDbLayoutUpdates($handle)
    {
        $_profilerKey = 'layout_db_update: ' . $handle;
        \Magento\Framework\Profiler::start($_profilerKey);
        $updateStr = $this->getDbUpdateString($handle);
        if (!$updateStr) {
            \Magento\Framework\Profiler::stop($_profilerKey);
            return false;
        }
        $updateStr = '<update_xml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' .
            $updateStr .
            '</update_xml>';
        $updateStr = $this->_substitutePlaceholders($updateStr);
        $updateXml = $this->_loadXmlString($updateStr);
        $this->_fetchRecursiveUpdates($updateXml);
        $updateInnerXml = $updateXml->innerXml();
        $this->validateUpdate($handle, $updateInnerXml);
        $this->addUpdate($updateInnerXml);

        \Magento\Framework\Profiler::stop($_profilerKey);
        return (bool)$updateStr;
    }

    public function validateUpdate($handle, $updateXml)
    {
        return;
    }

    protected function _substitutePlaceholders($xmlString)
    {
        if ($this->subst === null) {
            $placeholders = [
                'baseUrl' => $this->scope->getBaseUrl(),
                'baseSecureUrl' => $this->scope->getBaseUrl(\Magento\Framework\UrlInterface::URL_TYPE_LINK, true),
            ];
            $this->subst = [];
            foreach ($placeholders as $key => $value) {
                $this->subst['from'][] = '{{' . $key . '}}';
                $this->subst['to'][] = $value;
            }
        }
        return str_replace($this->subst['from'], $this->subst['to'], $xmlString);
    }

    public function getDbUpdateString($handle)
    {
        return null;
    }

    protected function _fetchRecursiveUpdates($updateXml)
    {
        foreach ($updateXml->children() as $child) {
            if (strtolower($child->getName()) == 'update' && isset($child['handle'])) {
                $this->_merge((string)$child['handle']);
            }
        }
        if (isset($updateXml['layout'])) {
            $this->pageLayout = (string)$updateXml['layout'];
        }
        return $this;
    }

    public function getFileLayoutUpdatesXml()
    {
        if ($this->layoutUpdatesCache) {
            return $this->layoutUpdatesCache;
        }
        $cacheId = $this->generateCacheId($this->cacheSuffix);
        $result = $this->_loadCache($cacheId);
        if ($result) {
            $result = $this->_loadXmlString($result);
        } else {
            $result = $this->_loadFileLayoutUpdatesXml();
            $this->_saveCache($result->asXML(), $cacheId);
        }
        $this->layoutUpdatesCache = $result;
        return $result;
    }

    protected function generateCacheId($suffix = '')
    {
        return "LAYOUT_{$this->theme->getArea()}_STORE{$this->scope->getId()}_{$this->theme->getId()}{$suffix}";
    }

    protected function _loadCache($cacheId)
    {
        return $this->cache->load($cacheId);
    }

    protected function _saveCache($data, $cacheId, array $cacheTags = [])
    {
        $this->cache->save($data, $cacheId, $cacheTags, null);
    }

    protected function _loadFileLayoutUpdatesXml()
    {
        $layoutStr = '';
        $theme = $this->_getPhysicalTheme($this->theme);
        $updateFiles = $this->fileSource->getFiles($theme, '*.xml');
        $updateFiles = array_merge($updateFiles, $this->pageLayoutFileSource->getFiles($theme, '*.xml'));
        $useErrors = libxml_use_internal_errors(true);
        foreach ($updateFiles as $file) {
            $fileReader = $this->readFactory->create($file->getFilename(), DriverPool::FILE);
            $fileStr = $fileReader->readAll($file->getName());
            $fileStr = $this->_substitutePlaceholders($fileStr);
            $fileXml = $this->_loadXmlString($fileStr);
            if (!$fileXml instanceof \Magento\Framework\View\Layout\Element) {
                $xmlErrors = $this->getXmlErrors(libxml_get_errors());
                $this->_logXmlErrors($file->getFilename(), $xmlErrors);
                if ($this->appState->getMode() === State::MODE_DEVELOPER) {
                    throw new ValidationException(
                        new \Magento\Framework\Phrase(
                            "Theme layout update file '%1' is not valid.\n%2",
                            [
                                $file->getFilename(),
                                implode("\n", $xmlErrors)
                            ]
                        )
                    );
                }
                libxml_clear_errors();
                continue;
            }
            if (!$file->isBase() && $fileXml->xpath(self::XPATH_HANDLE_DECLARATION)) {
                throw new \Magento\Framework\Exception\LocalizedException(
                    new \Magento\Framework\Phrase(
                        'Theme layout update file \'%1\' must not declare page types.',
                        [$file->getFileName()]
                    )
                );
            }
            $handleName = basename($file->getFilename(), '.xml');
            $tagName = $fileXml->getName() === 'layout' ? 'layout' : 'handle';
            $handleAttributes = ' id="' . $handleName . '"' . $this->_renderXmlAttributes($fileXml);
            $handleStr = '<' . $tagName . $handleAttributes . '>' . $fileXml->innerXml() . '</' . $tagName . '>';
            $layoutStr .= $handleStr;
        }
        libxml_use_internal_errors($useErrors);
        $layoutStr = '<layouts xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' . $layoutStr . '</layouts>';
        $layoutXml = $this->_loadXmlString($layoutStr);
        return $layoutXml;
    }

    protected function _logXmlErrors($fileName, $xmlErrors)
    {
        $this->logger->info(
            sprintf("Theme layout update file '%s' is not valid.\n%s", $fileName, implode("\n", $xmlErrors))
        );
    }

    private function getXmlErrors($libXmlErrors)
    {
        $errors = [];
        if (count($libXmlErrors)) {
            foreach ($libXmlErrors as $error) {
                $errors[] = "{$error->message} Line: {$error->line}";
            }
        }
        return $errors;
    }

    protected function _getPhysicalTheme(\Magento\Framework\View\Design\ThemeInterface $theme)
    {
        $result = $theme;
        while ($result !== null && $result->getId() && !$result->isPhysical()) {
            $result = $result->getParentTheme();
        }
        if (!$result) {
            throw new \Magento\Framework\Exception\LocalizedException(
                new \Magento\Framework\Phrase(
                    'Unable to find a physical ancestor for a theme \'%1\'.',
                    [$theme->getThemeTitle()]
                )
            );
        }
        return $result;
    }

    protected function _renderXmlAttributes(\SimpleXMLElement $node)
    {
        $result = '';
        foreach ($node->attributes() as $attributeName => $attributeValue) {
            $result .= ' ' . $attributeName . '="' . $attributeValue . '"';
        }
        return $result;
    }

    public function getContainers()
    {
        $result = [];
        $containerNodes = $this->asSimplexml()->xpath('//container');
        foreach ($containerNodes as $oneContainerNode) {
            $label = $oneContainerNode->getAttribute('label');
            if ($label) {
                $result[$oneContainerNode->getAttribute('name')] = (string)new \Magento\Framework\Phrase($label);
            }
        }
        return $result;
    }

    public function __destruct()
    {
        $this->updates = [];
        $this->layoutUpdatesCache = null;
    }

    public function isCustomerDesignAbstraction(array $abstraction)
    {
        if (!isset($abstraction['design_abstraction'])) {
            return false;
        }
        return $abstraction['design_abstraction'] === self::DESIGN_ABSTRACTION_CUSTOM;
    }

    public function isPageLayoutDesignAbstraction(array $abstraction)
    {
        if (!isset($abstraction['design_abstraction'])) {
            return false;
        }
        return $abstraction['design_abstraction'] === self::DESIGN_ABSTRACTION_PAGE_LAYOUT;
    }

    public function getTheme()
    {
        return $this->theme;
    }

    public function getScope()
    {
        return $this->scope;
    }

    public function getCacheId()
    {
        $layoutCacheKeys = $this->layoutCacheKey->getCacheKeys();
        return $this->generateCacheId(md5(implode('|', array_merge($this->getHandles(), $layoutCacheKeys))));
    }
}