CommentParser.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\CommentFormatter;
 
use File;
use HtmlArmor;
use Language;
use LinkBatch;
use LinkCache;
use Linker;
use MalformedTitleException;
use MediaWiki\Cache\LinkBatchFactory;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Linker\LinkTarget;
use NamespaceInfo;
use Parser;
use RepoGroup;
use Title;
use TitleParser;
use TitleValue;
 
class CommentParser {
    private $linkRenderer;
    private $linkBatchFactory;
    private $repoGroup;
    private $userLang;
    private $contLang;
    private $titleParser;
    private $namespaceInfo;
    private $hookRunner;
    private $linkCache;
 
    private $links = [];
    private $linkBatch;
 
    private $fileBatch;
    private $files = [];
 
    private const MAX_ID_SIZE = 7;
    private const MARKER_PREFIX = "\x1B\"'";
 
    public function __construct(
        LinkRenderer $linkRenderer,
        LinkBatchFactory $linkBatchFactory,
        LinkCache $linkCache,
        RepoGroup $repoGroup,
        Language $userLang,
        Language $contLang,
        TitleParser $titleParser,
        NamespaceInfo $namespaceInfo,
        HookContainer $hookContainer
    ) {
        $this->linkRenderer = $linkRenderer;
        $this->linkBatchFactory = $linkBatchFactory;
        $this->linkCache = $linkCache;
        $this->repoGroup = $repoGroup;
        $this->userLang = $userLang;
        $this->contLang = $contLang;
        $this->titleParser = $titleParser;
        $this->namespaceInfo = $namespaceInfo;
        $this->hookRunner = new HookRunner( $hookContainer );
    }
 
    public function preprocess( string $comment, LinkTarget $selfLinkTarget = null,
        $samePage = false, $wikiId = false, $enableSectionLinks = true
    ) {
        return $this->preprocessInternal( $comment, false, $selfLinkTarget,
            $samePage, $wikiId, $enableSectionLinks );
    }
 
    public function preprocessUnsafe( $comment, LinkTarget $selfLinkTarget = null,
        $samePage = false, $wikiId = false, $enableSectionLinks = true
    ) {
        return $this->preprocessInternal( $comment, true, $selfLinkTarget,
            $samePage, $wikiId, $enableSectionLinks );
    }
 
    public function finalize( $comments ) {
        $this->flushLinkBatches();
        return preg_replace_callback(
            '/' . self::MARKER_PREFIX . '([0-9]{' . self::MAX_ID_SIZE . '})/',
            function ( $m ) {
                $callback = $this->links[(int)$m[1]] ?? null;
                if ( $callback ) {
                    return $callback();
                } else {
                    return '<!-- MISSING -->';
                }
            },
            $comments
        );
    }
 
    private function preprocessInternal( $comment, $unsafe, $selfLinkTarget, $samePage, $wikiId,
        $enableSectionLinks
    ) {
        // Sanitize text a bit
        // \x1b needs to be stripped because it is used for link markers
        $comment = strtr( $comment, "\n\x1b", "  " );
        // Allow HTML entities (for T15815)
        if ( !$unsafe ) {
            $comment = \Sanitizer::escapeHtmlAllowEntities( $comment );
        }
        if ( $enableSectionLinks ) {
            $comment = $this->doSectionLinks( $comment, $selfLinkTarget, $samePage, $wikiId );
        }
        return $this->doWikiLinks( $comment, $selfLinkTarget, $samePage, $wikiId );
    }
 
