PPFrame_Hash.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use InvalidArgumentException;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Parser\Parsoid\Config\DataAccess;
use MediaWiki\Title\Title;
use RuntimeException;
use Stringable;
use Wikimedia\Parsoid\Fragments\HeadingPFragment;
 
// phpcs:ignore Squiz.Classes.ValidClassName.NotCamelCaps
class PPFrame_Hash implements Stringable, PPFrame {
 
    public $parser;
 
    public $preprocessor;
 
    public $title;
 
    public $titleCache;
 
    public $loopCheckHash;
 
    public $depth;
 
    private $volatile = false;
    private $ttl = null;
 
    protected $childExpansionCache;
    private $maxPPNodeCount;
    private $maxPPExpandDepth;
 
    private bool $useHeadingPFragments;
 
    public function __construct( $preprocessor ) {
        $this->preprocessor = $preprocessor;
        $this->parser = $preprocessor->parser;
        $this->title = $this->parser->getTitle();
        $this->maxPPNodeCount = $this->parser->getOptions()->getMaxPPNodeCount();
        $this->maxPPExpandDepth = $this->parser->getOptions()->getMaxPPExpandDepth();
        $this->titleCache = [ $this->title ? $this->title->getPrefixedDBkey() : false ];
        $this->loopCheckHash = [];
        $this->depth = 0;
        $this->childExpansionCache = [];
 
        $config = MediaWikiServices::getInstance()->getMainConfig();
        $this->useHeadingPFragments = in_array(
            'HeadingPFragment',
            $config->get( MainConfigNames::ReturnExperimentalPFragmentTypes ),
            true
        );
    }
 
    public function newChild( $args = false, $title = false, $indexOffset = 0 ) {
        $namedArgs = [];
        $numberedArgs = [];
        if ( $title === false ) {
            $title = $this->title;
        }
        if ( $args !== false ) {
            if ( $args instanceof PPNode_Hash_Array ) {
                $args = $args->value;
            } elseif ( !is_array( $args ) ) {
                throw new InvalidArgumentException( __METHOD__ . ': $args must be array or PPNode_Hash_Array' );
            }
            foreach ( $args as $arg ) {
                $bits = $arg->splitArg();
                if ( $bits['index'] !== '' ) {
                    // Numbered parameter
                    $index = $bits['index'] - $indexOffset;
                    if ( isset( $namedArgs[$index] ) || isset( $numberedArgs[$index] ) ) {
                        $this->parser->getOutput()->addWarningMsg(
                            'duplicate-args-warning',
                            wfEscapeWikiText( (string)$this->title ),
                            wfEscapeWikiText( (string)$title ),
                            Message::numParam( $index )
                        );
                        $this->parser->addTrackingCategory( 'duplicate-args-category' );
                    }
                    $numberedArgs[$index] = $bits['value'];
                    unset( $namedArgs[$index] );
                } else {
                    // Named parameter
                    $name = trim( $this->expand( $bits['name'], PPFrame::STRIP_COMMENTS ) );
                    if ( isset( $namedArgs[$name] ) || isset( $numberedArgs[$name] ) ) {
                        $this->parser->getOutput()->addWarningMsg(
                            'duplicate-args-warning',
                            wfEscapeWikiText( (string)$this->title ),
                            wfEscapeWikiText( (string)$title ),
                            // @phan-suppress-next-line SecurityCheck-DoubleEscaped
                            wfEscapeWikiText( $name )
                        );
                        $this->parser->addTrackingCategory( 'duplicate-args-category' );
                    }
                    $namedArgs[$name] = $bits['value'];
                    unset( $numberedArgs[$name] );
                }
            }
        }
        return new PPTemplateFrame_Hash( $this->preprocessor, $this, $numberedArgs, $namedArgs, $title );
    }
 
    public function cachedExpand( $key, $root, $flags = 0 ) {
        // we don't have a parent, so we don't have a cache
        return $this->expand( $root, $flags );
    }
 
