CommentFormatter.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\CommentFormatter;
 
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Permissions\Authority;
use MediaWiki\Revision\RevisionRecord;
use Traversable;
 
class CommentFormatter {
    protected $parserFactory;
 
    public function __construct( CommentParserFactory $parserFactory ) {
        $this->parserFactory = $parserFactory;
    }
 
    public function createBatch() {
        return new CommentBatch( $this );
    }
 
    public function format( string $comment, LinkTarget $selfLinkTarget = null,
        $samePage = false, $wikiId = false
    ) {
        return $this->formatInternal( $comment, true, false, false,
            $selfLinkTarget, $samePage, $wikiId );
    }
 
    public function formatBlock( string $comment, LinkTarget $selfLinkTarget = null,
        $samePage = false, $wikiId = false, $useParentheses = true
    ) {
        return $this->formatInternal( $comment, true, true, $useParentheses,
            $selfLinkTarget, $samePage, $wikiId );
    }
 
    public function formatLinksUnsafe( string $comment, LinkTarget $selfLinkTarget = null,
        $samePage = false, $wikiId = false
    ) {
        $parser = $this->parserFactory->create();
        $preprocessed = $parser->preprocessUnsafe( $comment, $selfLinkTarget,
            $samePage, $wikiId, false );
        return $parser->finalize( $preprocessed );
    }
 
    public function formatLinks( string $comment, LinkTarget $selfLinkTarget = null,
        $samePage = false, $wikiId = false
    ) {
        return $this->formatInternal( $comment, false, false, false,
            $selfLinkTarget, $samePage, $wikiId );
    }
 
    private function formatInternal( $comment, $enableSectionLinks, $useBlock, $useParentheses,
        $selfLinkTarget = null, $samePage = false, $wikiId = false
    ) {
        $parser = $this->parserFactory->create();
        $preprocessed = $parser->preprocess( $comment, $selfLinkTarget, $samePage, $wikiId,
            $enableSectionLinks );
        $output = $parser->finalize( $preprocessed );
        if ( $useBlock ) {
            $output = $this->wrapCommentWithBlock( $output, $useParentheses );
        }
        return $output;
    }
 
    public function formatStrings( $strings, LinkTarget $selfLinkTarget = null,
        $samePage = false, $wikiId = false
    ) {
        $parser = $this->parserFactory->create();
        $outputs = [];
        foreach ( $strings as $i => $comment ) {
            $outputs[$i] = $parser->preprocess( $comment, $selfLinkTarget, $samePage, $wikiId );
        }
        return $parser->finalize( $outputs );
    }
 
    public function formatStringsAsBlock( $strings, LinkTarget $selfLinkTarget = null,
        $samePage = false, $wikiId = false, $useParentheses = true
    ) {
        $parser = $this->parserFactory->create();
        $outputs = [];
        foreach ( $strings as $i => $comment ) {
            $outputs[$i] = $this->wrapCommentWithBlock(
                $parser->preprocess( $comment, $selfLinkTarget, $samePage, $wikiId ),
                $useParentheses );
        }
        return $parser->finalize( $outputs );
    }
 
    public function formatRevision(
        RevisionRecord $revision,
        Authority $authority,
        $samePage = false,
        $isPublic = false,
        $useParentheses = true
    ) {
        $parser = $this->parserFactory->create();
        return $parser->finalize( $this->preprocessRevComment(
            $parser, $authority, $revision, $samePage, $isPublic, $useParentheses ) );
    }
 
    public function formatRevisions(
        $revisions,
        Authority $authority,
        $samePage = false,
        $isPublic = false,
        $useParentheses = true,
        $indexById = false
    ) {
        $parser = $this->parserFactory->create();
        $outputs = [];
        foreach ( $revisions as $i => $rev ) {
            if ( $indexById ) {
                $key = $rev->getId();
            } else {
                $key = $i;
            }
            // @phan-suppress-next-line PhanTypeMismatchDimAssignment getId does not return null here
            $outputs[$key] = $this->preprocessRevComment(
                $parser, $authority, $rev, $samePage, $isPublic, $useParentheses );
        }
        return $parser->finalize( $outputs );
    }
 
    public function createRevisionBatch() {
        return new RevisionCommentBatch( $this );
    }
 
    public function formatItems( $items ) {
        return $this->formatItemsInternal( $items );
    }
 
    public function formatItemsInternal( $items, $selfLinkTarget = null,
        $samePage = null, $wikiId = null, $enableSectionLinks = null,
        $useBlock = null, $useParentheses = null
    ) {
        $outputs = [];
        $parser = $this->parserFactory->create();
        foreach ( $items as $index => $item ) {
            $preprocessed = $parser->preprocess(
                $item->comment,
                $item->selfLinkTarget ?? $selfLinkTarget,
                $item->samePage ?? $samePage ?? false,
                $item->wikiId ?? $wikiId ?? false,
                $enableSectionLinks ?? true
            );
            if ( $useBlock ?? false ) {
                $preprocessed = $this->wrapCommentWithBlock(
                    $preprocessed,
                    $useParentheses ?? true
                );
            }
            $outputs[$index] = $preprocessed;
        }
        return $parser->finalize( $outputs );
    }
 
    protected function wrapCommentWithBlock(
        $formatted, $useParentheses
    ) {
        // '*' used to be the comment inserted by the software way back
        // in antiquity in case none was provided, here for backwards
        // compatibility, acc. to brion -ævar
        if ( $formatted == '' || $formatted == '*' ) {
            return '';
        }
        if ( $useParentheses ) {
            $formatted = wfMessage( 'parentheses' )->rawParams( $formatted )->escaped();
            $classNames = 'comment';
        } else {
            $classNames = 'comment comment--without-parentheses';
        }
        return " <span class=\"$classNames\">$formatted</span>";
    }
 
    private function preprocessRevComment(
        CommentParser $parser,
        Authority $authority,
        RevisionRecord $revRecord,
        $samePage = false,
        $isPublic = false,
        $useParentheses = true
    ) {
        if ( $revRecord->getComment( RevisionRecord::RAW ) === null ) {
            return "";
        }
        if ( $revRecord->audienceCan(
            RevisionRecord::DELETED_COMMENT,
            $isPublic ? RevisionRecord::FOR_PUBLIC : RevisionRecord::FOR_THIS_USER,
            $authority )
        ) {
            $comment = $revRecord->getComment( RevisionRecord::FOR_THIS_USER, $authority );
            $block = $parser->preprocess(
                $comment ? $comment->text : '',
                $revRecord->getPageAsLinkTarget(),
                $samePage,
                null,
                true
            );
            $block = $this->wrapCommentWithBlock( $block, $useParentheses );
        } else {
            $block = " <span class=\"comment\">" . wfMessage( 'rev-deleted-comment' )->escaped() . "</span>";
        }
        if ( $revRecord->isDeleted( RevisionRecord::DELETED_COMMENT ) ) {
            $class = \MediaWiki\Linker\Linker::getRevisionDeletedClass( $revRecord );
            return " <span class=\"$class comment\">$block</span>";
        }
        return $block;
    }
 
}