TitleValue.php

Go to the documentation of this file.

<?php
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Page\PageIdentity;
use Wikimedia\Assert\Assert;
use Wikimedia\Assert\ParameterAssertionException;
use Wikimedia\Assert\ParameterTypeException;
 
class TitleValue implements LinkTarget {
 
    protected $namespace;
 
    protected $dbkey;
 
    protected $fragment;
 
    protected $interwiki;
 
    public $prefixedText = null;
 
    public static function tryNew( $namespace, $title, $fragment = '', $interwiki = '' ) {
        if ( !is_int( $namespace ) ) {
            throw new ParameterTypeException( '$namespace', 'int' );
        }
 
        try {
            return new static( $namespace, $title, $fragment, $interwiki );
        } catch ( ParameterAssertionException $ex ) {
            return null;
        }
    }
 
    public static function newFromPage( PageIdentity $page ) : TitleValue {
        if ( $page->getWikiId() ) {
            // TODO: we could allow "foreign" PageIdentities by providing an interwiki prefix,
            // but the exact semantics seem unclear. For instance, would the interwiki prefix
            // be valid in the context of the local wiki, or the wiki indicated by getWikiId()?
            throw new InvalidArgumentException( 'Not a local PageIdentity: ' . $page );
        }
 
        return new TitleValue( $page->getNamespace(), $page->getDBkey() );
    }
 
    public function __construct( $namespace, $title, $fragment = '', $interwiki = '' ) {
        self::assertValidSpec( $namespace, $title, $fragment, $interwiki );
 
        $this->namespace = $namespace;
        $this->dbkey = strtr( $title, ' ', '_' );
        $this->fragment = $fragment;
        $this->interwiki = $interwiki;
    }
 
    public static function assertValidSpec( $namespace, $title, $fragment = '', $interwiki = '' ) {
        if ( !is_int( $namespace ) ) {
            throw new ParameterTypeException( '$namespace', 'int' );
        }
        if ( !is_string( $title ) ) {
            throw new ParameterTypeException( '$title', 'string' );
        }
        if ( !is_string( $fragment ) ) {
            throw new ParameterTypeException( '$fragment', 'string' );
        }
        if ( !is_string( $interwiki ) ) {
            throw new ParameterTypeException( '$interwiki', 'string' );
        }
 
        Assert::parameter( !preg_match( '/^[_ ]|[\r\n\t]|[_ ]$/', $title ), '$title',
            "invalid name '$title'" );
 
        // NOTE: As of MW 1.34, [[#]] is rendered as a valid link, pointing to the empty
        // page title, effectively leading to the wiki's main page. This means that a completely
        // empty TitleValue has to be considered valid, for consistency with Title.
        // Also note that [[#foo]] is a valid on-page section links, and that [[acme:#foo]] is
        // a valid interwiki link.
        Assert::parameter(
            $title !== '' || $namespace === NS_MAIN,
            '$title',
            'should not be empty unless namespace is main'
        );
    }
 
    public function getNamespace() {
        return $this->namespace;
    }
 
    public function inNamespace( $ns ) {
        return $this->namespace == $ns;
    }
 
    public function getFragment() {
        return $this->fragment;
    }
 
    public function hasFragment() {
        return $this->fragment !== '';
    }
 
    public function getDBkey() {
        return $this->dbkey;
    }
 
    public function getText() {
        return str_replace( '_', ' ', $this->dbkey );
    }
 
    public function createFragmentTarget( $fragment ) {
        return new TitleValue(
            $this->namespace,
            $this->dbkey,
            $fragment,
            $this->interwiki
        );
    }
 
    public function isExternal() {
        return $this->interwiki !== '';
    }
 
    public function getInterwiki() {
        return $this->interwiki;
    }
 
    public function __toString(): string {
        $name = $this->namespace . ':' . $this->dbkey;
 
        if ( $this->fragment !== '' ) {
            $name .= '#' . $this->fragment;
        }
 
        if ( $this->interwiki !== '' ) {
            $name = $this->interwiki . ':' . $name;
        }
 
        return $name;
    }
 
    public function isSameLinkAs( LinkTarget $other ) {
        // NOTE: keep in sync with Title::isSameLinkAs()!
        return ( $other->getInterwiki() === $this->getInterwiki() )
            && ( $other->getDBkey() === $this->getDBkey() )
            && ( $other->getNamespace() === $this->getNamespace() )
            && ( $other->getFragment() === $this->getFragment() );
    }
}