TemplatesOnThisPageFormatter.php

Go to the documentation of this file.

<?php
namespace MediaWiki\EditPage;
 
use MediaWiki\Context\IContextSource;
use MediaWiki\Html\Html;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Message\Message;
use MediaWiki\Page\LinkBatchFactory;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageReference;
use MediaWiki\Permissions\RestrictionStore;
use MediaWiki\Title\Title;
use Wikimedia\Message\ListType;
 
class TemplatesOnThisPageFormatter {
 
    public function __construct(
        private readonly IContextSource $context,
        private readonly LinkRenderer $linkRenderer,
        private readonly LinkBatchFactory $linkBatchFactory,
        private readonly RestrictionStore $restrictionStore
    ) {
    }
 
    public function format( array $templates, $type = false, $more = null ) {
        if ( !$templates ) {
            // No templates
            return '';
        }
 
        # Do a batch existence check
        $batch = $this->linkBatchFactory->newLinkBatch( $templates );
        $batch->setCaller( __METHOD__ );
        $batch->execute();
 
        # Construct the HTML
        $outText = Html::openElement( 'div', [ 'class' => 'mw-templatesUsedExplanation' ] );
        $count = count( $templates );
        if ( $type === 'preview' ) {
            $outText .= $this->context->msg( 'templatesusedpreview' )->numParams( $count )
                ->parseAsBlock();
        } elseif ( $type === 'section' ) {
            $outText .= $this->context->msg( 'templatesusedsection' )->numParams( $count )
                ->parseAsBlock();
        } else {
            $outText .= $this->context->msg( 'templatesused' )->numParams( $count )
                ->parseAsBlock();
        }
        $outText .= Html::closeElement( 'div' ) . Html::openElement( 'ul' ) . "\n";
 
        usort( $templates, Title::compare( ... ) );
        foreach ( $templates as $template ) {
            $outText .= $this->formatTemplate( $template );
        }
 
        if ( $more instanceof PageReference ) {
            $outText .= Html::rawElement( 'li', [],
                $this->linkRenderer->makeLink(
                    $more,
                    $this->context->msg( 'moredotdotdot' )->text()
                )
            );
        } elseif ( $more ) {
            // Documented as should already be escaped
            $outText .= Html::rawElement( 'li', [], $more );
        }
 
        $outText .= Html::closeElement( 'ul' );
        return $outText;
    }
 
    private function formatTemplate( PageIdentity $target ) {
        if ( !$target->canExist() ) {
            return Html::rawElement( 'li', [], $this->linkRenderer->makeLink( $target ) );
        }
 
        $protected = $this->getRestrictionsText(
            $this->restrictionStore->getRestrictions( $target, 'edit' )
        );
        $editLink = $this->buildEditLink( $target );
        return Html::rawElement( 'li', [], $this->linkRenderer->makeLink( $target )
            . $this->context->msg( 'word-separator' )->escaped()
            . $this->context->msg( 'parentheses' )->rawParams( $editLink )->escaped()
            . $this->context->msg( 'word-separator' )->escaped()
            . $protected
        );
    }
 
    private function getRestrictionsText( array $restrictions ) {
        $protected = '';
        if ( !$restrictions ) {
            return $protected;
        }
 
        // Construct the message from restriction-level-*
        // e.g. restriction-level-sysop, restriction-level-autoconfirmed
        $msgs = [];
        foreach ( $restrictions as $r ) {
            $msgs[] = $this->context->msg( "restriction-level-$r" );
        }
 
        // Check backwards-compatible messages for the built-in protection levels
        $msg = null;
        if ( $restrictions === [ 'sysop' ] ) {
            $msg = $this->context->msg( 'template-protected' );
        } elseif ( $restrictions === [ 'autoconfirmed' ] ) {
            $msg = $this->context->msg( 'template-semiprotected' );
        }
        if ( !$msg || $msg->isDisabled() ) {
            // By default wrap protection levels in parentheses
            $msg = $this->context->msg( 'parentheses' );
        }
 
        return $msg->params( Message::listParam( $msgs, ListType::COMMA ) )->parse();
    }
 
    private function buildEditLink( PageIdentity $page ) {
        if ( $this->context->getAuthority()->probablyCan( 'edit', $page ) ) {
            $linkMsg = 'editlink';
        } else {
            $linkMsg = 'viewsourcelink';
        }
 
        return $this->linkRenderer->makeLink(
            $page,
            $this->context->msg( $linkMsg )->text(),
            [],
            [ 'action' => 'edit' ]
        );
    }
 
}