MWNamespace.php

Go to the documentation of this file.

<?php
class MWNamespace {

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

    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 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 ) {
        static $namespaces = null;
        if ( $namespaces === null || $rebuild ) {
            global $wgExtraNamespaces, $wgCanonicalNamespaceNames;
            $namespaces = [ NS_MAIN => '' ] + $wgCanonicalNamespaceNames;
            // Add extension namespaces
            $namespaces += ExtensionRegistry::getInstance()->getAttribute( 'ExtensionNamespaces' );
            if ( is_array( $wgExtraNamespaces ) ) {
                $namespaces += $wgExtraNamespaces;
            }
            Hooks::run( 'CanonicalNamespaces', [ &$namespaces ] );
        }
        return $namespaces;
    }

    public static function getCanonicalName( $index ) {
        $nslist = self::getCanonicalNamespaces();
        if ( isset( $nslist[$index] ) ) {
            return $nslist[$index];
        } else {
            return false;
        }
    }

    public static function getCanonicalIndex( $name ) {
        static $xNamespaces = false;
        if ( $xNamespaces === false ) {
            $xNamespaces = [];
            foreach ( self::getCanonicalNamespaces() as $i => $text ) {
                $xNamespaces[strtolower( $text )] = $i;
            }
        }
        if ( array_key_exists( $name, $xNamespaces ) ) {
            return $xNamespaces[$name];
        } else {
            return null;
        }
    }

    public static function getValidNamespaces() {
        static $mValidNamespaces = null;

        if ( is_null( $mValidNamespaces ) ) {
            foreach ( array_keys( self::getCanonicalNamespaces() ) as $ns ) {
                if ( $ns >= 0 ) {
                    $mValidNamespaces[] = $ns;
                }
            }
            // T109137: sort numerically
            sort( $mValidNamespaces, SORT_NUMERIC );
        }

        return $mValidNamespaces;
    }

    public static function canTalk( $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(
            MWNamespace::getValidNamespaces(),
            'MWNamespace::isSubject'
        );
    }

    public static function getTalkNamespaces() {
        return array_filter(
            MWNamespace::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;
    }
}