UserLinkRenderer.php

Go to the documentation of this file.

<?php
declare( strict_types=1 );
 
namespace MediaWiki\Linker;
 
use MediaWiki\Context\IContextSource;
use MediaWiki\DAO\WikiAwareEntity;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Html\Html;
use MediaWiki\Language\MessageLocalizer;
use MediaWiki\Page\PageReference;
use MediaWiki\SpecialPage\SpecialPageFactory;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleValue;
use MediaWiki\User\ExternalUserNames;
use MediaWiki\User\TempUser\TempUserConfig;
use MediaWiki\User\TempUser\TempUserDetailsLookup;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserIdentityLookup;
use MediaWiki\User\UserNameUtils;
use MediaWiki\WikiMap\WikiMap;
use Wikimedia\HtmlArmor\HtmlArmor;
use Wikimedia\IPUtils;
use Wikimedia\ObjectCache\MapCacheLRU;
 
class UserLinkRenderer {
 
    private HookRunner $hookRunner;
    private TempUserConfig $tempUserConfig;
    private SpecialPageFactory $specialPageFactory;
    private LinkRenderer $linkRenderer;
    private TempUserDetailsLookup $tempUserDetailsLookup;
    private UserIdentityLookup $userIdentityLookup;
    private UserNameUtils $userNameUtils;
 
    private MapCacheLRU $userLinkCache;
 
    public function __construct(
        HookContainer $hookContainer,
        TempUserConfig $tempUserConfig,
        SpecialPageFactory $specialPageFactory,
        LinkRenderer $linkRenderer,
        TempUserDetailsLookup $tempUserDetailsLookup,
        UserIdentityLookup $userIdentityLookup,
        UserNameUtils $userNameUtils
    ) {
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->tempUserConfig = $tempUserConfig;
        $this->specialPageFactory = $specialPageFactory;
        $this->linkRenderer = $linkRenderer;
        $this->tempUserDetailsLookup = $tempUserDetailsLookup;
        $this->userIdentityLookup = $userIdentityLookup;
        $this->userNameUtils = $userNameUtils;
 
        // Set a large enough cache size to accommodate long pagers,
        // such as Special:RecentChanges with a high limit.
        $this->userLinkCache = new MapCacheLRU( 1_000 );
    }
 
    public function userLink(
        UserIdentity $targetUser,
        IContextSource $context,
        ?string $altUserName = null,
        array $attributes = []
    ): string {
        $outputPage = $context->getOutput();
        $outputPage->addModuleStyles( [
            'mediawiki.interface.helpers.styles',
            'mediawiki.interface.helpers.linker.styles'
        ] );
 
        $userName = $targetUser->getName();
 
        if ( $this->isFromExternalWiki( $targetUser->getWikiId() ) ) {
            $html = $this->userLinkCache->getWithSetCallback(
                $this->userLinkCache->makeKey(
                    $targetUser->getWikiId(),
                    $userName,
                    $altUserName ?? '',
                    implode( ' ', $attributes )
                ),
                fn () => $this->renderExternalUserLink(
                    $targetUser,
                    $context,
                    $altUserName,
                    $attributes
                )
            );
        } else {
            $html = $this->userLinkCache->getWithSetCallback(
                $this->userLinkCache->makeKey(
                    $userName,
                    $altUserName ?? '',
                    implode( ' ', $attributes )
                ),
                fn () => $this->renderUserLink(
                    $targetUser,
                    $context,
                    $altUserName,
                    $attributes
                )
            );
        }
        $prefix = '';
        $postfix = '';
        $this->hookRunner->onUserLinkRendererUserLinkPostRender( $targetUser, $context, $html, $prefix, $postfix );
        return $prefix . $html . $postfix;
    }
 
    private function renderExternalUserLink(
        UserIdentity $targetUser,
        MessageLocalizer $messageLocalizer,
        ?string $altUserName = null,
        array $attributes = []
    ): string {
        $userName = $targetUser->getName();
        $targetPage = Title::makeTitle( NS_USER, $userName );
 
        $linkText = $altUserName ?? $userName;
        $isDefaultCaption = $this->linkRenderer->isDefaultLinkCaption( $targetPage, $linkText );
        $params = $this->getUserLinkParameters( $targetUser, $messageLocalizer, $isDefaultCaption );
        $attributes += $params[ 'extraAttr' ];
        $classes = $params[ 'classes' ];
        $postfix = $params[ 'postfix' ];
 
        $link = $this->linkRenderer->makeExternalLink(
            WikiMap::getForeignURL(
                $targetUser->getWikiId(),
                'User:' . strtr( $userName, ' ', '_' )
            ),
            new HtmlArmor(
                Html::element( 'bdi', [], $linkText ) . $postfix
            ),
            $targetPage,
            '',
            $attributes + [ 'class' => $classes ]
        );
 
        return $link;
    }
 
