added parser tests

Author: proggeler

README.md

@@ -2,6 +2,8 @@
 
 ## Usage
 
+Iterate over all the elements within the xml.
+
 ```php
 use DMT\XmlParser\Parser;
 use DMT\XmlParser\Source\StringParser;
@@ -17,3 +19,16 @@ while ($node = $parser->parse()) {
     // iterates: node <books>, node <book>, node <title>, text-node "A book title", node <book> etc
 }
 ```
+
+Select an element and call _parseXml_ to get the current element including its contents.
+
+```php
+while ($node = $parser->parse()) {
+    if ($node->localName !== 'book') {
+        continue;
+    }
+    $book = $parser->parseXml();
+    break;
+}
+// book is "<book><title>A book title</title></book>"
+```

src/Parser.php

@@ -2,26 +2,28 @@
 
 namespace DMT\XmlParser;
 
+use DMT\XmlParser\Node\Element;
 use DMT\XmlParser\Node\ElementNode;
-use DMT\XmlParser\Node\Node;
+use DMT\XmlParser\Node\XmlNamespace;
+use DMT\XmlParser\Node\XmlNamespaces;
 use Generator;
 
 class Parser
 {
     private ?ElementNode $current = null;
-    private ?Generator $iterator = null;
+    private Generator $iterator;
+    private XmlNamespaces $namespaces;
 
     /**
      * @param \DMT\XmlParser\Tokenizer $tokenizer
      */
     public function __construct(Tokenizer $tokenizer)
     {
-        if (!$this->iterator) {
-            $this->iterator = $tokenizer->tokenize();
-        }
+        $this->iterator = $tokenizer->tokenize();
+        $this->namespaces = $tokenizer->namespaces();
     }
 
-    public function parse(): ?Node
+    public function parse(): ?ElementNode
     {
         try {
             return $this->current = $this->iterator->current();
@@ -47,6 +49,27 @@ public function parseXml(): string
             $this->iterator->next();
         }
 
+        if ($this->namespaces->count() > 0 && $this->current instanceof Element) {
+            $this->applyParentNamespaces($this->current);
+        }
+
         return strval($this->current);
     }
+
+    private function applyParentNamespaces(Element $element): void
+    {
+        $prefixes = [];
+        foreach ($element->namespaces() As $namespace) {
+            $prefixes[] = $namespace->prefix;
+        }
+
+        $namespaces = array_filter(
+            $this->namespaces->getArrayCopy(),
+            fn (XmlNamespace $namespace) => !in_array($namespace->prefix, $prefixes)
+        );
+
+        foreach ($namespaces as $namespace) {
+            $element->addAttribute($namespace);
+        }
+    }
 }

src/Tokenizer.php

@@ -40,6 +40,11 @@ public function __construct(Parser $parser, string $encoding = null, int $flags
         xml_set_character_data_handler($this->handle, 'contents');
     }
 
