DomMerger.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\View\Element\UiComponent\Config;

use Magento\Framework\Config\Dom;
use Magento\Framework\Config\ValidationStateInterface;

class DomMerger implements DomMergerInterface
{
    const ERROR_FORMAT_DEFAULT = "Message: %message%\nLine: %line%\n";

    private $validationState;

    protected $schemaFilePath;

    protected $domDocument;

    protected $idAttributes = [];

    protected $contextXPath = [];

    protected $isMergeSimpleXMLElement;

    private $schema;

    public function __construct(
        ValidationStateInterface $validationState,
        $schema,
        $isMergeSimpleXMLElement = false,
        array $contextXPath = [],
        array $idAttributes = []
    ) {
        $this->validationState = $validationState;
        $this->schema = $schema;
        $this->isMergeSimpleXMLElement = $isMergeSimpleXMLElement;
        $this->contextXPath = $contextXPath;
        $this->idAttributes = $idAttributes;
    }

    protected function isIdAttribute($attributeName)
    {
        return in_array($attributeName, $this->idAttributes);
    }

    protected function isMergeContext($xPath)
    {
        foreach ($this->contextXPath as $context) {
            if (strpos($xPath, $context) === 0) {
                return true;
            }
        }
        return false;
    }

    protected function isContextXPath(array $xPath)
    {
        return count(array_intersect($xPath, $this->contextXPath)) === count($xPath);
    }

    protected function mergeAttributes(\DOMElement $baseNode, \DOMNode $mergeNode)
    {
        foreach ($mergeNode->attributes as $name => $attribute) {
            $baseNode->setAttribute($name, $attribute->value);
        }
    }

    protected function createXPath(\DOMNode $node)
    {
        $parentXPath = '';
        $currentXPath = $node->getNodePath();
        if ($node->parentNode !== null && !$node->isSameNode($node->parentNode)) {
            $parentXPath = $this->createXPath($node->parentNode);
            $pathParts = explode('/', $currentXPath);
            $currentXPath = '/' . end($pathParts);
        }
        $attributesXPath = '';
        if ($node->hasAttributes()) {
            $attributes = [];
            foreach ($node->attributes as $name => $attribute) {
                if ($this->isIdAttribute($name)) {
                    $attributes[] = sprintf('@%s="%s"', $name, $attribute->value);
                    break;
                }
            }
            if (!empty($attributes)) {
                if (substr($currentXPath, -1) === ']') {
                    $currentXPath = substr($currentXPath, 0, strrpos($currentXPath, '['));
                }
                $attributesXPath = '[' . implode(' and ', $attributes) . ']';
            }
        }
        return '/' . trim($parentXPath . $currentXPath . $attributesXPath, '/');
    }

    protected function nestedMerge(\DOMXPath $rootDomXPath, \DOMNodeList $insertedNodes, \DOMNode $contextNode)
    {
        for ($i = 0, $iLength = $insertedNodes->length; $i < $iLength; ++$i) {
            $insertedItem = $insertedNodes->item($i);
            switch ($insertedItem->nodeType) {
                case XML_TEXT_NODE:
                case XML_COMMENT_NODE:
                case XML_CDATA_SECTION_NODE:
                    if (trim($insertedItem->textContent) !== '') {
                        $this->insertBefore($contextNode, $insertedItem);
                    }
                    break;
                default:
                    $insertedXPath = $this->createXPath($insertedItem);
                    $rootMatchList = $rootDomXPath->query($insertedXPath, $contextNode);
                    $jLength = $rootMatchList->length;
                    if ($jLength > 0) {
                        for ($j = 0; $j < $jLength; ++$j) {
                            $rootItem = $rootMatchList->item($j);
                            $rootItemXPath = $this->createXPath($rootItem);
                            if ($this->isMergeContext($insertedXPath)) {
                                if ($this->isTextNode($insertedItem) && $this->isTextNode($rootItem)) {
                                    $rootItem->nodeValue = $insertedItem->nodeValue;
                                } elseif (!$this->isContextXPath([$rootItemXPath, $insertedXPath])
                                    && !$this->hasIdAttribute($rootItem)
                                    && !$this->hasIdAttribute($insertedItem)
                                ) {
                                    if ($this->isMergeSimpleXMLElement) {
                                        $this->nestedMerge($rootDomXPath, $insertedItem->childNodes, $rootItem);
                                        $this->mergeAttributes($rootItem, $insertedItem);
                                    } else {
                                        $this->appendChild($contextNode, $insertedItem);
                                    }
                                } else {
                                    $this->nestedMerge($rootDomXPath, $insertedItem->childNodes, $rootItem);
                                    $this->mergeAttributes($rootItem, $insertedItem);
                                }
                            } else {
                                $this->appendChild($contextNode, $insertedItem);
                            }
                        }
                    } else {
                        $this->appendChild($contextNode, $insertedItem);
                    }
                    break;
            }
        }
    }

