MWNamespace::canTalk() - Code Metrics - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

MWNamespace::canTalk() A
last analyzed 2016-11-13 17:42 UTC

↳ Parent: MWNamespace

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php
/**
 * Provide things related to namespaces.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 */

/**
 * This is a utility class with only static functions
 * for dealing with namespaces that encodes all the
 * "magic" behaviors of them based on index.  The textual
 * names of the namespaces are handled by Language.php.
 *
 * These are synonyms for the names given in the language file
 * Users and translators should not change them
 *
 */
class MWNamespace {

	/**
	 * These namespaces should always be first-letter capitalized, now and
	 * forevermore. Historically, they could've probably been lowercased too,
	 * but some things are just too ingrained now. :)
	 */
	private static $alwaysCapitalizedNamespaces = [ NS_SPECIAL, NS_USER, NS_MEDIAWIKI ];

	/**
	 * Throw an exception when trying to get the subject or talk page
	 * for a given namespace where it does not make sense.
	 * Special namespaces are defined in includes/Defines.php and have
	 * a value below 0 (ex: NS_SPECIAL = -1 , NS_MEDIA = -2)
	 *
	 * @param int $index
	 * @param string $method
	 *
	 * @throws MWException
	 * @return bool
	 */
	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;
	}

	/**
	 * Can pages in the given namespace be moved?
	 *
	 * @param int $index Namespace index
	 * @return bool
	 */
	public static function isMovable( $index ) {
		global $wgAllowImageMoving;

		$result = !( $index < NS_MAIN || ( $index == NS_FILE && !$wgAllowImageMoving ) );

		/**
		 * @since 1.20
		 */
		Hooks::run( 'NamespaceIsMovable', [ $index, &$result ] );

		return $result;
	}

	/**
	 * Is the given namespace is a subject (non-talk) namespace?
	 *
	 * @param int $index Namespace index
	 * @return bool
	 * @since 1.19
	 */
	public static function isSubject( $index ) {
		return !self::isTalk( $index );
	}

	/**
	 * Is the given namespace a talk namespace?
	 *
	 * @param int $index Namespace index
	 * @return bool
	 */
	public static function isTalk( $index ) {
		return $index > NS_MAIN
			&& $index % 2;
	}

	/**
	 * Get the talk namespace index for a given namespace
	 *
	 * @param int $index Namespace index
	 * @return int
	 */
	public static function getTalk( $index ) {
		self::isMethodValidFor( $index, __METHOD__ );
		return self::isTalk( $index )
			? $index
			: $index + 1;
	}

	/**
	 * Get the subject namespace index for a given namespace
	 * Special namespaces (NS_MEDIA, NS_SPECIAL) are always the subject.
	 *
	 * @param int $index Namespace index
	 * @return int
	 */
	public static function getSubject( $index ) {
		# Handle special namespaces
		if ( $index < NS_MAIN ) {
			return $index;
		}

		return self::isTalk( $index )
			? $index - 1
			: $index;
	}

	/**
	 * Get the associated namespace.
	 * For talk namespaces, returns the subject (non-talk) namespace
	 * For subject (non-talk) namespaces, returns the talk namespace
	 *
	 * @param int $index Namespace index
	 * @return int|null If no associated namespace could be found
	 */
	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;
		}
	}

	/**
	 * Returns whether the specified namespace exists
	 *
	 * @param int $index
	 *
	 * @return bool
	 * @since 1.19
	 */
	public static function exists( $index ) {
		$nslist = self::getCanonicalNamespaces();
		return isset( $nslist[$index] );
	}

	/**
	 * Returns whether the specified namespaces are the same namespace
	 *
	 * @note It's possible that in the future we may start using something
	 * other than just namespace indexes. Under that circumstance making use
	 * of this function rather than directly doing comparison will make
	 * sure that code will not potentially break.
	 *
	 * @param int $ns1 The first namespace index
	 * @param int $ns2 The second namespace index
	 *
	 * @return bool
	 * @since 1.19
	 */
	public static function equals( $ns1, $ns2 ) {
		return $ns1 == $ns2;
	}

	/**
	 * Returns whether the specified namespaces share the same subject.
	 * eg: NS_USER and NS_USER wil return true, as well
	 *     NS_USER and NS_USER_TALK will return true.
	 *
	 * @param int $ns1 The first namespace index
	 * @param int $ns2 The second namespace index
	 *
	 * @return bool
	 * @since 1.19
	 */
	public static function subjectEquals( $ns1, $ns2 ) {
		return self::getSubject( $ns1 ) == self::getSubject( $ns2 );
	}

	/**
	 * Returns array of all defined namespaces with their canonical
	 * (English) names.
	 *
	 * @param bool $rebuild Rebuild namespace list (default = false). Used for testing.
	 *
	 * @return array
	 * @since 1.17
	 */
	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;
	}

	/**
	 * Returns the canonical (English) name for a given index
	 *
	 * @param int $index Namespace index
	 * @return string|bool If no canonical definition.
	 */
	public static function getCanonicalName( $index ) {
		$nslist = self::getCanonicalNamespaces();
		if ( isset( $nslist[$index] ) ) {
			return $nslist[$index];
		} else {
			return false;
		}
	}

	/**
	 * Returns the index for a given canonical name, or NULL
	 * The input *must* be converted to lower case first
	 *
	 * @param string $name Namespace name
	 * @return int
	 */
	public static function getCanonicalIndex( $name ) {
		static $xNamespaces = false;
		if ( $xNamespaces === false ) {
			$xNamespaces = [];
			foreach ( self::getCanonicalNamespaces() as $i => $text ) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
				$xNamespaces[strtolower( $text )] = $i;
			}
		}
		if ( array_key_exists( $name, $xNamespaces ) ) {
			return $xNamespaces[$name];
		} else {
			return null;
		}
	}

	/**
	 * Returns an array of the namespaces (by integer id) that exist on the
	 * wiki. Used primarily by the api in help documentation.
	 * @return array
	 */
	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;
	}

	/**
	 * Can this namespace ever have a talk namespace?
	 *
	 * @param int $index Namespace index
	 * @return bool
	 */
	public static function canTalk( $index ) {
		return $index >= NS_MAIN;
	}

	/**
	 * Does this namespace contain content, for the purposes of calculating
	 * statistics, etc?
	 *
	 * @param int $index Index to check
	 * @return bool
	 */
	public static function isContent( $index ) {
		global $wgContentNamespaces;
		return $index == NS_MAIN || in_array( $index, $wgContentNamespaces );
	}

	/**
	 * Might pages in this namespace require the use of the Signature button on
	 * the edit toolbar?
	 *
	 * @param int $index Index to check
	 * @return bool
	 */
	public static function wantSignatures( $index ) {
		global $wgExtraSignatureNamespaces;
		return self::isTalk( $index ) || in_array( $index, $wgExtraSignatureNamespaces );
	}

	/**
	 * Can pages in a namespace be watched?
	 *
	 * @param int $index
	 * @return bool
	 */
	public static function isWatchable( $index ) {
		return $index >= NS_MAIN;
	}

	/**
	 * Does the namespace allow subpages?
	 *
	 * @param int $index Index to check
	 * @return bool
	 */
	public static function hasSubpages( $index ) {
		global $wgNamespacesWithSubpages;
		return !empty( $wgNamespacesWithSubpages[$index] );
	}

	/**
	 * Get a list of all namespace indices which are considered to contain content
	 * @return array Array of namespace indices
	 */
	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;
		}
	}

	/**
	 * List all namespace indices which are considered subject, aka not a talk
	 * or special namespace. See also MWNamespace::isSubject
	 *
	 * @return array Array of namespace indices
	 */
	public static function getSubjectNamespaces() {
		return array_filter(
			MWNamespace::getValidNamespaces(),
			'MWNamespace::isSubject'
		);
	}

	/**
	 * List all namespace indices which are considered talks, aka not a subject
	 * or special namespace. See also MWNamespace::isTalk
	 *
	 * @return array Array of namespace indices
	 */
	public static function getTalkNamespaces() {
		return array_filter(
			MWNamespace::getValidNamespaces(),
			'MWNamespace::isTalk'
		);
	}

	/**
	 * Is the namespace first-letter capitalized?
	 *
	 * @param int $index Index to check
	 * @return bool
	 */
	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;
	}

	/**
	 * Does the namespace (potentially) have different aliases for different
	 * genders. Not all languages make a distinction here.
	 *
	 * @since 1.18
	 * @param int $index Index to check
	 * @return bool
	 */
	public static function hasGenderDistinction( $index ) {
		return $index == NS_USER || $index == NS_USER_TALK;
	}

	/**
	 * It is not possible to use pages from this namespace as template?
	 *
	 * @since 1.20
	 * @param int $index Index to check
	 * @return bool
	 */
	public static function isNonincludable( $index ) {
		global $wgNonincludableNamespaces;
		return $wgNonincludableNamespaces && in_array( $index, $wgNonincludableNamespaces );
	}

	/**
	 * Get the default content model for a namespace
	 * This does not mean that all pages in that namespace have the model
	 *
	 * @since 1.21
	 * @param int $index Index to check
	 * @return null|string Default model name for the given namespace, if set
	 */
	public static function getNamespaceContentModel( $index ) {
		global $wgNamespaceContentModels;
		return isset( $wgNamespaceContentModels[$index] )
			? $wgNamespaceContentModels[$index]
			: null;
	}

	/**
	 * Determine which restriction levels it makes sense to use in a namespace,
	 * optionally filtered by a user's rights.
	 *
	 * @since 1.23
	 * @param int $index Index to check
	 * @param User $user User to check
	 * @return array
	 */
	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;
	}
}


