NamespaceInfo.php

Go to the documentation of this file.

<?php
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Linker\LinkTarget;

class NamespaceInfo {

    private $alwaysCapitalizedNamespaces = [ NS_SPECIAL, NS_USER, NS_MEDIAWIKI ];

    private $canonicalNamespaces = null;

    private $namespaceIndexes = false;

    private $validNamespaces = null;

    private $options;

    public static $constructorOptions = [
        'AllowImageMoving',
        'CanonicalNamespaceNames',
        'CapitalLinkOverrides',
        'CapitalLinks',
        'ContentNamespaces',
        'ExtraNamespaces',
        'ExtraSignatureNamespaces',
        'NamespaceContentModels',
        'NamespaceProtection',
        'NamespacesWithSubpages',
        'NonincludableNamespaces',
        'RestrictionLevels',
    ];

    public function __construct( ServiceOptions $options ) {
        $options->assertRequiredOptions( self::$constructorOptions );
        $this->options = $options;
    }

    private function isMethodValidFor( $index, $method ) {
        if ( $index < NS_MAIN ) {
            throw new MWException( "$method does not make any sense for given namespace $index" );
        }
        return true;
    }

    public function isMovable( $index ) {
        $result = $index >= NS_MAIN &&
            ( $index != NS_FILE || $this->options->get( 'AllowImageMoving' ) );

        Hooks::run( 'NamespaceIsMovable', [ $index, &$result ] );

        return $result;
    }

    public function isSubject( $index ) {
        return !$this->isTalk( $index );
    }

    public function isTalk( $index ) {
        return $index > NS_MAIN
            && $index % 2;
    }

    public function getTalk( $index ) {
        $this->isMethodValidFor( $index, __METHOD__ );
        return $this->isTalk( $index )
            ? $index
            : $index + 1;
    }

    public function getTalkPage( LinkTarget $target ) : LinkTarget {
        if ( $this->isTalk( $target->getNamespace() ) ) {
            return $target;
        }
        return new TitleValue( $this->getTalk( $target->getNamespace() ), $target->getDbKey() );
    }

    public function getSubject( $index ) {
        # 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 {
        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( 'CanonicalNamespaceNames' );
            $this->canonicalNamespaces +=
                ExtensionRegistry::getInstance()->getAttribute( 'ExtensionNamespaces' );
            if ( is_array( $this->options->get( 'ExtraNamespaces' ) ) ) {
                $this->canonicalNamespaces += $this->options->get( 'ExtraNamespaces' );
            }
            Hooks::run( 'CanonicalNamespaces', [ &$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 ( is_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( 'ContentNamespaces' ) );
    }

    public function wantSignatures( $index ) {
        return $this->isTalk( $index ) ||
            in_array( $index, $this->options->get( 'ExtraSignatureNamespaces' ) );
    }

    public function isWatchable( $index ) {
        return $index >= NS_MAIN;
    }

    public function hasSubpages( $index ) {
        return !empty( $this->options->get( 'NamespacesWithSubpages' )[$index] );
    }

    public function getContentNamespaces() {
        $contentNamespaces = $this->options->get( '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( 'CapitalLinkOverrides' );
        if ( isset( $overrides[$index] ) ) {
            // CapitalLinkOverrides is explicitly set
            return $overrides[$index];
        }
        // Default to the global setting
        return $this->options->get( 'CapitalLinks' );
    }

    public function hasGenderDistinction( $index ) {
        return $index == NS_USER || $index == NS_USER_TALK;
    }

    public function isNonincludable( $index ) {
        $namespaces = $this->options->get( 'NonincludableNamespaces' );
        return $namespaces && in_array( $index, $namespaces );
    }

    public function getNamespaceContentModel( $index ) {
        return $this->options->get( 'NamespaceContentModels' )[$index] ?? null;
    }

    public function getRestrictionLevels( $index, User $user = null ) {
        if ( !isset( $this->options->get( 'NamespaceProtection' )[$index] ) ) {
            // All levels are valid if there's no namespace restriction.
            // But still filter by user, if necessary
            $levels = $this->options->get( 'RestrictionLevels' );
            if ( $user ) {
                $levels = array_values( array_filter( $levels, function ( $level ) use ( $user ) {
                    $right = $level;
                    if ( $right == 'sysop' ) {
                        $right = 'editprotected'; // BC
                    }
                    if ( $right == 'autoconfirmed' ) {
                        $right = 'editsemiprotected'; // BC
                    }
                    return ( $right == '' || $user->isAllowed( $right ) );
                } ) );
            }
            return $levels;
        }

        // $wgNamespaceProtection can require one or more rights to edit the namespace, which
        // may be satisfied by membership in multiple groups each giving a subset of those rights.
        // A restriction level is redundant if, for any one of the namespace rights, all groups
        // giving that right also give the restriction level's right. Or, conversely, a
        // restriction level is not redundant if, for every namespace right, there's at least one
        // group giving that right without the restriction level's right.
        //
        // First, for each right, get a list of groups with that right.
        $namespaceRightGroups = [];
        foreach ( (array)$this->options->get( 'NamespaceProtection' )[$index] as $right ) {
            if ( $right == 'sysop' ) {
                $right = 'editprotected'; // BC
            }
            if ( $right == 'autoconfirmed' ) {
                $right = 'editsemiprotected'; // BC
            }
            if ( $right != '' ) {
                $namespaceRightGroups[$right] = User::getGroupsWithPermission( $right );
            }
        }

        // Now, go through the protection levels one by one.
        $usableLevels = [ '' ];
        foreach ( $this->options->get( 'RestrictionLevels' ) as $level ) {
            $right = $level;
            if ( $right == 'sysop' ) {
                $right = 'editprotected'; // BC
            }
            if ( $right == 'autoconfirmed' ) {
                $right = 'editsemiprotected'; // BC
            }

            if ( $right != '' &&
                !isset( $namespaceRightGroups[$right] ) &&
                ( !$user || $user->isAllowed( $right ) )
            ) {
                // Do any of the namespace rights imply the restriction right? (see explanation above)
                foreach ( $namespaceRightGroups as $groups ) {
                    if ( !array_diff( $groups, User::getGroupsWithPermission( $right ) ) ) {
                        // Yes, this one does.
                        continue 2;
                    }
                }
                // No, keep the restriction level
                $usableLevels[] = $level;
            }
        }

        return $usableLevels;
    }

    public function getCategoryLinkType( $index ) {
        $this->isMethodValidFor( $index, __METHOD__ );

        if ( $index == NS_CATEGORY ) {
            return 'subcat';
        } elseif ( $index == NS_FILE ) {
            return 'file';
        } else {
            return 'page';
        }
    }
}