SimpleSAML\XML\ExtendableElementTrait::setElements()

Complexity

Conditions	11
Paths	32

Size

Total Lines	77
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    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, 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 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 === 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(
                    'Elements from namespaces [ %s ] are not allowed inside a %s element.',
                    rtrim(implode(', ', $diff)),
                    self::NS,
                ),
                SchemaViolationException::class,
            );
        } elseif ($namespace === NS::OTHER) {
            // Must be any namespace other than the parent element, excluding elements with no namespace
            Assert::notInArray(null, $actual_namespaces, SchemaViolationException::class);
            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);
        } else {
            // XS_ANY_NS_ANY
        }

        $exclusionList = self::getElementExclusions();
        foreach ($elements as $i => $elt) {
            Assert::true(
                !in_array([$elt->getNamespaceURI(), $elt->getLocalName()], $exclusionList, true)
                && !in_array([$elt->getNamespaceURI(), '*'], $exclusionList, true),
                InvalidDOMElementException::class,
            );
        }

        $this->elements = $elements;
    }