    protected function appendChild(\DOMNode $parentNode, \DOMNode $childNode)
    {
        $importNode = $this->getDom()->importNode($childNode, true);
        $parentNode->appendChild($importNode);
    }

    protected function insertBefore(\DOMNode $parentNode, \DOMNode $childNode)
    {
        $importNode = $this->getDom()->importNode($childNode, true);
        $parentNode->insertBefore($importNode);
    }

    protected function isTextNode(\DOMNode $node)
    {
        return $node->childNodes->length == 1 && $node->childNodes->item(0) instanceof \DOMText;
    }

    protected function hasIdAttribute(\DOMNode $node)
    {
        if (!$node->hasAttributes()) {
            return false;
        }

        foreach ($node->attributes as $name => $attribute) {
            if (in_array($name, $this->idAttributes)) {
                return true;
            }
        }

        return false;
    }

    public function mergeNode(\DOMElement $node)
    {
        $parentDoom = $this->getDom();
        $this->nestedMerge(new \DOMXPath($parentDoom), $node->childNodes, $parentDoom->documentElement);
    }

    public function createDomDocument($xml)
    {
        $domDocument = new \DOMDocument();
        $domDocument->loadXML($xml);
        if ($this->validationState->isValidationRequired() && $this->schema) {
            $errors = $this->validateDomDocument($domDocument);
            if (count($errors)) {
                throw new \Magento\Framework\Exception\LocalizedException(
                    new \Magento\Framework\Phrase(implode("\n", $errors))
                );
            }
        }

        return $domDocument;
    }

    protected function validateDomDocument(\DOMDocument $domDocument, $schema = null)
    {
        $schema = $schema !== null ? $schema : $this->schema;
        libxml_use_internal_errors(true);
        try {
            $errors = \Magento\Framework\Config\Dom::validateDomDocument($domDocument, $schema);
        } catch (\Exception $exception) {
            libxml_use_internal_errors(false);
            throw $exception;
        }
        libxml_use_internal_errors(false);

        return $errors;
    }

    protected function renderErrorMessage(\LibXMLError $errorInfo)
    {
        $result = static::ERROR_FORMAT_DEFAULT;
        foreach ($errorInfo as $field => $value) {
            $result = str_replace('%' . $field . '%', trim((string)$value), $result);
        }
        if (strpos($result, '%') !== false) {
            throw new \Magento\Framework\Exception\LocalizedException(
                new \Magento\Framework\Phrase(
                    'Error format "' . static::ERROR_FORMAT_DEFAULT . '" contains unsupported placeholders.'
                )
            );
        }

        return $result;
    }

    public function merge($xml)
    {
        if (!isset($this->domDocument)) {
            $this->domDocument = $this->createDomDocument($xml);
        } else {
            $this->mergeNode($this->createDomDocument($xml)->documentElement);
        }
    }

    public function getDom()
    {
        if (!isset($this->domDocument)) {
            throw new \Magento\Framework\Exception\LocalizedException(
                new \Magento\Framework\Phrase('Object DOMDocument should be created.')
            );
        }

        return $this->domDocument;
    }

    public function setDom(\DOMDocument $domDocument)
    {
        $this->domDocument = $domDocument;
    }

    public function unsetDom()
    {
        unset($this->domDocument);
    }

    public function validate($schemaFilePath = null)
    {
        if (!$this->validationState->isValidationRequired()) {
            return [];
        }
        return $this->validateDomDocument($this->getDom(), $schemaFilePath);
    }
}