Ocubom\Twig\Extension\Svg\Util\DomHelper

Complexity

Total Complexity

26

Size/Duplication

Total Lines	293
Duplicated Lines	0 %

Test Coverage

Coverage

91.18%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	createElement()	0	25	5
A	replaceNode()	0	18	1
A	appendChildNode()	0	14	2
B	configureDocumentOptions()	0	94	2
A	query()	0	17	3
A	cloneNode()	0	11	2
A	removeNode()	0	6	1
A	toHtml()	0	16	2
A	toXml()	0	17	2
A	appendChildElement()	0	8	1
A	cloneElement()	0	10	1
A	__construct()	0	2	1
A	createDocument()	0	22	3

<?php

/*
 * This file is part of ocubom/twig-svg-extension
 *
 * © Oscar Cubo Medina <https://ocubom.github.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Ocubom\Twig\Extension\Svg\Util;

use function BenTools\IterableFunctions\iterable_to_array;

use Ocubom\Twig\Extension\Svg\Exception\RuntimeException;
use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;

/** @internal */
final class DomHelper
{
    /** @var OptionsResolver[] */
    private static array $resolver = [];
    private static \DOMDocument $doc;

    // @codeCoverageIgnoreStart
    private function __construct()
    {
    }
    // @codeCoverageIgnoreEnd

    public static function createDocument(iterable $options = null): \DOMDocument
    {
        $resolver = self::$resolver[__METHOD__] = self::$resolver[__METHOD__]
            ?? self::configureDocumentOptions();

        // Resolve options
        $options = $resolver->resolve(iterable_to_array($options ?? []));

        // Create document
        $doc = new \DOMDocument($options['version'], $options['encoding']);

        // Apply options
        foreach ($options as $key => $val) {
            if (in_array($key, ['version', 'encoding', 'standalone'])) {
                continue; // Ignore constructor arguments and deprecated options
            }

            // Apply property
            $doc->{$key} = $val;
        }

        return $doc;
    }

    public static function appendChildElement(
        \DOMElement $element,
        \DOMNode $parent
    ): \DOMElement {
        $child = self::appendChildNode($element, $parent);
        assert($child instanceof \DOMElement);

        return $child;
    }

    public static function appendChildNode(
        \DOMNode $node,
        \DOMNode $parent
    ): \DOMNode {
        assert($parent->ownerDocument instanceof \DOMDocument);

        $child = $parent->appendChild(
            $parent->ownerDocument === $node->ownerDocument
                ? $node->cloneNode(true)
                : $parent->ownerDocument->importNode($node, true)
        );
        assert($child instanceof \DOMNode);

        return $child;
    }

    public static function cloneElement(
        \DOMElement $element,
        bool $deep = true,
        \DOMDocument $document = null
    ): \DOMElement {
        $clone = self::cloneNode($element, $deep, $document);

        assert($clone instanceof \DOMElement);

        return $clone;
    }

    public static function cloneNode(
        \DOMNode $node,
        bool $deep = true,
        \DOMDocument $document = null
    ): \DOMNode {
        $doc = $document ?? self::createDocument();

        $clone = $node->ownerDocument === $doc ? $node->cloneNode($deep) : $doc->importNode($node, $deep);
        assert($clone instanceof \DOMNode);

        return $clone;
    }

    public static function createElement(
        string $name,
        string $value = '',
        \DOMNode $node = null
    ): \DOMElement {
        try {
            // Get node document ($node if is a DOMdocument)
            $doc = $node instanceof \DOMNode
                ? ($node->ownerDocument ?? $node)
                : self::createDocument();
            assert($doc instanceof \DOMDocument);

            $new = $doc->createElement($name, $value);
            if (null === $node || $doc === $node) {
                // Append child to the document
                $new = $doc->appendChild($new);
            } else {
                // Insert child before the end of the element
                $new = $node->insertBefore($new);
            }
            assert($new instanceof \DOMElement);

            return $new;
        } catch (\DOMException $exc) { // @codeCoverageIgnore
            throw new RuntimeException($exc->getMessage(), $exc->getCode(), $exc); // @codeCoverageIgnore
        }
    }

    public static function query(
        string $expression,
        \DOMNode $node,
        bool $registerNodeNS = true
    ): \DOMNodeList {
        $doc = $node instanceof \DOMDocument ? $node : $node->ownerDocument;
        assert($doc instanceof \DOMDocument);

        $nodes = (new \DOMXPath($doc))->query(
            $expression,
            $node instanceof \DOMDocument ? null : $node,
            $registerNodeNS
        );

        assert($nodes instanceof \DOMNodeList);

        return $nodes;
    }

