FluentDOM\XMLReader

Complexity

Total Complexity

37

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	prepareCondition()	0	12	4
A	__construct()	0	3	1
A	registerNamespace()	0	3	1
C	next()	0	23	13
C	read()	0	27	12
A	getAttribute()	0	7	2
A	expand()	0	8	2
A	attachStream()	0	8	2

<?php

namespace FluentDOM {

  use FluentDOM\DOM\Document;
  use FluentDOM\DOM\Node;
  use FluentDOM\Exceptions\InvalidArgument;
  use FluentDOM\Utility\Namespaces;
  use FluentDOM\Utility\QualifiedName;
  use FluentDOM\Utility\ResourceWrapper;

  class XMLReader extends \XMLReader {

    /**
     * @var Namespaces
     */
    private $_namespaces;

    /**
     * Store last used document to avoid early GC
     * @var Document
     */
    private $_document;

    public function __construct() {
      $this->_namespaces = new Namespaces();
    }

    /**
     * register a namespace prefix for the xml reader, it will be used in
     * next() and other methods with a tag name argument
     *
     * @param string $prefix
     * @param string $namespaceURI
     * @throws \LogicException
     */
    public function registerNamespace(string $prefix, string $namespaceURI) {
      $this->_namespaces[$prefix] = $namespaceURI;
    }

    /**
     * Positions cursor on the next node skipping all subtrees. If $name contains
     * a namespace prefix it will be resolved using the registered namespaces.
     *
     * @param NULL|string $name The name of the next node to move to.
     * @param NULL|string $namespaceURI
     * @param callable|NULL $filter
     * @return bool
     */
    public function next($name = NULL, string $namespaceURI = NULL, callable $filter = NULL): bool {
      if (NULL !== $name) {
        list($localName, $namespaceURI, $ignoreNamespace) = $this->prepareCondition($name, $namespaceURI);
      } else {
        $ignoreNamespace = NULL === $namespaceURI || '' === $namespaceURI;
        $localName = $name;
        $namespaceURI = '';
      }
      if ($ignoreNamespace && !$filter) {
        return NULL !== $name ? parent::next($name) : parent::next();
      }
      $found = empty($localName) ? parent::next() : parent::next($localName);
      while ($found) {
        if (
          ($ignoreNamespace || $this->namespaceURI === $namespaceURI) &&
          (!$filter || $filter($this))
        ) {
          return TRUE;
        }
        $found = empty($localName) ? parent::next() : parent::next($localName);
      }
      return FALSE;
    }

    /**
     * Move to next node in document, including subtrees. If $name contains
     * a namespace prefix it will be resolved using the registered namespaces.
     *
     * @param NULL|string $name The name of the next node to move to.
     * @param NULL|string $namespaceURI
     * @param callable|NULL $filter
     * @return bool
     */
    public function read(string $name = NULL, string $namespaceURI = NULL, callable $filter = NULL): bool {
      if (NULL !== $name) {
        list($localName, $namespaceURI, $ignoreNamespace) = $this->prepareCondition($name, $namespaceURI);
        while (parent::read()) {
          if (
            $this->nodeType === XML_ELEMENT_NODE &&
            $this->localName === $localName &&
            (
              ($ignoreNamespace || ($this->namespaceURI === $namespaceURI)) &&
              (!$filter || $filter($this))
            )
          ) {
            return TRUE;
          }
        }
        return FALSE;
      }
      if ($filter) {
        while (parent::read()) {
          if ($filter($this)) {
            return TRUE;
          }
        }
        return FALSE;
      }
      return parent::read();
    }

    /**
     * Return attribute by name, resolve namespace prefix if included.
     *
     * @param string $name
     * @return NULL|string
     */
    public function getAttribute($name) {
      list($prefix, $localName) = QualifiedName::split($name);
      if (empty($prefix)) {
        return parent::getAttribute($name);
      }
      return parent::getAttributeNs($localName, $this->_namespaces->resolveNamespace($prefix));
    }

    /**
     * @param \DOMNode $baseNode
     * @return Node|\DOMNode
     * @throws \LogicException
     */
    public function expand($baseNode = NULL) {
      if (NULL !== $baseNode) {
        return parent::expand($baseNode);
      }
      $this->_document = $document = new Document();
      $document->namespaces($this->_namespaces);
      return parent::expand($document);
    }

    /**
     * @param $name
     * @param $namespaceURI
     * @return array
     */
    private function prepareCondition($name, $namespaceURI): array {
      if (NULL !== $namespaceURI) {
        $localName = $name;
        $namespaceURI = (string)$namespaceURI;
        $ignoreNamespace = FALSE;
      } else {
        list($prefix, $localName) = QualifiedName::split($name);
        $namespaceURI = $prefix ? $this->_namespaces->resolveNamespace($prefix) : '';
        $ignoreNamespace = ($prefix === FALSE && $namespaceURI === '');
      }
      return [$localName, $namespaceURI, $ignoreNamespace];
    }

    /**
     * @param resource $stream
     * @param string $encoding
     * @param int $options
     * @return bool
     * @throws \FluentDOM\Exceptions\InvalidArgument
     */
    public function attachStream($stream, string $encoding = NULL, int $options = 0): bool {
      if (!is_resource($stream)) {
        throw new InvalidArgument('stream', 'resource');
      }
      list($uri, $context) = ResourceWrapper::createContext($stream);
      libxml_set_streams_context($context);
      return $this->open($uri, $encoding, $options);
    }
  }
}