LinkRenderer.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Linker;
 
use Html;
use HtmlArmor;
use LinkCache;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Page\PageReference;
use MediaWiki\SpecialPage\SpecialPageFactory;
use NamespaceInfo;
use Sanitizer;
use Title;
use TitleFormatter;
use TitleValue;
use Wikimedia\Assert\Assert;
 
class LinkRenderer {
 
    private $forceArticlePath = false;
 
    private $expandUrls = false;
 
    private $titleFormatter;
 
    private $linkCache;
 
    private $nsInfo;
 
    private $hookContainer;
 
    private $hookRunner;
 
    private $specialPageFactory;
 
    public function __construct(
        TitleFormatter $titleFormatter,
        LinkCache $linkCache,
        NamespaceInfo $nsInfo,
        SpecialPageFactory $specialPageFactory,
        HookContainer $hookContainer
    ) {
        $this->titleFormatter = $titleFormatter;
        $this->linkCache = $linkCache;
        $this->nsInfo = $nsInfo;
        $this->specialPageFactory = $specialPageFactory;
        $this->hookContainer = $hookContainer;
        $this->hookRunner = new HookRunner( $hookContainer );
    }
 
    public function setForceArticlePath( $force ) {
        $this->forceArticlePath = $force;
    }
 
    public function getForceArticlePath() {
        return $this->forceArticlePath;
    }
 
    public function setExpandURLs( $expand ) {
        $this->expandUrls = $expand;
    }
 
    public function getExpandURLs() {
        return $this->expandUrls;
    }
 
    public function setStubThreshold( $threshold ) {
        wfDeprecated( __METHOD__, '1.37' );
    }
 
    public function getStubThreshold() {
        wfDeprecated( __METHOD__, '1.37' );
        return 0;
    }
 
    public function makeLink(
        $target, $text = null, array $extraAttribs = [], array $query = []
    ) {
        Assert::parameterType( [ LinkTarget::class, PageReference::class ], $target, '$target' );
        if ( $this->castToTitle( $target )->isKnown() ) {
            return $this->makeKnownLink( $target, $text, $extraAttribs, $query );
        } else {
            return $this->makeBrokenLink( $target, $text, $extraAttribs, $query );
        }
    }
 
    private function runBeginHook( $target, &$text, &$extraAttribs, &$query, $isKnown ) {
        $ret = null;
        if ( !$this->hookRunner->onHtmlPageLinkRendererBegin(
            $this, $this->castToTitle( $target ), $text, $extraAttribs, $query, $ret )
        ) {
            return $ret;
        }
    }
 
    public function makePreloadedLink(
        $target, $text = null, $classes = '', array $extraAttribs = [], array $query = []
    ) {
        Assert::parameterType( [ LinkTarget::class, PageReference::class ], $target, '$target' );
 
        // Run begin hook
        $ret = $this->runBeginHook( $target, $text, $extraAttribs, $query, true );
        if ( $ret !== null ) {
            return $ret;
        }
        $target = $this->normalizeTarget( $target );
        $url = $this->getLinkURL( $target, $query );
        $attribs = [ 'class' => $classes ];
        $prefixedText = $this->titleFormatter->getPrefixedText( $target );
        if ( $prefixedText !== '' ) {
            $attribs['title'] = $prefixedText;
        }
 
        $attribs = [
            'href' => $url,
        ] + $this->mergeAttribs( $attribs, $extraAttribs );
 
        if ( $text === null ) {
            $text = $this->getLinkText( $target );
        }
 
        return $this->buildAElement( $target, $text, $attribs, true );
    }
 
    public function makeKnownLink(
        $target, $text = null, array $extraAttribs = [], array $query = []
    ) {
        Assert::parameterType( [ LinkTarget::class, PageReference::class ], $target, '$target' );
        if ( $target instanceof LinkTarget ) {
            $isExternal = $target->isExternal();
        } else {
            // $target instanceof PageReference
            // treat all PageReferences as local for now
            $isExternal = false;
        }
        $classes = [];
        if ( $isExternal ) {
            $classes[] = 'extiw';
        }
        $colour = $this->getLinkClasses( $target );
        if ( $colour !== '' ) {
            $classes[] = $colour;
        }
 
        return $this->makePreloadedLink(
            $target,
            $text,
            implode( ' ', $classes ),
            $extraAttribs,
            $query
        );
    }
 
