DomHelper::replaceNode() - Code Metrics - Inspection of "Import SVG symbols filter" - ocubom/twig-svg-extension - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 77e259...371264 )

by Oscar

created 2022-12-31 09:35 UTC

DomHelper::replaceNode() A

↳ Parent: DomHelper

Complexity

Conditions	1
Paths	1

Size

Total Lines	18
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	8
c	1
b	0
f	0
dl	0
loc	18
ccs	6
cts	6
cp	1
rs	10
cc	1
nc	1
nop	2
crap	1

<?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;
    }
}


1		<?php
2
3		/*
4		* This file is part of ocubom/twig-svg-extension
5		*
6		* © Oscar Cubo Medina <https://ocubom.github.io>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Ocubom\Twig\Extension\Svg\Util;
13
14		use function BenTools\IterableFunctions\iterable_to_array;
15
16		use Ocubom\Twig\Extension\Svg\Exception\RuntimeException;
17		use Symfony\Component\OptionsResolver\Options;
18		use Symfony\Component\OptionsResolver\OptionsResolver;
19
20		/** @internal */
21		final class DomHelper
22		{
23		/** @var OptionsResolver[] */
24		private static array $resolver = [];
25		private static \DOMDocument $doc;
26
27		// @codeCoverageIgnoreStart
28		private function __construct()
29		{
30		}
31		// @codeCoverageIgnoreEnd
32
33	5	public static function createDocument(iterable $options = null): \DOMDocument
34		{
35	5	$resolver = self::$resolver[__METHOD__] = self::$resolver[__METHOD__]
36	1	?? self::configureDocumentOptions();
37
38		// Resolve options
39	5	$options = $resolver->resolve(iterable_to_array($options ?? []));
40
41		// Create document
42	5	$doc = new \DOMDocument($options['version'], $options['encoding']);
43
44		// Apply options
45	5	foreach ($options as $key => $val) {
46	5	if (in_array($key, ['version', 'encoding', 'standalone'])) {
47	5	continue; // Ignore constructor arguments and deprecated options
48		}
49
50		// Apply property
51	5	$doc->{$key} = $val;
52		}
53
54	5	return $doc;
55		}
56
57	3	public static function appendChildElement(
58		\DOMElement $element,
59		\DOMNode $parent
60		): \DOMElement {
61	3	$child = self::appendChildNode($element, $parent);
62		assert($child instanceof \DOMElement);
63
64	3	return $child;
65		}
66
67	3	public static function appendChildNode(
68		\DOMNode $node,
69		\DOMNode $parent
70		): \DOMNode {
71		assert($parent->ownerDocument instanceof \DOMDocument);
72
73	3	$child = $parent->appendChild(
74	3	$parent->ownerDocument === $node->ownerDocument
75	3	? $node->cloneNode(true)
76	3	: $parent->ownerDocument->importNode($node, true)
77	3	);
78		assert($child instanceof \DOMNode);
79
80	3	return $child;
81		}
82
83	5	public static function cloneElement(
84		\DOMElement $element,
85		bool $deep = true,
86		\DOMDocument $document = null
87		): \DOMElement {
88	5	$clone = self::cloneNode($element, $deep, $document);
89
90		assert($clone instanceof \DOMElement);
91
92	5	return $clone;
93		}
94
95	5	public static function cloneNode(
96		\DOMNode $node,
97		bool $deep = true,
98		\DOMDocument $document = null
99		): \DOMNode {
100	5	$doc = $document ?? self::createDocument();
101
102	5	$clone = $node->ownerDocument === $doc ? $node->cloneNode($deep) : $doc->importNode($node, $deep);
103		assert($clone instanceof \DOMNode);
104
105	5	return $clone;
106		}
107
108	3	public static function createElement(
109		string $name,
110		string $value = '',
111		\DOMNode $node = null
112		): \DOMElement {
113		try {
114		// Get node document ($node if is a DOMdocument)
115	3	$doc = $node instanceof \DOMNode
116	3	? ($node->ownerDocument ?? $node)
117	3	: self::createDocument();
118		assert($doc instanceof \DOMDocument);
119
120	3	$new = $doc->createElement($name, $value);
121	3	if (null === $node \|\| $doc === $node) {
122		// Append child to the document
123	3	$new = $doc->appendChild($new);
124		} else {
125		// Insert child before the end of the element
126	3	$new = $node->insertBefore($new);
127		}
128		assert($new instanceof \DOMElement);
129
130	3	return $new;
131		} catch (\DOMException $exc) { // @codeCoverageIgnore
132		throw new RuntimeException($exc->getMessage(), $exc->getCode(), $exc); // @codeCoverageIgnore
133		}
134		}
135
136		public static function query(
137		string $expression,
138		\DOMNode $node,
139		bool $registerNodeNS = true
140		): \DOMNodeList {
141		$doc = $node instanceof \DOMDocument ? $node : $node->ownerDocument;
142		assert($doc instanceof \DOMDocument);
143
144		$nodes = (new \DOMXPath($doc))->query(
145		$expression,
146		$node instanceof \DOMDocument ? null : $node,
147		$registerNodeNS
148		);
149
150		assert($nodes instanceof \DOMNodeList);
151
152		return $nodes;
153		}
154
155	1	public static function removeNode(
156		\DOMNode $node
157		): void {
158		assert($node->parentNode instanceof \DOMNode);
159
160	1	$node->parentNode->removeChild($node);
161		}
162
163	3	public static function replaceNode(
164		\DOMNode $old,
165		\DOMNode $new
166		): \DOMNode {
167	3	$doc = $old->ownerDocument;
168		assert($doc instanceof \DOMDocument);
169
170		// Clone new node in the document
171	3	$new = $doc->importNode($new, true);
172		assert($new instanceof \DOMNode);
173
174		// Obtain parent
175	3	$parent = $old->parentNode;
176		assert($parent instanceof \DOMNode);
177
178	3	$parent->replaceChild($new, $old);
179
180	3	return $new;
181		}
182
183		public static function toHtml(
184		\DOMNode $node
185		): string {
186		assert($node->ownerDocument instanceof \DOMDocument);
187
188		$output = $node->ownerDocument->saveHTML($node);
189		if (false === $output) {
190		// @codeCoverageIgnoreStart
191		throw new RuntimeException(sprintf(
192		'Unable to convert %s to HTML',
193		get_class($node)
194		));
195		// @codeCoverageIgnoreEnd
196		}
197
198		return $output;
199		}
200
201	4	public static function toXml(
202		\DOMNode $node,
203		int $options = 0
204		): string {
205		assert($node->ownerDocument instanceof \DOMDocument);
206
207	4	$output = $node->ownerDocument->saveXML($node, $options);
208	4	if (false === $output) {
209		// @codeCoverageIgnoreStart
210		throw new RuntimeException(sprintf(
211		'Unable to convert %s to XML',
212		get_class($node)
213		));
214		// @codeCoverageIgnoreEnd
215		}
216
217	4	return $output;
218		}
219
220	5	private static function configureDocumentOptions(OptionsResolver $resolver = null): OptionsResolver
221		{
222	1	$resolver = $resolver ?? new OptionsResolver();
223
224	1	$resolver->define('encoding')
225	1	->default('')
226	1	->allowedTypes('string')
227	1	->info('Encoding of the document, as specified by the XML declaration');
228
229	1	$resolver->define('standalone')
230	1	->default(true)
231	1	->allowedTypes('bool')
232	1	->deprecated(
233	1	'ocubom/twig-svg-extension',
234	1	'1.0',
235	1	'The option "standalone" is deprecated, use "xmlStandalone" instead.'
236	1	)
237	1	->info('Whether or not the document is standalone, as specified by the XML declaration');
238
239	1	$resolver->define('xmlStandalone')
240	1	->default(true)
241	1	->allowedTypes('null', 'bool')
242	1	->normalize(function (Options $options, ?bool $value): bool {
243	5	return $value ?? (bool) $options
244	5	->/* @scrutinizer ignore-call */ offsetGet('standalone', false);
245	1	})
246	1	->info('Whether or not the document is standalone, as specified by the XML declaration');
247
248	1	$resolver->define('version')
249	1	->default('1.0')
250	1	->allowedTypes('string')
251	1	->deprecated(
252	1	'ocubom/twig-svg-extension',
253	1	'1.0',
254	1	'The option "version" is deprecated, use "xmlVersion" instead.'
255	1	)
256	1	->info('The version number of this document, as specified by the XML declaration');
257
258	1	$resolver->define('xmlVersion')
259	1	->default('1.0')
260	1	->allowedTypes('null', 'string')
261	1	->normalize(function (Options $options, ?string $value): string {
262	5	return $value ?? (string) $options
263	5	->/* @scrutinizer ignore-call */ offsetGet('version', false);
264	1	})
265	1	->info('The version number of this document, as specified by the XML declaration');
266
267	1	$resolver->define('strictErrorChecking')
268	1	->default(true)
269	1	->allowedTypes('bool')
270	1	->info('Throws \DOMException on errors');
271
272	1	$resolver->define('documentURI')
273	1	->default(null)
274	1	->allowedTypes('null', 'string')
275	1	->info('The location of the document');
276
277	1	$resolver->define('formatOutput')
278	1	->default(true) // LibXML default is false
279	1	->allowedTypes('bool')
280	1	->info('Nicely formats output with indentation and extra space');
281
282	1	$resolver->define('validateOnParse')
283	1	->default(false)
284	1	->allowedTypes('bool')
285	1	->info('Loads and validates against the DTD');
286
287	1	$resolver->define('resolveExternals')
288	1	->default(false)
289	1	->allowedTypes('bool')
290	1	->info('Load external entities from a doctype declaration');
291
292	1	$resolver->define('preserveWhiteSpace')
293	1	->default(true)
294	1	->allowedTypes('bool')
295	1	->normalize(function (Options $options, bool $value): bool {
296		// Must be false to enable formatOutput
297	5	return $options['formatOutput'] ? false : $value;
298	1	})
299	1	->info('Do not remove redundant white space');
300
301		// LibXML specific
302	1	$resolver->define('recover')
303	1	->default(false)
304	1	->allowedTypes('bool')
305	1	->info('Enables recovery mode');
306
307		// LibXML specific
308	1	$resolver->define('substituteEntities')
309	1	->default(false)
310	1	->allowedTypes('bool')
311	1	->info('Whether or not to substitute entities');
312
313	1	return $resolver;
314		}
315		}
316

ocubom / twig-svg-extension

Push — main ( 77e259...371264 )

DomHelper::replaceNode() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like