Namespace.php

Go to the documentation of this file.

<?php
class MWNamespace {

        private static $alwaysCapitalizedNamespaces = array( 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 ) || $index == NS_CATEGORY );

                wfRunHooks( 'NamespaceIsMovable', array( $index, &$result ) );

                return $result;
        }

        public static function isSubject( $index ) {
                return !self::isTalk( $index );
        }

        public static function isMain( $index ) {
                wfDeprecated( __METHOD__, '1.19' );
                return self::isSubject( $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 = array( NS_MAIN => '' ) + $wgCanonicalNamespaceNames;
                        if ( is_array( $wgExtraNamespaces ) ) {
                                $namespaces += $wgExtraNamespaces;
                        }
                        wfRunHooks( 'CanonicalNamespaces', array( &$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 = array();
                        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;
                                }
                        }
                }

                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 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 === array() ) {
                        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( array( 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;
        }
}