ExtendableElementTrait::setElements() - Code Metrics - simplesamlphp/xml-common - Measure and Improve Code Quality continuously with Scrutinizer

ExtendableElementTrait::setElements() B
last analyzed 2025-08-11 10:28 UTC

↳ Parent: ExtendableElementTrait

Complexity

Conditions	11
Paths	48

Size

Total Lines	74
Code Lines	39

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	11
eloc	39
nc	48
nop	1
dl	0
loc	74
rs	7.3166
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace SimpleSAML\XML;

use DOMElement;
use RuntimeException;
use SimpleSAML\XML\Assert\Assert;
use SimpleSAML\XML\Chunk;
use SimpleSAML\XML\Constants as C;
use SimpleSAML\XML\Registry\ElementRegistry;
use SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum;

use function array_diff;
use function array_map;
use function array_search;
use function defined;
use function implode;
use function is_array;
use function rtrim;
use function sprintf;

/**
 * Trait grouping common functionality for elements implementing the xs:any element.
 *
 * @package simplesamlphp/xml-common
 */
trait ExtendableElementTrait
{
    /** @var \SimpleSAML\XML\SerializableElementInterface[] */
    protected array $elements = [];


    /**
     * Parse an XML document and get the child elements from the specified namespace(s).
     * The namespace defaults to the XS_ANY_ELT_NAMESPACE constant on the element.
     * NOTE: In case the namespace is ##any, this method will also return local non-namespaced elements!
     *
     * @param \DOMElement $xml
     * @param (
     *   \SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum|
     *   array<\SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum|string>|
     *   null
     * ) $namespace
     *
     * @return list<\SimpleSAML\XML\SerializableElementInterface> $elements
     */
    protected static function getChildElementsFromXML(
        DOMElement $xml,
        NamespaceEnum|array|null $namespace = null,
    ): array {
        $namespace = $namespace ?? self::XS_ANY_ELT_NAMESPACE;
        $exclusionList = self::getElementExclusions();
        $registry = ElementRegistry::getInstance();
        $elements = [];

        // Validate namespace value
        if (!is_array($namespace)) {
            // Must be one of the predefined values
            Assert::oneOf($namespace, NamespaceEnum::cases());

            foreach ($xml->childNodes as $elt) {
                if (!($elt instanceof DOMElement)) {
                    continue;
                } elseif (in_array([$elt->namespaceURI, $elt->localName], $exclusionList, true)) {
                    continue;
                } elseif ($namespace === NamespaceEnum::Other && in_array($elt->namespaceURI, [self::NS, null], true)) {

                    continue;
                } elseif ($namespace === NamespaceEnum::TargetNamespace && $elt->namespaceURI !== self::NS) {
                    continue;
                } elseif ($namespace === NamespaceEnum::Local && $elt->namespaceURI !== null) {
                    continue;
                }

                $handler = $registry->getElementHandler($elt->namespaceURI, $elt->localName);
                $elements[] = ($handler === null) ? Chunk::fromXML($elt) : $handler::fromXML($elt);
            }
        } else {
            // Array must be non-empty and cannot contain ##any or ##other
            Assert::notEmpty($namespace);
            Assert::allStringNotEmpty($namespace);
            Assert::allNotSame($namespace, NamespaceEnum::Any);
            Assert::allNotSame($namespace, NamespaceEnum::Other);

            // Replace the ##targetedNamespace with the actual namespace
            if (($key = array_search(NamespaceEnum::TargetNamespace, $namespace)) !== false) {
                $namespace[$key] = self::NS;
            }

            // Replace the ##local with null
            if (($key = array_search(NamespaceEnum::Local, $namespace)) !== false) {
                $namespace[$key] = null;
            }

            foreach ($xml->childNodes as $elt) {
                if (!($elt instanceof DOMElement)) {
                    continue;
                } elseif (in_array([$elt->namespaceURI, $elt->localName], $exclusionList, true)) {
                    continue;
                } elseif (!in_array($elt->namespaceURI, $namespace, true)) {
                    continue;
                }

                $handler = $registry->getElementHandler($elt->namespaceURI, $elt->localName);
                $elements[] = ($handler === null) ? Chunk::fromXML($elt) : $handler::fromXML($elt);
            }
        }

        return $elements;

    }


