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

ExtendableAttributesTrait::getAttributeNamespace() A
last analyzed 2025-12-23 14:49 UTC

↳ Parent: ExtendableAttributesTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	0
dl	0
loc	10
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace SimpleSAML\XML;

use DOMElement;
use RuntimeException;
use SimpleSAML\XML\Assert\Assert;
use SimpleSAML\XML\Attribute;
use SimpleSAML\XML\Constants as C;
filter:
    dependency_paths: ["lib/*"]
use SimpleSAML\XMLSchema\Exception\InvalidDOMAttributeException;
use SimpleSAML\XMLSchema\Exception\SchemaViolationException;
use SimpleSAML\XMLSchema\Type\StringValue;
filter:
    dependency_paths: ["lib/*"]
use SimpleSAML\XMLSchema\XML\Constants\NS;
filter:
    dependency_paths: ["lib/*"]

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

/**
 * Trait for elements that can have arbitrary namespaced attributes.
 *
 * @package simplesamlphp/xml-common
 */
trait ExtendableAttributesTrait
{
    /**
     * Extra (namespace qualified) attributes.
     *
     * @var array<int, \SimpleSAML\XML\Attribute>
     */
    protected array $namespacedAttributes = [];


    /**
     * Check if a namespace-qualified attribute exists.
     *
     * @param string|null $namespaceURI The namespace URI.
     * @param string $localName The local name.
     * @return bool true if the attribute exists, false if not.
     */
    public function hasAttributeNS(?string $namespaceURI, string $localName): bool
    {
        foreach ($this->getAttributesNS() as $attr) {
            if ($attr->getNamespaceURI() === $namespaceURI && $attr->getAttrName() === $localName) {
                return true;
            }
        }
        return false;
    }


    /**
     * Get a namespace-qualified attribute.
     *
     * @param string|null $namespaceURI The namespace URI.
     * @param string $localName The local name.
     * @return \SimpleSAML\XML\Attribute|null The value of the attribute, or null if the attribute does not exist.
     */
    public function getAttributeNS(?string $namespaceURI, string $localName): ?Attribute
    {
        foreach ($this->getAttributesNS() as $attr) {
            if ($attr->getNamespaceURI() === $namespaceURI && $attr->getAttrName() === $localName) {
                return $attr;
            }
        }
        return null;
    }


    /**
     * Get the namespaced attributes in this element.
     *
     * @return array<int, \SimpleSAML\XML\Attribute>
     */
    public function getAttributesNS(): array
    {
        return $this->namespacedAttributes;
    }