    public function makeBrokenLink(
        $target, $text = null, array $extraAttribs = [], array $query = []
    ) {
        Assert::parameterType( [ LinkTarget::class, PageReference::class ], $target, '$target' );
        // Run legacy hook
        $ret = $this->runBeginHook( $target, $text, $extraAttribs, $query, false );
        if ( $ret !== null ) {
            return $ret;
        }
 
        if ( $target instanceof LinkTarget ) {
            # We don't want to include fragments for broken links, because they
            # generally make no sense.
            if ( $target->hasFragment() ) {
                $target = $target->createFragmentTarget( '' );
            }
        }
        $target = $this->normalizeTarget( $target );
 
        if ( !isset( $query['action'] ) && $target->getNamespace() !== NS_SPECIAL ) {
            $query['action'] = 'edit';
            $query['redlink'] = '1';
        }
 
        $url = $this->getLinkURL( $target, $query );
        $attribs = [ 'class' => 'new' ];
        $prefixedText = $this->titleFormatter->getPrefixedText( $target );
        if ( $prefixedText !== '' ) {
            // This ends up in parser cache!
            $attribs['title'] = wfMessage( 'red-link-title', $prefixedText )
                ->inContentLanguage()
                ->text();
        }
 
        $attribs = [
            'href' => $url,
        ] + $this->mergeAttribs( $attribs, $extraAttribs );
 
        if ( $text === null ) {
            $text = $this->getLinkText( $target );
        }
 
        return $this->buildAElement( $target, $text, $attribs, false );
    }
 
    private function buildAElement( $target, $text, array $attribs, $isKnown ) {
        $ret = null;
        if ( !$this->hookRunner->onHtmlPageLinkRendererEnd(
            $this, $this->castToLinkTarget( $target ), $isKnown, $text, $attribs, $ret )
        ) {
            return $ret;
        }
 
        return Html::rawElement( 'a', $attribs, HtmlArmor::getHtml( $text ) );
    }
 
    private function getLinkText( $target ) {
        $prefixedText = $this->titleFormatter->getPrefixedText( $target );
        // If the target is just a fragment, with no title, we return the fragment
        // text.  Otherwise, we return the title text itself.
        if ( $prefixedText === '' && $target instanceof LinkTarget && $target->hasFragment() ) {
            return $target->getFragment();
        }
 
        return $prefixedText;
    }
 
    private function getLinkURL( $target, $query = [] ) {
        if ( $this->forceArticlePath ) {
            $realQuery = $query;
            $query = [];
        } else {
            $realQuery = [];
        }
        $url = $this->castToTitle( $target )->getLinkURL( $query, false, $this->expandUrls );
 
        if ( $this->forceArticlePath && $realQuery ) {
            $url = wfAppendQuery( $url, $realQuery );
        }
 
        return $url;
    }
 
    public function normalizeTarget( $target ) {
        $target = $this->castToLinkTarget( $target );
        if ( $target->getNamespace() === NS_SPECIAL && !$target->isExternal() ) {
            list( $name, $subpage ) = $this->specialPageFactory->resolveAlias(
                $target->getDBkey()
            );
            if ( $name ) {
                return new TitleValue(
                    NS_SPECIAL,
                    $this->specialPageFactory->getLocalNameFor( $name, $subpage ),
                    $target->getFragment()
                );
            }
        }
 
        return $target;
    }
 
    private function mergeAttribs( $defaults, $attribs ) {
        if ( !$attribs ) {
            return $defaults;
        }
        # Merge the custom attribs with the default ones, and iterate
        # over that, deleting all "false" attributes.
        $ret = [];
        $merged = Sanitizer::mergeAttributes( $defaults, $attribs );
        foreach ( $merged as $key => $val ) {
            # A false value suppresses the attribute
            if ( $val !== false ) {
                $ret[$key] = $val;
            }
        }
        return $ret;
    }
 
    public function getLinkClasses( $target ) {
        Assert::parameterType( [ LinkTarget::class, PageReference::class ], $target, '$target' );
        $target = $this->castToLinkTarget( $target );
        // Don't call LinkCache if the target is "non-proper"
        if ( $target->isExternal() || $target->getText() === '' || $target->getNamespace() < 0 ) {
            return '';
        }
        // Make sure the target is in the cache
        $id = $this->linkCache->addLinkObj( $target );
        if ( $id == 0 ) {
            // Doesn't exist
            return '';
        }
 
        if ( $this->linkCache->getGoodLinkFieldObj( $target, 'redirect' ) ) {
            # Page is a redirect
            return 'mw-redirect';
        }
 
        return '';
    }
 
    private function castToTitle( $target ): Title {
        if ( $target instanceof LinkTarget ) {
            return Title::newFromLinkTarget( $target );
        }
        // $target instanceof PageReference
        return Title::castFromPageReference( $target );
    }
 
    private function castToLinkTarget( $target ): LinkTarget {
        if ( $target instanceof PageReference ) {
            return Title::castFromPageReference( $target );
        }
        // $target instanceof LinkTarget
        return $target;
    }
}