    private function renderUserLink(
        UserIdentity $targetUser,
        MessageLocalizer $messageLocalizer,
        ?string $altUserName = null,
        array $attributes = []
    ): string {
        $userName = $targetUser->getName();
        $classes = [];
 
        if ( $this->tempUserConfig->isTempName( $userName ) ) {
            $pageName = $this->specialPageFactory->getLocalNameFor( 'Contributions', $userName );
            $page = new TitleValue( NS_SPECIAL, $pageName );
        } elseif ( !$targetUser->isRegistered() ) {
            $page = ExternalUserNames::getUserLinkTitle( $userName );
 
            if ( ExternalUserNames::isExternal( $userName ) ) {
                $classes[] = 'mw-extuserlink';
            } else {
                $altUserName ??= IPUtils::prettifyIP( $userName );
            }
            $classes[] = 'mw-anonuserlink'; // Separate link class for anons (T45179)
        } else {
            $page = TitleValue::tryNew( NS_USER, strtr( $userName, ' ', '_' ) );
        }
 
        $linkText = $altUserName ?? $userName;
        $isDefaultCaption = $this->linkRenderer->isDefaultLinkCaption( $page, $linkText );
        $params = $this->getUserLinkParameters( $targetUser, $messageLocalizer, $isDefaultCaption );
        $attributes += $params[ 'extraAttr' ];
        $classes = array_merge( $params[ 'classes' ], $classes );
        $postfix = $params[ 'postfix' ];
 
        // Wrap the output with <bdi> tags for directionality isolation
        $linkText =
            '<bdi>' . htmlspecialchars( $linkText ) . '</bdi>'
             . $postfix;
 
        if ( isset( $attributes['class'] ) ) {
            $classes[] = $attributes['class'];
        }
 
        $attributes['class'] = $classes;
 
        if ( $page !== null ) {
            return $this->linkRenderer->makeLink( $page, new HtmlArmor( $linkText ), $attributes );
        }
 
        return Html::rawElement( 'span', $attributes, $linkText );
    }
 
    private function getUserLinkParameters(
        UserIdentity $targetUser,
        MessageLocalizer $messageLocalizer,
        bool $isDefaultCaption,
    ) {
        $attributes = [];
        $userName = $targetUser->getName();
        $isExpired = false;
        $postfix = '';
 
        $classes = $this->getLinkClassesFromUserName( $userName, $isDefaultCaption );
        $classes[] = 'mw-userlink';
        if ( $this->tempUserConfig->isTempName( $userName ) ) {
            $attributes['data-mw-target'] = $userName;
 
            if ( $this->isFromExternalWiki( $targetUser->getWikiId() ) ) {
                // Check if the local wiki has an account with the same name and,
                // if it does, check if it is expired. We can do this because
                // temporary accounts expire on all wikis at the same time for a
                // wiki farm.
                $localIdentity = $this->userIdentityLookup->getUserIdentityByName(
                    $userName
                );
            } else {
                // For local users, we can directly use $targetUser
                $localIdentity = $targetUser;
            }
 
            if ( $localIdentity instanceof UserIdentity ) {
                $isExpired = $this->tempUserDetailsLookup->isExpired(
                    $localIdentity
                );
            }
        }
 
        // Adjust the styling of expired temporary account links (T358469).
        if ( $isExpired ) {
            $classes[] = 'mw-tempuserlink-expired';
 
            $description = $messageLocalizer->msg(
                'tempuser-expired-link-tooltip'
            )->text();
 
            $postfix = Html::element(
                'span',
                [
                    'role' => 'presentation',
                    'class' => 'cdx-tooltip mw-tempuserlink-expired--tooltip',
                ],
                $description
            );
 
            $attributes['aria-description'] = $description;
 
            // Hide default link title when rendering expired temporary account
            // links to avoid conflicting with the tooltip.
            $attributes['title'] = null;
        }
 
        return [
            'classes' => $classes,
            'extraAttr' => $attributes,
            'postfix' => $postfix
        ];
    }
 
    protected function isFromExternalWiki( $wikiId ): bool {
        if ( $wikiId === WikiAwareEntity::LOCAL ) {
            return false;
        }
 
        return !WikiMap::isCurrentWikiDbDomain( $wikiId );
    }
 
    private function getLinkClassesFromUserName( string $userName, bool $isDefaultCaption ): array {
        $classes = [];
 
        // mw-tempuserlink should be added only in cases like [[User:~2025-1|~2025-1]] and
        // not e.g. [[User:~2025-1|this user]]: T398952#10994965.
        if ( $isDefaultCaption && $this->tempUserConfig->isTempName( $userName ) ) {
            $classes[] = 'mw-tempuserlink';
        }
        return $classes;
    }
 
    public function getLinkClasses( LinkTarget|PageReference $target, bool $isDefaultCaption = false ): array {
        $ns = $target->getNamespace();
        $userName = null;
        if ( $ns === NS_USER ) {
            // Recognize direct links to users
            $userName = $target->getDBkey();
        } elseif ( $ns === NS_SPECIAL ) {
            // Recognize links to contributions pages
            [ $name, $subpage ] = $this->specialPageFactory->resolveAlias( $target->getDBkey() );
            if ( $name === 'Contributions' && $subpage !== null ) {
                $userName = $subpage;
            }
        }
        if ( $userName !== null ) {
            $userName = $this->userNameUtils->getCanonical( $userName );
            if ( $userName !== false ) {
                return $this->getLinkClassesFromUserName( $userName, $isDefaultCaption );
            }
        }
        return [];
    }
}