    /**
     * Parse an XML document and get the namespaced attributes from the specified namespace(s).
     * The namespace defaults to the XS_ANY_ATTR_NAMESPACE constant on the element.
     * NOTE: In case the namespace is ##any, this method will also return local non-namespaced attributes!
     *
     * @param \DOMElement $xml
     * @param string|string[]|null $namespace
     * @return list<\SimpleSAML\XML\Attribute>
     */
    protected static function getAttributesNSFromXML(
        DOMElement $xml,
        string|array|null $namespace = null,
    ): array {
        $namespace = $namespace ?? static::XS_ANY_ATTR_NAMESPACE;
        $exclusionList = self::getAttributeExclusions();
        $attributes = [];

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

            foreach ($xml->attributes as $a) {
                if (
                    $exclusionList

                    && (in_array([$a->namespaceURI, $a->localName], $exclusionList, true)
                        || in_array([$a->namespaceURI, '*'], $exclusionList, true))
                ) {
                    continue;
                } elseif ($namespace === NS::OTHER && in_array($a->namespaceURI, [self::NS, null], true)) {
                    continue;
                } elseif ($namespace === NS::TARGETNAMESPACE && $a->namespaceURI !== self::NS) {
                    continue;
                } elseif ($namespace === NS::LOCAL && $a->namespaceURI !== null) {
                    continue;
                }

                $attributes[] = new Attribute(
                    $a->namespaceURI,
                    $a->prefix,
                    $a->localName,
                    StringValue::fromString($a->nodeValue),
                );
            }
        } else {
            // Array must be non-empty and cannot contain ##any or ##other
            Assert::notEmpty($namespace);
            Assert::allStringNotEmpty($namespace);
            Assert::allNotSame($namespace, NS::ANY);
            Assert::allNotSame($namespace, NS::OTHER);

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

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

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

                $attributes[] = new Attribute(
                    $a->namespaceURI,
                    $a->prefix,
                    $a->localName,
                    StringValue::fromString($a->nodeValue),
                );
            }
        }

        return $attributes;
    }


    /**
     * @param array<int, \SimpleSAML\XML\Attribute> $attributes
     * @throws \SimpleSAML\Assert\AssertionFailedException if $attributes contains anything other than Attribute objects
     */
    protected function setAttributesNS(array $attributes): void
    {
        Assert::maxCount($attributes, C::UNBOUNDED_LIMIT);
        Assert::allIsInstanceOf(
            $attributes,
            Attribute::class,
            'Arbitrary XML attributes can only be an instance of Attribute.',
        );
        $namespace = $this->getAttributeNamespace();

        // Validate namespace value
        if (!is_array($namespace)) {
            // Must be one of the predefined values
            Assert::oneOf($namespace, NS::$PREDEFINED);
        } else {
            // Array must be non-empty and cannot contain ##any or ##other
            Assert::notEmpty($namespace);
            Assert::allNotSame($namespace, NS::ANY);
            Assert::allNotSame($namespace, NS::OTHER);
        }

        // Get namespaces for all attributes
        $actual_namespaces = array_map(
            /**
             * @param \SimpleSAML\XML\Attribute $elt
             * @return string|null
             */
            function (Attribute $attr) {
                return $attr->getNamespaceURI();
            },
            $attributes,
        );

        if ($namespace === NS::LOCAL) {
            // If ##local then all namespaces must be null
            Assert::allNull($actual_namespaces, SchemaviolationException::class);
        } 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(NS::TARGETNAMESPACE, $allowed_namespaces)) !== false) {
                $allowed_namespaces[$key] = self::NS;
            }

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

            $diff = array_diff($actual_namespaces, $allowed_namespaces);
            Assert::isEmpty(
                $diff,
                sprintf(
                    'Attributes from namespaces [ %s ] are not allowed inside a %s element.',
                    rtrim(implode(', ', $diff)),
                    self::NS,
                ),
                SchemaViolationException::class,
            );
        } else {
            if ($namespace === NS::OTHER) {
                // All attributes must be namespaced, ergo non-null
                Assert::allNotNull($actual_namespaces, SchemaViolationException::class);

                // Must be any namespace other than the parent element
                Assert::allNotSame($actual_namespaces, self::NS, SchemaViolationException::class);
            } elseif ($namespace === NS::TARGETNAMESPACE) {
                // Must be the same namespace as the one of the parent element
                Assert::allSame($actual_namespaces, self::NS, SchemaViolationException::class);
            }
        }

        $exclusionList = self::getAttributeExclusions();
        foreach ($attributes as $i => $attr) {
            Assert::true(
                !in_array([$attr->getNamespaceURI(), $attr->getAttrName()], $exclusionList, true)
                && !in_array([$attr->getNamespaceURI(), '*'], $exclusionList, true),
                InvalidDOMAttributeException::class,
            );
        }

        $this->namespacedAttributes = $attributes;
    }


    /**
     * @return string[]|string
     */
    public function getAttributeNamespace(): array|string
    {
        Assert::true(
            defined('static::XS_ANY_ATTR_NAMESPACE'),
            self::getClassName(self::class)
            . '::XS_ANY_ATTR_NAMESPACE constant must be defined and set to the namespace for the xs:anyAttribute.',
            RuntimeException::class,
        );

        return static::XS_ANY_ATTR_NAMESPACE;
    }


    /**
     * Get the exclusions list for getAttributeNSFromXML.
     *
     * @return array{array{string|null, string}}|array{}
     */
    public static function getAttributeExclusions(): array
    {
        if (defined('static::XS_ANY_ATTR_EXCLUSIONS')) {
            return static::XS_ANY_ATTR_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\Attribute;
11			use SimpleSAML\XML\Constants as C;
			0 ignored issues – show Bug introduced 2025-12-17 09:53 UTC by Report Bug Copy Issue Report The type `SimpleSAML\XML\Constants` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
12			use SimpleSAML\XMLSchema\Exception\InvalidDOMAttributeException;
13			use SimpleSAML\XMLSchema\Exception\SchemaViolationException;
14			use SimpleSAML\XMLSchema\Type\StringValue;
			0 ignored issues – show Bug introduced 2025-12-17 09:53 UTC by Report Bug Copy Issue Report The type `SimpleSAML\XMLSchema\Type\StringValue` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
15			use SimpleSAML\XMLSchema\XML\Constants\NS;
			0 ignored issues – show Bug introduced 2025-12-17 09:53 UTC by Report Bug Copy Issue Report The type `SimpleSAML\XMLSchema\XML\Constants\NS` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
16
17			use function array_diff;
18			use function array_map;
19			use function array_search;
20			use function defined;
21			use function implode;
22			use function in_array;
23			use function is_array;
24			use function rtrim;
25			use function sprintf;
26
27			/**
28			* Trait for elements that can have arbitrary namespaced attributes.
29			*
30			* @package simplesamlphp/xml-common
31			*/
32			trait ExtendableAttributesTrait
33			{
34			/**
35			* Extra (namespace qualified) attributes.
36			*
37			* @var array<int, \SimpleSAML\XML\Attribute>
38			*/
39			protected array $namespacedAttributes = [];
40
41
42			/**
43			* Check if a namespace-qualified attribute exists.
44			*
45			* @param string\|null $namespaceURI The namespace URI.
46			* @param string $localName The local name.
47			* @return bool true if the attribute exists, false if not.
48			*/
49			public function hasAttributeNS(?string $namespaceURI, string $localName): bool
50			{
51			foreach ($this->getAttributesNS() as $attr) {
52			if ($attr->getNamespaceURI() === $namespaceURI && $attr->getAttrName() === $localName) {
53			return true;
54			}
55			}
56			return false;
57			}
58
59
60			/**
61			* Get a namespace-qualified attribute.
62			*
63			* @param string\|null $namespaceURI The namespace URI.
64			* @param string $localName The local name.
65			* @return \SimpleSAML\XML\Attribute\|null The value of the attribute, or null if the attribute does not exist.
66			*/
67			public function getAttributeNS(?string $namespaceURI, string $localName): ?Attribute
68			{
69			foreach ($this->getAttributesNS() as $attr) {
70			if ($attr->getNamespaceURI() === $namespaceURI && $attr->getAttrName() === $localName) {
71			return $attr;
72			}
73			}
74			return null;
75			}
76
77
78			/**
79			* Get the namespaced attributes in this element.
80			*
81			* @return array<int, \SimpleSAML\XML\Attribute>
82			*/
83			public function getAttributesNS(): array
84			{
85			return $this->namespacedAttributes;
86			}
87
88
89			/**
90			* Parse an XML document and get the namespaced attributes from the specified namespace(s).
91			* The namespace defaults to the XS_ANY_ATTR_NAMESPACE constant on the element.
92			* NOTE: In case the namespace is ##any, this method will also return local non-namespaced attributes!
93			*
94			* @param \DOMElement $xml
95			* @param string\|string[]\|null $namespace
96			* @return list<\SimpleSAML\XML\Attribute>
97			*/
98			protected static function getAttributesNSFromXML(
99			DOMElement $xml,
100			string\|array\|null $namespace = null,
101			): array {
102			$namespace = $namespace ?? static::XS_ANY_ATTR_NAMESPACE;
103			$exclusionList = self::getAttributeExclusions();
104			$attributes = [];
105
106			// Validate namespace value
107			if (!is_array($namespace)) {
108			// Must be one of the predefined values
109			Assert::oneOf($namespace, NS::$PREDEFINED);
110
111			foreach ($xml->attributes as $a) {
112			if (
113			$exclusionList
			0 ignored issues – show Bug Best Practice introduced 2025-12-18 23:19 UTC by Report Bug Copy Issue Report The expression `$exclusionList` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
114			&& (in_array([$a->namespaceURI, $a->localName], $exclusionList, true)
115			\|\| in_array([$a->namespaceURI, '*'], $exclusionList, true))
116			) {
117			continue;
118			} elseif ($namespace === NS::OTHER && in_array($a->namespaceURI, [self::NS, null], true)) {
119			continue;
120			} elseif ($namespace === NS::TARGETNAMESPACE && $a->namespaceURI !== self::NS) {
121			continue;
122			} elseif ($namespace === NS::LOCAL && $a->namespaceURI !== null) {
123			continue;
124			}
125
126			$attributes[] = new Attribute(
127			$a->namespaceURI,
128			$a->prefix,
129			$a->localName,
130			StringValue::fromString($a->nodeValue),
131			);
132			}
133			} else {
134			// Array must be non-empty and cannot contain ##any or ##other
135			Assert::notEmpty($namespace);
136			Assert::allStringNotEmpty($namespace);
137			Assert::allNotSame($namespace, NS::ANY);
138			Assert::allNotSame($namespace, NS::OTHER);
139
140			// Replace the ##targetedNamespace with the actual namespace
141			if (($key = array_search(NS::TARGETNAMESPACE, $namespace)) !== false) {
142			$namespace[$key] = self::NS;
143			}
144
145			// Replace the ##local with null
146			if (($key = array_search(NS::LOCAL, $namespace)) !== false) {
147			$namespace[$key] = null;
148			}
149
150			foreach ($xml->attributes as $a) {
151			if (in_array([$a->namespaceURI, $a->localName], $exclusionList, true)) {
152			continue;
153			} elseif (!in_array($a->namespaceURI, $namespace, true)) {
154			continue;
155			}
156
157			$attributes[] = new Attribute(
158			$a->namespaceURI,
159			$a->prefix,
160			$a->localName,
161			StringValue::fromString($a->nodeValue),
162			);
163			}
164			}
165
166			return $attributes;
167			}
168
169
170			/**
171			* @param array<int, \SimpleSAML\XML\Attribute> $attributes
172			* @throws \SimpleSAML\Assert\AssertionFailedException if $attributes contains anything other than Attribute objects
173			*/
174			protected function setAttributesNS(array $attributes): void
175			{
176			Assert::maxCount($attributes, C::UNBOUNDED_LIMIT);
177			Assert::allIsInstanceOf(
178			$attributes,
179			Attribute::class,
180			'Arbitrary XML attributes can only be an instance of Attribute.',
181			);
182			$namespace = $this->getAttributeNamespace();
183
184			// Validate namespace value
185			if (!is_array($namespace)) {
186			// Must be one of the predefined values
187			Assert::oneOf($namespace, NS::$PREDEFINED);
188			} else {
189			// Array must be non-empty and cannot contain ##any or ##other
190			Assert::notEmpty($namespace);
191			Assert::allNotSame($namespace, NS::ANY);
192			Assert::allNotSame($namespace, NS::OTHER);
193			}
194
195			// Get namespaces for all attributes
196			$actual_namespaces = array_map(
197			/**
198			* @param \SimpleSAML\XML\Attribute $elt
199			* @return string\|null
200			*/
201			function (Attribute $attr) {
202			return $attr->getNamespaceURI();
203			},
204			$attributes,
205			);
206
207			if ($namespace === NS::LOCAL) {
208			// If ##local then all namespaces must be null
209			Assert::allNull($actual_namespaces, SchemaviolationException::class);
210			} elseif (is_array($namespace)) {
211			// Make a local copy of the property that we can edit
212			$allowed_namespaces = $namespace;
213
214			// Replace the ##targetedNamespace with the actual namespace
215			if (($key = array_search(NS::TARGETNAMESPACE, $allowed_namespaces)) !== false) {
216			$allowed_namespaces[$key] = self::NS;
217			}
218
219			// Replace the ##local with null
220			if (($key = array_search(NS::LOCAL, $allowed_namespaces)) !== false) {
221			$allowed_namespaces[$key] = null;
222			}
223
224			$diff = array_diff($actual_namespaces, $allowed_namespaces);
225			Assert::isEmpty(
226			$diff,
227			sprintf(
228			'Attributes from namespaces [ %s ] are not allowed inside a %s element.',
229			rtrim(implode(', ', $diff)),
230			self::NS,
231			),
232			SchemaViolationException::class,
233			);
234			} else {
235			if ($namespace === NS::OTHER) {
236			// All attributes must be namespaced, ergo non-null
237			Assert::allNotNull($actual_namespaces, SchemaViolationException::class);
238
239			// Must be any namespace other than the parent element
240			Assert::allNotSame($actual_namespaces, self::NS, SchemaViolationException::class);
241			} elseif ($namespace === NS::TARGETNAMESPACE) {
242			// Must be the same namespace as the one of the parent element
243			Assert::allSame($actual_namespaces, self::NS, SchemaViolationException::class);
244			}
245			}
246
247			$exclusionList = self::getAttributeExclusions();
248			foreach ($attributes as $i => $attr) {
249			Assert::true(
250			!in_array([$attr->getNamespaceURI(), $attr->getAttrName()], $exclusionList, true)
251			&& !in_array([$attr->getNamespaceURI(), '*'], $exclusionList, true),
252			InvalidDOMAttributeException::class,
253			);
254			}
255
256			$this->namespacedAttributes = $attributes;
257			}
258
259
260			/**
261			* @return string[]\|string
262			*/
263			public function getAttributeNamespace(): array\|string
264			{
265			Assert::true(
266			defined('static::XS_ANY_ATTR_NAMESPACE'),
267			self::getClassName(self::class)
268			. '::XS_ANY_ATTR_NAMESPACE constant must be defined and set to the namespace for the xs:anyAttribute.',
269			RuntimeException::class,
270			);
271
272			return static::XS_ANY_ATTR_NAMESPACE;
273			}
274
275
276			/**
277			* Get the exclusions list for getAttributeNSFromXML.
278			*
279			* @return array{array{string\|null, string}}\|array{}
280			*/
281			public static function getAttributeExclusions(): array
282			{
283			if (defined('static::XS_ANY_ATTR_EXCLUSIONS')) {
284			return static::XS_ANY_ATTR_EXCLUSIONS;
285			}
286
287			return [];
288			}
289			}
290

simplesamlphp / xml-common

ExtendableAttributesTrait::getAttributeNamespace() A last analyzed 2025-12-23 14:49 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ExtendableAttributesTrait::getAttributeNamespace() A
last analyzed 2025-12-23 14:49 UTC