+    public function namespaces(): XmlNamespaces
+    {
+        return $this->namespaces;
+    }
+
     public function tokenize(): Generator
     {
         foreach ($this->parser->parse() as $data) {

tests/Node/XmlNamespacesTest.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace DMT\Test\XmlParser\Node;
+
+use DMT\XmlParser\Node\XmlNamespace;
+use DMT\XmlParser\Node\XmlNamespaces;
+use PHPUnit\Framework\TestCase;
+
+class XmlNamespacesTest extends TestCase
+{
+    public function testPop(): void
+    {
+        $namespaces = new XmlNamespaces([
+            new XmlNamespace('http://example.org/ns', ''),
+            new XmlNamespace('http://example.org/ns1', 'ns1'),
+            new XmlNamespace('http://example.org/ns2', 'ns2'),
+            $last = new XmlNamespace('http://example.org/ns', 'ns'),
+        ]);
+
+        $this->assertSame($last, $namespaces->pop());
+        $this->assertNotContains($last, $namespaces);
+    }
+
+    public function testPopEmpty(): void
+    {
+        $namespaces = new XmlNamespaces();
+        $this->assertNull($namespaces->pop());
+    }
+
+    public function testFind(): void
+    {
+        $namespaces = new XmlNamespaces([
+            new XmlNamespace('http://example.org/ns', ''),
+            new XmlNamespace('http://example.org/ns1', 'ns1'),
+            $find = new XmlNamespace('http://example.org/ns', 'ns'),
+            new XmlNamespace('http://example.org/ns2', 'ns2'),
+        ]);
+
+        $this->assertSame($find, $namespaces->find('http://example.org/ns'));
+    }
+
+    public function testNotFound()
+    {
+        $namespaces = new XmlNamespaces([
+            new XmlNamespace('http://example.org/ns1', 'ns1'),
+            new XmlNamespace('http://example.org/ns2', 'ns2'),
+        ]);
+
+        $this->assertNull($namespaces->find('http://example.org/ns'));
+    }
+}

tests/ParserTest.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace DMT\Test\XmlParser;
+
+use DMT\XmlParser\Node\ElementNode;
+use DMT\XmlParser\Node\Text;
+use DMT\XmlParser\Parser;
+use DMT\XmlParser\Source\FileParser;
+use DMT\XmlParser\Source\StringParser;
+use DMT\XmlParser\Tokenizer;
+use PHPUnit\Framework\TestCase;
+
+class ParserTest extends TestCase
+{
+    public function testParse(): void
+    {
+        $parser = new Parser(new Tokenizer(new StringParser('<book><title>A title</title><author/></book>')));
+
+        $elements = [];
+        while ($element = $parser->parse()) {
+            $this->assertInstanceOf(ElementNode::class, $element);
+            $elements[] = $element->localName ?? $element->contents;
+        }
+
+        $this->assertSame(['book', 'title', 'A title', 'author'], $elements);
+    }
+
+    public function testParseXml()
+    {
+        $parser = new Parser(new Tokenizer(new FileParser(__DIR__ . '/fixtures/books.xml')));
+
+        $books = [];
+        while ($element = $parser->parse()) {
+            if ($element->localName === 'book') {
+                $books[] = $parser->parseXml();
+            }
+        }
+
+        $this->assertCount(2, $books);
+    }
+
+    public function testParseXmlWithInheritNamespaces()
+    {
+        $xml = '<books xmlns:ns1="urn:ns-uri" xmlns:x="lang">
+            <ns1:book xmlns:x="alt-lang">
+                <ns1:title x:lang="en_US">A title</ns1:title>
+                <author/>
+            </ns1:book>
+        </books>';
+
+        $parser = new Parser(new Tokenizer(new StringParser($xml)));
+
+        while ($element = $parser->parse()) {
+            if ($element->localName === 'book') {
+                $book = $parser->parseXml();
+            }
+        }
+
+        $this->assertStringContainsString('xmlns:ns1="urn:ns-uri"', $book);
+        $this->assertStringContainsString('xmlns:x="alt-lang"', $book);
+    }
+
+    public function testDropNamespaces()
+    {
+        $xml = '<book xmlns="http://example.org/ns" xmlns:ns1="http://example.org/ns">
+            <ns1:title>A title</ns1:title>
+            <ns1:author/>
+        </book>';
+
+        $xml = (new Parser(new Tokenizer(new StringParser($xml), null, Tokenizer::XML_DROP_NAMESPACES)))->parseXml();
+
+        $this->assertStringNotContainsString('ns1', $xml);
+        $this->assertStringNotContainsString('xmlns', $xml);
+    }
+
+    public function testUseCData()
+    {
+        $xml = '<book><title>A title</title><author/></book>';
+
+        $parser = new Parser(new Tokenizer(new StringParser($xml), null, Tokenizer::XML_USE_CDATA));
+        do {
+            $element = $parser->parse();
+        } while (!$element instanceof Text);
+
+        $this->assertMatchesRegularExpression('~\<\!\[CDATA\[.*\]\]\>~', strval($element));
+    }
+}