    public function expand( $root, $flags = 0 ) {
        static $expansionDepth = 0;
        if ( is_string( $root ) ) {
            return $root;
        }
 
        if ( ++$this->parser->mPPNodeCount > $this->maxPPNodeCount ) {
            $this->parser->limitationWarn( 'node-count-exceeded',
                    $this->parser->mPPNodeCount,
                    $this->maxPPNodeCount
            );
            return '<span class="error">Node-count limit exceeded</span>';
        }
        if ( $expansionDepth > $this->maxPPExpandDepth ) {
            $this->parser->limitationWarn( 'expansion-depth-exceeded',
                    $expansionDepth,
                    $this->maxPPExpandDepth
            );
            return '<span class="error">Expansion depth limit exceeded</span>';
        }
        ++$expansionDepth;
        if ( $expansionDepth > $this->parser->mHighestExpansionDepth ) {
            $this->parser->mHighestExpansionDepth = $expansionDepth;
        }
 
        $outStack = [ '', '' ];
        $iteratorStack = [ false, $root ];
        $indexStack = [ 0, 0 ];
 
        while ( count( $iteratorStack ) > 1 ) {
            $level = count( $outStack ) - 1;
            $iteratorNode =& $iteratorStack[$level];
            $out =& $outStack[$level];
            $index =& $indexStack[$level];
 
            if ( is_array( $iteratorNode ) ) {
                if ( $index >= count( $iteratorNode ) ) {
                    // All done with this iterator
                    $iteratorStack[$level] = false;
                    $contextNode = false;
                } else {
                    $contextNode = $iteratorNode[$index];
                    $index++;
                }
            } elseif ( $iteratorNode instanceof PPNode_Hash_Array ) {
                if ( $index >= $iteratorNode->getLength() ) {
                    // All done with this iterator
                    $iteratorStack[$level] = false;
                    $contextNode = false;
                } else {
                    $contextNode = $iteratorNode->item( $index );
                    $index++;
                }
            } else {
                // Copy to $contextNode and then delete from iterator stack,
                // because this is not an iterator but we do have to execute it once
                $contextNode = $iteratorStack[$level];
                $iteratorStack[$level] = false;
            }
 
            $newIterator = false;
            $contextName = false;
            $contextChildren = false;
 
            if ( $contextNode === false ) {
                // nothing to do
            } elseif ( is_string( $contextNode ) ) {
                $out .= $contextNode;
            } elseif ( $contextNode instanceof PPNode_Hash_Array ) {
                $newIterator = $contextNode;
            } elseif ( $contextNode instanceof PPNode_Hash_Attr ) {
                // No output
            } elseif ( $contextNode instanceof PPNode_Hash_Text ) {
                $out .= $contextNode->value;
            } elseif ( $contextNode instanceof PPNode_Hash_Tree ) {
                $contextName = $contextNode->name;
                $contextChildren = $contextNode->getRawChildren();
            } elseif ( is_array( $contextNode ) ) {
                // Node descriptor array
                if ( count( $contextNode ) !== 2 ) {
                    throw new RuntimeException( __METHOD__ .
                        ': found an array where a node descriptor should be' );
                }
                [ $contextName, $contextChildren ] = $contextNode;
            } else {
                throw new RuntimeException( __METHOD__ . ': Invalid parameter type' );
            }
 
            // Handle node descriptor array or tree object
            if ( $contextName === false ) {
                // Not a node, already handled above
            } elseif ( $contextName[0] === '@' ) {
                // Attribute: no output
            } elseif ( $contextName === 'template' ) {
                # Double-brace expansion
                $bits = PPNode_Hash_Tree::splitRawTemplate( $contextChildren );
                if ( $flags & PPFrame::NO_TEMPLATES ) {
                    $newIterator = $this->virtualBracketedImplode(
                        '{{', '|', '}}',
                        $bits['title'],
                        $bits['parts']
                    );
                } else {
                    $ret = $this->parser->braceSubstitution( $bits, $this );
                    if ( isset( $ret['object'] ) ) {
                        $newIterator = $ret['object'];
                    } else {
                        $out .= $ret['text'];
                    }
                }
            } elseif ( $contextName === 'tplarg' ) {
                # Triple-brace expansion
                $bits = PPNode_Hash_Tree::splitRawTemplate( $contextChildren );
                if ( $flags & PPFrame::NO_ARGS ) {
                    $newIterator = $this->virtualBracketedImplode(
                        '{{{', '|', '}}}',
                        $bits['title'],
                        $bits['parts']
                    );
                } else {
                    $ret = $this->parser->argSubstitution( $bits, $this );
                    if ( isset( $ret['object'] ) ) {
                        $newIterator = $ret['object'];
                    } else {
                        $out .= $ret['text'];
                    }
                }
            } elseif ( $contextName === 'comment' ) {
                # HTML-style comment
                # Remove it in HTML, pre+remove and STRIP_COMMENTS modes
                # Not in RECOVER_COMMENTS mode (msgnw) though.
                if ( ( $this->parser->getOutputType() === Parser::OT_HTML
                    || ( $this->parser->getOutputType() === Parser::OT_PREPROCESS &&
                        $this->parser->getOptions()->getRemoveComments() )
                    || ( $flags & PPFrame::STRIP_COMMENTS )
                    ) && !( $flags & PPFrame::RECOVER_COMMENTS )
                ) {
                    $out .= '';
                } elseif (
                    $this->parser->getOutputType() === Parser::OT_WIKI &&
                    !( $flags & PPFrame::RECOVER_COMMENTS )
                ) {
                    # Add a strip marker in PST mode so that pstPass2() can
                    # run some old-fashioned regexes on the result.
                    # Not in RECOVER_COMMENTS mode (extractSections) though.
                    $out .= $this->parser->insertStripItem( $contextChildren[0] );
                } else {
                    # Recover the literal comment in RECOVER_COMMENTS and pre+no-remove
                    $out .= $contextChildren[0];
                }
            } elseif ( $contextName === 'ignore' ) {
                # Output suppression used by <includeonly> etc.
                # OT_WIKI will only respect <ignore> in substed templates.
                # The other output types respect it unless NO_IGNORE is set.
                # extractSections() sets NO_IGNORE and so never respects it.
                if ( ( !isset( $this->parent ) && $this->parser->getOutputType() === Parser::OT_WIKI )
                    || ( $flags & PPFrame::NO_IGNORE )
                ) {
                    $out .= $contextChildren[0];
                } else {
                    // $out .= '';
                }
            } elseif ( $contextName === 'ext' ) {
                # Extension tag
                $bits = PPNode_Hash_Tree::splitRawExt( $contextChildren ) +
                    [ 'attr' => null, 'inner' => null, 'close' => null ];
                if ( $flags & PPFrame::NO_TAGS ) {
                    $s = '<' . $bits['name']->getFirstChild()->value;
                    if ( $bits['attr'] ) {
                        $s .= $bits['attr']->getFirstChild()->value;
                    }
                    if ( $bits['inner'] ) {
                        $s .= '>' . $bits['inner']->getFirstChild()->value;
                        if ( $bits['close'] ) {
                            $s .= $bits['close']->getFirstChild()->value;
                        }
                    } else {
                        $s .= '/>';
                    }
                    $out .= $s;
                } else {
                    $out .= $this->parser->extensionSubstitution( $bits, $this );
                }
            } elseif ( $contextName === 'h' ) {
                # Heading
                if ( $this->parser->getOutputType() === Parser::OT_HTML ) {
                    # Expand immediately and insert heading index marker
                    $s = $this->expand( $contextChildren, $flags );
                    $bits = PPNode_Hash_Tree::splitRawHeading( $contextChildren );
                    $titleText = $this->title->getPrefixedDBkey();
                    $this->parser->mHeadings[] = [ $titleText, $bits['i'] ];
                    $serial = count( $this->parser->mHeadings ) - 1;
                    $marker = Parser::MARKER_PREFIX . "-h-$serial-" . Parser::MARKER_SUFFIX;
                    $s = substr( $s, 0, $bits['level'] ) . $marker . substr( $s, $bits['level'] );
                    $this->parser->getStripState()->addGeneral( $marker, '' );
                    $out .= $s;
                } elseif (
                    $this->useHeadingPFragments &&
                    $this->parser->useParsoidFragments() &&
                    $this->parser->getOutputType() === Parser::OT_PREPROCESS
                ) {
                    $s = $this->expand( $contextChildren, $flags );
                    $fragment = DataAccess::unstripForParsoid( $s, $this->parser );
                    $bits = PPNode_Hash_Tree::splitRawHeading( $contextChildren );
                    $pFragment = new HeadingPFragment( $fragment, $this->title, $bits['i'] );
 
                    // Just generate a unique marker
                    $this->parser->mHeadings[] = [];
                    $serial = count( $this->parser->mHeadings ) - 1;
                    $marker = Parser::MARKER_PREFIX . "-h-$serial-" . Parser::MARKER_SUFFIX;
 
                    $this->parser->getStripState()->addParsoidOpaque( $marker, $pFragment );
                    $out .= $marker;
                } else {
                    # Expand in virtual stack
                    $newIterator = $contextChildren;
                }
            } else {
                # Generic recursive expansion
                $newIterator = $contextChildren;
            }
 
            if ( $newIterator !== false ) {
                $outStack[] = '';
                $iteratorStack[] = $newIterator;
                $indexStack[] = 0;
            } elseif ( $iteratorStack[$level] === false ) {
                // Return accumulated value to parent
                // With tail recursion
                while ( $iteratorStack[$level] === false && $level > 0 ) {
                    $outStack[$level - 1] .= $out;
                    array_pop( $outStack );
                    array_pop( $iteratorStack );
                    array_pop( $indexStack );
                    $level--;
                }
            }
        }
        --$expansionDepth;
        return $outStack[0];
    }
 