    private function doSectionLinks(
        $comment,
        $selfLinkTarget = null,
        $samePage = false,
        $wikiId = false
    ) {
        // @todo $append here is something of a hack to preserve the status
        // quo. Someone who knows more about bidi and such should decide
        // (1) what sensible rendering even *is* for an LTR edit summary on an RTL
        // wiki, both when autocomments exist and when they don't, and
        // (2) what markup will make that actually happen.
        $append = '';
        $comment = preg_replace_callback(
        // To detect the presence of content before or after the
        // auto-comment, we use capturing groups inside optional zero-width
        // assertions. But older versions of PCRE can't directly make
        // zero-width assertions optional, so wrap them in a non-capturing
        // group.
            '!(?:(?<=(.)))?/\*\s*(.*?)\s*\*/(?:(?=(.)))?!',
            function ( $match ) use ( &$append, $selfLinkTarget, $samePage, $wikiId ) {
                // Ensure all match positions are defined
                $match += [ '', '', '', '' ];
 
                $pre = $match[1] !== '';
                $auto = $match[2];
                $post = $match[3] !== '';
                $comment = null;
 
                $this->hookRunner->onFormatAutocomments(
                    $comment, $pre, $auto, $post,
                    Title::castFromLinkTarget( $selfLinkTarget ),
                    $samePage,
                    $wikiId );
                if ( $comment !== null ) {
                    return $comment;
                }
 
                if ( $selfLinkTarget ) {
                    $section = $auto;
                    # Remove links that a user may have manually put in the autosummary
                    # This could be improved by copying as much of Parser::stripSectionName as desired.
                    $section = str_replace( [
                        '[[:',
                        '[[',
                        ']]'
                    ], '', $section );
 
                    // We don't want any links in the auto text to be linked, but we still
                    // want to show any [[ ]]
                    $sectionText = str_replace( '[[', '&#91;[', $auto );
 
                    $section = substr( Parser::guessSectionNameFromStrippedText( $section ), 1 );
                    if ( $section !== '' ) {
                        if ( $samePage ) {
                            $sectionTitle = new TitleValue( NS_MAIN, '', $section );
                        } else {
                            $sectionTitle = $selfLinkTarget->createFragmentTarget( $section );
                        }
                        $auto = $this->makeSectionLink(
                            $sectionTitle,
                            $this->userLang->getArrow() . $this->userLang->getDirMark() . $sectionText,
                            $wikiId
                        );
                    }
                }
                if ( $pre ) {
                    # written summary $presep autocomment (summary /* section */)
                    $pre = wfMessage( 'autocomment-prefix' )->inContentLanguage()->escaped();
                }
                if ( $post ) {
                    # autocomment $postsep written summary (/* section */ summary)
                    $auto .= wfMessage( 'colon-separator' )->inContentLanguage()->escaped();
                }
                if ( $auto ) {
                    $auto = '<span dir="auto"><span class="autocomment">' . $auto . '</span>';
                    $append .= '</span>';
                }
                $comment = $pre . $auto;
                return $comment;
            },
            $comment
        );
        return $comment . $append;
    }
 
    private function makeSectionLink(
        LinkTarget $target, $text, $wikiId
    ) {
        if ( $wikiId !== null && $wikiId !== false && !$target->isExternal() ) {
            return Linker::makeExternalLink(
                \WikiMap::getForeignURL(
                    $wikiId,
                    $target->getNamespace() === 0
                        ? $target->getDBkey()
                        : $this->namespaceInfo->getCanonicalName( $target->getNamespace() ) .
                        ':' . $target->getDBkey(),
                    $target->getFragment()
                ),
                $text,
                /* escape = */ false // Already escaped
            );
        }
        return $this->linkRenderer->makePreloadedLink( $target, new HtmlArmor( $text ), '' );
    }
 