    public static function removeNode(
        \DOMNode $node
    ): void {
        assert($node->parentNode instanceof \DOMNode);

        $node->parentNode->removeChild($node);
    }

    public static function replaceNode(
        \DOMNode $old,
        \DOMNode $new
    ): \DOMNode {
        $doc = $old->ownerDocument;
        assert($doc instanceof \DOMDocument);

        // Clone new node in the document
        $new = $doc->importNode($new, true);
        assert($new instanceof \DOMNode);

        // Obtain parent
        $parent = $old->parentNode;
        assert($parent instanceof \DOMNode);

        $parent->replaceChild($new, $old);

        return $new;
    }

    public static function toHtml(
        \DOMNode $node
    ): string {
        assert($node->ownerDocument instanceof \DOMDocument);

        $output = $node->ownerDocument->saveHTML($node);
        if (false === $output) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException(sprintf(
                'Unable to convert %s to HTML',
                get_class($node)
            ));
            // @codeCoverageIgnoreEnd
        }

        return $output;
    }

    public static function toXml(
        \DOMNode $node,
        int $options = 0
    ): string {
        assert($node->ownerDocument instanceof \DOMDocument);

        $output = $node->ownerDocument->saveXML($node, $options);
        if (false === $output) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException(sprintf(
                'Unable to convert %s to XML',
                get_class($node)
            ));
            // @codeCoverageIgnoreEnd
        }

        return $output;
    }

    private static function configureDocumentOptions(OptionsResolver $resolver = null): OptionsResolver
    {
        $resolver = $resolver ?? new OptionsResolver();

        $resolver->define('encoding')
            ->default('')
            ->allowedTypes('string')
            ->info('Encoding of the document, as specified by the XML declaration');

        $resolver->define('standalone')
            ->default(true)
            ->allowedTypes('bool')
            ->deprecated(
                'ocubom/twig-svg-extension',
                '1.0',
                'The option "standalone" is deprecated, use "xmlStandalone" instead.'
            )
            ->info('Whether or not the document is standalone, as specified by the XML declaration');

        $resolver->define('xmlStandalone')
            ->default(true)
            ->allowedTypes('null', 'bool')
            ->normalize(function (Options $options, ?bool $value): bool {
                return $value ?? (bool) $options
                    ->/* @scrutinizer ignore-call */ offsetGet('standalone', false);
            })
            ->info('Whether or not the document is standalone, as specified by the XML declaration');

        $resolver->define('version')
            ->default('1.0')
            ->allowedTypes('string')
            ->deprecated(
                'ocubom/twig-svg-extension',
                '1.0',
                'The option "version" is deprecated, use "xmlVersion" instead.'
            )
            ->info('The version number of this document, as specified by the XML declaration');

        $resolver->define('xmlVersion')
            ->default('1.0')
            ->allowedTypes('null', 'string')
            ->normalize(function (Options $options, ?string $value): string {
                return $value ?? (string) $options
                    ->/* @scrutinizer ignore-call */ offsetGet('version', false);
            })
            ->info('The version number of this document, as specified by the XML declaration');

        $resolver->define('strictErrorChecking')
            ->default(true)
            ->allowedTypes('bool')
            ->info('Throws \DOMException on errors');

        $resolver->define('documentURI')
            ->default(null)
            ->allowedTypes('null', 'string')
            ->info('The location of the document');

        $resolver->define('formatOutput')
            ->default(true) // LibXML default is false
            ->allowedTypes('bool')
            ->info('Nicely formats output with indentation and extra space');

        $resolver->define('validateOnParse')
            ->default(false)
            ->allowedTypes('bool')
            ->info('Loads and validates against the DTD');

        $resolver->define('resolveExternals')
            ->default(false)
            ->allowedTypes('bool')
            ->info('Load external entities from a doctype declaration');

        $resolver->define('preserveWhiteSpace')
            ->default(true)
            ->allowedTypes('bool')
            ->normalize(function (Options $options, bool $value): bool {
                // Must be false to enable formatOutput
                return $options['formatOutput'] ? false : $value;
            })
            ->info('Do not remove redundant white space');

        // LibXML specific
        $resolver->define('recover')
            ->default(false)
            ->allowedTypes('bool')
            ->info('Enables recovery mode');

        // LibXML specific
        $resolver->define('substituteEntities')
            ->default(false)
            ->allowedTypes('bool')
            ->info('Whether or not to substitute entities');

        return $resolver;
    }
}