WikitextContent.php

Go to the documentation of this file.

<?php
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
 
class WikitextContent extends TextContent {
    private $redirectTargetAndText = null;
 
    private $hadSignature = false;
 
    private $previousParseStackTrace = null;
 
    public function __construct( $text ) {
        parent::__construct( $text, CONTENT_MODEL_WIKITEXT );
    }
 
    public function getSection( $sectionId ) {
        $text = $this->getText();
        $sect = MediaWikiServices::getInstance()->getParser()
            ->getSection( $text, $sectionId, false );
 
        if ( $sect === false ) {
            return false;
        } else {
            return new static( $sect );
        }
    }
 
    public function replaceSection( $sectionId, Content $with, $sectionTitle = '' ) {
        $myModelId = $this->getModel();
        $sectionModelId = $with->getModel();
 
        if ( $sectionModelId != $myModelId ) {
            throw new MWException( "Incompatible content model for section: " .
                "document uses $myModelId but " .
                "section uses $sectionModelId." );
        }
        '@phan-var self $with';
 
        $oldtext = $this->getText();
        $text = $with->getText();
 
        if ( strval( $sectionId ) === '' ) {
            return $with; # XXX: copy first?
        }
 
        if ( $sectionId === 'new' ) {
            # Inserting a new section
            $subject = $sectionTitle ? wfMessage( 'newsectionheaderdefaultlevel' )
                    ->plaintextParams( $sectionTitle )->inContentLanguage()->text() . "\n\n" : '';
            if ( Hooks::runner()->onPlaceNewSection( $this, $oldtext, $subject, $text ) ) {
                $text = strlen( trim( $oldtext ) ) > 0
                    ? "{$oldtext}\n\n{$subject}{$text}"
                    : "{$subject}{$text}";
            }
        } else {
            # Replacing an existing section; roll out the big guns
            $text = MediaWikiServices::getInstance()->getParser()
                ->replaceSection( $oldtext, $sectionId, $text );
        }
 
        $newContent = new static( $text );
 
        return $newContent;
    }
 
    public function addSectionHeader( $header ) {
        $text = wfMessage( 'newsectionheaderdefaultlevel' )
            ->rawParams( $header )->inContentLanguage()->text();
        $text .= "\n\n";
        $text .= $this->getText();
 
        return new static( $text );
    }
 
    public function preSaveTransform( Title $title, User $user, ParserOptions $popts ) {
        $text = $this->getText();
 
        $parser = MediaWikiServices::getInstance()->getParser();
        $pst = $parser->preSaveTransform( $text, $title, $user, $popts );
 
        if ( $text === $pst ) {
            return $this;
        }
 
        $ret = new static( $pst );
 
        if ( $parser->getOutput()->getFlag( 'user-signature' ) ) {
            $ret->hadSignature = true;
        }
 
        return $ret;
    }
 
    public function preloadTransform( Title $title, ParserOptions $popts, $params = [] ) {
        $text = $this->getText();
        $plt = MediaWikiServices::getInstance()->getParser()
            ->getPreloadText( $text, $title, $popts, $params );
 
        return new static( $plt );
    }
 
    protected function getRedirectTargetAndText() {
        global $wgMaxRedirects;
 
        if ( $this->redirectTargetAndText !== null ) {
            return $this->redirectTargetAndText;
        }
 
        if ( $wgMaxRedirects < 1 ) {
            // redirects are disabled, so quit early
            $this->redirectTargetAndText = [ null, $this->getText() ];
            return $this->redirectTargetAndText;
        }
 
        $redir = MediaWikiServices::getInstance()->getMagicWordFactory()->get( 'redirect' );
        $text = ltrim( $this->getText() );
        if ( $redir->matchStartAndRemove( $text ) ) {
            // Extract the first link and see if it's usable
            // Ensure that it really does come directly after #REDIRECT
            // Some older redirects included a colon, so don't freak about that!
            $m = [];
            if ( preg_match( '!^\s*:?\s*\[{2}(.*?)(?:\|.*?)?\]{2}\s*!', $text, $m ) ) {
                // Strip preceding colon used to "escape" categories, etc.
                // and URL-decode links
                if ( strpos( $m[1], '%' ) !== false ) {
                    // Match behavior of inline link parsing here;
                    $m[1] = rawurldecode( ltrim( $m[1], ':' ) );
                }
                $title = Title::newFromText( $m[1] );
                // If the title is a redirect to bad special pages or is invalid, return null
                if ( !$title instanceof Title || !$title->isValidRedirectTarget() ) {
                    $this->redirectTargetAndText = [ null, $this->getText() ];
                    return $this->redirectTargetAndText;
                }
 
                $this->redirectTargetAndText = [ $title, substr( $text, strlen( $m[0] ) ) ];
                return $this->redirectTargetAndText;
            }
        }
 
        $this->redirectTargetAndText = [ null, $this->getText() ];
        return $this->redirectTargetAndText;
    }
 
