MWNamespace.php

Go to the documentation of this file.

<?php
class MWNamespace {
 
    private static $alwaysCapitalizedNamespaces = [ NS_SPECIAL, NS_USER, NS_MEDIAWIKI ];
 
    private static $canonicalNamespaces = null;
 
    private static $namespaceIndexes = false;
 
    private static $validNamespaces = null;
 
    private static function isMethodValidFor( $index, $method ) {
        if ( $index < NS_MAIN ) {
            throw new MWException( "$method does not make any sense for given namespace $index" );
        }
        return true;
    }
 
    public static function clearCaches() {
        self::$canonicalNamespaces = null;
        self::$namespaceIndexes = false;
        self::$validNamespaces = null;
    }
 
    public static function isMovable( $index ) {
        global $wgAllowImageMoving;
 
        $result = !( $index < NS_MAIN || ( $index == NS_FILE && !$wgAllowImageMoving ) );
 
        Hooks::run( 'NamespaceIsMovable', [ $index, &$result ] );
 
        return $result;
    }
 
    public static function isSubject( $index ) {
        return !self::isTalk( $index );
    }
 
    public static function isTalk( $index ) {
        return $index > NS_MAIN
            && $index % 2;
    }
 
    public static function getTalk( $index ) {
        self::isMethodValidFor( $index, __METHOD__ );
        return self::isTalk( $index )
            ? $index
            : $index + 1;
    }
 
    public static function getSubject( $index ) {
        # Handle special namespaces
        if ( $index < NS_MAIN ) {
            return $index;
        }
 
        return self::isTalk( $index )
            ? $index - 1
            : $index;
    }
 
    public static function getAssociated( $index ) {
        self::isMethodValidFor( $index, __METHOD__ );
 
        if ( self::isSubject( $index ) ) {
            return self::getTalk( $index );
        } elseif ( self::isTalk( $index ) ) {
            return self::getSubject( $index );
        } else {
            return null;
        }
    }
 
    public static function exists( $index ) {
        $nslist = self::getCanonicalNamespaces();
        return isset( $nslist[$index] );
    }
 
    public static function equals( $ns1, $ns2 ) {
        return $ns1 == $ns2;
    }
 
    public static function subjectEquals( $ns1, $ns2 ) {
        return self::getSubject( $ns1 ) == self::getSubject( $ns2 );
    }
 
    public static function getCanonicalNamespaces( $rebuild = false ) {
        if ( $rebuild ) {
            self::clearCaches();
        }
 
        if ( self::$canonicalNamespaces === null ) {
            global $wgExtraNamespaces, $wgCanonicalNamespaceNames;
            self::$canonicalNamespaces = [ NS_MAIN => '' ] + $wgCanonicalNamespaceNames;
            // Add extension namespaces
            self::$canonicalNamespaces +=
                ExtensionRegistry::getInstance()->getAttribute( 'ExtensionNamespaces' );
            if ( is_array( $wgExtraNamespaces ) ) {
                self::$canonicalNamespaces += $wgExtraNamespaces;
            }
            Hooks::run( 'CanonicalNamespaces', [ &self::$canonicalNamespaces ] );
        }
        return self::$canonicalNamespaces;
    }
 
    public static function getCanonicalName( $index ) {
        $nslist = self::getCanonicalNamespaces();
        if ( isset( $nslist[$index] ) ) {
            return $nslist[$index];
        } else {
            return false;
        }
    }
 
    public static function getCanonicalIndex( $name ) {
        if ( self::$namespaceIndexes === false ) {
            self::$namespaceIndexes = [];
            foreach ( self::getCanonicalNamespaces() as $i => $text ) {
                self::$namespaceIndexes[strtolower( $text )] = $i;
            }
        }
        if ( array_key_exists( $name, self::$namespaceIndexes ) ) {
            return self::$namespaceIndexes[$name];
        } else {
            return null;
        }
    }
 
    public static function getValidNamespaces() {
        if ( is_null( self::$validNamespaces ) ) {
            foreach ( array_keys( self::getCanonicalNamespaces() ) as $ns ) {
                if ( $ns >= 0 ) {
                    self::$validNamespaces[] = $ns;
                }
            }
            // T109137: sort numerically
            sort( self::$validNamespaces, SORT_NUMERIC );
        }
 
        return self::$validNamespaces;
    }
 
    public static function canTalk( $index ) {
        return self::hasTalkNamespace( $index );
    }
 
    public static function hasTalkNamespace( $index ) {
        return $index >= NS_MAIN;
    }
 