1			<?php
2			/**
3			* Provide things related to namespaces.
4			*
5			* This program is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU General Public License as published by
7			* the Free Software Foundation; either version 2 of the License, or
8			* (at your option) any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License along
16			* with this program; if not, write to the Free Software Foundation, Inc.,
17			* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18			* http://www.gnu.org/copyleft/gpl.html
19			*
20			* @file
21			*/
22
23			/**
24			* This is a utility class with only static functions
25			* for dealing with namespaces that encodes all the
26			* "magic" behaviors of them based on index. The textual
27			* names of the namespaces are handled by Language.php.
28			*
29			* These are synonyms for the names given in the language file
30			* Users and translators should not change them
31			*
32			*/
33			class MWNamespace {
34
35			/**
36			* These namespaces should always be first-letter capitalized, now and
37			* forevermore. Historically, they could've probably been lowercased too,
38			* but some things are just too ingrained now. :)
39			*/
40			private static $alwaysCapitalizedNamespaces = [ NS_SPECIAL, NS_USER, NS_MEDIAWIKI ];
41
42			/**
43			* Throw an exception when trying to get the subject or talk page
44			* for a given namespace where it does not make sense.
45			* Special namespaces are defined in includes/Defines.php and have
46			* a value below 0 (ex: NS_SPECIAL = -1 , NS_MEDIA = -2)
47			*
48			* @param int $index
49			* @param string $method
50			*
51			* @throws MWException
52			* @return bool
53			*/
54			private static function isMethodValidFor( $index, $method ) {
55			if ( $index < NS_MAIN ) {
56			throw new MWException( "$method does not make any sense for given namespace $index" );
57			}
58			return true;
59			}
60
61			/**
62			* Can pages in the given namespace be moved?
63			*
64			* @param int $index Namespace index
65			* @return bool
66			*/
67			public static function isMovable( $index ) {
68			global $wgAllowImageMoving;
69
70			$result = !( $index < NS_MAIN \|\| ( $index == NS_FILE && !$wgAllowImageMoving ) );
71
72			/**
73			* @since 1.20
74			*/
75			Hooks::run( 'NamespaceIsMovable', [ $index, &$result ] );
76
77			return $result;
78			}
79
80			/**
81			* Is the given namespace is a subject (non-talk) namespace?
82			*
83			* @param int $index Namespace index
84			* @return bool
85			* @since 1.19
86			*/
87			public static function isSubject( $index ) {
88			return !self::isTalk( $index );
89			}
90
91			/**
92			* Is the given namespace a talk namespace?
93			*
94			* @param int $index Namespace index
95			* @return bool
96			*/
97			public static function isTalk( $index ) {
98			return $index > NS_MAIN
99			&& $index % 2;
100			}
101
102			/**
103			* Get the talk namespace index for a given namespace
104			*
105			* @param int $index Namespace index
106			* @return int
107			*/
108			public static function getTalk( $index ) {
109			self::isMethodValidFor( $index, __METHOD__ );
110			return self::isTalk( $index )
111			? $index
112			: $index + 1;
113			}
114
115			/**
116			* Get the subject namespace index for a given namespace
117			* Special namespaces (NS_MEDIA, NS_SPECIAL) are always the subject.
118			*
119			* @param int $index Namespace index
120			* @return int
121			*/
122			public static function getSubject( $index ) {
123			# Handle special namespaces
124			if ( $index < NS_MAIN ) {
125			return $index;
126			}
127
128			return self::isTalk( $index )
129			? $index - 1
130			: $index;
131			}
132
133			/**
134			* Get the associated namespace.
135			* For talk namespaces, returns the subject (non-talk) namespace
136			* For subject (non-talk) namespaces, returns the talk namespace
137			*
138			* @param int $index Namespace index
139			* @return int\|null If no associated namespace could be found
140			*/
141			public static function getAssociated( $index ) {
142			self::isMethodValidFor( $index, __METHOD__ );
143
144			if ( self::isSubject( $index ) ) {
145			return self::getTalk( $index );
146			} elseif ( self::isTalk( $index ) ) {
147			return self::getSubject( $index );
148			} else {
149			return null;
150			}
151			}
152
153			/**
154			* Returns whether the specified namespace exists
155			*
156			* @param int $index
157			*
158			* @return bool
159			* @since 1.19
160			*/
161			public static function exists( $index ) {
162			$nslist = self::getCanonicalNamespaces();
163			return isset( $nslist[$index] );
164			}
165
166			/**
167			* Returns whether the specified namespaces are the same namespace
168			*
169			* @note It's possible that in the future we may start using something
170			* other than just namespace indexes. Under that circumstance making use
171			* of this function rather than directly doing comparison will make
172			* sure that code will not potentially break.
173			*
174			* @param int $ns1 The first namespace index
175			* @param int $ns2 The second namespace index
176			*
177			* @return bool
178			* @since 1.19
179			*/
180			public static function equals( $ns1, $ns2 ) {
181			return $ns1 == $ns2;
182			}
183
184			/**
185			* Returns whether the specified namespaces share the same subject.
186			* eg: NS_USER and NS_USER wil return true, as well
187			* NS_USER and NS_USER_TALK will return true.
188			*
189			* @param int $ns1 The first namespace index
190			* @param int $ns2 The second namespace index
191			*
192			* @return bool
193			* @since 1.19
194			*/
195			public static function subjectEquals( $ns1, $ns2 ) {
196			return self::getSubject( $ns1 ) == self::getSubject( $ns2 );
197			}
198
199			/**
200			* Returns array of all defined namespaces with their canonical
201			* (English) names.
202			*
203			* @param bool $rebuild Rebuild namespace list (default = false). Used for testing.
204			*
205			* @return array
206			* @since 1.17
207			*/
208			public static function getCanonicalNamespaces( $rebuild = false ) {
209			static $namespaces = null;
210			if ( $namespaces === null \|\| $rebuild ) {
211			global $wgExtraNamespaces, $wgCanonicalNamespaceNames;
212			$namespaces = [ NS_MAIN => '' ] + $wgCanonicalNamespaceNames;
213			// Add extension namespaces
214			$namespaces += ExtensionRegistry::getInstance()->getAttribute( 'ExtensionNamespaces' );
215			if ( is_array( $wgExtraNamespaces ) ) {
216			$namespaces += $wgExtraNamespaces;
217			}
218			Hooks::run( 'CanonicalNamespaces', [ &$namespaces ] );
219			}
220			return $namespaces;
221			}
222
223			/**
224			* Returns the canonical (English) name for a given index
225			*
226			* @param int $index Namespace index
227			* @return string\|bool If no canonical definition.
228			*/
229			public static function getCanonicalName( $index ) {
230			$nslist = self::getCanonicalNamespaces();
231			if ( isset( $nslist[$index] ) ) {
232			return $nslist[$index];
233			} else {
234			return false;
235			}
236			}
237
238			/**
239			* Returns the index for a given canonical name, or NULL
240			* The input must be converted to lower case first
241			*
242			* @param string $name Namespace name
243			* @return int
244			*/
245			public static function getCanonicalIndex( $name ) {
246			static $xNamespaces = false;
247			if ( $xNamespaces === false ) {
248			$xNamespaces = [];
249			foreach ( self::getCanonicalNamespaces() as $i => $text ) {
			0 ignored issues – show Bug introduced 2016-01-16 18:00 UTC by Report Bug Copy Issue Report The expression `self::getCanonicalNamespaces()` of type `array\|null` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
250			$xNamespaces[strtolower( $text )] = $i;
251			}
252			}
253			if ( array_key_exists( $name, $xNamespaces ) ) {
254			return $xNamespaces[$name];
255			} else {
256			return null;
257			}
258			}
259
260			/**
261			* Returns an array of the namespaces (by integer id) that exist on the
262			* wiki. Used primarily by the api in help documentation.
263			* @return array
264			*/
265			public static function getValidNamespaces() {
266			static $mValidNamespaces = null;
267
268			if ( is_null( $mValidNamespaces ) ) {
269			foreach ( array_keys( self::getCanonicalNamespaces() ) as $ns ) {
270			if ( $ns >= 0 ) {
271			$mValidNamespaces[] = $ns;
272			}
273			}
274			// T109137: sort numerically
275			sort( $mValidNamespaces, SORT_NUMERIC );
276			}
277
278			return $mValidNamespaces;
279			}
280
281			/**
282			* Can this namespace ever have a talk namespace?
283			*
284			* @param int $index Namespace index
285			* @return bool
286			*/
287			public static function canTalk( $index ) {
288			return $index >= NS_MAIN;
289			}
290
291			/**
292			* Does this namespace contain content, for the purposes of calculating
293			* statistics, etc?
294			*
295			* @param int $index Index to check
296			* @return bool
297			*/
298			public static function isContent( $index ) {
299			global $wgContentNamespaces;
300			return $index == NS_MAIN \|\| in_array( $index, $wgContentNamespaces );
301			}
302
303			/**
304			* Might pages in this namespace require the use of the Signature button on
305			* the edit toolbar?
306			*
307			* @param int $index Index to check
308			* @return bool
309			*/
310			public static function wantSignatures( $index ) {
311			global $wgExtraSignatureNamespaces;
312			return self::isTalk( $index ) \|\| in_array( $index, $wgExtraSignatureNamespaces );
313			}
314
315			/**
316			* Can pages in a namespace be watched?
317			*
318			* @param int $index
319			* @return bool
320			*/
321			public static function isWatchable( $index ) {
322			return $index >= NS_MAIN;
323			}
324
325			/**
326			* Does the namespace allow subpages?
327			*
328			* @param int $index Index to check
329			* @return bool
330			*/
331			public static function hasSubpages( $index ) {
332			global $wgNamespacesWithSubpages;
333			return !empty( $wgNamespacesWithSubpages[$index] );
334			}
335
336			/**
337			* Get a list of all namespace indices which are considered to contain content
338			* @return array Array of namespace indices
339			*/
340			public static function getContentNamespaces() {
341			global $wgContentNamespaces;
342			if ( !is_array( $wgContentNamespaces ) \|\| $wgContentNamespaces === [] ) {
343			return [ NS_MAIN ];
344			} elseif ( !in_array( NS_MAIN, $wgContentNamespaces ) ) {
345			// always force NS_MAIN to be part of array (to match the algorithm used by isContent)
346			return array_merge( [ NS_MAIN ], $wgContentNamespaces );
347			} else {
348			return $wgContentNamespaces;
349			}
350			}
351
352			/**
353			* List all namespace indices which are considered subject, aka not a talk
354			* or special namespace. See also MWNamespace::isSubject
355			*
356			* @return array Array of namespace indices
357			*/
358			public static function getSubjectNamespaces() {
359			return array_filter(
360			MWNamespace::getValidNamespaces(),
361			'MWNamespace::isSubject'
362			);
363			}
364
365			/**
366			* List all namespace indices which are considered talks, aka not a subject
367			* or special namespace. See also MWNamespace::isTalk
368			*
369			* @return array Array of namespace indices
370			*/
371			public static function getTalkNamespaces() {
372			return array_filter(
373			MWNamespace::getValidNamespaces(),
374			'MWNamespace::isTalk'
375			);
376			}
377
378			/**
379			* Is the namespace first-letter capitalized?
380			*
381			* @param int $index Index to check
382			* @return bool
383			*/
384			public static function isCapitalized( $index ) {
385			global $wgCapitalLinks, $wgCapitalLinkOverrides;
386			// Turn NS_MEDIA into NS_FILE
387			$index = $index === NS_MEDIA ? NS_FILE : $index;
388
389			// Make sure to get the subject of our namespace
390			$index = self::getSubject( $index );
391
392			// Some namespaces are special and should always be upper case
393			if ( in_array( $index, self::$alwaysCapitalizedNamespaces ) ) {
394			return true;
395			}
396			if ( isset( $wgCapitalLinkOverrides[$index] ) ) {
397			// $wgCapitalLinkOverrides is explicitly set
398			return $wgCapitalLinkOverrides[$index];
399			}
400			// Default to the global setting
401			return $wgCapitalLinks;
402			}
403
404			/**
405			* Does the namespace (potentially) have different aliases for different
406			* genders. Not all languages make a distinction here.
407			*
408			* @since 1.18
409			* @param int $index Index to check
410			* @return bool
411			*/
412			public static function hasGenderDistinction( $index ) {
413			return $index == NS_USER \|\| $index == NS_USER_TALK;
414			}
415
416			/**
417			* It is not possible to use pages from this namespace as template?
418			*
419			* @since 1.20
420			* @param int $index Index to check
421			* @return bool
422			*/
423			public static function isNonincludable( $index ) {
424			global $wgNonincludableNamespaces;
425			return $wgNonincludableNamespaces && in_array( $index, $wgNonincludableNamespaces );
426			}
427
428			/**
429			* Get the default content model for a namespace
430			* This does not mean that all pages in that namespace have the model
431			*
432			* @since 1.21
433			* @param int $index Index to check
434			* @return null\|string Default model name for the given namespace, if set
435			*/
436			public static function getNamespaceContentModel( $index ) {
437			global $wgNamespaceContentModels;
438			return isset( $wgNamespaceContentModels[$index] )
439			? $wgNamespaceContentModels[$index]
440			: null;
441			}
442
443			/**
444			* Determine which restriction levels it makes sense to use in a namespace,
445			* optionally filtered by a user's rights.
446			*
447			* @since 1.23
448			* @param int $index Index to check
449			* @param User $user User to check
450			* @return array
451			*/
452			public static function getRestrictionLevels( $index, User $user = null ) {
453			global $wgNamespaceProtection, $wgRestrictionLevels;
454
455			if ( !isset( $wgNamespaceProtection[$index] ) ) {
456			// All levels are valid if there's no namespace restriction.
457			// But still filter by user, if necessary
458			$levels = $wgRestrictionLevels;
459			if ( $user ) {
460			$levels = array_values( array_filter( $levels, function ( $level ) use ( $user ) {
461			$right = $level;
462			if ( $right == 'sysop' ) {
463			$right = 'editprotected'; // BC
464			}
465			if ( $right == 'autoconfirmed' ) {
466			$right = 'editsemiprotected'; // BC
467			}
468			return ( $right == '' \|\| $user->isAllowed( $right ) );
469			} ) );
470			}
471			return $levels;
472			}
473
474			// First, get the list of groups that can edit this namespace.
475			$namespaceGroups = [];
476			$combine = 'array_merge';
477			foreach ( (array)$wgNamespaceProtection[$index] as $right ) {
478			if ( $right == 'sysop' ) {
479			$right = 'editprotected'; // BC
480			}
481			if ( $right == 'autoconfirmed' ) {
482			$right = 'editsemiprotected'; // BC
483			}
484			if ( $right != '' ) {
485			$namespaceGroups = call_user_func( $combine, $namespaceGroups,
486			User::getGroupsWithPermission( $right ) );
487			$combine = 'array_intersect';
488			}
489			}
490
491			// Now, keep only those restriction levels where there is at least one
492			// group that can edit the namespace but would be blocked by the
493			// restriction.
494			$usableLevels = [ '' ];
495			foreach ( $wgRestrictionLevels as $level ) {
496			$right = $level;
497			if ( $right == 'sysop' ) {
498			$right = 'editprotected'; // BC
499			}
500			if ( $right == 'autoconfirmed' ) {
501			$right = 'editsemiprotected'; // BC
502			}
503			if ( $right != '' && ( !$user \|\| $user->isAllowed( $right ) ) &&
504			array_diff( $namespaceGroups, User::getGroupsWithPermission( $right ) )
505			) {
506			$usableLevels[] = $level;
507			}
508			}
509
510			return $usableLevels;
511			}
512			}
513

wikimedia / mediawiki

MWNamespace::canTalk() A last analyzed 2016-11-13 17:42 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

MWNamespace::canTalk() A
last analyzed 2016-11-13 17:42 UTC