PPNode_Hash_Tree.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use BadMethodCallException;
use InvalidArgumentException;
use Stringable;
 
// phpcs:ignore Squiz.Classes.ValidClassName.NotCamelCaps
class PPNode_Hash_Tree implements Stringable, PPNode {
 
    public $name;
 
    private $rawChildren;
 
    private $store;
 
    private $index;
 
    public const NAME = 0;
 
    public const CHILDREN = 1;
 
    public function __construct( array $store, $index ) {
        $this->store = $store;
        $this->index = $index;
        [ $this->name, $this->rawChildren ] = $this->store[$index];
    }
 
    public static function factory( array $store, $index ) {
        if ( !isset( $store[$index] ) ) {
            return false;
        }
 
        $descriptor = $store[$index];
        if ( is_string( $descriptor ) ) {
            $class = PPNode_Hash_Text::class;
        } elseif ( is_array( $descriptor ) ) {
            if ( $descriptor[self::NAME][0] === '@' ) {
                $class = PPNode_Hash_Attr::class;
            } else {
                $class = self::class;
            }
        } else {
            throw new InvalidArgumentException( __METHOD__ . ': invalid node descriptor' );
        }
        return new $class( $store, $index );
    }
 
    public function __toString() {
        $inner = '';
        $attribs = '';
        for ( $node = $this->getFirstChild(); $node; $node = $node->getNextSibling() ) {
            if ( $node instanceof PPNode_Hash_Attr ) {
                $attribs .= ' ' . $node->name .
                    '="' . htmlspecialchars( $node->value, ENT_COMPAT ) . '"';
            } else {
                $inner .= $node->__toString();
            }
        }
        if ( $inner === '' ) {
            return "<{$this->name}$attribs/>";
        } else {
            return "<{$this->name}$attribs>$inner</{$this->name}>";
        }
    }
 
    public function getChildren() {
        $children = [];
        foreach ( $this->rawChildren as $i => $child ) {
            $children[] = self::factory( $this->rawChildren, $i );
        }
        return new PPNode_Hash_Array( $children );
    }
 
    public function getFirstChild() {
        if ( !isset( $this->rawChildren[0] ) ) {
            return false;
        } else {
            return self::factory( $this->rawChildren, 0 );
        }
    }
 
    public function getNextSibling() {
        return self::factory( $this->store, $this->index + 1 );
    }
 
    public function getChildrenOfType( $name ) {
        $children = [];
        foreach ( $this->rawChildren as $i => $child ) {
            if ( is_array( $child ) && $child[self::NAME] === $name ) {
                $children[] = self::factory( $this->rawChildren, $i );
            }
        }
        return new PPNode_Hash_Array( $children );
    }
 
    public function getRawChildren() {
        return $this->rawChildren;
    }
 
    public function getLength() {
        return false;
    }
 
    public function item( $i ) {
        return false;
    }
 
    public function getName() {
        return $this->name;
    }
 
    public function splitArg() {
        return self::splitRawArg( $this->rawChildren );
    }
 
    public static function splitRawArg( array $children ) {
        $bits = [];
        foreach ( $children as $i => $child ) {
            if ( !is_array( $child ) ) {
                continue;
            }
            if ( $child[self::NAME] === 'name' ) {
                $bits['name'] = new self( $children, $i );
                if ( isset( $child[self::CHILDREN][0][self::NAME] )
                    && $child[self::CHILDREN][0][self::NAME] === '@index'
                ) {
                    $bits['index'] = $child[self::CHILDREN][0][self::CHILDREN][0];
                }
            } elseif ( $child[self::NAME] === 'value' ) {
                $bits['value'] = new self( $children, $i );
            }
        }
 
        if ( !isset( $bits['name'] ) ) {
            throw new InvalidArgumentException( 'Invalid brace node passed to ' . __METHOD__ );
        }
        if ( !isset( $bits['index'] ) ) {
            $bits['index'] = '';
        }
        return $bits;
    }
 
    public function splitExt() {
        return self::splitRawExt( $this->rawChildren );
    }
 
    public static function splitRawExt( array $children ) {
        $bits = [];
        foreach ( $children as $i => $child ) {
            if ( !is_array( $child ) ) {
                continue;
            }
            switch ( $child[self::NAME] ) {
                case 'name':
                    $bits['name'] = new self( $children, $i );
                    break;
                case 'attr':
                    $bits['attr'] = new self( $children, $i );
                    break;
                case 'inner':
                    $bits['inner'] = new self( $children, $i );
                    break;
                case 'close':
                    $bits['close'] = new self( $children, $i );
                    break;
            }
        }
        if ( !isset( $bits['name'] ) ) {
            throw new InvalidArgumentException( 'Invalid ext node passed to ' . __METHOD__ );
        }
        return $bits;
    }
 
    public function splitHeading() {
        if ( $this->name !== 'h' ) {
            throw new BadMethodCallException( 'Invalid h node passed to ' . __METHOD__ );
        }
        return self::splitRawHeading( $this->rawChildren );
    }
 
    public static function splitRawHeading( array $children ) {
        $bits = [];
        foreach ( $children as $child ) {
            if ( !is_array( $child ) ) {
                continue;
            }
            if ( $child[self::NAME] === '@i' ) {
                $bits['i'] = $child[self::CHILDREN][0];
            } elseif ( $child[self::NAME] === '@level' ) {
                $bits['level'] = $child[self::CHILDREN][0];
            }
        }
        if ( !isset( $bits['i'] ) ) {
            throw new InvalidArgumentException( 'Invalid h node passed to ' . __METHOD__ );
        }
        return $bits;
    }
 
    public function splitTemplate() {
        return self::splitRawTemplate( $this->rawChildren );
    }
 
    public static function splitRawTemplate( array $children ) {
        $parts = [];
        $bits = [ 'lineStart' => '' ];
        foreach ( $children as $i => $child ) {
            if ( !is_array( $child ) ) {
                continue;
            }
            switch ( $child[self::NAME] ) {
                case 'title':
                    $bits['title'] = new self( $children, $i );
                    break;
                case 'part':
                    $parts[] = new self( $children, $i );
                    break;
                case '@lineStart':
                    $bits['lineStart'] = '1';
                    break;
            }
        }
        if ( !isset( $bits['title'] ) ) {
            throw new InvalidArgumentException( 'Invalid node passed to ' . __METHOD__ );
        }
        $bits['parts'] = new PPNode_Hash_Array( $parts );
        return $bits;
    }
}
 
class_alias( PPNode_Hash_Tree::class, 'PPNode_Hash_Tree' );