    public function implodeWithFlags( $sep, $flags, ...$args ) {
        $first = true;
        $s = '';
        foreach ( $args as $root ) {
            if ( $root instanceof PPNode_Hash_Array ) {
                $root = $root->value;
            }
            if ( !is_array( $root ) ) {
                $root = [ $root ];
            }
            foreach ( $root as $node ) {
                if ( $first ) {
                    $first = false;
                } else {
                    $s .= $sep;
                }
                $s .= $this->expand( $node, $flags );
            }
        }
        return $s;
    }
 
    public function implode( $sep, ...$args ) {
        $first = true;
        $s = '';
        foreach ( $args as $root ) {
            if ( $root instanceof PPNode_Hash_Array ) {
                $root = $root->value;
            }
            if ( !is_array( $root ) ) {
                $root = [ $root ];
            }
            foreach ( $root as $node ) {
                if ( $first ) {
                    $first = false;
                } else {
                    $s .= $sep;
                }
                $s .= $this->expand( $node );
            }
        }
        return $s;
    }
 
    public function virtualImplode( $sep, ...$args ) {
        $out = [];
        $first = true;
 
        foreach ( $args as $root ) {
            if ( $root instanceof PPNode_Hash_Array ) {
                $root = $root->value;
            }
            if ( !is_array( $root ) ) {
                $root = [ $root ];
            }
            foreach ( $root as $node ) {
                if ( $first ) {
                    $first = false;
                } else {
                    $out[] = $sep;
                }
                $out[] = $node;
            }
        }
        return new PPNode_Hash_Array( $out );
    }
 