    public static function isContent( $index ) {
        global $wgContentNamespaces;
        return $index == NS_MAIN || in_array( $index, $wgContentNamespaces );
    }
 
    public static function wantSignatures( $index ) {
        global $wgExtraSignatureNamespaces;
        return self::isTalk( $index ) || in_array( $index, $wgExtraSignatureNamespaces );
    }
 
    public static function isWatchable( $index ) {
        return $index >= NS_MAIN;
    }
 
    public static function hasSubpages( $index ) {
        global $wgNamespacesWithSubpages;
        return !empty( $wgNamespacesWithSubpages[$index] );
    }
 
    public static function getContentNamespaces() {
        global $wgContentNamespaces;
        if ( !is_array( $wgContentNamespaces ) || $wgContentNamespaces === [] ) {
            return [ NS_MAIN ];
        } elseif ( !in_array( NS_MAIN, $wgContentNamespaces ) ) {
            // always force NS_MAIN to be part of array (to match the algorithm used by isContent)
            return array_merge( [ NS_MAIN ], $wgContentNamespaces );
        } else {
            return $wgContentNamespaces;
        }
    }
 
    public static function getSubjectNamespaces() {
        return array_filter(
            self::getValidNamespaces(),
            'MWNamespace::isSubject'
        );
    }
 
    public static function getTalkNamespaces() {
        return array_filter(
            self::getValidNamespaces(),
            'MWNamespace::isTalk'
        );
    }
 
    public static function isCapitalized( $index ) {
        global $wgCapitalLinks, $wgCapitalLinkOverrides;
        // Turn NS_MEDIA into NS_FILE
        $index = $index === NS_MEDIA ? NS_FILE : $index;
 
        // Make sure to get the subject of our namespace
        $index = self::getSubject( $index );
 
        // Some namespaces are special and should always be upper case
        if ( in_array( $index, self::$alwaysCapitalizedNamespaces ) ) {
            return true;
        }
        if ( isset( $wgCapitalLinkOverrides[$index] ) ) {
            // $wgCapitalLinkOverrides is explicitly set
            return $wgCapitalLinkOverrides[$index];
        }
        // Default to the global setting
        return $wgCapitalLinks;
    }
 
    public static function hasGenderDistinction( $index ) {
        return $index == NS_USER || $index == NS_USER_TALK;
    }
 
    public static function isNonincludable( $index ) {
        global $wgNonincludableNamespaces;
        return $wgNonincludableNamespaces && in_array( $index, $wgNonincludableNamespaces );
    }
 
    public static function getNamespaceContentModel( $index ) {
        global $wgNamespaceContentModels;
        return isset( $wgNamespaceContentModels[$index] )
            ? $wgNamespaceContentModels[$index]
            : null;
    }
 
    public static function getRestrictionLevels( $index, User $user = null ) {
        global $wgNamespaceProtection, $wgRestrictionLevels;
 
        if ( !isset( $wgNamespaceProtection[$index] ) ) {
            // All levels are valid if there's no namespace restriction.
            // But still filter by user, if necessary
            $levels = $wgRestrictionLevels;
            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;
        }
 
        // First, get the list of groups that can edit this namespace.
        $namespaceGroups = [];
        $combine = 'array_merge';
        foreach ( (array)$wgNamespaceProtection[$index] as $right ) {
            if ( $right == 'sysop' ) {
                $right = 'editprotected'; // BC
            }
            if ( $right == 'autoconfirmed' ) {
                $right = 'editsemiprotected'; // BC
            }
            if ( $right != '' ) {
                $namespaceGroups = call_user_func( $combine, $namespaceGroups,
                    User::getGroupsWithPermission( $right ) );
                $combine = 'array_intersect';
            }
        }
 
        // Now, keep only those restriction levels where there is at least one
        // group that can edit the namespace but would be blocked by the
        // restriction.
        $usableLevels = [ '' ];
        foreach ( $wgRestrictionLevels as $level ) {
            $right = $level;
            if ( $right == 'sysop' ) {
                $right = 'editprotected'; // BC
            }
            if ( $right == 'autoconfirmed' ) {
                $right = 'editsemiprotected'; // BC
            }
            if ( $right != '' && ( !$user || $user->isAllowed( $right ) ) &&
                array_diff( $namespaceGroups, User::getGroupsWithPermission( $right ) )
            ) {
                $usableLevels[] = $level;
            }
        }
 
        return $usableLevels;
    }
}