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