    public function virtualBracketedImplode( $start, $sep, $end, ...$args ) {
        $out = [ $start ];
        $first = true;
 
        foreach ( $args as $root ) {
            if ( $root instanceof PPNode_Hash_Array ) {
                $root = $root->value;
            }
            if ( !is_array( $root ) ) {
                $root = [ $root ];
            }
            foreach ( $root as $node ) {
                if ( $first ) {
                    $first = false;
                } else {
                    $out[] = $sep;
                }
                $out[] = $node;
            }
        }
        $out[] = $end;
        return new PPNode_Hash_Array( $out );
    }
 
    public function __toString() {
        return 'frame{}';
    }
 
    public function getPDBK( $level = false ) {
        if ( $level === false ) {
            return $this->title->getPrefixedDBkey();
        } else {
            return $this->titleCache[$level] ?? false;
        }
    }
 
    public function getArguments() {
        return [];
    }
 
    public function getNumberedArguments() {
        return [];
    }
 
    public function getNamedArguments() {
        return [];
    }
 
    public function isEmpty() {
        return true;
    }
 
    public function getArgument( $name ) {
        return false;
    }
 
    public function loopCheck( $title ) {
        return !isset( $this->loopCheckHash[$title->getPrefixedDBkey()] );
    }
 
    public function isTemplate() {
        return false;
    }
 
    public function getTitle() {
        return $this->title;
    }
 
    public function setVolatile( $flag = true ) {
        $this->volatile = $flag;
    }
 
    public function isVolatile() {
        return $this->volatile;
    }
 
    public function setTTL( $ttl ) {
        wfDeprecated( __METHOD__, '1.44' );
        if ( $ttl !== null && ( $this->ttl === null || $ttl < $this->ttl ) ) {
            $this->ttl = $ttl;
        }
    }
 
    public function getTTL() {
        wfDeprecated( __METHOD__, '1.46' );
        return $this->ttl;
    }
}
 
class_alias( PPFrame_Hash::class, 'PPFrame_Hash' );