Merge pull request #28 from simplesamlphp/feature/elt-exclusion-list

Add exclusion-list for ExtendableElementTrait

src/ExtendableElementTrait.php

@@ -4,10 +4,12 @@
 
 namespace SimpleSAML\XML;
 
+use DOMElement;
 use RuntimeException;
 use SimpleSAML\Assert\Assert;
 use SimpleSAML\XML\Chunk;
 use SimpleSAML\XML\Constants as C;
+use SimpleSAML\XML\Registry\ElementRegistry;
 use SimpleSAML\XML\XsNamespace as NS;
 
 use function array_diff;
@@ -30,6 +32,79 @@ trait ExtendableElementTrait
  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\XML\XsNamespace|array|null $namespace
+ *
+ * @return list<\SimpleSAML\XML\SerializableElementInterface> $elements
+ */
+ protected static function getChildElementsFromXML(DOMElement $xml, NS|array $namespace = null): array
+ {
+ $namespace = $namespace ?? static::XS_ANY_ELT_NAMESPACE;
+ $exclusionList = static::getElementExclusions();
+ $registry = ElementRegistry::getInstance();
+ $elements = [];
+
+ // Validate namespace value
+ if (!is_array($namespace)) {
+ // Must be one of the predefined values
+ Assert::oneOf($namespace, NS::cases());
+
+ foreach ($xml->childNodes as $elt) {
+ if (!($elt instanceof DOMElement)) {
+ continue;
+ } elseif (in_array([$elt->namespaceURI, $elt->localName], $exclusionList, true)) {
+ continue;
+ } elseif ($namespace === NS::OTHER && in_array($elt->namespaceURI, [static::NS, null], true)) {
+ continue;
+ } elseif ($namespace === NS::TARGET && $elt->namespaceURI !== static::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::TARGET, $namespace)) !== false) {
+ $namespace[$key] = static::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.
  *
@@ -102,6 +177,13 @@ function (SerializableElementInterface $elt) {
  // XS_ANY_NS_ANY
  }
 
+ $exclusionList = static::getElementExclusions();
+ foreach ($elements as $i => $elt) {
+ if (in_array([$elt->getNamespaceURI(), $elt->getLocalName()], $exclusionList, true)) {
+ unset($elements[$i]);
+ }
+ }
+
  $this->elements = $elements;
  }
 
@@ -131,4 +213,19 @@ public function getElementNamespace(): array|NS
 
  return static::XS_ANY_ELT_NAMESPACE;
  }
+
+
+ /**
+ * Get the exclusions list for getChildElementsFromXML.
+ *
+ * @return array<string, string>
+ */
+ public static function getElementExclusions(): array
+ {
+ if (defined('static::XS_ANY_ELT_EXCLUSIONS')) {
+ return static::XS_ANY_ELT_EXCLUSIONS;
+ }
+
+ return [];
+ }
 }

tests/Utils/ExtendableElement.php

@@ -34,6 +34,11 @@ class ExtendableElement extends AbstractElement
  /** @var \SimpleSAML\XML\XsNamespace|array<int, \SimpleSAML\XML\XsNamespace> */
  public const XS_ANY_ELT_NAMESPACE = NS::ANY;
 
+ /** @var array{array{string, string}} */
+ public const XS_ANY_ELT_EXCLUSIONS = [
+ ['urn:custom:other', 'Chunk'],
+ ];
+
 
  /**
  * Get the namespace for the element.

tests/XML/ExtendableElementTest.php

@@ -51,16 +51,22 @@ public function testMarshalling(): void
  $dummyDocument2 = DOMDocumentFactory::fromString(
  '<dummy:Chunk xmlns:dummy="urn:custom:dummy">some</dummy:Chunk>',
  );
+ $dummyDocument3 = DOMDocumentFactory::fromString(
+ '<other:Chunk xmlns:other="urn:custom:other">some</other:Chunk>',
+ );
 
  /** @var \DOMElement $dummyElement1 */
  $dummyElement1 = $dummyDocument1->documentElement;
  /** @var \DOMElement $dummyElement2 */
  $dummyElement2 = $dummyDocument2->documentElement;
+ /** @var \DOMElement $dummyElement3 */
+ $dummyElement3 = $dummyDocument3->documentElement;
 
  $extendableElement = new ExtendableElement(
  [
  new Chunk($dummyElement1),
  new Chunk($dummyElement2),
+ new Chunk($dummyElement3),
  ],
  );
 
@@ -69,4 +75,25 @@ public function testMarshalling(): void
  strval($extendableElement),
  );
  }
+
+
+ /**
+ */
+ public function testGetChildElementsFromXML(): void
+ {
+ /** @var \DOMElement $element */
+ $element = self::$xmlRepresentation->documentElement;
+
+ $elt = ExtendableElement::fromXML($element);
+ /** @var \SimpleSAML\XML\Chunk[] $elements */
+ $elements = $elt->getElements();
+
+ $this->assertCount(2, $elements);
+ $this->assertEquals($elements[0]->getNamespaceURI(), 'urn:x-simplesamlphp:namespace');
+ $this->assertEquals($elements[0]->getPrefix(), 'ssp');
+ $this->assertEquals($elements[0]->getLocalName(), 'Chunk');
+ $this->assertEquals($elements[1]->getNamespaceURI(), 'urn:custom:dummy');
+ $this->assertEquals($elements[1]->getPrefix(), 'dummy');
+ $this->assertEquals($elements[1]->getLocalName(), 'Chunk');
+ }
 }

tests/resources/schemas/simplesamlphp.xsd

@@ -22,7 +22,7 @@
 <complexType name="ExtendableElementType">
  <sequence> 
  <element ref="ssp:Chunk"/> 
- <any namespace="##other" processContents="lax"/>
+ <any namespace="##any" processContents="lax"/>
  <!-- (1,1) elements from (1,1) external namespace -->
  </sequence> 
 </complexType>