    private function doWikiLinks( $comment, $selfLinkTarget = null, $samePage = false, $wikiId = false ) {
        return preg_replace_callback(
            '/
                \[\[
                \s*+ # ignore leading whitespace, the *+ quantifier disallows backtracking
                :? # ignore optional leading colon
                ([^[\]|]+) # 1. link target; page names cannot include [, ] or |
                (?:\|
                    # 2. link text
                    # Stop matching at ]] without relying on backtracking.
                    ((?:]?[^\]])*+)
                )?
                \]\]
                ([^[]*) # 3. link trail (the text up until the next link)
            /x',
            function ( $match ) use ( $selfLinkTarget, $samePage, $wikiId ) {
                $medians = '(?:';
                $medians .= preg_quote(
                    $this->namespaceInfo->getCanonicalName( NS_MEDIA ), '/' );
                $medians .= '|';
                $medians .= preg_quote(
                        $this->contLang->getNsText( NS_MEDIA ),
                        '/'
                    ) . '):';
 
                $comment = $match[0];
 
                // Fix up urlencoded title texts (copied from Parser::replaceInternalLinks)
                if ( strpos( $match[1], '%' ) !== false ) {
                    $match[1] = strtr(
                        rawurldecode( $match[1] ),
                        [ '<' => '&lt;', '>' => '&gt;' ]
                    );
                }
 
                // Handle link renaming [[foo|text]] will show link as "text"
                if ( $match[2] != "" ) {
                    $text = $match[2];
                } else {
                    $text = $match[1];
                }
                $submatch = [];
                $linkMarker = null;
                if ( preg_match( '/^' . $medians . '(.*)$/i', $match[1], $submatch ) ) {
                    // Media link; trail not supported.
                    $linkRegexp = '/\[\[(.*?)\]\]/';
                    $linkTarget = $this->titleParser->makeTitleValueSafe( NS_FILE, $submatch[1] );
                    if ( $linkTarget ) {
                        $linkMarker = $this->addFileLink( $linkTarget, $text );
                    }
                } else {
                    // Other kind of link
                    // Make sure its target is non-empty
                    if ( isset( $match[1][0] ) && $match[1][0] == ':' ) {
                        $match[1] = substr( $match[1], 1 );
                    }
                    // @phan-suppress-next-line PhanTypePossiblyInvalidDimOffset False positive
                    if ( $match[1] !== false && $match[1] !== null && $match[1] !== '' ) {
                        if ( preg_match(
                            $this->contLang->linkTrail(),
                            $match[3],
                            $submatch
                        ) ) {
                            $trail = $submatch[1];
                        } else {
                            $trail = "";
                        }
                        $linkRegexp = '/\[\[(.*?)\]\]' . preg_quote( $trail, '/' ) . '/';
                        list( $inside, $trail ) = Linker::splitTrail( $trail );
 
                        $linkText = $text;
                        $linkTarget = Linker::normalizeSubpageLink( $selfLinkTarget, $match[1], $linkText );
 
                        try {
                            $target = $this->titleParser->parseTitle( $linkTarget );
 
                            if ( $target->getText() == '' && !$target->isExternal()
                                && !$samePage && $selfLinkTarget
                            ) {
                                $target = $selfLinkTarget->createFragmentTarget( $target->getFragment() );
                            }
 
                            $linkMarker = $this->addPageLink( $target, $linkText . $inside, $wikiId );
                            $linkMarker .= $trail;
                        } catch ( MalformedTitleException $e ) {
                            // Fall through
                        }
                    }
                }
                if ( $linkMarker ) {
                    // If the link is still valid, go ahead and replace it in!
                    $comment = preg_replace(
                        // @phan-suppress-next-next-line PhanPossiblyUndeclaredVariable linkRegexp set when used
                        // @phan-suppress-next-line PhanTypeMismatchArgumentNullableInternal linkRegexp set when used
                        $linkRegexp,
                        $linkMarker,
                        $comment,
                        1
                    );
                }
 
                return $comment;
            },
            $comment
        );
    }
 
    private function addLinkMarker( $callback ) {
        $nextId = count( $this->links );
        if ( strlen( (string)$nextId ) > self::MAX_ID_SIZE ) {
            throw new \RuntimeException( 'Too many links in comment batch' );
        }
        $this->links[] = $callback;
        return sprintf( self::MARKER_PREFIX . "%0" . self::MAX_ID_SIZE . 'd', $nextId );
    }
 
    private function addPageLink( LinkTarget $target, $text, $wikiId ) {
        if ( $wikiId !== null && $wikiId !== false && !$target->isExternal() ) {
            // Handle links from a foreign wiki ID
            return Linker::makeExternalLink(
                \WikiMap::getForeignURL(
                    $wikiId,
                    $target->getNamespace() === 0
                        ? $target->getDBkey()
                        : $this->namespaceInfo->getCanonicalName( $target->getNamespace() ) .
                        ':' . $target->getDBkey(),
                    $target->getFragment()
                ),
                $text,
                /* escape = */ false // Already escaped
            );
        } elseif ( $this->linkCache->getGoodLinkID( $target ) ||
            Title::newFromLinkTarget( $target )->isAlwaysKnown()
        ) {
            // Already known
            return $this->linkRenderer->makeKnownLink( $target, new HtmlArmor( $text ) );
        } elseif ( $this->linkCache->isBadLink( $target ) ) {
            // Already cached as unknown
            return $this->linkRenderer->makeBrokenLink( $target, new HtmlArmor( $text ) );
        }
 
        // Defer page link
        if ( !$this->linkBatch ) {
            $this->linkBatch = $this->linkBatchFactory->newLinkBatch();
            $this->linkBatch->setCaller( __METHOD__ );
        }
        $this->linkBatch->addObj( $target );
        return $this->addLinkMarker( function () use ( $target, $text ) {
            return $this->linkRenderer->makeLink( $target, new HtmlArmor( $text ) );
        } );
    }
 
    private function addFileLink( LinkTarget $target, $html ) {
        $this->fileBatch[] = [
            'title' => $target
        ];
        return $this->addLinkMarker( function () use ( $target, $html ) {
            return Linker::makeMediaLinkFile(
                $target,
                $this->files[$target->getDBkey()] ?? false,
                $html
            );
        } );
    }
 
    private function flushLinkBatches() {
        if ( $this->linkBatch ) {
            $this->linkBatch->execute();
            $this->linkBatch = null;
        }
        if ( $this->fileBatch ) {
            $this->files += $this->repoGroup->findFiles( $this->fileBatch );
            $this->fileBatch = [];
        }
    }
 
}