simplesamlphp / xml-common

src/XML/ExtendableElementTrait.php

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

The type SimpleSAML\XML\Constants was not found. Maybe you did not declare it correctly or list all dependencies?

use SimpleSAML\XML\Registry\ElementRegistry;
use SimpleSAML\XMLSchema\Exception\InvalidDOMElementException;
use SimpleSAML\XMLSchema\Exception\SchemaViolationException;
use SimpleSAML\XMLSchema\XML\Constants\NS;

The type SimpleSAML\XMLSchema\XML\Constants\NS was not found. Maybe you did not declare it correctly or list all dependencies?

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 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 string|string[]|null $namespace
     * @return list<\SimpleSAML\XML\SerializableElementInterface> $elements
     */
    protected static function getChildElementsFromXML(
        DOMElement $xml,
        string|array|null $namespace = null,
    ): array {
        $namespace = $namespace ?? static::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, NS::$PREDEFINED);

            foreach ($xml->childNodes as $elt) {
                if (!($elt instanceof DOMElement)) {
                    continue;
                } elseif (
                    $exclusionList

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.

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

The constant SimpleSAML\XML\ExtendableElementTrait::NS was not found. Maybe you did not declare it correctly or list all dependencies?

                    continue;
                } elseif ($namespace === NS::TARGETNAMESPACE && $elt->namespaceURI !== self::NS) {
                    continue;
                } elseif ($namespace === NS::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, 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->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
     */
    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;
    }


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


    /**
     * @return string|string[]
     */
    public function getElementNamespace(): array|string
    {
        Assert::true(
            defined('static::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 static::XS_ANY_ELT_NAMESPACE;
    }


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

The doc comment array{array{string|null, string}}|array{} at position 2 could not be parsed: Expected ':' at position 2, but found 'array'.

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

        return [];
    }
}