    /**
     * Set an array with all elements present.
     *
     * @param \SimpleSAML\XML\SerializableElementInterface[] $elements
     * @return void
     */
    protected function setElements(array $elements): void
    {
        Assert::maxCount($elements, C::UNBOUNDED_LIMIT);
        Assert::allIsInstanceOf($elements, SerializableElementInterface::class);

        $namespace = $this->getElementNamespace();
        // Validate namespace value
        if (!is_array($namespace)) {
            // Must be one of the predefined values
            Assert::oneOf($namespace, NamespaceEnum::cases());
        } else {
            // Array must be non-empty and cannot contain ##any or ##other
            Assert::notEmpty($namespace);
            Assert::allNotSame($namespace, NamespaceEnum::Any);
            Assert::allNotSame($namespace, NamespaceEnum::Other);
        }

        // Get namespaces for all elements
        /** @var array<\SimpleSAML\XML\AbstractElement|\SimpleSAML\XML\Chunk> $elements */
        $actual_namespaces = array_map(
            /**
             * @return string|null
             */
            function (AbstractElement|Chunk $elt): ?string {
                return ($elt instanceof Chunk) ? $elt->getNamespaceURI() : $elt::getNamespaceURI();
            },
            $elements,
        );

        if ($namespace === NamespaceEnum::Local) {
            // If ##local then all namespaces must be null
            Assert::allNull($actual_namespaces);
        } elseif (is_array($namespace)) {
            // Make a local copy of the property that we can edit
            $allowed_namespaces = $namespace;

            // Replace the ##targetedNamespace with the actual namespace
            if (($key = array_search(NamespaceEnum::TargetNamespace, $allowed_namespaces)) !== false) {
                $allowed_namespaces[$key] = self::NS;
            }

            // Replace the ##local with null
            if (($key = array_search(NamespaceEnum::Local, $allowed_namespaces)) !== false) {
                $allowed_namespaces[$key] = null;
            }

            $diff = array_diff($actual_namespaces, $allowed_namespaces);
            Assert::isEmpty(
                $diff,
                sprintf(
                    'Elements from namespaces [ %s ] are not allowed inside a %s element.',
                    rtrim(implode(', ', $diff)),
                    self::NS,
                ),
            );
        } elseif ($namespace === NamespaceEnum::Other) {
            // Must be any namespace other than the parent element, excluding elements with no namespace
            Assert::notInArray(null, $actual_namespaces);
            Assert::allNotSame($actual_namespaces, self::NS);
        } elseif ($namespace === NamespaceEnum::TargetNamespace) {
            // Must be the same namespace as the one of the parent element
            Assert::allSame($actual_namespaces, self::NS);
        } else {
            // XS_ANY_NS_ANY
        }

        $exclusionList = self::getElementExclusions();
        foreach ($elements as $i => $elt) {
            if (in_array([$elt->getNamespaceURI(), $elt->getLocalName()], $exclusionList, true)) {
                unset($elements[$i]);
            }
        }

        $this->elements = $elements;
    }


    /**
     * Get an array with all elements present.
     *
     * @return \SimpleSAML\XML\SerializableElementInterface[]
     */
    public function getElements(): array
    {
        return $this->elements;
    }


    /**
     * @return (
     *   array<\SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum|string>|
     *   \SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum
     * )
     */
    public function getElementNamespace(): array|NamespaceEnum
    {
        Assert::true(
            defined('self::XS_ANY_ELT_NAMESPACE'),
            self::getClassName(self::class)
            . '::XS_ANY_ELT_NAMESPACE constant must be defined and set to the namespace for the xs:any element.',
            RuntimeException::class,
        );

        return self::XS_ANY_ELT_NAMESPACE;
    }


