NamespaceInfo.php

Go to the documentation of this file.

<?php
use MediaWiki\Config\ServiceOptions;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\MainConfigNames;
 
class NamespaceInfo {
 
    private $alwaysCapitalizedNamespaces = [ NS_SPECIAL, NS_USER, NS_MEDIAWIKI ];
 
    private $canonicalNamespaces = null;
 
    private $namespaceIndexes = false;
 
    private $validNamespaces = null;
 
    private $options;
 
    private $hookRunner;
 
    public const CANONICAL_NAMES = [
        NS_MEDIA            => 'Media',
        NS_SPECIAL          => 'Special',
        NS_MAIN             => '',
        NS_TALK             => 'Talk',
        NS_USER             => 'User',
        NS_USER_TALK        => 'User_talk',
        NS_PROJECT          => 'Project',
        NS_PROJECT_TALK     => 'Project_talk',
        NS_FILE             => 'File',
        NS_FILE_TALK        => 'File_talk',
        NS_MEDIAWIKI        => 'MediaWiki',
        NS_MEDIAWIKI_TALK   => 'MediaWiki_talk',
        NS_TEMPLATE         => 'Template',
        NS_TEMPLATE_TALK    => 'Template_talk',
        NS_HELP             => 'Help',
        NS_HELP_TALK        => 'Help_talk',
        NS_CATEGORY         => 'Category',
        NS_CATEGORY_TALK    => 'Category_talk',
    ];
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::CanonicalNamespaceNames,
        MainConfigNames::CapitalLinkOverrides,
        MainConfigNames::CapitalLinks,
        MainConfigNames::ContentNamespaces,
        MainConfigNames::ExtraNamespaces,
        MainConfigNames::ExtraSignatureNamespaces,
        MainConfigNames::NamespaceContentModels,
        MainConfigNames::NamespacesWithSubpages,
        MainConfigNames::NonincludableNamespaces,
    ];
 
    public function __construct( ServiceOptions $options, HookContainer $hookContainer ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->options = $options;
        $this->hookRunner = new HookRunner( $hookContainer );
    }
 
    private function isMethodValidFor( $index, $method ) {
        if ( $index < NS_MAIN ) {
            throw new MWException( "$method does not make any sense for given namespace $index" );
        }
        return true;
    }
 
    private function makeValidNamespace( $index, $method ) {
        if ( !(
            is_int( $index )
            // Namespace index numbers as strings
            || ctype_digit( $index )
            // Negative numbers as strings
            || ( $index[0] === '-' && ctype_digit( substr( $index, 1 ) ) )
        ) ) {
            throw new InvalidArgumentException(
                "$method called with non-integer (" . gettype( $index ) . ") namespace '$index'"
            );
        }
 
        return intval( $index );
    }
 
    public function isMovable( $index ) {
        $extensionRegistry = ExtensionRegistry::getInstance();
        $extNamespaces = $extensionRegistry->getAttribute( 'ImmovableNamespaces' );
 
        $result = $index >= NS_MAIN && !in_array( $index, $extNamespaces );
 
        $this->hookRunner->onNamespaceIsMovable( $index, $result );
 
        return $result;
    }
 
    public function isSubject( $index ) {
        return !$this->isTalk( $index );
    }
 
    public function isTalk( $index ) {
        $index = $this->makeValidNamespace( $index, __METHOD__ );
 
        return $index > NS_MAIN
            && $index % 2;
    }
 
    public function getTalk( $index ) {
        $index = $this->makeValidNamespace( $index, __METHOD__ );
 
        $this->isMethodValidFor( $index, __METHOD__ );
        return $this->isTalk( $index )
            ? $index
            : $index + 1;
    }
 
    public function getTalkPage( LinkTarget $target ): LinkTarget {
        if ( $target->getText() === '' ) {
            throw new MWException( 'Can\'t determine talk page associated with relative section link' );
        }
 
        if ( $target->getInterwiki() !== '' ) {
            throw new MWException( 'Can\'t determine talk page associated with interwiki link' );
        }
 
        if ( $this->isTalk( $target->getNamespace() ) ) {
            return $target;
        }
 
        // NOTE: getTalk throws on bad namespaces!
        return new TitleValue( $this->getTalk( $target->getNamespace() ), $target->getDBkey() );
    }
 
    public function canHaveTalkPage( LinkTarget $target ) {
        if ( $target->getText() === '' || $target->getInterwiki() !== '' ) {
            return false;
        }
 
        if ( $target->getNamespace() < NS_MAIN ) {
            return false;
        }
 
        return true;
    }
 
    public function getSubject( $index ) {
        $index = $this->makeValidNamespace( $index, __METHOD__ );
 
        # Handle special namespaces
        if ( $index < NS_MAIN ) {
            return $index;
        }
 
        return $this->isTalk( $index )
            ? $index - 1
            : $index;
    }
 
    public function getSubjectPage( LinkTarget $target ): LinkTarget {
        if ( $this->isSubject( $target->getNamespace() ) ) {
            return $target;
        }
        return new TitleValue( $this->getSubject( $target->getNamespace() ), $target->getDBkey() );
    }
 
    public function getAssociated( $index ) {
        $this->isMethodValidFor( $index, __METHOD__ );
 
        if ( $this->isSubject( $index ) ) {
            return $this->getTalk( $index );
        }
        return $this->getSubject( $index );
    }
 
    public function getAssociatedPage( LinkTarget $target ): LinkTarget {
        if ( $target->getText() === '' ) {
            throw new MWException( 'Can\'t determine talk page associated with relative section link' );
        }
 
        if ( $target->getInterwiki() !== '' ) {
            throw new MWException( 'Can\'t determine talk page associated with interwiki link' );
        }
 
        return new TitleValue(
            $this->getAssociated( $target->getNamespace() ), $target->getDBkey() );
    }
 
    public function exists( $index ) {
        $nslist = $this->getCanonicalNamespaces();
        return isset( $nslist[$index] );
    }
 
    public function equals( $ns1, $ns2 ) {
        return $ns1 == $ns2;
    }
 
    public function subjectEquals( $ns1, $ns2 ) {
        return $this->getSubject( $ns1 ) == $this->getSubject( $ns2 );
    }
 
    public function getCanonicalNamespaces() {
        if ( $this->canonicalNamespaces === null ) {
            $this->canonicalNamespaces =
                [ NS_MAIN => '' ] + $this->options->get( MainConfigNames::CanonicalNamespaceNames );
            $this->canonicalNamespaces +=
                ExtensionRegistry::getInstance()->getAttribute( 'ExtensionNamespaces' );
            if ( is_array( $this->options->get( MainConfigNames::ExtraNamespaces ) ) ) {
                $this->canonicalNamespaces += $this->options->get( MainConfigNames::ExtraNamespaces );
            }
            $this->hookRunner->onCanonicalNamespaces( $this->canonicalNamespaces );
        }
        return $this->canonicalNamespaces;
    }
 
    public function getCanonicalName( $index ) {
        $nslist = $this->getCanonicalNamespaces();
        return $nslist[$index] ?? false;
    }
 
    public function getCanonicalIndex( $name ) {
        if ( $this->namespaceIndexes === false ) {
            $this->namespaceIndexes = [];
            foreach ( $this->getCanonicalNamespaces() as $i => $text ) {
                $this->namespaceIndexes[strtolower( $text )] = $i;
            }
        }
        if ( array_key_exists( $name, $this->namespaceIndexes ) ) {
            return $this->namespaceIndexes[$name];
        } else {
            return null;
        }
    }
 
    public function getValidNamespaces() {
        if ( $this->validNamespaces === null ) {
            $this->validNamespaces = [];
            foreach ( array_keys( $this->getCanonicalNamespaces() ) as $ns ) {
                if ( $ns >= 0 ) {
                    $this->validNamespaces[] = $ns;
                }
            }
            // T109137: sort numerically
            sort( $this->validNamespaces, SORT_NUMERIC );
        }
 
        return $this->validNamespaces;
    }
 
    public function hasTalkNamespace( $index ) {
        return $index >= NS_MAIN;
    }
 
    public function isContent( $index ) {
        return $index == NS_MAIN ||
            in_array( $index, $this->options->get( MainConfigNames::ContentNamespaces ) );
    }
 
    public function wantSignatures( $index ) {
        return $this->isTalk( $index ) ||
            in_array( $index, $this->options->get( MainConfigNames::ExtraSignatureNamespaces ) );
    }
 
    public function isWatchable( $index ) {
        return $index >= NS_MAIN;
    }
 
    public function hasSubpages( $index ) {
        return !empty( $this->options->get( MainConfigNames::NamespacesWithSubpages )[$index] );
    }
 
    public function getContentNamespaces() {
        $contentNamespaces = $this->options->get( MainConfigNames::ContentNamespaces );
        if ( !is_array( $contentNamespaces ) || $contentNamespaces === [] ) {
            return [ NS_MAIN ];
        } elseif ( !in_array( NS_MAIN, $contentNamespaces ) ) {
            // always force NS_MAIN to be part of array (to match the algorithm used by isContent)
            return array_merge( [ NS_MAIN ], $contentNamespaces );
        } else {
            return $contentNamespaces;
        }
    }
 
    public function getSubjectNamespaces() {
        return array_filter(
            $this->getValidNamespaces(),
            [ $this, 'isSubject' ]
        );
    }
 
    public function getTalkNamespaces() {
        return array_filter(
            $this->getValidNamespaces(),
            [ $this, 'isTalk' ]
        );
    }
 
    public function isCapitalized( $index ) {
        // Turn NS_MEDIA into NS_FILE
        $index = $index === NS_MEDIA ? NS_FILE : $index;
 
        // Make sure to get the subject of our namespace
        $index = $this->getSubject( $index );
 
        // Some namespaces are special and should always be upper case
        if ( in_array( $index, $this->alwaysCapitalizedNamespaces ) ) {
            return true;
        }
        $overrides = $this->options->get( MainConfigNames::CapitalLinkOverrides );
        if ( isset( $overrides[$index] ) ) {
            // CapitalLinkOverrides is explicitly set
            return $overrides[$index];
        }
        // Default to the global setting
        return $this->options->get( MainConfigNames::CapitalLinks );
    }
 
    public function hasGenderDistinction( $index ) {
        return $index == NS_USER || $index == NS_USER_TALK;
    }
 
    public function isNonincludable( $index ) {
        $namespaces = $this->options->get( MainConfigNames::NonincludableNamespaces );
        return $namespaces && in_array( $index, $namespaces );
    }
 
    public function getNamespaceContentModel( $index ) {
        return $this->options->get( MainConfigNames::NamespaceContentModels )[$index] ?? null;
    }
 
    public function getCategoryLinkType( $index ) {
        $this->isMethodValidFor( $index, __METHOD__ );
 
        if ( $index == NS_CATEGORY ) {
            return 'subcat';
        } elseif ( $index == NS_FILE ) {
            return 'file';
        } else {
            return 'page';
        }
    }
 
    public static function getCommonNamespaces() {
        return array_keys( self::CANONICAL_NAMES );
    }
}