    public function getRedirectTarget() {
        list( $title, ) = $this->getRedirectTargetAndText();
 
        return $title;
    }
 
    public function updateRedirect( Title $target ) {
        if ( !$this->isRedirect() ) {
            return $this;
        }
 
        # Fix the text
        # Remember that redirect pages can have categories, templates, etc.,
        # so the regex has to be fairly general
        $newText = preg_replace( '/ \[ \[  [^\]]*  \] \] /x',
            '[[' . $target->getFullText() . ']]',
            $this->getText(), 1 );
 
        return new static( $newText );
    }
 
    public function isCountable( $hasLinks = null, Title $title = null ) {
        global $wgArticleCountMethod;
 
        if ( $this->isRedirect() ) {
            return false;
        }
 
        if ( $wgArticleCountMethod === 'link' ) {
            if ( $hasLinks === null ) { # not known, find out
                // @TODO: require an injected title
                if ( !$title ) {
                    $context = RequestContext::getMain();
                    $title = $context->getTitle();
                }
 
                $po = $this->getParserOutput( $title, null, null, false );
                $links = $po->getLinks();
                $hasLinks = !empty( $links );
            }
 
            return $hasLinks;
        }
 
        return true;
    }
 
    public function getTextForSummary( $maxlength = 250 ) {
        $truncatedtext = parent::getTextForSummary( $maxlength );
 
        # clean up unfinished links
        # XXX: make this optional? wasn't there in autosummary, but required for
        # deletion summary.
        $truncatedtext = preg_replace( '/\[\[([^\]]*)\]?$/', '$1', $truncatedtext );
 
        return $truncatedtext;
    }
 
    protected function fillParserOutput( Title $title, $revId,
            ParserOptions $options, $generateHtml, ParserOutput &$output
    ) {
        $stackTrace = ( new RuntimeException() )->getTraceAsString();
        if ( $this->previousParseStackTrace ) {
            // NOTE: there may be legitimate changes to re-parse the same WikiText content,
            // e.g. if predicted revision ID for the REVISIONID magic word mismatched.
            // But that should be rare.
            $logger = LoggerFactory::getInstance( 'DuplicateParse' );
            $logger->debug(
                __METHOD__ . ': Possibly redundant parse!',
                [
                    'title' => $title->getPrefixedDBkey(),
                    'rev' => $revId,
                    'options-hash' => $options->optionsHash(
                        ParserOptions::allCacheVaryingOptions(),
                        $title
                    ),
                    'trace' => $stackTrace,
                    'previous-trace' => $this->previousParseStackTrace,
                ]
            );
        }
        $this->previousParseStackTrace = $stackTrace;
 
        list( $redir, $text ) = $this->getRedirectTargetAndText();
        $output = MediaWikiServices::getInstance()->getParser()
            ->parse( $text, $title, $options, true, true, $revId );
 
        // Add redirect indicator at the top
        if ( $redir ) {
            // Make sure to include the redirect link in pagelinks
            $output->addLink( $redir );
            if ( $generateHtml ) {
                $chain = $this->getRedirectChain();
                $output->setText(
                    Article::getRedirectHeaderHtml( $title->getPageLanguage(), $chain, false ) .
                    $output->getRawText()
                );
                $output->addModuleStyles( 'mediawiki.action.view.redirectPage' );
            }
        }
 
        // Pass along user-signature flag
        if ( $this->hadSignature ) {
            $output->setFlag( 'user-signature' );
        }
    }
 
    protected function getHtml() {
        throw new MWException(
            "getHtml() not implemented for wikitext. "
                . "Use getParserOutput()->getText()."
        );
    }
 
    public function matchMagicWord( MagicWord $word ) {
        return $word->match( $this->getText() );
    }
 
}