<?php
/**
* Holds a bundle definition in a structure serializable to a native array.
*/
class Loco_config_ArrayModel extends Loco_config_Model {
/**
* @var LocoConfigDocument
*/
private $dom;
/**
* {@inheritdoc}
*/
public function createDom(){
$this->dom = new LocoConfigDocument( ['#document', [], [] ] );
}
/**
* @return LocoConfigDocument
*/
public function getDom(){
return $this->dom;
}
/**
* Construct model from serialized JSON
* @return void
*/
public function loadJson( $json ){
$root = json_decode( $json, true );
if( ! $root || ! is_array($root) ){
throw new Loco_error_ParseException('Invalid JSON');
}
$this->loadArray( $root );
}
/**
* Construct model from exported array
* @return void
*/
public function loadArray( array $root ){
$dom = $this->getDom();
$dom->load( ['#document', [], [$root] ] );
}
/**
* {@inheritdoc}
* Emulates *very limited* XPath queries used by the XML DOM.
*/
public function query( $query, $context = null ){
$match = new LocoConfigNodeList;
$query = explode('/', $query );
// absolute path always starts in document
if( empty($query[0]) ){
$match->append( $this->getDom() );
}
// else start with base for relative path
else if( $context instanceof LocoConfigNode ){
$match->append( $context );
}
while( $query ){
$name = array_shift($query);
// self references do nothing
if( ! $name || '.' === $name ){
continue;
}
// match all current branches to produce new set of parents
$next = new LocoConfigNodeList;
foreach( $match as $parent ){
foreach( $parent->childNodes as $child ){
if( $name === $child->nodeName || ( '*' === $name && $child instanceof LocoConfigElement ) || ( 'text()' === $name && $child instanceof LocoConfigText) ){
$next->append( $child );
}
}
}
$match = $next;
}
return $match;
}
}
// The following classes are "private" to this file:
// They partially implement the same interfaces as the core DOM classes and are used for code hints.
// Interfaces are deliberately not used as the real DOM classes would not be able to implement them.
/**
* Node
* @property-read string $textContent
* @property-read string $nodeName
* @property-read LocoConfigNodeList $childNodes
*/
abstract class LocoConfigNode implements IteratorAggregate {
/**
* Raw data of internal format
* @var array|string
*/
protected $data;
/**
* Child nodes once cast to node objects
* @var LocoConfigNodeList
*/
protected $children;
/**
* @return mixed
*/
abstract public function export();
/**
* @param array|string $data
*/
final public function __construct( $data ){
$this->data = $data;
}
/**
* @internal
*/
protected function get_nodeName(){
return $this->data[0];
}
/**
* @internal
*/
protected function get_childNodes(){
return $this->getIterator();
}
public function __get( $prop ){
$method = [ $this, 'get_'.$prop ];
if( is_callable($method) ){
return call_user_func( $method );
}
return null;
}
/** @return LocoConfigNode */
public function appendChild( LocoConfigNode $child ){
$children = $this->getIterator();
$children->append( $child );
return $child;
}
/** @return bool */
public function hasChildNodes(){
return (bool) count( $this->getIterator() );
}
/**
* @return LocoConfigNodeList
*/
#[ReturnTypeWillChange]
public function getIterator(){
if( ! $this->children ){
//$raw = isset($this->data[2]) ? $this->data[2] : array();
$this->children = new LocoConfigNodeList( $this->data[2] );
}
return $this->children;
}
public function get_textContent(){
$s = '';
foreach( $this as $child ){
$s .= $child->get_textContent();
}
return $s;
}
}
/**
* NodeList
*/
class LocoConfigNodeList implements Iterator, Countable, ArrayAccess {
private $nodes;
private $i;
private $n;
public function __construct( array $nodes = [] ){
$this->nodes = $nodes;
$this->n = count( $nodes );
}
#[ReturnTypeWillChange]
public function count(){
return $this->n;
}
#[ReturnTypeWillChange]
public function rewind(){
$this->i = -1;
$this->next();
}
#[ReturnTypeWillChange]
public function key(){
return $this->i;
}
#[ReturnTypeWillChange]
public function current(){
return $this[ $this->i ];
}
#[ReturnTypeWillChange]
public function valid(){
return is_int($this->i);
}
#[ReturnTypeWillChange]
public function next(){
if( ++$this->i === $this->n ){
$this->i = null;
}
}
#[ReturnTypeWillChange]
public function offsetExists( $offset ){
return $offset >= 0 && $offset < $this->n;
}
#[ReturnTypeWillChange]
public function offsetGet( $offset ){
$node = $this->nodes[$offset];
if( ! $node instanceof LocoConfigNode ){
if( is_array($node) ){
$node = new LocoConfigElement( $node );
}
else {
$node = new LocoConfigText( $node );
}
$this->nodes[$offset] = $node;
}
return $node;
}
/**
* @codeCoverageIgnore
*/
#[ReturnTypeWillChange]
public function offsetSet( $offset, $value ){
throw new LogicException('Use append');
}
/**
* @codeCoverageIgnore
*/
#[ReturnTypeWillChange]
public function offsetUnset( $offset ){
throw new LogicException('Read only');
}
public function append( LocoConfigNode $node ){
$this->nodes[] = $node;
$this->n++;
}
/**
* Revert nodes back to raw array form and return for exporting
* @return array
*/
public function normalize(){
foreach( $this->nodes as $i => $node ){
if( $node instanceof LocoConfigNode ){
$this->nodes[$i] = $node->export();
}
}
return $this->nodes;
}
}
/**
* Document
* @property-read LocoConfigElement $documentElement
*/
class LocoConfigDocument extends LocoConfigNode {
/**
* Rapidly set new data for document
*/
public function load( $data ){
$this->data = $data;
$this->children = null;
}
/**
* @return LocoConfigElement
*/
public function createElement( $name ){
return new LocoConfigElement( [ $name, [], [] ] );
}
/**
* @return LocoConfigText
*/
public function createTextNode( $text ){
return new LocoConfigText( $text );
}
/**
* @return LocoConfigElement
*/
public function get_documentElement(){
$child = null;
foreach( $this as $child ){
break;
}
return $child;
}
/**
* {@inheritdoc}
* Override to keep single element root
*/
public function export(){
$root = $this->get_documentElement();
return $root ? $root->export() : null;
}
}
/**
* Element
*/
class LocoConfigElement extends LocoConfigNode {
public function setAttribute( $prop, $value ){
$this->data[1][$prop] = $value;
}
public function removeAttribute( $prop ){
unset( $this->data[1][$prop] );
}
public function getAttribute( $prop ){
if( isset($this->data[1][$prop]) ){
return $this->data[1][$prop];
}
return '';
}
public function hasAttribute( $prop ){
return isset($this->data[1][$prop]);
}
/**
* {@inheritdoc}
*/
public function export(){
$raw = $this->data;
// return any cast elements back to raw data
if( $this->children ){
$raw[2] = $this->children->normalize();
}
return $raw;
}
}
/**
* Text node
* @property-read string $nodeValue
* @property-read string $textContent
*/
class LocoConfigText extends LocoConfigNode {
protected function get_nodeName(){
return '#text';
}
public function hasChildNodes(){
return false;
}
public function getIterator(){
return new ArrayIterator;
}
public function export(){
return (string) $this->data;
}
/** @internal */
public function get_nodeValue(){
return (string) $this->data;
}
/** @internal */
public function get_textContent(){
return (string) $this->data;
}
}