| blob | bdba5786bc707d85e584eac30d5c83dc035f3a86 |
1 <?php
2 /**
3 * Representation a title within %MediaWiki.
4 *
5 * See title.txt
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 * http://www.gnu.org/copyleft/gpl.html
21 *
22 * @file
23 */
25 /**
26 * Represents a title within MediaWiki.
27 * Optionally may contain an interwiki designation or namespace.
28 * @note This class can fetch various kinds of data from the database;
29 * however, it does so inefficiently.
30 *
31 * @internal documentation reviewed 15 Mar 2010
32 */
34 /** @var MapCacheLRU */
37 /**
38 * Title::newFromText maintains a cache to avoid expensive re-normalization of
39 * commonly used titles. On a batch operation this can become a memory leak
40 * if not bounded. After hitting this many titles reset the cache.
41 */
44 /**
45 * Used to be GAID_FOR_UPDATE define. Used with getArticleID() and friends
46 * to use the master DB
47 */
50 /**
51 * @name Private member variables
52 * Please use the accessor functions instead.
53 * @private
54 */
55 // @{
66 var $mContentModel = false; // /< ID of the page's content model, i.e. one of the CONTENT_MODEL_XXX constants
70 var $mCascadeRestriction; ///< Cascade restrictions on this page to included templates and images?
78 # Don't change the following default, NS_MAIN is hardcoded in several
79 # places. See bug 696.
80 # Zero except in {{transclusion}} tags
82 var $mWatched = null; // /< Is $wgUser watching this page? null if unfilled, accessed through userIsWatching()
87 private $mPageLanguage = false; // /< The (string) language code of the page's language and content code.
88 // @}
90 /**
91 * Constructor
92 */
95 /**
96 * Create a new Title from a prefixed DB key
97 *
98 * @param string $key the database key, which has underscores
99 * instead of spaces, possibly including namespace and
100 * interwiki prefixes
101 * @return Title, or NULL on an error
102 */
110 }
111 }
113 /**
114 * Create a new Title from text, such as what one would find in a link. De-
115 * codes any HTML entities in the text.
116 *
117 * @param string $text the link text; spaces, prefixes, and an
118 * initial ':' indicating the main namespace are accepted.
119 * @param int $defaultNamespace the namespace to use if none is specified
120 * by a prefix. If you want to force a specific namespace even if
121 * $text might begin with a namespace prefix, use makeTitle() or
122 * makeTitleSafe().
123 * @throws MWException
124 * @return Title|null - Title or null on an error.
125 */
129 }
133 /**
134 * Wiki pages often contain multiple links to the same page.
135 * Title normalization and parsing can become expensive on
136 * pages with many links, so we can save a little time by
137 * caching them.
138 *
139 * In theory these are value objects and won't get changed...
140 */
143 }
145 # Convert things like é ā or 〗 into normalized (bug 14952) text
155 }
160 }
161 }
163 /**
164 * THIS IS NOT THE FUNCTION YOU WANT. Use Title::newFromText().
165 *
166 * Example of wrong and broken code:
167 * $title = Title::newFromURL( $wgRequest->getVal( 'title' ) );
168 *
169 * Example of right code:
170 * $title = Title::newFromText( $wgRequest->getVal( 'title' ) );
171 *
172 * Create a new Title from URL-encoded text. Ensures that
173 * the given title's length does not exceed the maximum.
174 *
175 * @param string $url the title, as might be taken from a URL
176 * @return Title the new object, or NULL on an error
177 */
181 # For compatibility with old buggy URLs. "+" is usually not valid in titles,
182 # but some URLs used it as a space replacement and they still come
183 # from some external search tools.
186 }
193 }
194 }
196 /**
197 * @return MapCacheLRU
198 */
202 }
204 }
206 /**
207 * Returns a list of fields that are to be selected for initializing Title objects or LinkCache entries.
208 * Uses $wgContentHandlerUseDB to determine whether to include page_content_model.
209 *
210 * @return array
211 */
218 );
222 }
225 }
227 /**
228 * Create a new Title from an article ID
229 *
230 * @param int $id the page_id corresponding to the Title to create
231 * @param int $flags use Title::GAID_FOR_UPDATE to use master
232 * @return Title|null the new object, or NULL on an error
233 */
240 __METHOD__
241 );
246 }
248 }
250 /**
251 * Make an array of titles from an array of IDs
252 *
253 * @param array $ids of Int Array of IDs
254 * @return Array of Titles
255 */
259 }
266 __METHOD__
267 );
272 }
274 }
276 /**
277 * Make a Title object from a DB row
278 *
279 * @param stdClass $row Object database row (needs at least page_title,page_namespace)
280 * @return Title corresponding Title
281 */
286 }
288 /**
289 * Load Title object fields from a DB row.
290 * If false is given, the title will be treated as non-existing.
291 *
292 * @param $row stdClass|bool database row
293 */
298 }
301 }
304 }
307 }
312 }
319 }
320 }
322 /**
323 * Create a new Title from a namespace index and a DB key.
324 * It's assumed that $ns and $title are *valid*, for instance when
325 * they came directly from the database or a special page name.
326 * For convenience, spaces are converted to underscores so that
327 * eg user_text fields can be used directly.
328 *
329 * @param int $ns the namespace of the article
330 * @param string $title the unprefixed database key form
331 * @param string $fragment the link fragment (after the "#")
332 * @param string $interwiki the interwiki prefix
333 * @return Title the new object
334 */
346 }
348 /**
349 * Create a new Title from a namespace index and a DB key.
350 * The parameters will be checked for validity, which is a bit slower
351 * than makeTitle() but safer for user-provided data.
352 *
353 * @param int $ns the namespace of the article
354 * @param string $title database key form
355 * @param string $fragment the link fragment (after the "#")
356 * @param string $interwiki interwiki prefix
357 * @return Title the new object, or NULL on an error
358 */
362 }
370 }
371 }
373 /**
374 * Create a new Title for the Main Page
375 *
376 * @return Title the new object
377 */
380 // Don't give fatal errors if the message is broken
383 }
385 }
387 /**
388 * Extract a redirect destination from a string and return the
389 * Title, or null if the text doesn't contain a valid redirect
390 * This will only return the very next target, useful for
391 * the redirect table and other checks that don't need full recursion
392 *
393 * @param string $text Text with possible redirect
394 * @return Title: The corresponding Title
395 * @deprecated since 1.21, use Content::getRedirectTarget instead.
396 */
402 }
404 /**
405 * Extract a redirect destination from a string and return the
406 * Title, or null if the text doesn't contain a valid redirect
407 * This will recurse down $wgMaxRedirects times or until a non-redirect target is hit
408 * in order to provide (hopefully) the Title of the final destination instead of another redirect
409 *
410 * @param string $text Text with possible redirect
411 * @return Title
412 * @deprecated since 1.21, use Content::getUltimateRedirectTarget instead.
413 */
419 }
421 /**
422 * Extract a redirect destination from a string and return an
423 * array of Titles, or null if the text doesn't contain a valid redirect
424 * The last element in the array is the final destination after all redirects
425 * have been resolved (up to $wgMaxRedirects times)
426 *
427 * @param string $text Text with possible redirect
428 * @return Array of Titles, with the destination last
429 * @deprecated since 1.21, use Content::getRedirectChain instead.
430 */
436 }
438 /**
439 * Get the prefixed DB key associated with an ID
440 *
441 * @param int $id the page_id of the article
442 * @return Title an object representing the article, or NULL if no such article was found
443 */
451 __METHOD__
452 );
455 }
459 }
461 /**
462 * Get a regex character class describing the legal characters in a link
463 *
464 * @return String the list of characters, not delimited
465 */
469 }
471 /**
472 * Returns a simple regex that will match on characters and sequences invalid in titles.
473 * Note that this doesn't pick up many things that could be wrong with titles, but that
474 * replacing this regex with something valid will make many titles valid.
475 *
476 * @return String regex string
477 */
481 # Matching titles will be held as illegal.
483 # Any character not allowed is forbidden...
485 # URL percent encoding sequences interfere with the ability
486 # to round-trip titles -- you can't link to them consistently.
488 # XML/HTML character references produce similar issues.
493 }
496 }
498 /**
499 * Utility method for converting a character sequence from bytes to Unicode.
500 *
501 * Primary usecase being converting $wgLegalTitleChars to a sequence usable in
502 * javascript, as PHP uses UTF-8 bytes where javascript uses Unicode code units.
503 *
504 * @param string $byteClass
505 * @return string
506 */
509 // Input token queue
511 // Decoded queue
513 // Decoded integer codepoints
515 // Re-encoded queue
517 // Output
519 // Flags
522 // Shift the queues down
531 // Load the current input token and decoded values
548 }
551 }
553 // Load the current re-encoded value
557 // Allow unicode if a single high-bit character appears
564 }
565 // Do the output
567 // Range
569 // Empty range
571 // Unicode range
574 // Keep the non-unicode section of the range
576 }
578 // Normal range
580 }
581 // Reset state to the initial value
584 // ASCII character
586 }
587 }
590 }
593 }
596 }
598 }
600 /**
601 * Get a string representation of a title suitable for
602 * including in a search index
603 *
604 * @param int $ns a namespace index
605 * @param string $title text-form main part
606 * @return String a stripped-down title string ready for the search index
607 */
616 # Handle 's, s'
624 }
626 }
628 /**
629 * Make a prefixed DB key from a DB key and a namespace index
630 *
631 * @param int $ns numerical representation of the namespace
632 * @param string $title the DB key form the title
633 * @param string $fragment The link fragment (after the "#")
634 * @param string $interwiki The interwiki prefix
635 * @return String the prefixed form of the title
636 */
644 }
647 }
649 }
651 /**
652 * Escape a text fragment, say from a link, for a URL
653 *
654 * @param string $fragment containing a URL or link fragment (after the "#")
655 * @return String: escaped string
656 */
658 # Note that we don't urlencode the fragment. urlencoded Unicode
659 # fragments appear not to work in IE (at least up to 7) or in at least
660 # one version of Opera 9.x. The W3C validator, for one, doesn't seem
661 # to care if they aren't encoded.
663 }
665 /**
666 * Callback for usort() to do title sorts by (namespace, title)
667 *
668 * @param $a Title
669 * @param $b Title
670 *
671 * @return Integer: result of string comparison, or namespace comparison
672 */
678 }
679 }
681 /**
682 * Determine whether the object refers to a page within
683 * this project.
684 *
685 * @return Bool TRUE if this is an in-project interwiki link or a wikilink, FALSE otherwise
686 */
692 }
693 }
695 }
697 /**
698 * Is this Title interwiki?
699 *
700 * @return Bool
701 */
704 }
706 /**
707 * Get the interwiki prefix
708 *
709 * Use Title::isExternal to check if a interwiki is set
710 *
711 * @return String Interwiki prefix
712 */
715 }
717 /**
718 * Determine whether the object refers to a page within
719 * this project and is transcludable.
720 *
721 * @return Bool TRUE if this is transcludable
722 */
726 }
729 }
731 /**
732 * Returns the DB name of the distant wiki which owns the object.
733 *
734 * @return String the DB name
735 */
739 }
742 }
744 /**
745 * Get the text form (spaces not underscores) of the main part
746 *
747 * @return String Main part of the title
748 */
751 }
753 /**
754 * Get the URL-encoded form of the main part
755 *
756 * @return String Main part of the title, URL-encoded
757 */
760 }
762 /**
763 * Get the main part with underscores
764 *
765 * @return String: Main part of the title, with underscores
766 */
769 }
771 /**
772 * Get the DB key with the initial letter case as specified by the user
773 *
774 * @return String DB key
775 */
780 // If created via makeTitle(), $this->mUserCaseDBKey is not set.
782 }
783 }
785 /**
786 * Get the namespace index, i.e. one of the NS_xxxx constants.
787 *
788 * @return Integer: Namespace index
789 */
792 }
794 /**
795 * Get the page's content model id, see the CONTENT_MODEL_XXX constants.
796 *
797 * @throws MWException
798 * @return String: Content model id
799 */
804 }
808 }
812 }
815 }
817 /**
818 * Convenience method for checking a title's content model name
819 *
820 * @param string $id The content model ID (use the CONTENT_MODEL_XXX constants).
821 * @return Boolean true if $this->getContentModel() == $id
822 */
825 }
827 /**
828 * Get the namespace text
829 *
830 * @return String: Namespace text
831 */
836 // This probably shouldn't even happen. ohh man, oh yuck.
837 // But for interwiki transclusion it sometimes does.
838 // Shit. Shit shit shit.
839 //
840 // Use the canonical namespaces if possible to try to
841 // resolve a foreign namespace.
844 }
845 }
851 }
854 }
856 /**
857 * Get the namespace text of the subject (rather than talk) page
858 *
859 * @return String Namespace text
860 */
864 }
866 /**
867 * Get the namespace text of the talk page
868 *
869 * @return String Namespace text
870 */
874 }
876 /**
877 * Could this title have a corresponding talk page?
878 *
879 * @return Bool TRUE or FALSE
880 */
883 }
885 /**
886 * Is this in a namespace that allows actual pages?
887 *
888 * @return Bool
889 * @internal note -- uses hardcoded namespace index instead of constants
890 */
893 }
895 /**
896 * Can this title be added to a user's watchlist?
897 *
898 * @return Bool TRUE or FALSE
899 */
902 }
904 /**
905 * Returns true if this is a special page.
906 *
907 * @return boolean
908 */
911 }
913 /**
914 * Returns true if this title resolves to the named special page
915 *
916 * @param string $name The special page name
917 * @return boolean
918 */
924 }
925 }
927 }
929 /**
930 * If the Title refers to a special page alias which is not the local default, resolve
931 * the alias, and localise the name as necessary. Otherwise, return $this
932 *
933 * @return Title
934 */
942 }
943 }
944 }
946 }
948 /**
949 * Returns true if the title is inside the specified namespace.
950 *
951 * Please make use of this instead of comparing to getNamespace()
952 * This function is much more resistant to changes we may make
953 * to namespaces than code that makes direct comparisons.
954 * @param int $ns The namespace
955 * @return bool
956 * @since 1.19
957 */
960 }
962 /**
963 * Returns true if the title is inside one of the specified namespaces.
964 *
965 * @param ...$namespaces The namespaces to check for
966 * @return bool
967 * @since 1.19
968 */
973 }
978 }
979 }
982 }
984 /**
985 * Returns true if the title has the same subject namespace as the
986 * namespace specified.
987 * For example this method will take NS_USER and return true if namespace
988 * is either NS_USER or NS_USER_TALK since both of them have NS_USER
989 * as their subject namespace.
990 *
991 * This is MUCH simpler than individually testing for equivalence
992 * against both NS_USER and NS_USER_TALK, and is also forward compatible.
993 * @since 1.19
994 * @param $ns int
995 * @return bool
996 */
999 }
1001 /**
1002 * Is this Title in a namespace which contains content?
1003 * In other words, is this a content page, for the purposes of calculating
1004 * statistics, etc?
1005 *
1006 * @return Boolean
1007 */
1010 }
1012 /**
1013 * Would anybody with sufficient privileges be able to move this page?
1014 * Some pages just aren't movable.
1015 *
1016 * @return Bool TRUE or FALSE
1017 */
1020 // Interwiki title or immovable namespace. Hooks don't get to override here
1022 }
1027 }
1029 /**
1030 * Is this the mainpage?
1031 * @note Title::newFromText seems to be sufficiently optimized by the title
1032 * cache that we don't need to over-optimize by doing direct comparisons and
1033 * accidentally creating new bugs where $title->equals( Title::newFromText() )
1034 * ends up reporting something differently than $title->isMainPage();
1035 *
1036 * @since 1.18
1037 * @return Bool
1038 */
1041 }
1043 /**
1044 * Is this a subpage?
1045 *
1046 * @return Bool
1047 */
1052 }
1054 /**
1055 * Is this a conversion table for the LanguageConverter?
1056 *
1057 * @return Bool
1058 */
1060 // @todo ConversionTable should become a separate content model.
1064 }
1066 /**
1067 * Does that page contain wikitext, or it is JS, CSS or whatever?
1068 *
1069 * @return Bool
1070 */
1073 }
1075 /**
1076 * Could this page contain custom CSS or JavaScript for the global UI.
1077 * This is generally true for pages in the MediaWiki namespace having CONTENT_MODEL_CSS
1078 * or CONTENT_MODEL_JAVASCRIPT.
1079 *
1080 * This method does *not* return true for per-user JS/CSS. Use isCssJsSubpage() for that!
1081 *
1082 * Note that this method should not return true for pages that contain and show "inactive" CSS or JS.
1083 *
1084 * @return Bool
1085 */
1091 #NOTE: this hook is also called in ContentHandler::getDefaultModel. It's called here again to make sure
1092 # hook functions can force this method to return true even outside the mediawiki namespace.
1097 }
1099 /**
1100 * Is this a .css or .js subpage of a user page?
1101 * @return Bool
1102 */
1107 }
1109 /**
1110 * Trim down a .css or .js subpage title to get the corresponding skin name
1111 *
1112 * @return string containing skin name from .css or .js subpage title
1113 */
1120 }
1122 }
1124 /**
1125 * Is this a .css subpage of a user page?
1126 *
1127 * @return Bool
1128 */
1132 }
1134 /**
1135 * Is this a .js subpage of a user page?
1136 *
1137 * @return Bool
1138 */
1142 }
1144 /**
1145 * Is this a talk page of some sort?
1146 *
1147 * @return Bool
1148 */
1151 }
1153 /**
1154 * Get a Title object associated with the talk page of this article
1155 *
1156 * @return Title the object for the talk page
1157 */
1160 }
1162 /**
1163 * Get a title object associated with the subject page of this
1164 * talk page
1165 *
1166 * @return Title the object for the subject page
1167 */
1169 // Is this the same title?
1173 }
1175 }
1177 /**
1178 * Get the default namespace index, for when there is no namespace
1179 *
1180 * @return Int Default namespace index
1181 */
1184 }
1186 /**
1187 * Get title for search index
1188 *
1189 * @return String a stripped-down title string ready for the
1190 * search index
1191 */
1194 }
1196 /**
1197 * Get the Title fragment (i.e.\ the bit after the #) in text form
1198 *
1199 * Use Title::hasFragment to check for a fragment
1200 *
1201 * @return String Title fragment
1202 */
1205 }
1207 /**
1208 * Check if a Title fragment is set
1209 *
1210 * @return bool
1211 * @since 1.23
1212 */
1215 }
1217 /**
1218 * Get the fragment in URL form, including the "#" character if there is one
1219 * @return String Fragment in URL form
1220 */
1226 }
1227 }
1229 /**
1230 * Set the fragment for this title. Removes the first character from the
1231 * specified fragment before setting, so it assumes you're passing it with
1232 * an initial "#".
1233 *
1234 * Deprecated for public use, use Title::makeTitle() with fragment parameter.
1235 * Still in active use privately.
1236 *
1237 * @param string $fragment text
1238 */
1241 }
1243 /**
1244 * Prefix some arbitrary text with the namespace or interwiki prefix
1245 * of this object
1246 *
1247 * @param string $name the text
1248 * @return String the prefixed text
1249 * @private
1250 */
1255 }
1259 }
1261 }
1263 /**
1264 * Get the prefixed database key form
1265 *
1266 * @return String the prefixed title, with underscores and
1267 * any interwiki and namespace prefixes
1268 */
1273 }
1275 /**
1276 * Get the prefixed title with spaces.
1277 * This is the form usually used for display
1278 *
1279 * @return String the prefixed title, with spaces
1280 */
1286 }
1288 }
1290 /**
1291 * Return a string representation of this title
1292 *
1293 * @return String representation of this title
1294 */
1297 }
1299 /**
1300 * Get the prefixed title with spaces, plus any fragment
1301 * (part beginning with '#')
1302 *
1303 * @return String the prefixed title, with spaces and the fragment, including '#'
1304 */
1309 }
1311 }
1313 /**
1314 * Get the root page name text without a namespace, i.e. the leftmost part before any slashes
1315 *
1316 * @par Example:
1317 * @code
1318 * Title::newFromText('User:Foo/Bar/Baz')->getRootText();
1319 * # returns: 'Foo'
1320 * @endcode
1321 *
1322 * @return String Root name
1323 * @since 1.20
1324 */
1328 }
1331 }
1333 /**
1334 * Get the root page name title, i.e. the leftmost part before any slashes
1335 *
1336 * @par Example:
1337 * @code
1338 * Title::newFromText('User:Foo/Bar/Baz')->getRootTitle();
1339 * # returns: Title{User:Foo}
1340 * @endcode
1341 *
1342 * @return Title Root title
1343 * @since 1.20
1344 */
1347 }
1349 /**
1350 * Get the base page name without a namespace, i.e. the part before the subpage name
1351 *
1352 * @par Example:
1353 * @code
1354 * Title::newFromText('User:Foo/Bar/Baz')->getBaseText();
1355 * # returns: 'Foo/Bar'
1356 * @endcode
1357 *
1358 * @return String Base name
1359 */
1363 }
1366 # Don't discard the real title if there's no subpage involved
1369 }
1371 }
1373 /**
1374 * Get the base page name title, i.e. the part before the subpage name
1375 *
1376 * @par Example:
1377 * @code
1378 * Title::newFromText('User:Foo/Bar/Baz')->getBaseTitle();
1379 * # returns: Title{User:Foo/Bar}
1380 * @endcode
1381 *
1382 * @return Title Base title
1383 * @since 1.20
1384 */
1387 }
1389 /**
1390 * Get the lowest-level subpage name, i.e. the rightmost part after any slashes
1391 *
1392 * @par Example:
1393 * @code
1394 * Title::newFromText('User:Foo/Bar/Baz')->getSubpageText();
1395 * # returns: "Baz"
1396 * @endcode
1397 *
1398 * @return String Subpage name
1399 */
1403 }
1406 }
1408 /**
1409 * Get the title for a subpage of the current page
1410 *
1411 * @par Example:
1412 * @code
1413 * Title::newFromText('User:Foo/Bar/Baz')->getSubpage("Asdf");
1414 * # returns: Title{User:Foo/Bar/Baz/Asdf}
1415 * @endcode
1416 *
1417 * @param string $text The subpage name to add to the title
1418 * @return Title Subpage title
1419 * @since 1.20
1420 */
1423 }
1425 /**
1426 * Get the HTML-escaped displayable text form.
1427 * Used for the title field in <a> tags.
1428 *
1429 * @return String the text, including any prefixes
1430 * @deprecated since 1.19
1431 */
1435 }
1437 /**
1438 * Get a URL-encoded form of the subpage text
1439 *
1440 * @return String URL-encoded subpage name
1441 */
1446 }
1448 /**
1449 * Get a URL-encoded title (not an actual URL) including interwiki
1450 *
1451 * @return String the URL-encoded form
1452 */
1457 }
1459 /**
1460 * Helper to fix up the get{Canonical,Full,Link,Local,Internal}URL args
1461 * get{Canonical,Full,Link,Local,Internal}URL methods accepted an optional
1462 * second argument named variant. This was deprecated in favor
1463 * of passing an array of option with a "variant" key
1464 * Once $query2 is removed for good, this helper can be dropped
1465 * and the wfArrayToCgi moved to getLocalURL();
1466 *
1467 * @since 1.19 (r105919)
1468 * @param $query
1469 * @param $query2 bool
1470 * @return String
1471 */
1477 }
1480 }
1483 // $query2 is a string, we will consider this to be
1484 // a deprecated $variant argument and add it to the query
1488 }
1489 // If we have $query content add a & to it first
1492 }
1493 // Now append the queries together
1495 }
1497 }
1499 /**
1500 * Get a real URL referring to this title, with interwiki link and
1501 * fragment
1502 *
1503 * See getLocalURL for the arguments.
1504 *
1505 * @see self::getLocalURL
1506 * @see wfExpandUrl
1507 * @param $query
1508 * @param $query2 bool
1509 * @param $proto Protocol type to use in URL
1510 * @return String the URL
1511 */
1515 # Hand off all the decisions on urls to getLocalURL
1518 # Expand the url to make it a full url. Note that getLocalURL has the
1519 # potential to output full urls for a variety of reasons, so we use
1520 # wfExpandUrl instead of simply prepending $wgServer
1523 # Finally, add the fragment.
1528 }
1530 /**
1531 * Get a URL with no fragment or server name. If this page is generated
1532 * with action=render, $wgServer is prepended.
1533 *
1534 * @param string|array $query an optional query string,
1535 * not used for interwiki links. Can be specified as an associative array as well,
1536 * e.g., array( 'action' => 'edit' ) (keys and values will be URL-escaped).
1537 * Some query patterns will trigger various shorturl path replacements.
1538 * @param $query2 Mixed: An optional secondary query array. This one MUST
1539 * be an array. If a string is passed it will be interpreted as a deprecated
1540 * variant argument and urlencoded into a variant= argument.
1541 * This second query argument will be added to the $query
1542 * The second parameter is deprecated since 1.19. Pass it as a key,value
1543 * pair in the first parameter array instead.
1544 *
1545 * @return String the URL
1546 */
1556 # Can this actually happen? Interwikis shouldn't be parsed.
1557 # Yes! It can in interwiki transclusion. But... it probably shouldn't.
1559 }
1574 ) {
1580 }
1584 }
1585 }
1586 }
1593 ) {
1596 // Only do the variant replacement if the given variant is a valid
1597 // variant for the page's language.
1600 }
1601 }
1606 }
1608 }
1609 }
1613 // @todo FIXME: This causes breakage in various places when we
1614 // actually expected a local URL and end up with dupe prefixes.
1617 }
1618 }
1621 }
1623 /**
1624 * Get a URL that's the simplest URL that will be valid to link, locally,
1625 * to the current Title. It includes the fragment, but does not include
1626 * the server unless action=render is used (or the link is external). If
1627 * there's a fragment but the prefixed text is empty, we just return a link
1628 * to the fragment.
1629 *
1630 * The result obviously should not be URL-escaped, but does need to be
1631 * HTML-escaped if it's being output in HTML.
1632 *
1633 * See getLocalURL for the arguments.
1634 *
1635 * @param $query
1636 * @param $query2 bool
1637 * @param $proto Protocol to use; setting this will cause a full URL to be used
1638 * @see self::getLocalURL
1639 * @return String the URL
1640 */
1649 }
1652 }
1654 /**
1655 * Get an HTML-escaped version of the URL form, suitable for
1656 * using in a link, without a server name or fragment
1657 *
1658 * See getLocalURL for the arguments.
1659 *
1660 * @see self::getLocalURL
1661 * @param $query string
1662 * @param $query2 bool|string
1663 * @return String the URL
1664 * @deprecated since 1.19
1665 */
1669 }
1671 /**
1672 * Get an HTML-escaped version of the URL form, suitable for
1673 * using in a link, including the server name and fragment
1674 *
1675 * See getLocalURL for the arguments.
1676 *
1677 * @see self::getLocalURL
1678 * @return String the URL
1679 * @deprecated since 1.19
1680 */
1684 }
1686 /**
1687 * Get the URL form for an internal link.
1688 * - Used in various Squid-related code, in case we have a different
1689 * internal hostname for the server from the exposed one.
1690 *
1691 * This uses $wgInternalServer to qualify the path, or $wgServer
1692 * if $wgInternalServer is not set. If the server variable used is
1693 * protocol-relative, the URL will be expanded to http://
1694 *
1695 * See getLocalURL for the arguments.
1696 *
1697 * @see self::getLocalURL
1698 * @return String the URL
1699 */
1707 }
1709 /**
1710 * Get the URL for a canonical link, for use in things like IRC and
1711 * e-mail notifications. Uses $wgCanonicalServer and the
1712 * GetCanonicalURL hook.
1713 *
1714 * NOTE: Unlike getInternalURL(), the canonical URL includes the fragment
1715 *
1716 * See getLocalURL for the arguments.
1717 *
1718 * @see self::getLocalURL
1719 * @return string The URL
1720 * @since 1.18
1721 */
1724 $url = wfExpandUrl( $this->getLocalURL( $query ) . $this->getFragmentForURL(), PROTO_CANONICAL );
1727 }
1729 /**
1730 * HTML-escaped version of getCanonicalURL()
1731 *
1732 * See getLocalURL for the arguments.
1733 *
1734 * @see self::getLocalURL
1735 * @since 1.18
1736 * @return string
1737 * @deprecated since 1.19
1738 */
1742 }
1744 /**
1745 * Get the edit URL for this Title
1746 *
1747 * @return String the URL, or a null string if this is an
1748 * interwiki link
1749 */
1753 }
1757 }
1759 /**
1760 * Is $wgUser watching this page?
1761 *
1762 * @deprecated in 1.20; use User::isWatched() instead.
1763 * @return Bool
1764 */
1773 }
1774 }
1776 }
1778 /**
1779 * Can $wgUser read this page?
1780 *
1781 * @deprecated in 1.19; use userCan(), quickUserCan() or getUserPermissionsErrors() instead
1782 * @return Bool
1783 * @todo fold these checks into userCan()
1784 */
1788 }
1790 /**
1791 * Can $user perform $action on this page?
1792 * This skips potentially expensive cascading permission checks
1793 * as well as avoids expensive error formatting
1794 *
1795 * Suitable for use for nonessential UI controls in common cases, but
1796 * _not_ for functional access control.
1797 *
1798 * May provide false positives, but should never provide a false negative.
1799 *
1800 * @param string $action action that permission needs to be checked for
1801 * @param $user User to check (since 1.19); $wgUser will be used if not
1802 * provided.
1803 * @return Bool
1804 */
1807 }
1809 /**
1810 * Can $user perform $action on this page?
1811 *
1812 * @param string $action action that permission needs to be checked for
1813 * @param $user User to check (since 1.19); $wgUser will be used if not
1814 * provided.
1815 * @param bool $doExpensiveQueries Set this to false to avoid doing
1816 * unnecessary queries.
1817 * @return Bool
1818 */
1823 }
1824 return !count( $this->getUserPermissionsErrorsInternal( $action, $user, $doExpensiveQueries, true ) );
1825 }
1827 /**
1828 * Can $user perform $action on this page?
1829 *
1830 * @todo FIXME: This *does not* check throttles (User::pingLimiter()).
1831 *
1832 * @param string $action action that permission needs to be checked for
1833 * @param $user User to check
1834 * @param bool $doExpensiveQueries Set this to false to avoid doing unnecessary
1835 * queries by skipping checks for cascading protections and user blocks.
1836 * @param array $ignoreErrors of Strings Set this to a list of message keys
1837 * whose corresponding errors may be ignored.
1838 * @return Array of arguments to wfMessage to explain permissions problems.
1839 */
1840 public function getUserPermissionsErrors( $action, $user, $doExpensiveQueries = true, $ignoreErrors = array() ) {
1843 // Remove the errors being ignored.
1849 }
1850 }
1853 }
1855 /**
1856 * Permissions checks that fail most often, and which are easiest to test.
1857 *
1858 * @param string $action the action to check
1859 * @param $user User user to check
1860 * @param array $errors list of current errors
1861 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1862 * @param $short Boolean short circuit on first error
1863 *
1864 * @return Array list of errors
1865 */
1866 private function checkQuickPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1867 if ( !wfRunHooks( 'TitleQuickPermissions', array( $this, $user, $action, &$errors, $doExpensiveQueries, $short ) ) ) {
1869 }
1875 ) {
1877 }
1881 // Show user page-specific message only if the user can move other pages
1883 }
1885 // Check if user is allowed to move files if it's a file
1888 }
1891 // User can't move anything
1895 // custom message if logged-in users without any special rights can move
1899 }
1900 }
1903 // User can't move anything
1907 // Show user page-specific message only if the user can move other pages
1909 }
1912 }
1915 }
1917 /**
1918 * Add the resulting error code to the errors array
1919 *
1920 * @param array $errors list of current errors
1921 * @param $result Mixed result of errors
1922 *
1923 * @return Array list of errors
1924 */
1927 // A single array representing an error
1930 // A nested array representing multiple errors
1933 // A string representing a message-id
1936 // a generic "We don't want them to do that"
1938 }
1940 }
1942 /**
1943 * Check various permission hooks
1944 *
1945 * @param string $action the action to check
1946 * @param $user User user to check
1947 * @param array $errors list of current errors
1948 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1949 * @param $short Boolean short circuit on first error
1950 *
1951 * @return Array list of errors
1952 */
1953 private function checkPermissionHooks( $action, $user, $errors, $doExpensiveQueries, $short ) {
1954 // Use getUserPermissionsErrors instead
1958 }
1959 // Check getUserPermissionsErrors hook
1962 }
1963 // Check getUserPermissionsErrorsExpensive hook
1965 $doExpensiveQueries
1967 && !wfRunHooks( 'getUserPermissionsErrorsExpensive', array( &$this, &$user, $action, &$result ) )
1968 ) {
1970 }
1973 }
1975 /**
1976 * Check permissions on special pages & namespaces
1977 *
1978 * @param string $action the action to check
1979 * @param $user User user to check
1980 * @param array $errors list of current errors
1981 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1982 * @param $short Boolean short circuit on first error
1983 *
1984 * @return Array list of errors
1985 */
1986 private function checkSpecialsAndNSPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1987 # Only 'createaccount' can be performed on special pages,
1988 # which don't actually exist in the DB.
1991 }
1993 # Check $wgNamespaceProtection for restricted namespaces
1999 }
2002 }
2004 /**
2005 * Check CSS/JS sub-page permissions
2006 *
2007 * @param string $action the action to check
2008 * @param $user User user to check
2009 * @param array $errors list of current errors
2010 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2011 * @param $short Boolean short circuit on first error
2012 *
2013 * @return Array list of errors
2014 */
2015 private function checkCSSandJSPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2016 # Protect css/js subpages of user pages
2017 # XXX: this might be better using restrictions
2018 # XXX: right 'editusercssjs' is deprecated, for backward compatibility only
2025 }
2031 }
2032 }
2033 }
2036 }
2038 /**
2039 * Check against page_restrictions table requirements on this
2040 * page. The user must possess all required rights for this
2041 * action.
2042 *
2043 * @param string $action the action to check
2044 * @param $user User user to check
2045 * @param array $errors list of current errors
2046 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2047 * @param $short Boolean short circuit on first error
2048 *
2049 * @return Array list of errors
2050 */
2051 private function checkPageRestrictions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2053 // Backwards compatibility, rewrite sysop -> editprotected
2056 }
2057 // Backwards compatibility, rewrite autoconfirmed -> editsemiprotected
2060 }
2063 }
2068 }
2069 }
2072 }
2074 /**
2075 * Check restrictions on cascading pages.
2076 *
2077 * @param string $action the action to check
2078 * @param $user User to check
2079 * @param array $errors list of current errors
2080 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2081 * @param $short Boolean short circuit on first error
2082 *
2083 * @return Array list of errors
2084 */
2085 private function checkCascadingSourcesRestrictions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2087 # We /could/ use the protection level on the source page, but it's
2088 # fairly ugly as we have to establish a precedence hierarchy for pages
2089 # included by multiple cascade-protected pages. So just restrict
2090 # it to people with 'protect' permission, as they could remove the
2091 # protection anyway.
2093 # Cascading protection depends on more than this page...
2094 # Several cascading protected pages may include this page...
2095 # Check each cascading level
2096 # This is only for protection restrictions, not for all actions
2099 // Backwards compatibility, rewrite sysop -> editprotected
2102 }
2103 // Backwards compatibility, rewrite autoconfirmed -> editsemiprotected
2106 }
2111 }
2113 }
2114 }
2115 }
2116 }
2119 }
2121 /**
2122 * Check action permissions not already checked in checkQuickPermissions
2123 *
2124 * @param string $action the action to check
2125 * @param $user User to check
2126 * @param array $errors list of current errors
2127 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2128 * @param $short Boolean short circuit on first error
2129 *
2130 * @return Array list of errors
2131 */
2132 private function checkActionPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2136 if ( count( $this->getUserPermissionsErrorsInternal( 'edit', $user, $doExpensiveQueries, true ) ) ) {
2137 // If they can't edit, they shouldn't protect.
2139 }
2145 }
2148 }
2151 ) {
2152 $errors[] = array( 'titleprotected', User::whoIs( $title_protection['pt_user'] ), $title_protection['pt_reason'] );
2153 }
2154 }
2156 // Check for immobile pages
2158 // Specific message for this case
2161 // Less specific message for rarer cases
2163 }
2169 }
2173 ) {
2175 }
2176 }
2178 }
2180 /**
2181 * Check that the user isn't blocked from editing.
2182 *
2183 * @param string $action the action to check
2184 * @param $user User to check
2185 * @param array $errors list of current errors
2186 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2187 * @param $short Boolean short circuit on first error
2188 *
2189 * @return Array list of errors
2190 */
2192 // Account creation blocks handled at userlogin.
2193 // Unblocking handled in SpecialUnblock
2196 }
2202 }
2205 // Don't block the user from editing their own talk page unless they've been
2206 // explicitly blocked from that too.
2208 // @todo FIXME: Pass the relevant context into this function.
2210 }
2213 }
2215 /**
2216 * Check that the user is allowed to read this page.
2217 *
2218 * @param string $action the action to check
2219 * @param $user User to check
2220 * @param array $errors list of current errors
2221 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2222 * @param $short Boolean short circuit on first error
2223 *
2224 * @return Array list of errors
2225 */
2226 private function checkReadPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2231 # Shortcut for public wikis, allows skipping quite a bit of code
2234 # If the user is allowed to read pages, he is allowed to read all pages
2239 ) {
2240 # Always grant access to the login page.
2241 # Even anons need to be able to log in.
2244 # Time to check the whitelist
2245 # Only do these checks is there's something to check against
2249 // Check for explicit whitelisting with and without underscores
2250 if ( in_array( $name, $wgWhitelistRead, true ) || in_array( $dbName, $wgWhitelistRead, true ) ) {
2253 # Old settings might have the title prefixed with
2254 # a colon for main-namespace pages
2257 }
2259 # If it's a special page, ditch the subpage bit and check again
2266 }
2267 }
2268 }
2269 }
2271 if ( !$whitelisted && is_array( $wgWhitelistReadRegexp ) && !empty( $wgWhitelistReadRegexp ) ) {
2273 // Check for regex whitelisting
2278 }
2279 }
2280 }
2283 # If the title is not whitelisted, give extensions a chance to do so...
2287 }
2288 }
2291 }
2293 /**
2294 * Get a description array when the user doesn't have the right to perform
2295 * $action (i.e. when User::isAllowed() returns false)
2296 *
2297 * @param string $action the action to check
2298 * @param $short Boolean short circuit on first error
2299 * @return Array list of errors
2300 */
2302 // We avoid expensive display logic for quickUserCan's and such
2305 }
2316 );
2319 }
2320 }
2322 /**
2323 * Can $user perform $action on this page? This is an internal function,
2324 * which checks ONLY that previously checked by userCan (i.e. it leaves out
2325 * checks on wfReadOnly() and blocks)
2326 *
2327 * @param string $action action that permission needs to be checked for
2328 * @param $user User to check
2329 * @param bool $doExpensiveQueries Set this to false to avoid doing unnecessary queries.
2330 * @param bool $short Set this to true to stop after the first permission error.
2331 * @return Array of arrays of the arguments to wfMessage to explain permissions problems.
2332 */
2333 protected function getUserPermissionsErrorsInternal( $action, $user, $doExpensiveQueries = true, $short = false ) {
2336 # Read has special handling
2341 );
2351 'checkUserBlock'
2352 );
2353 }
2360 }
2364 }
2366 /**
2367 * Get a filtered list of all restriction types supported by this wiki.
2368 * @param bool $exists True to get all restriction types that apply to
2369 * titles that do exist, False for all restriction types that apply to
2370 * titles that do not exist
2371 * @return array
2372 */
2377 # Remove the create restriction for existing titles
2380 # Only the create and upload restrictions apply to non-existing titles
2382 }
2384 }
2386 /**
2387 * Returns restriction types for the current Title
2388 *
2389 * @return array applicable restriction types
2390 */
2394 }
2399 # Remove the upload restriction for non-file titles
2401 }
2409 }
2411 /**
2412 * Is this title subject to title protection?
2413 * Title protection is the one applied against creation of such title.
2414 *
2415 * @return Mixed An associative array representing any existent title
2416 * protection, or false if there's none.
2417 */
2419 // Can't protect pages in special namespaces
2422 }
2424 // Can't protect pages that exist.
2427 }
2435 __METHOD__
2436 );
2438 // fetchRow returns false if there are no rows.
2440 }
2442 }
2444 /**
2445 * Update the title protection status
2446 *
2447 * @deprecated in 1.19; use WikiPage::doUpdateRestrictions() instead.
2448 * @param $create_perm String Permission required for creation
2449 * @param string $reason Reason for protection
2450 * @param string $expiry Expiry timestamp
2451 * @return boolean true
2452 */
2466 }
2468 /**
2469 * Remove any title protection due to page existing
2470 */
2477 __METHOD__
2478 );
2480 }
2482 /**
2483 * Is this page "semi-protected" - the *only* protection levels are listed
2484 * in $wgSemiprotectedRestrictionLevels?
2485 *
2486 * @param string $action Action to check (default: edit)
2487 * @return Bool
2488 */
2495 // Not protected, or all protection is full protection
2497 }
2499 // Remap autoconfirmed to editsemiprotected for BC
2502 }
2505 }
2508 }
2510 /**
2511 * Does the title correspond to a protected article?
2512 *
2513 * @param string $action the action the page is protected from,
2514 * by default checks all actions.
2515 * @return Bool
2516 */
2522 # Special pages have inherent protection
2525 }
2527 # Check regular protection levels
2534 }
2535 }
2536 }
2537 }
2540 }
2542 /**
2543 * Determines if $user is unable to edit this page because it has been protected
2544 * by $wgNamespaceProtection.
2545 *
2546 * @param $user User object to check permissions
2547 * @return Bool
2548 */
2556 }
2557 }
2558 }
2560 }
2562 /**
2563 * Cascading protection: Return true if cascading restrictions apply to this page, false if not.
2564 *
2565 * @return Bool If the page is subject to cascading restrictions.
2566 */
2570 }
2572 /**
2573 * Determines whether cascading protection sources have already been loaded from
2574 * the database.
2575 *
2576 * @param bool $getPages True to check if the pages are loaded, or false to check
2577 * if the status is loaded.
2578 * @return bool Whether or not the specified information has been loaded
2579 * @since 1.23
2580 */
2582 return $getPages ? isset( $this->mCascadeSources ) : isset( $this->mHasCascadingRestrictions );
2583 }
2585 /**
2586 * Cascading protection: Get the source of any cascading restrictions on this page.
2587 *
2588 * @param bool $getPages Whether or not to retrieve the actual pages
2589 * that the restrictions have come from.
2590 * @return Mixed Array of Title objects of the pages from which cascading restrictions
2591 * have come, false for none, or true if such restrictions exist, but $getPages
2592 * was not set. The restriction array is an array of each type, each of which
2593 * contains a array of unique groups.
2594 */
2603 }
2615 );
2623 );
2624 }
2633 }
2649 # Add groups needed for each restriction type if its not already there
2650 # Make sure this restriction type still exists
2654 }
2659 ) {
2661 }
2664 }
2666 // Trigger lazy purge of expired restrictions from the db
2668 }
2669 }
2672 }
2679 }
2683 }
2685 /**
2686 * Accessor for mRestrictionsLoaded
2687 *
2688 * @return bool Whether or not the page's restrictions have already been
2689 * loaded from the database
2690 * @since 1.23
2691 */
2694 }
2696 /**
2697 * Accessor/initialisation for mRestrictions
2698 *
2699 * @param string $action action that permission needs to be checked for
2700 * @return Array of Strings the array of groups allowed to edit this article
2701 */
2705 }
2709 }
2711 /**
2712 * Accessor/initialisation for mRestrictions
2713 *
2714 * @return Array of Arrays of Strings the first level indexed by
2715 * action, the second level containing the names of the groups
2716 * allowed to perform each action
2717 * @since 1.23
2718 */
2722 }
2724 }
2726 /**
2727 * Get the expiry time for the restriction against a given action
2728 *
2729 * @param $action
2730 * @return String|Bool 14-char timestamp, or 'infinity' if the page is protected forever
2731 * or not protected at all, or false if the action is not recognised.
2732 */
2736 }
2737 return isset( $this->mRestrictionsExpiry[$action] ) ? $this->mRestrictionsExpiry[$action] : false;
2738 }
2740 /**
2741 * Returns cascading restrictions for the current article
2742 *
2743 * @return Boolean
2744 */
2748 }
2751 }
2753 /**
2754 * Loads a string into mRestrictions array
2755 *
2756 * @param $res Resource restrictions as an SQL result.
2757 * @param string $oldFashionedRestrictions comma-separated list of page
2758 * restrictions from page table (pre 1.10)
2759 */
2765 }
2768 }
2770 /**
2771 * Compiles list of active page restrictions from both page table (pre 1.10)
2772 * and page_restrictions table for this existing page.
2773 * Public for usage by LiquidThreads.
2774 *
2775 * @param array $rows of db result objects
2776 * @param string $oldFashionedRestrictions comma-separated list of page
2777 * restrictions from page table (pre 1.10)
2778 */
2788 }
2792 # Backwards-compatibility: also load the restrictions from the page record (old format).
2797 }
2804 // old old format should be treated as edit/move restriction
2811 }
2812 }
2813 }
2817 }
2820 # Current system - load second to make them override.
2824 # Cycle through all the restrictions.
2827 // Don't take care of restrictions types that aren't allowed
2830 }
2832 // This code should be refactored, now that it's being used more generally,
2833 // But I don't really see any harm in leaving it in Block for now -werdna
2836 // Only apply the restrictions if they haven't expired!
2843 // Trigger a lazy purge of expired restrictions
2845 }
2846 }
2850 }
2851 }
2854 }
2856 /**
2857 * Load restrictions from the page_restrictions table
2858 *
2859 * @param string $oldFashionedRestrictions comma-separated list of page
2860 * restrictions from page table (pre 1.10)
2861 */
2872 __METHOD__
2873 );
2884 // Apply the restrictions
2890 }
2893 }
2895 }
2896 }
2897 }
2899 /**
2900 * Flush the protection cache in this object and force reload from the database.
2901 * This is used when updating protection from WikiPage::doUpdateRestrictions().
2902 */
2906 }
2908 /**
2909 * Purge expired restrictions from the page_restrictions table
2910 */
2914 }
2922 $method
2923 );
2927 $method
2928 );
2929 } );
2930 }
2932 /**
2933 * Does this have subpages? (Warning, usually requires an extra DB query.)
2934 *
2935 * @return Bool
2936 */
2939 # Duh
2941 }
2943 # We dynamically add a member variable for the purpose of this method
2944 # alone to cache the result. There's no point in having it hanging
2945 # around uninitialized in every Title object; therefore we only add it
2946 # if needed and don't declare it statically.
2952 }
2953 }
2956 }
2958 /**
2959 * Get all subpages of this page.
2960 *
2961 * @param int $limit maximum number of subpages to fetch; -1 for no limit
2962 * @return mixed TitleArray, or empty array if this page's namespace
2963 * doesn't allow subpages
2964 */
2968 }
2976 }
2981 __METHOD__,
2982 $options
2983 )
2984 );
2986 }
2988 /**
2989 * Is there a version of this page in the deletion archive?
2990 *
2991 * @return Int the number of archived revisions
2992 */
3001 __METHOD__
3002 );
3006 __METHOD__
3007 );
3008 }
3009 }
3011 }
3013 /**
3014 * Is there a version of this page in the deletion archive?
3015 *
3016 * @return Boolean
3017 */
3021 }
3025 __METHOD__
3026 );
3030 __METHOD__
3031 );
3032 }
3034 }
3036 /**
3037 * Get the article ID for this Title from the link cache,
3038 * adding it if necessary
3039 *
3040 * @param int $flags a bit field; may be Title::GAID_FOR_UPDATE to select
3041 * for update
3042 * @return Int the ID
3043 */
3048 }
3058 }
3059 }
3061 }
3063 /**
3064 * Is this an article that is a redirect page?
3065 * Uses link cache, adding it if necessary
3066 *
3067 * @param int $flags a bit field; may be Title::GAID_FOR_UPDATE to select for update
3068 * @return Bool
3069 */
3073 }
3074 # Calling getArticleID() loads the field from cache as needed
3078 }
3083 # Trust LinkCache's state over our own
3084 # LinkCache is telling us that the page doesn't exist, despite there being cached
3085 # data relating to an existing page in $this->mArticleID. Updaters should clear
3086 # LinkCache as appropriate, or use $flags = Title::GAID_FOR_UPDATE. If that flag is
3087 # set, then LinkCache will definitely be up to date here, since getArticleID() forces
3088 # LinkCache to refresh its data from the master.
3091 }
3096 }
3098 /**
3099 * What is the length of this page?
3100 * Uses link cache, adding it if necessary
3101 *
3102 * @param int $flags a bit field; may be Title::GAID_FOR_UPDATE to select for update
3103 * @return Int
3104 */
3108 }
3109 # Calling getArticleID() loads the field from cache as needed
3113 }
3117 # Trust LinkCache's state over our own, as for isRedirect()
3120 }
3125 }
3127 /**
3128 * What is the page_latest field for this page?
3129 *
3130 * @param int $flags a bit field; may be Title::GAID_FOR_UPDATE to select for update
3131 * @return Int or 0 if the page doesn't exist
3132 */
3136 }
3137 # Calling getArticleID() loads the field from cache as needed
3141 }
3146 # Trust LinkCache's state over our own, as for isRedirect()
3149 }
3154 }
3156 /**
3157 * This clears some fields in this object, and clears any associated
3158 * keys in the "bad links" section of the link cache.
3159 *
3160 * - This is called from WikiPage::doEdit() and WikiPage::insertOn() to allow
3161 * loading of the new page_id. It's also called from
3162 * WikiPage::doDeleteArticleReal()
3163 *
3164 * @param int $newid the new Article ID
3165 */
3174 }
3183 }
3185 /**
3186 * Capitalize a text string for a title if it belongs to a namespace that capitalizes
3187 *
3188 * @param string $text containing title to capitalize
3189 * @param int $ns namespace index, defaults to NS_MAIN
3190 * @return String containing capitalized title
3191 */
3199 }
3200 }
3202 /**
3203 * Secure and split - main initialisation function for this object
3204 *
3205 * Assumes that mDbkeyform has been set, and is urldecoded
3206 * and uses underscores, but not otherwise munged. This function
3207 * removes illegal characters, splits off the interwiki and
3208 * namespace prefixes, sets the other forms, and canonicalizes
3209 * everything.
3210 *
3211 * @return Bool true on success
3212 */
3216 # Initialisation
3223 # Strip Unicode bidi override characters.
3224 # Sometimes they slip into cut-n-pasted page titles, where the
3225 # override chars get included in list displays.
3228 # Clean up whitespace
3229 # Note: use of the /u option on preg_replace here will cause
3230 # input with invalid UTF-8 sequences to be nullified out in PHP 5.2.x,
3231 # conveniently disabling them.
3232 $dbkey = preg_replace( '/[ _\xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}]+/u', '_', $dbkey );
3236 # Contained illegal UTF-8 sequences or forbidden Unicode chars.
3238 }
3242 # Initial colon indicates main namespace rather than specified default
3243 # but should not create invalid {ns,title} pairs such as {0,Project:Foo}
3248 }
3252 }
3254 # Namespace or interwiki prefix
3262 # Ordinary namespace
3265 # For Talk:X pages, check if X has a "namespace" prefix
3268 # Disallow Talk:File:x type titles...
3271 # Disallow Talk:Interwiki:x type titles...
3273 }
3274 }
3277 # Can't make a local interwiki link to an interwiki link.
3278 # That's just crazy!
3280 }
3282 # Interwiki link
3286 # Redundant interwiki prefix to the local wiki
3289 ) {
3291 # Can't have an empty self-link
3293 }
3296 # Do another namespace split...
3298 }
3300 # If there's an initial colon after the interwiki, that also
3301 # resets the default namespace
3305 }
3306 }
3307 # If there's no recognized interwiki or namespace,
3308 # then let the colon expression be part of the title.
3309 }
3317 # remove whitespace again: prevents "Foo_bar_#"
3318 # becoming "Foo_bar_"
3320 }
3322 # Reject illegal characters.
3326 }
3328 # Pages with "/./" or "/../" appearing in the URLs will often be un-
3329 # reachable due to the way web browsers deal with 'relative' URLs.
3330 # Also, they conflict with subpage syntax. Forbid them explicitly.
3333 (
3341 )
3342 ) {
3344 }
3346 # Magic tilde sequences? Nu-uh!
3349 }
3351 # Limit the size of titles to 255 bytes. This is typically the size of the
3352 # underlying database field. We make an exception for special pages, which
3353 # don't need to be stored in the database, and may edge over 255 bytes due
3354 # to subpage syntax for long titles, e.g. [[Special:Block/Long name]]
3358 ) {
3360 }
3362 # Normally, all wiki links are forced to have an initial capital letter so [[foo]]
3363 # and [[Foo]] point to the same place. Don't force it for interwikis, since the
3364 # other site might be case-sensitive.
3368 }
3370 # Can't make a link to a namespace alone... "empty" local links can only be
3371 # self-links with a fragment identifier.
3374 }
3376 // Allow IPv6 usernames to start with '::' by canonicalizing IPv6 titles.
3377 // IP names are not allowed for accounts, and can only be referring to
3378 // edits from the IP. Given '::' abbreviations and caps/lowercaps,
3379 // there are numerous ways to present the same IP. Having sp:contribs scan
3380 // them all is silly and having some show the edits and others not is
3381 // inconsistent. Same for talk/userpages. Keep them normalized instead.
3384 }
3386 // Any remaining initial :s are illegal.
3389 }
3391 # Fill fields
3397 # We already know that some pages won't be in the database!
3400 }
3403 }
3405 /**
3406 * Get an array of Title objects linking to this Title
3407 * Also stores the IDs in the link cache.
3408 *
3409 * WARNING: do not use this function on arbitrary user-supplied titles!
3410 * On heavily-used templates it will max out the memory.
3411 *
3412 * @param array $options may be FOR UPDATE
3413 * @param string $table table name
3414 * @param string $prefix fields prefix
3415 * @return Array of Title objects linking here
3416 */
3422 }
3431 __METHOD__,
3432 $options
3433 );
3443 }
3444 }
3445 }
3447 }
3449 /**
3450 * Get an array of Title objects using this Title as a template
3451 * Also stores the IDs in the link cache.
3452 *
3453 * WARNING: do not use this function on arbitrary user-supplied titles!
3454 * On heavily-used templates it will max out the memory.
3455 *
3456 * @param array $options may be FOR UPDATE
3457 * @return Array of Title the Title objects linking here
3458 */
3461 }
3463 /**
3464 * Get an array of Title objects linked from this Title
3465 * Also stores the IDs in the link cache.
3466 *
3467 * WARNING: do not use this function on arbitrary user-supplied titles!
3468 * On heavily-used templates it will max out the memory.
3469 *
3470 * @param array $options may be FOR UPDATE
3471 * @param string $table table name
3472 * @param string $prefix fields prefix
3473 * @return Array of Title objects linking here
3474 */
3480 # If the page doesn't exist; there can't be any link from this page
3483 }
3489 }
3494 $fields = array( $namespaceFiled, $titleField, 'page_id', 'page_len', 'page_is_redirect', 'page_latest' );
3497 }
3503 __METHOD__,
3505 array( 'page' => array( 'LEFT JOIN', array( "page_namespace=$namespaceFiled", "page_title=$titleField" ) ) )
3506 );
3518 }
3520 }
3521 }
3522 }
3524 }
3526 /**
3527 * Get an array of Title objects used on this Title as a template
3528 * Also stores the IDs in the link cache.
3529 *
3530 * WARNING: do not use this function on arbitrary user-supplied titles!
3531 * On heavily-used templates it will max out the memory.
3532 *
3533 * @param array $options may be FOR UPDATE
3534 * @return Array of Title the Title objects used here
3535 */
3538 }
3540 /**
3541 * Get an array of Title objects referring to non-existent articles linked from this page
3542 *
3543 * @todo check if needed (used only in SpecialBrokenRedirects.php, and should use redirect table in this case)
3544 * @return Array of Title the Title objects
3545 */
3548 # All links from article ID 0 are false positives
3550 }
3558 'page_namespace IS NULL'
3559 ),
3565 )
3566 )
3567 );
3572 }
3574 }
3576 /**
3577 * Get a list of URLs to purge from the Squid cache when this
3578 * page changes
3579 *
3580 * @return Array of String the URLs
3581 */
3586 );
3593 }
3594 }
3596 // If we are looking at a css/js user subpage, purge the action=raw.
3601 }
3605 }
3607 /**
3608 * Purge all applicable Squid URLs
3609 */
3616 }
3617 }
3619 /**
3620 * Move this page without authentication
3621 *
3622 * @param $nt Title the new page Title
3623 * @return Mixed true on success, getUserPermissionsErrors()-like array on failure
3624 */
3627 }
3629 /**
3630 * Check whether a given move operation would be valid.
3631 * Returns true if ok, or a getUserPermissionsErrors()-like array otherwise
3632 *
3633 * @param $nt Title the new title
3634 * @param bool $auth indicates whether $wgUser's permissions
3635 * should be checked
3636 * @param string $reason is the log summary of the move, used for spam checking
3637 * @return Mixed True on success, getUserPermissionsErrors()-like array on failure
3638 */
3644 // Normally we'd add this to $errors, but we'll get
3645 // lots of syntax errors if $nt is not an object
3647 }
3650 }
3653 }
3656 }
3659 }
3666 }
3671 ) {
3673 }
3675 // Content model checks
3678 // can't move a page if that would change the page's content model
3683 );
3684 }
3686 // Image-specific checks
3689 }
3693 }
3701 }
3705 // This is kind of lame, won't display nice
3707 }
3712 }
3714 # The move is allowed only if (1) the target doesn't exist, or
3715 # (2) the target is a redirect to the source, and has no history
3716 # (so we can undo bad moves right after they're done).
3721 }
3727 }
3730 }
3733 }
3734 }
3737 }
3739 }
3741 /**
3742 * Check if the requested move target is a valid file move target
3743 * @param Title $nt Target title
3744 * @return array List of errors
3745 */
3751 // wfFindFile( $nt ) / wfLocalFile( $nt ) is not allowed until below
3757 }
3760 }
3761 }
3765 // From here we want to do checks on a file object, so if we can't
3766 // create one, we must return.
3768 }
3770 // wfFindFile( $nt ) / wfLocalFile( $nt ) is allowed below here
3775 }
3778 }
3780 /**
3781 * Move a title to a new location
3782 *
3783 * @param $nt Title the new title
3784 * @param bool $auth indicates whether $wgUser's permissions
3785 * should be checked
3786 * @param string $reason the reason for the move
3787 * @param bool $createRedirect Whether to create a redirect from the old title to the new title.
3788 * Ignored if the user doesn't have the suppressredirect right.
3789 * @return Mixed true on success, getUserPermissionsErrors()-like array on failure
3790 */
3795 // Auto-block user's IP if the account was "hard" blocked
3798 }
3799 // Check suppressredirect permission
3802 }
3806 // If it is a file, move it first.
3807 // It is done before all other moving stuff is done because it's hard to revert.
3815 }
3816 }
3817 // Clear RepoGroup process cache
3820 }
3822 $dbw->begin( __METHOD__ ); # If $file was a LocalFile, its transaction would have closed our own.
3826 // Do the actual move
3829 // Refresh the sortkey for this row. Be careful to avoid resetting
3830 // cl_timestamp, which may disturb time-based lists on some sites.
3835 __METHOD__
3836 );
3848 __METHOD__
3849 );
3850 }
3855 # Protect the redirect title as the title used to be...
3864 ),
3866 __METHOD__,
3868 );
3869 # Update the protection log
3878 }
3879 // @todo FIXME: $params?
3881 }
3883 # Update watchlists
3891 }
3897 }
3899 /**
3900 * Move page to a title which is either a redirect to the
3901 * source page or nonexistent
3902 *
3903 * @param $nt Title the page to move to, which should be a redirect or nonexistent
3904 * @param string $reason The reason for the move
3905 * @param bool $createRedirect Whether to leave a redirect at the old title. Does not check
3906 * if the user has the suppressredirect right
3907 * @throws MWException
3908 */
3918 }
3925 // NOTE: If this page's content model does not support redirects, $redirectContent will be null.
3928 }
3937 ) );
3944 }
3945 # Truncate for whole multibyte characters.
3958 # Delete the old redirect. We don't save it to history since
3959 # by definition if we've got here it's rather uninteresting.
3960 # We have to remove it so that the next step doesn't trigger
3961 # a conflict on the unique namespace+title index...
3965 }
3967 # Save a null revision in the page's history notifying of the move
3971 }
3975 # Change the name of the target page:
3980 ),
3982 __METHOD__
3983 );
3985 // clean up the old title before reset article id - bug 45348
3988 }
4003 }
4005 # Recreate the redirect, this time in the other direction.
4024 }
4025 }
4027 # Log the move
4030 }
4032 /**
4033 * Move this page's subpages to be subpages of $nt
4034 *
4035 * @param $nt Title Move target
4036 * @param bool $auth Whether $wgUser's permissions should be checked
4037 * @param string $reason The reason for the move
4038 * @param bool $createRedirect Whether to create redirects from the old subpages to
4039 * the new ones Ignored if the user doesn't have the 'suppressredirect' right
4040 * @return mixed array with old page titles as keys, and strings (new page titles) or
4041 * arrays (errors) as values, or an error array with numeric indices if no pages
4042 * were moved
4043 */
4046 // Check permissions
4049 }
4050 // Do the source and target namespaces support subpages?
4054 }
4058 }
4070 }
4072 // We don't know whether this function was called before
4073 // or after moving the root page, so check both
4074 // $this and $nt
4077 ) {
4078 // When moving a page to a subpage of itself,
4079 // don't move it twice
4081 }
4090 }
4091 # Bug 14385: we need makeTitleSafe because the new page names may
4092 # be longer than 255 characters.
4100 }
4101 }
4103 }
4105 /**
4106 * Checks if this page is just a one-rev redirect.
4107 * Adds lock, so don't use just for light purposes.
4108 *
4109 * @return Bool
4110 */
4116 # Is it a redirect?
4120 }
4125 __METHOD__,
4127 );
4128 # Cache some fields we may want
4132 $this->mContentModel = $row && isset( $row->page_content_model ) ? strval( $row->page_content_model ) : false;
4135 }
4136 # Does the article have a history?
4142 'page_latest != rev_id'
4143 ),
4144 __METHOD__,
4146 );
4147 # Return true if there was no history
4149 }
4151 /**
4152 * Checks if $this can be moved to a given Title
4153 * - Selects for update, so don't call it unless you mean business
4154 *
4155 * @param $nt Title the new title to check
4156 * @return Bool
4157 */
4159 # Is it an existing file?
4165 }
4166 }
4167 # Is it a redirect with no history?
4171 }
4172 # Get the article text
4176 }
4178 # Does the redirect point to the source?
4179 # Or is it a broken self-redirect, usually caused by namespace collisions?
4189 }
4191 # Fail safe (not a redirect after all. strange.)
4195 }
4196 }
4198 /**
4199 * Get categories to which this Title belongs and return an array of
4200 * categories' names.
4201 *
4202 * @return Array of parents in the form:
4203 * $parent => $currentarticle
4204 */
4214 }
4222 __METHOD__
4223 );
4227 // $data[] = Title::newFromText($wgContLang->getNsText ( NS_CATEGORY ).':'.$row->cl_to);
4229 }
4230 }
4232 }
4234 /**
4235 * Get a tree of parent categories
4236 *
4237 * @param array $children with the children in the keys, to check for circular refs
4238 * @return Array Tree of parent categories
4239 */
4247 # Circular reference
4253 }
4254 }
4255 }
4256 }
4259 }
4261 /**
4262 * Get an associative array for selecting this title from
4263 * the "page" table
4264 *
4265 * @return Array suitable for the $where parameter of DB::select()
4266 */
4269 // PK avoids secondary lookups in InnoDB, shouldn't hurt other DBs
4273 }
4274 }
4276 /**
4277 * Get the revision ID of the previous revision
4278 *
4279 * @param int $revId Revision ID. Get the revision that was before this one.
4280 * @param int $flags Title::GAID_FOR_UPDATE
4281 * @return Int|Bool Old revision ID, or FALSE if none exists
4282 */
4289 ),
4290 __METHOD__,
4292 );
4298 }
4299 }
4301 /**
4302 * Get the revision ID of the next revision
4303 *
4304 * @param int $revId Revision ID. Get the revision that was after this one.
4305 * @param int $flags Title::GAID_FOR_UPDATE
4306 * @return Int|Bool Next revision ID, or FALSE if none exists
4307 */
4314 ),
4315 __METHOD__,
4317 );
4323 }
4324 }
4326 /**
4327 * Get the first revision of the page
4328 *
4329 * @param int $flags Title::GAID_FOR_UPDATE
4330 * @return Revision|Null if page doesn't exist
4331 */
4338 __METHOD__,
4340 );
4343 }
4344 }
4346 }
4348 /**
4349 * Get the oldest revision timestamp of this page
4350 *
4351 * @param int $flags Title::GAID_FOR_UPDATE
4352 * @return String: MW timestamp
4353 */
4357 }
4359 /**
4360 * Check if this is a new page
4361 *
4362 * @return bool
4363 */
4367 }
4369 /**
4370 * Check whether the number of revisions of this page surpasses $wgDeleteRevisionsLimit
4371 *
4372 * @return bool
4373 */
4379 }
4383 }
4385 /**
4386 * Get the approximate revision count of this page.
4387 *
4388 * @return int
4389 */
4393 }
4399 }
4402 }
4404 /**
4405 * Get the number of revisions between the given revision.
4406 * Used for diffs and other things that really need it.
4407 *
4408 * @param int|Revision $old Old revision or rev ID (first before range)
4409 * @param int|Revision $new New revision or rev ID (first after range)
4410 * @return Int Number of revisions between these revisions.
4411 */
4415 }
4418 }
4421 }
4428 ),
4429 __METHOD__
4430 );
4431 }
4433 /**
4434 * Get the number of authors between the given revisions or revision IDs.
4435 * Used for diffs and other things that really need it.
4436 *
4437 * @param int|Revision $old Old revision or rev ID (first before range by default)
4438 * @param int|Revision $new New revision or rev ID (first after range by default)
4439 * @param int $limit Maximum number of authors
4440 * @param string|array $options (Optional): Single option, or an array of options:
4441 * 'include_old' Include $old in the range; $new is excluded.
4442 * 'include_new' Include $new in the range; $old is excluded.
4443 * 'include_both' Include both $old and $new in the range.
4444 * Unknown option values are ignored.
4445 * @return int Number of revision authors in the range; zero if not both revisions exist
4446 */
4450 }
4453 }
4454 // XXX: what if Revision objects are passed in, but they don't refer to this title?
4455 // Add $old->getPage() != $new->getPage() || $old->getPage() != $this->getArticleID()
4456 // in the sanity check below?
4459 }
4465 }
4468 }
4472 }
4473 // No DB query needed if $old and $new are the same or successive revisions:
4479 }
4481 }
4490 );
4492 }
4494 /**
4495 * Compare with another title.
4496 *
4497 * @param $title Title
4498 * @return Bool
4499 */
4501 // Note: === is necessary for proper matching of number-like titles.
4505 }
4507 /**
4508 * Check if this title is a subpage of another title
4509 *
4510 * @param $title Title
4511 * @return Bool
4512 */
4517 }
4519 /**
4520 * Check if page exists. For historical reasons, this function simply
4521 * checks for the existence of the title in the page table, and will
4522 * thus return false for interwiki links, special pages and the like.
4523 * If you want to know if a title can be meaningfully viewed, you should
4524 * probably call the isKnown() method instead.
4525 *
4526 * @return Bool
4527 */
4530 }
4532 /**
4533 * Should links to this title be shown as potentially viewable (i.e. as
4534 * "bluelinks"), even if there's no record by this title in the page
4535 * table?
4536 *
4537 * This function is semi-deprecated for public use, as well as somewhat
4538 * misleadingly named. You probably just want to call isKnown(), which
4539 * calls this function internally.
4540 *
4541 * (ISSUE: Most of these checks are cheap, but the file existence check
4542 * can potentially be quite expensive. Including it here fixes a lot of
4543 * existing code, but we might want to add an optional parameter to skip
4544 * it and any other expensive checks.)
4545 *
4546 * @return Bool
4547 */
4551 /**
4552 * Allows overriding default behavior for determining if a page exists.
4553 * If $isKnown is kept as null, regular checks happen. If it's
4554 * a boolean, this value is returned by the isKnown method.
4555 *
4556 * @since 1.20
4557 *
4558 * @param Title $title
4559 * @param boolean|null $isKnown
4560 */
4565 }
4569 }
4574 // file exists, possibly in a foreign repo
4577 // valid special page
4580 // selflink, possibly with fragment
4583 // known system message
4587 }
4588 }
4590 /**
4591 * Does this title refer to a page that can (or might) be meaningfully
4592 * viewed? In particular, this function may be used to determine if
4593 * links to the title should be rendered as "bluelinks" (as opposed to
4594 * "redlinks" to non-existent pages).
4595 * Adding something else to this function will cause inconsistency
4596 * since LinkHolderArray calls isAlwaysKnown() and does its own
4597 * page existence check.
4598 *
4599 * @return Bool
4600 */
4603 }
4605 /**
4606 * Does this page have source text?
4607 *
4608 * @return Boolean
4609 */
4613 }
4616 // If the page doesn't exist but is a known system message, default
4617 // message content will be displayed, same for language subpages-
4618 // Use always content language to avoid loading hundreds of languages
4619 // to get the link color.
4621 list( $name, ) = MessageCache::singleton()->figureMessage( $wgContLang->lcfirst( $this->getText() ) );
4624 }
4627 }
4629 /**
4630 * Get the default message text or false if the message doesn't exist
4631 *
4632 * @return String or false
4633 */
4639 }
4641 list( $name, $lang ) = MessageCache::singleton()->figureMessage( $wgContLang->lcfirst( $this->getText() ) );
4648 }
4649 }
4651 /**
4652 * Updates page_touched for this page; called from LinksUpdate.php
4653 *
4654 * @return Bool true if the update succeeded
4655 */
4659 }
4669 $method
4670 );
4671 } );
4674 }
4676 /**
4677 * Update page_touched timestamps and send squid purge messages for
4678 * pages linking to this title. May be sent to the job queue depending
4679 * on the number of links. Typically called on create and delete.
4680 */
4688 }
4689 }
4691 /**
4692 * Get the last touched timestamp
4693 *
4694 * @param $db DatabaseBase: optional db
4695 * @return String last-touched timestamp
4696 */
4701 }
4703 /**
4704 * Get the timestamp when this page was updated since the user last saw it.
4705 *
4706 * @param $user User
4707 * @return String|Null
4708 */
4711 // Assume current user if none given
4714 }
4715 // Check cache first
4717 // avoid isset here, as it'll return false for null entries
4720 }
4724 }
4725 // Don't cache too much!
4728 }
4736 ),
4737 __METHOD__
4738 );
4740 }
4742 /**
4743 * Generate strings used for xml 'id' names in monobook tabs
4744 *
4745 * @param string $prepend defaults to 'nstab-'
4746 * @return String XML 'id' name
4747 */
4750 // Gets the subject namespace if this title
4752 // Checks if canonical namespace name exists for namespace
4754 // Uses canonical namespace name
4757 // Uses text of namespace
4759 }
4760 // Makes namespace key lowercase
4762 // Uses main
4765 }
4766 // Changes file to image for backwards compatibility
4769 }
4771 }
4773 /**
4774 * Get all extant redirects to this Title
4775 *
4776 * @param int|Null $ns Single namespace to consider; NULL to consider all namespaces
4777 * @return Title[] Array of Title redirects to this title
4778 */
4786 'rd_from = page_id'
4787 );
4792 }
4795 }
4801 __METHOD__
4802 );
4806 }
4808 }
4810 /**
4811 * Check if this Title is a valid redirect target
4812 *
4813 * @return Bool
4814 */
4818 // invalid redirect targets are stored in a global array, but explicitly disallow Userlogout here
4821 }
4826 }
4827 }
4830 }
4832 /**
4833 * Get a backlink cache object
4834 *
4835 * @return BacklinkCache
4836 */
4839 }
4841 /**
4842 * Whether the magic words __INDEX__ and __NOINDEX__ function for this page.
4843 *
4844 * @return Boolean
4845 */
4850 ? $wgContentNamespaces
4855 }
4857 /**
4858 * Returns the raw sort key to be used for categories, with the specified
4859 * prefix. This will be fed to Collation::getSortKey() to get a
4860 * binary sortkey that can be used for actual sorting.
4861 *
4862 * @param string $prefix The prefix to be used, specified using
4863 * {{defaultsort:}} or like [[Category:Foo|prefix]]. Empty for no
4864 * prefix.
4865 * @return string
4866 */
4870 // Anything that uses this hook should only depend
4871 // on the Title object passed in, and should probably
4872 // tell the users to run updateCollations.php --force
4873 // in order to re-sort existing category relations.
4876 # Separate with a line feed, so the unprefixed part is only used as
4877 # a tiebreaker when two pages have the exact same prefix.
4878 # In UCA, tab is the only character that can sort above LF
4879 # so we strip both of them from the original prefix.
4882 }
4884 }
4886 /**
4887 * Get the language in which the content of this page is written in
4888 * wikitext. Defaults to $wgContLang, but in certain cases it can be
4889 * e.g. $wgLang (such as special pages, which are in the user language).
4890 *
4891 * @since 1.18
4892 * @return Language
4893 */
4898 // special pages are in the user language
4901 }
4904 // Note that this may depend on user settings, so the cache should be only per-request.
4905 // NOTE: ContentHandler::getPageLanguage() may need to load the content to determine the page language!
4906 // Checking $wgLanguageCode hasn't changed for the benefit of unit tests.
4912 }
4915 }
4917 /**
4918 * Get the language in which the content of this page is written when
4919 * viewed by user. Defaults to $wgContLang, but in certain cases it can be
4920 * e.g. $wgLang (such as special pages, which are in the user language).
4921 *
4922 * @since 1.20
4923 * @return Language
4924 */
4929 // If the user chooses a variant, the content is actually
4930 // in a language whose code is the variant code.
4934 }
4937 }
4939 //NOTE: can't be cached persistently, depends on user settings
4940 //NOTE: ContentHandler::getPageViewLanguage() may need to load the content to determine the page language!
4944 }
4946 /**
4947 * Get a list of rendered edit notices for this page.
4948 *
4949 * Array is keyed by the original message key, and values are rendered using parseAsBlock, so
4950 * they will already be wrapped in paragraphs.
4951 *
4952 * @since 1.21
4953 * @param int oldid Revision ID that's being edited
4954 * @return Array
4955 */
4959 # Optional notices on a per-namespace and per-page basis
4964 }
4973 }
4974 }
4976 # Even if there are no subpages in namespace, we still don't want / in MW ns.
4981 }
4982 }
4986 }
4987 }