FluentDOM\Namespaces

Complexity

Total Complexity

20

Size/Duplication

Total Lines	94
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	resolveNamespace()	0	3	1
A	isReservedPrefix()	0	3	1
A	offsetExists()	0	3	2
A	offsetSet()	0	9	2
A	offsetGet()	0	13	4
A	offsetUnset()	0	6	2
A	getIterator()	0	3	1
A	count()	0	3	1
A	assign()	0	6	2
A	validatePrefix()	0	3	2

<?php

namespace FluentDOM {

  class Namespaces implements NamespaceResolver, \ArrayAccess, \IteratorAggregate, \Countable {

    /**
     * @var array
     */
    private $_namespaces = [];

    /**
     * @var array
     */
    private $_reserved = [
      'xml' => 'http://www.w3.org/XML/1998/namespace',
      'xmlns' => 'http://www.w3.org/2000/xmlns/'
    ];

    /**
     * Namespaces constructor.
     * @param null|array|\Traversable $namespaces
     */
    public function __construct($namespaces = NULL) {
      if (isset($namespaces)) {
        $this->assign($namespaces);
      }
    }

    public function resolveNamespace($prefix) {
      return $this[$prefix];
    }

    public function isReservedPrefix($prefix) {
      return array_key_exists($prefix, $this->_reserved);
    }

    public function offsetExists($prefix) {
      return array_key_exists($prefix, $this->_reserved) || array_key_exists($prefix, $this->_namespaces);
    }

    public function offsetSet($prefix, $namespaceUri) {
      $prefix = $this->validatePrefix($prefix);
      if (isset($this->_reserved[$prefix])) {
        throw new \LogicException(
          sprintf('Can not register reserved namespace prefix "%s".', $prefix)
        );
      }
      $this->_namespaces[$prefix] = $namespaceUri;
    }

    public function offsetGet($prefix) {
      $prefix = $this->validatePrefix($prefix);
      if (array_key_exists($prefix, $this->_reserved)) {
        return $this->_reserved[$prefix];
      } elseif (array_key_exists($prefix, $this->_namespaces)) {
        return $this->_namespaces[$prefix];
      } elseif ($prefix === '#default') {
        return '';
      }
      throw new \LogicException(
        sprintf('Unknown namespace prefix "%s".', $prefix)
      );
    }

    public function offsetUnset($prefix) {
      $prefix = $this->validatePrefix($prefix);
      if (array_key_exists($prefix, $this->_namespaces)) {
        unset($this->_namespaces[$prefix]);
      }
    }

    public function getIterator() {
      return new \ArrayIterator($this->_namespaces);
    }

    public function count() {
      return count($this->_namespaces);
    }

    /**
     * @param array|\Traversable $namespaces
     */
    public function assign($namespaces) {
      $this->_namespaces = [];
      foreach ($namespaces as $prefix => $namespaceUri) {
        $this->offsetSet($prefix, $namespaceUri);
      }
    }

    /**
     * @param string $prefix
     * @return string
     */
    private function validatePrefix($prefix) {
      return empty($prefix) ? '#default' : $prefix;
    }
  }
}