    /**
     * Get the exclusions list for getChildElementsFromXML.
     *
     * @return array{array{string|null, string}}|array{}

     */
    public static function getElementExclusions(): array
    {
        if (defined('self::XS_ANY_ELT_EXCLUSIONS')) {
            return self::XS_ANY_ELT_EXCLUSIONS;
        }

        return [];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace SimpleSAML\XML;
6
7			use DOMElement;
8			use RuntimeException;
9			use SimpleSAML\XML\Assert\Assert;
10			use SimpleSAML\XML\Chunk;
11			use SimpleSAML\XML\Constants as C;
12			use SimpleSAML\XML\Registry\ElementRegistry;
13			use SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum;
14
15			use function array_diff;
16			use function array_map;
17			use function array_search;
18			use function defined;
19			use function implode;
20			use function is_array;
21			use function rtrim;
22			use function sprintf;
23
24			/**
25			* Trait grouping common functionality for elements implementing the xs:any element.
26			*
27			* @package simplesamlphp/xml-common
28			*/
29			trait ExtendableElementTrait
30			{
31			/** @var \SimpleSAML\XML\SerializableElementInterface[] */
32			protected array $elements = [];
33
34
35			/**
36			* Parse an XML document and get the child elements from the specified namespace(s).
37			* The namespace defaults to the XS_ANY_ELT_NAMESPACE constant on the element.
38			* NOTE: In case the namespace is ##any, this method will also return local non-namespaced elements!
39			*
40			* @param \DOMElement $xml
41			* @param (
42			* \SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum\|
43			* array<\SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum\|string>\|
44			* null
45			* ) $namespace
46			*
47			* @return list<\SimpleSAML\XML\SerializableElementInterface> $elements
48			*/
49			protected static function getChildElementsFromXML(
50			DOMElement $xml,
51			NamespaceEnum\|array\|null $namespace = null,
52			): array {
53			$namespace = $namespace ?? self::XS_ANY_ELT_NAMESPACE;
54			$exclusionList = self::getElementExclusions();
55			$registry = ElementRegistry::getInstance();
56			$elements = [];
57
58			// Validate namespace value
59			if (!is_array($namespace)) {
60			// Must be one of the predefined values
61			Assert::oneOf($namespace, NamespaceEnum::cases());
62
63			foreach ($xml->childNodes as $elt) {
64			if (!($elt instanceof DOMElement)) {
65			continue;
66			} elseif (in_array([$elt->namespaceURI, $elt->localName], $exclusionList, true)) {
67			continue;
68			} elseif ($namespace === NamespaceEnum::Other && in_array($elt->namespaceURI, [self::NS, null], true)) {
			0 ignored issues – show Bug introduced 2025-06-28 19:06 UTC by Report Bug Copy Issue Report The constant `SimpleSAML\XML\ExtendableElementTrait::NS` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
69			continue;
70			} elseif ($namespace === NamespaceEnum::TargetNamespace && $elt->namespaceURI !== self::NS) {
71			continue;
72			} elseif ($namespace === NamespaceEnum::Local && $elt->namespaceURI !== null) {
73			continue;
74			}
75
76			$handler = $registry->getElementHandler($elt->namespaceURI, $elt->localName);
77			$elements[] = ($handler === null) ? Chunk::fromXML($elt) : $handler::fromXML($elt);
78			}
79			} else {
80			// Array must be non-empty and cannot contain ##any or ##other
81			Assert::notEmpty($namespace);
82			Assert::allStringNotEmpty($namespace);
83			Assert::allNotSame($namespace, NamespaceEnum::Any);
84			Assert::allNotSame($namespace, NamespaceEnum::Other);
85
86			// Replace the ##targetedNamespace with the actual namespace
87			if (($key = array_search(NamespaceEnum::TargetNamespace, $namespace)) !== false) {
88			$namespace[$key] = self::NS;
89			}
90
91			// Replace the ##local with null
92			if (($key = array_search(NamespaceEnum::Local, $namespace)) !== false) {
93			$namespace[$key] = null;
94			}
95
96			foreach ($xml->childNodes as $elt) {
97			if (!($elt instanceof DOMElement)) {
98			continue;
99			} elseif (in_array([$elt->namespaceURI, $elt->localName], $exclusionList, true)) {
100			continue;
101			} elseif (!in_array($elt->namespaceURI, $namespace, true)) {
102			continue;
103			}
104
105			$handler = $registry->getElementHandler($elt->namespaceURI, $elt->localName);
106			$elements[] = ($handler === null) ? Chunk::fromXML($elt) : $handler::fromXML($elt);
107			}
108			}
109
110			return $elements;
			0 ignored issues – show Bug Best Practice introduced 2025-06-28 19:06 UTC by Report Bug Copy Issue Report The expression `return $elements` returns the type `array\|array<mixed,SimpleSAML\XML\Chunk\|mixed>` which is incompatible with the documented return type `SimpleSAML\XML\list`. Loading history...
111			}
112
113
114			/**
115			* Set an array with all elements present.
116			*
117			* @param \SimpleSAML\XML\SerializableElementInterface[] $elements
118			* @return void
119			*/
120			protected function setElements(array $elements): void
121			{
122			Assert::maxCount($elements, C::UNBOUNDED_LIMIT);
123			Assert::allIsInstanceOf($elements, SerializableElementInterface::class);
124
125			$namespace = $this->getElementNamespace();
126			// Validate namespace value
127			if (!is_array($namespace)) {
128			// Must be one of the predefined values
129			Assert::oneOf($namespace, NamespaceEnum::cases());
130			} else {
131			// Array must be non-empty and cannot contain ##any or ##other
132			Assert::notEmpty($namespace);
133			Assert::allNotSame($namespace, NamespaceEnum::Any);
134			Assert::allNotSame($namespace, NamespaceEnum::Other);
135			}
136
137			// Get namespaces for all elements
138			/** @var array<\SimpleSAML\XML\AbstractElement\|\SimpleSAML\XML\Chunk> $elements */
139			$actual_namespaces = array_map(
140			/**
141			* @return string\|null
142			*/
143			function (AbstractElement\|Chunk $elt): ?string {
144			return ($elt instanceof Chunk) ? $elt->getNamespaceURI() : $elt::getNamespaceURI();
145			},
146			$elements,
147			);
148
149			if ($namespace === NamespaceEnum::Local) {
150			// If ##local then all namespaces must be null
151			Assert::allNull($actual_namespaces);
152			} elseif (is_array($namespace)) {
153			// Make a local copy of the property that we can edit
154			$allowed_namespaces = $namespace;
155
156			// Replace the ##targetedNamespace with the actual namespace
157			if (($key = array_search(NamespaceEnum::TargetNamespace, $allowed_namespaces)) !== false) {
158			$allowed_namespaces[$key] = self::NS;
159			}
160
161			// Replace the ##local with null
162			if (($key = array_search(NamespaceEnum::Local, $allowed_namespaces)) !== false) {
163			$allowed_namespaces[$key] = null;
164			}
165
166			$diff = array_diff($actual_namespaces, $allowed_namespaces);
167			Assert::isEmpty(
168			$diff,
169			sprintf(
170			'Elements from namespaces [ %s ] are not allowed inside a %s element.',
171			rtrim(implode(', ', $diff)),
172			self::NS,
173			),
174			);
175			} elseif ($namespace === NamespaceEnum::Other) {
176			// Must be any namespace other than the parent element, excluding elements with no namespace
177			Assert::notInArray(null, $actual_namespaces);
178			Assert::allNotSame($actual_namespaces, self::NS);
179			} elseif ($namespace === NamespaceEnum::TargetNamespace) {
180			// Must be the same namespace as the one of the parent element
181			Assert::allSame($actual_namespaces, self::NS);
182			} else {
183			// XS_ANY_NS_ANY
184			}
185
186			$exclusionList = self::getElementExclusions();
187			foreach ($elements as $i => $elt) {
188			if (in_array([$elt->getNamespaceURI(), $elt->getLocalName()], $exclusionList, true)) {
189			unset($elements[$i]);
190			}
191			}
192
193			$this->elements = $elements;
194			}
195
196
197			/**
198			* Get an array with all elements present.
199			*
200			* @return \SimpleSAML\XML\SerializableElementInterface[]
201			*/
202			public function getElements(): array
203			{
204			return $this->elements;
205			}
206
207
208			/**
209			* @return (
210			* array<\SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum\|string>\|
211			* \SimpleSAML\XMLSchema\XML\Enumeration\NamespaceEnum
212			* )
213			*/
214			public function getElementNamespace(): array\|NamespaceEnum
215			{
216			Assert::true(
217			defined('self::XS_ANY_ELT_NAMESPACE'),
218			self::getClassName(self::class)
219			. '::XS_ANY_ELT_NAMESPACE constant must be defined and set to the namespace for the xs:any element.',
220			RuntimeException::class,
221			);
222
223			return self::XS_ANY_ELT_NAMESPACE;
224			}
225
226
227			/**
228			* Get the exclusions list for getChildElementsFromXML.
229			*
230			* @return array{array{string\|null, string}}\|array{}
			0 ignored issues – show Documentation Bug introduced 2025-06-28 19:06 UTC by Report Bug Copy Issue Report The doc comment `array{array{string\|null, string}}\|array{}` at position `2` could not be parsed: Expected ':' at position 2, but found 'array'. Loading history...
231			*/
232			public static function getElementExclusions(): array
233			{
234			if (defined('self::XS_ANY_ELT_EXCLUSIONS')) {
235			return self::XS_ANY_ELT_EXCLUSIONS;
236			}
237
238			return [];
239			}
240			}
241

simplesamlphp / xml-common

ExtendableElementTrait::setElements() B last analyzed 2025-08-11 10:28 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ExtendableElementTrait::setElements() B
last analyzed 2025-08-11 10:28 UTC