| blob | 096a04d3fd484240853b4b5cb2a8c9fb7505af9e |
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 * @return String Interwiki prefix
710 */
713 }
715 /**
716 * Determine whether the object refers to a page within
717 * this project and is transcludable.
718 *
719 * @return Bool TRUE if this is transcludable
720 */
724 }
727 }
729 /**
730 * Returns the DB name of the distant wiki which owns the object.
731 *
732 * @return String the DB name
733 */
737 }
740 }
742 /**
743 * Get the text form (spaces not underscores) of the main part
744 *
745 * @return String Main part of the title
746 */
749 }
751 /**
752 * Get the URL-encoded form of the main part
753 *
754 * @return String Main part of the title, URL-encoded
755 */
758 }
760 /**
761 * Get the main part with underscores
762 *
763 * @return String: Main part of the title, with underscores
764 */
767 }
769 /**
770 * Get the DB key with the initial letter case as specified by the user
771 *
772 * @return String DB key
773 */
778 // If created via makeTitle(), $this->mUserCaseDBKey is not set.
780 }
781 }
783 /**
784 * Get the namespace index, i.e. one of the NS_xxxx constants.
785 *
786 * @return Integer: Namespace index
787 */
790 }
792 /**
793 * Get the page's content model id, see the CONTENT_MODEL_XXX constants.
794 *
795 * @throws MWException
796 * @return String: Content model id
797 */
802 }
806 }
810 }
813 }
815 /**
816 * Convenience method for checking a title's content model name
817 *
818 * @param string $id The content model ID (use the CONTENT_MODEL_XXX constants).
819 * @return Boolean true if $this->getContentModel() == $id
820 */
823 }
825 /**
826 * Get the namespace text
827 *
828 * @return String: Namespace text
829 */
834 // This probably shouldn't even happen. ohh man, oh yuck.
835 // But for interwiki transclusion it sometimes does.
836 // Shit. Shit shit shit.
837 //
838 // Use the canonical namespaces if possible to try to
839 // resolve a foreign namespace.
842 }
843 }
849 }
852 }
854 /**
855 * Get the namespace text of the subject (rather than talk) page
856 *
857 * @return String Namespace text
858 */
862 }
864 /**
865 * Get the namespace text of the talk page
866 *
867 * @return String Namespace text
868 */
872 }
874 /**
875 * Could this title have a corresponding talk page?
876 *
877 * @return Bool TRUE or FALSE
878 */
881 }
883 /**
884 * Is this in a namespace that allows actual pages?
885 *
886 * @return Bool
887 * @internal note -- uses hardcoded namespace index instead of constants
888 */
891 }
893 /**
894 * Can this title be added to a user's watchlist?
895 *
896 * @return Bool TRUE or FALSE
897 */
900 }
902 /**
903 * Returns true if this is a special page.
904 *
905 * @return boolean
906 */
909 }
911 /**
912 * Returns true if this title resolves to the named special page
913 *
914 * @param string $name The special page name
915 * @return boolean
916 */
922 }
923 }
925 }
927 /**
928 * If the Title refers to a special page alias which is not the local default, resolve
929 * the alias, and localise the name as necessary. Otherwise, return $this
930 *
931 * @return Title
932 */
940 }
941 }
942 }
944 }
946 /**
947 * Returns true if the title is inside the specified namespace.
948 *
949 * Please make use of this instead of comparing to getNamespace()
950 * This function is much more resistant to changes we may make
951 * to namespaces than code that makes direct comparisons.
952 * @param int $ns The namespace
953 * @return bool
954 * @since 1.19
955 */
958 }
960 /**
961 * Returns true if the title is inside one of the specified namespaces.
962 *
963 * @param ...$namespaces The namespaces to check for
964 * @return bool
965 * @since 1.19
966 */
971 }
976 }
977 }
980 }
982 /**
983 * Returns true if the title has the same subject namespace as the
984 * namespace specified.
985 * For example this method will take NS_USER and return true if namespace
986 * is either NS_USER or NS_USER_TALK since both of them have NS_USER
987 * as their subject namespace.
988 *
989 * This is MUCH simpler than individually testing for equivalence
990 * against both NS_USER and NS_USER_TALK, and is also forward compatible.
991 * @since 1.19
992 * @param $ns int
993 * @return bool
994 */
997 }
999 /**
1000 * Is this Title in a namespace which contains content?
1001 * In other words, is this a content page, for the purposes of calculating
1002 * statistics, etc?
1003 *
1004 * @return Boolean
1005 */
1008 }
1010 /**
1011 * Would anybody with sufficient privileges be able to move this page?
1012 * Some pages just aren't movable.
1013 *
1014 * @return Bool TRUE or FALSE
1015 */
1018 // Interwiki title or immovable namespace. Hooks don't get to override here
1020 }
1025 }
1027 /**
1028 * Is this the mainpage?
1029 * @note Title::newFromText seems to be sufficiently optimized by the title
1030 * cache that we don't need to over-optimize by doing direct comparisons and
1031 * accidentally creating new bugs where $title->equals( Title::newFromText() )
1032 * ends up reporting something differently than $title->isMainPage();
1033 *
1034 * @since 1.18
1035 * @return Bool
1036 */
1039 }
1041 /**
1042 * Is this a subpage?
1043 *
1044 * @return Bool
1045 */
1050 }
1052 /**
1053 * Is this a conversion table for the LanguageConverter?
1054 *
1055 * @return Bool
1056 */
1058 // @todo ConversionTable should become a separate content model.
1062 }
1064 /**
1065 * Does that page contain wikitext, or it is JS, CSS or whatever?
1066 *
1067 * @return Bool
1068 */
1071 }
1073 /**
1074 * Could this page contain custom CSS or JavaScript for the global UI.
1075 * This is generally true for pages in the MediaWiki namespace having CONTENT_MODEL_CSS
1076 * or CONTENT_MODEL_JAVASCRIPT.
1077 *
1078 * This method does *not* return true for per-user JS/CSS. Use isCssJsSubpage() for that!
1079 *
1080 * Note that this method should not return true for pages that contain and show "inactive" CSS or JS.
1081 *
1082 * @return Bool
1083 */
1089 #NOTE: this hook is also called in ContentHandler::getDefaultModel. It's called here again to make sure
1090 # hook functions can force this method to return true even outside the mediawiki namespace.
1095 }
1097 /**
1098 * Is this a .css or .js subpage of a user page?
1099 * @return Bool
1100 */
1105 }
1107 /**
1108 * Trim down a .css or .js subpage title to get the corresponding skin name
1109 *
1110 * @return string containing skin name from .css or .js subpage title
1111 */
1118 }
1120 }
1122 /**
1123 * Is this a .css subpage of a user page?
1124 *
1125 * @return Bool
1126 */
1130 }
1132 /**
1133 * Is this a .js subpage of a user page?
1134 *
1135 * @return Bool
1136 */
1140 }
1142 /**
1143 * Is this a talk page of some sort?
1144 *
1145 * @return Bool
1146 */
1149 }
1151 /**
1152 * Get a Title object associated with the talk page of this article
1153 *
1154 * @return Title the object for the talk page
1155 */
1158 }
1160 /**
1161 * Get a title object associated with the subject page of this
1162 * talk page
1163 *
1164 * @return Title the object for the subject page
1165 */
1167 // Is this the same title?
1171 }
1173 }
1175 /**
1176 * Get the default namespace index, for when there is no namespace
1177 *
1178 * @return Int Default namespace index
1179 */
1182 }
1184 /**
1185 * Get title for search index
1186 *
1187 * @return String a stripped-down title string ready for the
1188 * search index
1189 */
1192 }
1194 /**
1195 * Get the Title fragment (i.e.\ the bit after the #) in text form
1196 *
1197 * @return String Title fragment
1198 */
1201 }
1203 /**
1204 * Get the fragment in URL form, including the "#" character if there is one
1205 * @return String Fragment in URL form
1206 */
1212 }
1213 }
1215 /**
1216 * Set the fragment for this title. Removes the first character from the
1217 * specified fragment before setting, so it assumes you're passing it with
1218 * an initial "#".
1219 *
1220 * Deprecated for public use, use Title::makeTitle() with fragment parameter.
1221 * Still in active use privately.
1222 *
1223 * @param string $fragment text
1224 */
1227 }
1229 /**
1230 * Prefix some arbitrary text with the namespace or interwiki prefix
1231 * of this object
1232 *
1233 * @param string $name the text
1234 * @return String the prefixed text
1235 * @private
1236 */
1241 }
1245 }
1247 }
1249 /**
1250 * Get the prefixed database key form
1251 *
1252 * @return String the prefixed title, with underscores and
1253 * any interwiki and namespace prefixes
1254 */
1259 }
1261 /**
1262 * Get the prefixed title with spaces.
1263 * This is the form usually used for display
1264 *
1265 * @return String the prefixed title, with spaces
1266 */
1272 }
1274 }
1276 /**
1277 * Return a string representation of this title
1278 *
1279 * @return String representation of this title
1280 */
1283 }
1285 /**
1286 * Get the prefixed title with spaces, plus any fragment
1287 * (part beginning with '#')
1288 *
1289 * @return String the prefixed title, with spaces and the fragment, including '#'
1290 */
1295 }
1297 }
1299 /**
1300 * Get the root page name text without a namespace, i.e. the leftmost part before any slashes
1301 *
1302 * @par Example:
1303 * @code
1304 * Title::newFromText('User:Foo/Bar/Baz')->getRootText();
1305 * # returns: 'Foo'
1306 * @endcode
1307 *
1308 * @return String Root name
1309 * @since 1.20
1310 */
1314 }
1317 }
1319 /**
1320 * Get the root page name title, i.e. the leftmost part before any slashes
1321 *
1322 * @par Example:
1323 * @code
1324 * Title::newFromText('User:Foo/Bar/Baz')->getRootTitle();
1325 * # returns: Title{User:Foo}
1326 * @endcode
1327 *
1328 * @return Title Root title
1329 * @since 1.20
1330 */
1333 }
1335 /**
1336 * Get the base page name without a namespace, i.e. the part before the subpage name
1337 *
1338 * @par Example:
1339 * @code
1340 * Title::newFromText('User:Foo/Bar/Baz')->getBaseText();
1341 * # returns: 'Foo/Bar'
1342 * @endcode
1343 *
1344 * @return String Base name
1345 */
1349 }
1352 # Don't discard the real title if there's no subpage involved
1355 }
1357 }
1359 /**
1360 * Get the base page name title, i.e. the part before the subpage name
1361 *
1362 * @par Example:
1363 * @code
1364 * Title::newFromText('User:Foo/Bar/Baz')->getBaseTitle();
1365 * # returns: Title{User:Foo/Bar}
1366 * @endcode
1367 *
1368 * @return Title Base title
1369 * @since 1.20
1370 */
1373 }
1375 /**
1376 * Get the lowest-level subpage name, i.e. the rightmost part after any slashes
1377 *
1378 * @par Example:
1379 * @code
1380 * Title::newFromText('User:Foo/Bar/Baz')->getSubpageText();
1381 * # returns: "Baz"
1382 * @endcode
1383 *
1384 * @return String Subpage name
1385 */
1389 }
1392 }
1394 /**
1395 * Get the title for a subpage of the current page
1396 *
1397 * @par Example:
1398 * @code
1399 * Title::newFromText('User:Foo/Bar/Baz')->getSubpage("Asdf");
1400 * # returns: Title{User:Foo/Bar/Baz/Asdf}
1401 * @endcode
1402 *
1403 * @param string $text The subpage name to add to the title
1404 * @return Title Subpage title
1405 * @since 1.20
1406 */
1409 }
1411 /**
1412 * Get the HTML-escaped displayable text form.
1413 * Used for the title field in <a> tags.
1414 *
1415 * @return String the text, including any prefixes
1416 * @deprecated since 1.19
1417 */
1421 }
1423 /**
1424 * Get a URL-encoded form of the subpage text
1425 *
1426 * @return String URL-encoded subpage name
1427 */
1432 }
1434 /**
1435 * Get a URL-encoded title (not an actual URL) including interwiki
1436 *
1437 * @return String the URL-encoded form
1438 */
1443 }
1445 /**
1446 * Helper to fix up the get{Canonical,Full,Link,Local,Internal}URL args
1447 * get{Canonical,Full,Link,Local,Internal}URL methods accepted an optional
1448 * second argument named variant. This was deprecated in favor
1449 * of passing an array of option with a "variant" key
1450 * Once $query2 is removed for good, this helper can be dropped
1451 * and the wfArrayToCgi moved to getLocalURL();
1452 *
1453 * @since 1.19 (r105919)
1454 * @param $query
1455 * @param $query2 bool
1456 * @return String
1457 */
1463 }
1466 }
1469 // $query2 is a string, we will consider this to be
1470 // a deprecated $variant argument and add it to the query
1474 }
1475 // If we have $query content add a & to it first
1478 }
1479 // Now append the queries together
1481 }
1483 }
1485 /**
1486 * Get a real URL referring to this title, with interwiki link and
1487 * fragment
1488 *
1489 * See getLocalURL for the arguments.
1490 *
1491 * @see self::getLocalURL
1492 * @see wfExpandUrl
1493 * @param $query
1494 * @param $query2 bool
1495 * @param $proto Protocol type to use in URL
1496 * @return String the URL
1497 */
1501 # Hand off all the decisions on urls to getLocalURL
1504 # Expand the url to make it a full url. Note that getLocalURL has the
1505 # potential to output full urls for a variety of reasons, so we use
1506 # wfExpandUrl instead of simply prepending $wgServer
1509 # Finally, add the fragment.
1514 }
1516 /**
1517 * Get a URL with no fragment or server name. If this page is generated
1518 * with action=render, $wgServer is prepended.
1519 *
1520 * @param string|array $query an optional query string,
1521 * not used for interwiki links. Can be specified as an associative array as well,
1522 * e.g., array( 'action' => 'edit' ) (keys and values will be URL-escaped).
1523 * Some query patterns will trigger various shorturl path replacements.
1524 * @param $query2 Mixed: An optional secondary query array. This one MUST
1525 * be an array. If a string is passed it will be interpreted as a deprecated
1526 * variant argument and urlencoded into a variant= argument.
1527 * This second query argument will be added to the $query
1528 * The second parameter is deprecated since 1.19. Pass it as a key,value
1529 * pair in the first parameter array instead.
1530 *
1531 * @return String the URL
1532 */
1542 # Can this actually happen? Interwikis shouldn't be parsed.
1543 # Yes! It can in interwiki transclusion. But... it probably shouldn't.
1545 }
1560 ) {
1566 }
1570 }
1571 }
1572 }
1579 ) {
1582 // Only do the variant replacement if the given variant is a valid
1583 // variant for the page's language.
1586 }
1587 }
1592 }
1594 }
1595 }
1599 // @todo FIXME: This causes breakage in various places when we
1600 // actually expected a local URL and end up with dupe prefixes.
1603 }
1604 }
1607 }
1609 /**
1610 * Get a URL that's the simplest URL that will be valid to link, locally,
1611 * to the current Title. It includes the fragment, but does not include
1612 * the server unless action=render is used (or the link is external). If
1613 * there's a fragment but the prefixed text is empty, we just return a link
1614 * to the fragment.
1615 *
1616 * The result obviously should not be URL-escaped, but does need to be
1617 * HTML-escaped if it's being output in HTML.
1618 *
1619 * See getLocalURL for the arguments.
1620 *
1621 * @param $query
1622 * @param $query2 bool
1623 * @param $proto Protocol to use; setting this will cause a full URL to be used
1624 * @see self::getLocalURL
1625 * @return String the URL
1626 */
1635 }
1638 }
1640 /**
1641 * Get an HTML-escaped version of the URL form, suitable for
1642 * using in a link, without a server name or fragment
1643 *
1644 * See getLocalURL for the arguments.
1645 *
1646 * @see self::getLocalURL
1647 * @param $query string
1648 * @param $query2 bool|string
1649 * @return String the URL
1650 * @deprecated since 1.19
1651 */
1655 }
1657 /**
1658 * Get an HTML-escaped version of the URL form, suitable for
1659 * using in a link, including the server name and fragment
1660 *
1661 * See getLocalURL for the arguments.
1662 *
1663 * @see self::getLocalURL
1664 * @return String the URL
1665 * @deprecated since 1.19
1666 */
1670 }
1672 /**
1673 * Get the URL form for an internal link.
1674 * - Used in various Squid-related code, in case we have a different
1675 * internal hostname for the server from the exposed one.
1676 *
1677 * This uses $wgInternalServer to qualify the path, or $wgServer
1678 * if $wgInternalServer is not set. If the server variable used is
1679 * protocol-relative, the URL will be expanded to http://
1680 *
1681 * See getLocalURL for the arguments.
1682 *
1683 * @see self::getLocalURL
1684 * @return String the URL
1685 */
1693 }
1695 /**
1696 * Get the URL for a canonical link, for use in things like IRC and
1697 * e-mail notifications. Uses $wgCanonicalServer and the
1698 * GetCanonicalURL hook.
1699 *
1700 * NOTE: Unlike getInternalURL(), the canonical URL includes the fragment
1701 *
1702 * See getLocalURL for the arguments.
1703 *
1704 * @see self::getLocalURL
1705 * @return string The URL
1706 * @since 1.18
1707 */
1710 $url = wfExpandUrl( $this->getLocalURL( $query ) . $this->getFragmentForURL(), PROTO_CANONICAL );
1713 }
1715 /**
1716 * HTML-escaped version of getCanonicalURL()
1717 *
1718 * See getLocalURL for the arguments.
1719 *
1720 * @see self::getLocalURL
1721 * @since 1.18
1722 * @return string
1723 * @deprecated since 1.19
1724 */
1728 }
1730 /**
1731 * Get the edit URL for this Title
1732 *
1733 * @return String the URL, or a null string if this is an
1734 * interwiki link
1735 */
1739 }
1743 }
1745 /**
1746 * Is $wgUser watching this page?
1747 *
1748 * @deprecated in 1.20; use User::isWatched() instead.
1749 * @return Bool
1750 */
1759 }
1760 }
1762 }
1764 /**
1765 * Can $wgUser read this page?
1766 *
1767 * @deprecated in 1.19; use userCan(), quickUserCan() or getUserPermissionsErrors() instead
1768 * @return Bool
1769 * @todo fold these checks into userCan()
1770 */
1774 }
1776 /**
1777 * Can $user perform $action on this page?
1778 * This skips potentially expensive cascading permission checks
1779 * as well as avoids expensive error formatting
1780 *
1781 * Suitable for use for nonessential UI controls in common cases, but
1782 * _not_ for functional access control.
1783 *
1784 * May provide false positives, but should never provide a false negative.
1785 *
1786 * @param string $action action that permission needs to be checked for
1787 * @param $user User to check (since 1.19); $wgUser will be used if not
1788 * provided.
1789 * @return Bool
1790 */
1793 }
1795 /**
1796 * Can $user perform $action on this page?
1797 *
1798 * @param string $action action that permission needs to be checked for
1799 * @param $user User to check (since 1.19); $wgUser will be used if not
1800 * provided.
1801 * @param bool $doExpensiveQueries Set this to false to avoid doing
1802 * unnecessary queries.
1803 * @return Bool
1804 */
1809 }
1810 return !count( $this->getUserPermissionsErrorsInternal( $action, $user, $doExpensiveQueries, true ) );
1811 }
1813 /**
1814 * Can $user perform $action on this page?
1815 *
1816 * @todo FIXME: This *does not* check throttles (User::pingLimiter()).
1817 *
1818 * @param string $action action that permission needs to be checked for
1819 * @param $user User to check
1820 * @param bool $doExpensiveQueries Set this to false to avoid doing unnecessary
1821 * queries by skipping checks for cascading protections and user blocks.
1822 * @param array $ignoreErrors of Strings Set this to a list of message keys
1823 * whose corresponding errors may be ignored.
1824 * @return Array of arguments to wfMessage to explain permissions problems.
1825 */
1826 public function getUserPermissionsErrors( $action, $user, $doExpensiveQueries = true, $ignoreErrors = array() ) {
1829 // Remove the errors being ignored.
1835 }
1836 }
1839 }
1841 /**
1842 * Permissions checks that fail most often, and which are easiest to test.
1843 *
1844 * @param string $action the action to check
1845 * @param $user User user to check
1846 * @param array $errors list of current errors
1847 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1848 * @param $short Boolean short circuit on first error
1849 *
1850 * @return Array list of errors
1851 */
1852 private function checkQuickPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1853 if ( !wfRunHooks( 'TitleQuickPermissions', array( $this, $user, $action, &$errors, $doExpensiveQueries, $short ) ) ) {
1855 }
1861 ) {
1863 }
1867 // Show user page-specific message only if the user can move other pages
1869 }
1871 // Check if user is allowed to move files if it's a file
1874 }
1877 // User can't move anything
1881 // custom message if logged-in users without any special rights can move
1885 }
1886 }
1889 // User can't move anything
1893 // Show user page-specific message only if the user can move other pages
1895 }
1898 }
1901 }
1903 /**
1904 * Add the resulting error code to the errors array
1905 *
1906 * @param array $errors list of current errors
1907 * @param $result Mixed result of errors
1908 *
1909 * @return Array list of errors
1910 */
1913 // A single array representing an error
1916 // A nested array representing multiple errors
1919 // A string representing a message-id
1922 // a generic "We don't want them to do that"
1924 }
1926 }
1928 /**
1929 * Check various permission hooks
1930 *
1931 * @param string $action the action to check
1932 * @param $user User user to check
1933 * @param array $errors list of current errors
1934 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1935 * @param $short Boolean short circuit on first error
1936 *
1937 * @return Array list of errors
1938 */
1939 private function checkPermissionHooks( $action, $user, $errors, $doExpensiveQueries, $short ) {
1940 // Use getUserPermissionsErrors instead
1944 }
1945 // Check getUserPermissionsErrors hook
1948 }
1949 // Check getUserPermissionsErrorsExpensive hook
1951 $doExpensiveQueries
1953 && !wfRunHooks( 'getUserPermissionsErrorsExpensive', array( &$this, &$user, $action, &$result ) )
1954 ) {
1956 }
1959 }
1961 /**
1962 * Check permissions on special pages & namespaces
1963 *
1964 * @param string $action the action to check
1965 * @param $user User user to check
1966 * @param array $errors list of current errors
1967 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1968 * @param $short Boolean short circuit on first error
1969 *
1970 * @return Array list of errors
1971 */
1972 private function checkSpecialsAndNSPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1973 # Only 'createaccount' can be performed on special pages,
1974 # which don't actually exist in the DB.
1977 }
1979 # Check $wgNamespaceProtection for restricted namespaces
1985 }
1988 }
1990 /**
1991 * Check CSS/JS sub-page permissions
1992 *
1993 * @param string $action the action to check
1994 * @param $user User user to check
1995 * @param array $errors list of current errors
1996 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1997 * @param $short Boolean short circuit on first error
1998 *
1999 * @return Array list of errors
2000 */
2001 private function checkCSSandJSPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2002 # Protect css/js subpages of user pages
2003 # XXX: this might be better using restrictions
2004 # XXX: right 'editusercssjs' is deprecated, for backward compatibility only
2011 }
2017 }
2018 }
2019 }
2022 }
2024 /**
2025 * Check against page_restrictions table requirements on this
2026 * page. The user must possess all required rights for this
2027 * action.
2028 *
2029 * @param string $action the action to check
2030 * @param $user User user to check
2031 * @param array $errors list of current errors
2032 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2033 * @param $short Boolean short circuit on first error
2034 *
2035 * @return Array list of errors
2036 */
2037 private function checkPageRestrictions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2039 // Backwards compatibility, rewrite sysop -> editprotected
2042 }
2043 // Backwards compatibility, rewrite autoconfirmed -> editsemiprotected
2046 }
2049 }
2054 }
2055 }
2058 }
2060 /**
2061 * Check restrictions on cascading pages.
2062 *
2063 * @param string $action the action to check
2064 * @param $user User to check
2065 * @param array $errors list of current errors
2066 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2067 * @param $short Boolean short circuit on first error
2068 *
2069 * @return Array list of errors
2070 */
2071 private function checkCascadingSourcesRestrictions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2073 # We /could/ use the protection level on the source page, but it's
2074 # fairly ugly as we have to establish a precedence hierarchy for pages
2075 # included by multiple cascade-protected pages. So just restrict
2076 # it to people with 'protect' permission, as they could remove the
2077 # protection anyway.
2079 # Cascading protection depends on more than this page...
2080 # Several cascading protected pages may include this page...
2081 # Check each cascading level
2082 # This is only for protection restrictions, not for all actions
2085 // Backwards compatibility, rewrite sysop -> editprotected
2088 }
2089 // Backwards compatibility, rewrite autoconfirmed -> editsemiprotected
2092 }
2097 }
2099 }
2100 }
2101 }
2102 }
2105 }
2107 /**
2108 * Check action permissions not already checked in checkQuickPermissions
2109 *
2110 * @param string $action the action to check
2111 * @param $user User to check
2112 * @param array $errors list of current errors
2113 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2114 * @param $short Boolean short circuit on first error
2115 *
2116 * @return Array list of errors
2117 */
2118 private function checkActionPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2122 if ( count( $this->getUserPermissionsErrorsInternal( 'edit', $user, $doExpensiveQueries, true ) ) ) {
2123 // If they can't edit, they shouldn't protect.
2125 }
2131 }
2134 }
2137 ) {
2138 $errors[] = array( 'titleprotected', User::whoIs( $title_protection['pt_user'] ), $title_protection['pt_reason'] );
2139 }
2140 }
2142 // Check for immobile pages
2144 // Specific message for this case
2147 // Less specific message for rarer cases
2149 }
2155 }
2159 ) {
2161 }
2162 }
2164 }
2166 /**
2167 * Check that the user isn't blocked from editing.
2168 *
2169 * @param string $action the action to check
2170 * @param $user User to check
2171 * @param array $errors list of current errors
2172 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2173 * @param $short Boolean short circuit on first error
2174 *
2175 * @return Array list of errors
2176 */
2178 // Account creation blocks handled at userlogin.
2179 // Unblocking handled in SpecialUnblock
2182 }
2188 }
2191 // Don't block the user from editing their own talk page unless they've been
2192 // explicitly blocked from that too.
2194 // @todo FIXME: Pass the relevant context into this function.
2196 }
2199 }
2201 /**
2202 * Check that the user is allowed to read this page.
2203 *
2204 * @param string $action the action to check
2205 * @param $user User to check
2206 * @param array $errors list of current errors
2207 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
2208 * @param $short Boolean short circuit on first error
2209 *
2210 * @return Array list of errors
2211 */
2212 private function checkReadPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
2217 # Shortcut for public wikis, allows skipping quite a bit of code
2220 # If the user is allowed to read pages, he is allowed to read all pages
2225 ) {
2226 # Always grant access to the login page.
2227 # Even anons need to be able to log in.
2230 # Time to check the whitelist
2231 # Only do these checks is there's something to check against
2235 // Check for explicit whitelisting with and without underscores
2236 if ( in_array( $name, $wgWhitelistRead, true ) || in_array( $dbName, $wgWhitelistRead, true ) ) {
2239 # Old settings might have the title prefixed with
2240 # a colon for main-namespace pages
2243 }
2245 # If it's a special page, ditch the subpage bit and check again
2252 }
2253 }
2254 }
2255 }
2257 if ( !$whitelisted && is_array( $wgWhitelistReadRegexp ) && !empty( $wgWhitelistReadRegexp ) ) {
2259 // Check for regex whitelisting
2264 }
2265 }
2266 }
2269 # If the title is not whitelisted, give extensions a chance to do so...
2273 }
2274 }
2277 }
2279 /**
2280 * Get a description array when the user doesn't have the right to perform
2281 * $action (i.e. when User::isAllowed() returns false)
2282 *
2283 * @param string $action the action to check
2284 * @param $short Boolean short circuit on first error
2285 * @return Array list of errors
2286 */
2288 // We avoid expensive display logic for quickUserCan's and such
2291 }
2302 );
2305 }
2306 }
2308 /**
2309 * Can $user perform $action on this page? This is an internal function,
2310 * which checks ONLY that previously checked by userCan (i.e. it leaves out
2311 * checks on wfReadOnly() and blocks)
2312 *
2313 * @param string $action action that permission needs to be checked for
2314 * @param $user User to check
2315 * @param bool $doExpensiveQueries Set this to false to avoid doing unnecessary queries.
2316 * @param bool $short Set this to true to stop after the first permission error.
2317 * @return Array of arrays of the arguments to wfMessage to explain permissions problems.
2318 */
2319 protected function getUserPermissionsErrorsInternal( $action, $user, $doExpensiveQueries = true, $short = false ) {
2322 # Read has special handling
2327 );
2337 'checkUserBlock'
2338 );
2339 }
2346 }
2350 }
2352 /**
2353 * Get a filtered list of all restriction types supported by this wiki.
2354 * @param bool $exists True to get all restriction types that apply to
2355 * titles that do exist, False for all restriction types that apply to
2356 * titles that do not exist
2357 * @return array
2358 */
2363 # Remove the create restriction for existing titles
2366 # Only the create and upload restrictions apply to non-existing titles
2368 }
2370 }
2372 /**
2373 * Returns restriction types for the current Title
2374 *
2375 * @return array applicable restriction types
2376 */
2380 }
2385 # Remove the upload restriction for non-file titles
2387 }
2395 }
2397 /**
2398 * Is this title subject to title protection?
2399 * Title protection is the one applied against creation of such title.
2400 *
2401 * @return Mixed An associative array representing any existent title
2402 * protection, or false if there's none.
2403 */
2405 // Can't protect pages in special namespaces
2408 }
2410 // Can't protect pages that exist.
2413 }
2421 __METHOD__
2422 );
2424 // fetchRow returns false if there are no rows.
2426 }
2428 }
2430 /**
2431 * Update the title protection status
2432 *
2433 * @deprecated in 1.19; use WikiPage::doUpdateRestrictions() instead.
2434 * @param $create_perm String Permission required for creation
2435 * @param string $reason Reason for protection
2436 * @param string $expiry Expiry timestamp
2437 * @return boolean true
2438 */
2452 }
2454 /**
2455 * Remove any title protection due to page existing
2456 */
2463 __METHOD__
2464 );
2466 }
2468 /**
2469 * Is this page "semi-protected" - the *only* protection levels are listed
2470 * in $wgSemiprotectedRestrictionLevels?
2471 *
2472 * @param string $action Action to check (default: edit)
2473 * @return Bool
2474 */
2481 // Not protected, or all protection is full protection
2483 }
2485 // Remap autoconfirmed to editsemiprotected for BC
2488 }
2491 }
2494 }
2496 /**
2497 * Does the title correspond to a protected article?
2498 *
2499 * @param string $action the action the page is protected from,
2500 * by default checks all actions.
2501 * @return Bool
2502 */
2508 # Special pages have inherent protection
2511 }
2513 # Check regular protection levels
2520 }
2521 }
2522 }
2523 }
2526 }
2528 /**
2529 * Determines if $user is unable to edit this page because it has been protected
2530 * by $wgNamespaceProtection.
2531 *
2532 * @param $user User object to check permissions
2533 * @return Bool
2534 */
2542 }
2543 }
2544 }
2546 }
2548 /**
2549 * Cascading protection: Return true if cascading restrictions apply to this page, false if not.
2550 *
2551 * @return Bool If the page is subject to cascading restrictions.
2552 */
2556 }
2558 /**
2559 * Cascading protection: Get the source of any cascading restrictions on this page.
2560 *
2561 * @param bool $getPages Whether or not to retrieve the actual pages
2562 * that the restrictions have come from.
2563 * @return Mixed Array of Title objects of the pages from which cascading restrictions
2564 * have come, false for none, or true if such restrictions exist, but $getPages
2565 * was not set. The restriction array is an array of each type, each of which
2566 * contains a array of unique groups.
2567 */
2576 }
2588 );
2596 );
2597 }
2606 }
2622 # Add groups needed for each restriction type if its not already there
2623 # Make sure this restriction type still exists
2627 }
2632 ) {
2634 }
2637 }
2639 // Trigger lazy purge of expired restrictions from the db
2641 }
2642 }
2645 }
2652 }
2656 }
2658 /**
2659 * Accessor/initialisation for mRestrictions
2660 *
2661 * @param string $action action that permission needs to be checked for
2662 * @return Array of Strings the array of groups allowed to edit this article
2663 */
2667 }
2671 }
2673 /**
2674 * Get the expiry time for the restriction against a given action
2675 *
2676 * @param $action
2677 * @return String|Bool 14-char timestamp, or 'infinity' if the page is protected forever
2678 * or not protected at all, or false if the action is not recognised.
2679 */
2683 }
2684 return isset( $this->mRestrictionsExpiry[$action] ) ? $this->mRestrictionsExpiry[$action] : false;
2685 }
2687 /**
2688 * Returns cascading restrictions for the current article
2689 *
2690 * @return Boolean
2691 */
2695 }
2698 }
2700 /**
2701 * Loads a string into mRestrictions array
2702 *
2703 * @param $res Resource restrictions as an SQL result.
2704 * @param string $oldFashionedRestrictions comma-separated list of page
2705 * restrictions from page table (pre 1.10)
2706 */
2712 }
2715 }
2717 /**
2718 * Compiles list of active page restrictions from both page table (pre 1.10)
2719 * and page_restrictions table for this existing page.
2720 * Public for usage by LiquidThreads.
2721 *
2722 * @param array $rows of db result objects
2723 * @param string $oldFashionedRestrictions comma-separated list of page
2724 * restrictions from page table (pre 1.10)
2725 */
2735 }
2739 # Backwards-compatibility: also load the restrictions from the page record (old format).
2744 }
2751 // old old format should be treated as edit/move restriction
2758 }
2759 }
2760 }
2764 }
2767 # Current system - load second to make them override.
2771 # Cycle through all the restrictions.
2774 // Don't take care of restrictions types that aren't allowed
2777 }
2779 // This code should be refactored, now that it's being used more generally,
2780 // But I don't really see any harm in leaving it in Block for now -werdna
2783 // Only apply the restrictions if they haven't expired!
2790 // Trigger a lazy purge of expired restrictions
2792 }
2793 }
2797 }
2798 }
2801 }
2803 /**
2804 * Load restrictions from the page_restrictions table
2805 *
2806 * @param string $oldFashionedRestrictions comma-separated list of page
2807 * restrictions from page table (pre 1.10)
2808 */
2819 __METHOD__
2820 );
2831 // Apply the restrictions
2837 }
2840 }
2842 }
2843 }
2844 }
2846 /**
2847 * Flush the protection cache in this object and force reload from the database.
2848 * This is used when updating protection from WikiPage::doUpdateRestrictions().
2849 */
2853 }
2855 /**
2856 * Purge expired restrictions from the page_restrictions table
2857 */
2861 }
2869 $method
2870 );
2874 $method
2875 );
2876 } );
2877 }
2879 /**
2880 * Does this have subpages? (Warning, usually requires an extra DB query.)
2881 *
2882 * @return Bool
2883 */
2886 # Duh
2888 }
2890 # We dynamically add a member variable for the purpose of this method
2891 # alone to cache the result. There's no point in having it hanging
2892 # around uninitialized in every Title object; therefore we only add it
2893 # if needed and don't declare it statically.
2899 }
2900 }
2903 }
2905 /**
2906 * Get all subpages of this page.
2907 *
2908 * @param int $limit maximum number of subpages to fetch; -1 for no limit
2909 * @return mixed TitleArray, or empty array if this page's namespace
2910 * doesn't allow subpages
2911 */
2915 }
2923 }
2928 __METHOD__,
2929 $options
2930 )
2931 );
2933 }
2935 /**
2936 * Is there a version of this page in the deletion archive?
2937 *
2938 * @return Int the number of archived revisions
2939 */
2948 __METHOD__
2949 );
2953 __METHOD__
2954 );
2955 }
2956 }
2958 }
2960 /**
2961 * Is there a version of this page in the deletion archive?
2962 *
2963 * @return Boolean
2964 */
2968 }
2972 __METHOD__
2973 );
2977 __METHOD__
2978 );
2979 }
2981 }
2983 /**
2984 * Get the article ID for this Title from the link cache,
2985 * adding it if necessary
2986 *
2987 * @param int $flags a bit field; may be Title::GAID_FOR_UPDATE to select
2988 * for update
2989 * @return Int the ID
2990 */
2995 }
3005 }
3006 }
3008 }
3010 /**
3011 * Is this an article that is a redirect page?
3012 * Uses link cache, adding it if necessary
3013 *
3014 * @param int $flags a bit field; may be Title::GAID_FOR_UPDATE to select for update
3015 * @return Bool
3016 */
3020 }
3021 # Calling getArticleID() loads the field from cache as needed
3025 }
3030 # Trust LinkCache's state over our own
3031 # LinkCache is telling us that the page doesn't exist, despite there being cached
3032 # data relating to an existing page in $this->mArticleID. Updaters should clear
3033 # LinkCache as appropriate, or use $flags = Title::GAID_FOR_UPDATE. If that flag is
3034 # set, then LinkCache will definitely be up to date here, since getArticleID() forces
3035 # LinkCache to refresh its data from the master.
3038 }
3043 }
3045 /**
3046 * What is the length of this page?
3047 * Uses link cache, adding it if necessary
3048 *
3049 * @param int $flags a bit field; may be Title::GAID_FOR_UPDATE to select for update
3050 * @return Int
3051 */
3055 }
3056 # Calling getArticleID() loads the field from cache as needed
3060 }
3064 # Trust LinkCache's state over our own, as for isRedirect()
3067 }
3072 }
3074 /**
3075 * What is the page_latest field for this page?
3076 *
3077 * @param int $flags a bit field; may be Title::GAID_FOR_UPDATE to select for update
3078 * @return Int or 0 if the page doesn't exist
3079 */
3083 }
3084 # Calling getArticleID() loads the field from cache as needed
3088 }
3093 # Trust LinkCache's state over our own, as for isRedirect()
3096 }
3101 }
3103 /**
3104 * This clears some fields in this object, and clears any associated
3105 * keys in the "bad links" section of the link cache.
3106 *
3107 * - This is called from WikiPage::doEdit() and WikiPage::insertOn() to allow
3108 * loading of the new page_id. It's also called from
3109 * WikiPage::doDeleteArticleReal()
3110 *
3111 * @param int $newid the new Article ID
3112 */
3121 }
3130 }
3132 /**
3133 * Capitalize a text string for a title if it belongs to a namespace that capitalizes
3134 *
3135 * @param string $text containing title to capitalize
3136 * @param int $ns namespace index, defaults to NS_MAIN
3137 * @return String containing capitalized title
3138 */
3146 }
3147 }
3149 /**
3150 * Secure and split - main initialisation function for this object
3151 *
3152 * Assumes that mDbkeyform has been set, and is urldecoded
3153 * and uses underscores, but not otherwise munged. This function
3154 * removes illegal characters, splits off the interwiki and
3155 * namespace prefixes, sets the other forms, and canonicalizes
3156 * everything.
3157 *
3158 * @return Bool true on success
3159 */
3163 # Initialisation
3169 # Strip Unicode bidi override characters.
3170 # Sometimes they slip into cut-n-pasted page titles, where the
3171 # override chars get included in list displays.
3174 # Clean up whitespace
3175 # Note: use of the /u option on preg_replace here will cause
3176 # input with invalid UTF-8 sequences to be nullified out in PHP 5.2.x,
3177 # conveniently disabling them.
3178 $dbkey = preg_replace( '/[ _\xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}]+/u', '_', $dbkey );
3182 # Contained illegal UTF-8 sequences or forbidden Unicode chars.
3184 }
3188 # Initial colon indicates main namespace rather than specified default
3189 # but should not create invalid {ns,title} pairs such as {0,Project:Foo}
3194 }
3198 }
3200 # Namespace or interwiki prefix
3208 # Ordinary namespace
3211 # For Talk:X pages, check if X has a "namespace" prefix
3214 # Disallow Talk:File:x type titles...
3217 # Disallow Talk:Interwiki:x type titles...
3219 }
3220 }
3223 # Can't make a local interwiki link to an interwiki link.
3224 # That's just crazy!
3226 }
3228 # Interwiki link
3232 # Redundant interwiki prefix to the local wiki
3235 ) {
3237 # Can't have an empty self-link
3239 }
3242 # Do another namespace split...
3244 }
3246 # If there's an initial colon after the interwiki, that also
3247 # resets the default namespace
3251 }
3252 }
3253 # If there's no recognized interwiki or namespace,
3254 # then let the colon expression be part of the title.
3255 }
3259 # We already know that some pages won't be in the database!
3262 }
3267 # remove whitespace again: prevents "Foo_bar_#"
3268 # becoming "Foo_bar_"
3270 }
3272 # Reject illegal characters.
3276 }
3278 # Pages with "/./" or "/../" appearing in the URLs will often be un-
3279 # reachable due to the way web browsers deal with 'relative' URLs.
3280 # Also, they conflict with subpage syntax. Forbid them explicitly.
3283 (
3291 )
3292 ) {
3294 }
3296 # Magic tilde sequences? Nu-uh!
3299 }
3301 # Limit the size of titles to 255 bytes. This is typically the size of the
3302 # underlying database field. We make an exception for special pages, which
3303 # don't need to be stored in the database, and may edge over 255 bytes due
3304 # to subpage syntax for long titles, e.g. [[Special:Block/Long name]]
3308 ) {
3310 }
3312 # Normally, all wiki links are forced to have an initial capital letter so [[foo]]
3313 # and [[Foo]] point to the same place. Don't force it for interwikis, since the
3314 # other site might be case-sensitive.
3318 }
3320 # Can't make a link to a namespace alone... "empty" local links can only be
3321 # self-links with a fragment identifier.
3324 }
3326 // Allow IPv6 usernames to start with '::' by canonicalizing IPv6 titles.
3327 // IP names are not allowed for accounts, and can only be referring to
3328 // edits from the IP. Given '::' abbreviations and caps/lowercaps,
3329 // there are numerous ways to present the same IP. Having sp:contribs scan
3330 // them all is silly and having some show the edits and others not is
3331 // inconsistent. Same for talk/userpages. Keep them normalized instead.
3336 // Any remaining initial :s are illegal.
3339 }
3341 # Fill fields
3348 }
3350 /**
3351 * Get an array of Title objects linking to this Title
3352 * Also stores the IDs in the link cache.
3353 *
3354 * WARNING: do not use this function on arbitrary user-supplied titles!
3355 * On heavily-used templates it will max out the memory.
3356 *
3357 * @param array $options may be FOR UPDATE
3358 * @param string $table table name
3359 * @param string $prefix fields prefix
3360 * @return Array of Title objects linking here
3361 */
3367 }
3376 __METHOD__,
3377 $options
3378 );
3388 }
3389 }
3390 }
3392 }
3394 /**
3395 * Get an array of Title objects using this Title as a template
3396 * Also stores the IDs in the link cache.
3397 *
3398 * WARNING: do not use this function on arbitrary user-supplied titles!
3399 * On heavily-used templates it will max out the memory.
3400 *
3401 * @param array $options may be FOR UPDATE
3402 * @return Array of Title the Title objects linking here
3403 */
3406 }
3408 /**
3409 * Get an array of Title objects linked from this Title
3410 * Also stores the IDs in the link cache.
3411 *
3412 * WARNING: do not use this function on arbitrary user-supplied titles!
3413 * On heavily-used templates it will max out the memory.
3414 *
3415 * @param array $options may be FOR UPDATE
3416 * @param string $table table name
3417 * @param string $prefix fields prefix
3418 * @return Array of Title objects linking here
3419 */
3425 # If the page doesn't exist; there can't be any link from this page
3428 }
3434 }
3439 $fields = array( $namespaceFiled, $titleField, 'page_id', 'page_len', 'page_is_redirect', 'page_latest' );
3442 }
3448 __METHOD__,
3450 array( 'page' => array( 'LEFT JOIN', array( "page_namespace=$namespaceFiled", "page_title=$titleField" ) ) )
3451 );
3463 }
3465 }
3466 }
3467 }
3469 }
3471 /**
3472 * Get an array of Title objects used on this Title as a template
3473 * Also stores the IDs in the link cache.
3474 *
3475 * WARNING: do not use this function on arbitrary user-supplied titles!
3476 * On heavily-used templates it will max out the memory.
3477 *
3478 * @param array $options may be FOR UPDATE
3479 * @return Array of Title the Title objects used here
3480 */
3483 }
3485 /**
3486 * Get an array of Title objects referring to non-existent articles linked from this page
3487 *
3488 * @todo check if needed (used only in SpecialBrokenRedirects.php, and should use redirect table in this case)
3489 * @return Array of Title the Title objects
3490 */
3493 # All links from article ID 0 are false positives
3495 }
3503 'page_namespace IS NULL'
3504 ),
3510 )
3511 )
3512 );
3517 }
3519 }
3521 /**
3522 * Get a list of URLs to purge from the Squid cache when this
3523 * page changes
3524 *
3525 * @return Array of String the URLs
3526 */
3531 );
3538 }
3539 }
3541 // If we are looking at a css/js user subpage, purge the action=raw.
3546 }
3550 }
3552 /**
3553 * Purge all applicable Squid URLs
3554 */
3561 }
3562 }
3564 /**
3565 * Move this page without authentication
3566 *
3567 * @param $nt Title the new page Title
3568 * @return Mixed true on success, getUserPermissionsErrors()-like array on failure
3569 */
3572 }
3574 /**
3575 * Check whether a given move operation would be valid.
3576 * Returns true if ok, or a getUserPermissionsErrors()-like array otherwise
3577 *
3578 * @param $nt Title the new title
3579 * @param bool $auth indicates whether $wgUser's permissions
3580 * should be checked
3581 * @param string $reason is the log summary of the move, used for spam checking
3582 * @return Mixed True on success, getUserPermissionsErrors()-like array on failure
3583 */
3589 // Normally we'd add this to $errors, but we'll get
3590 // lots of syntax errors if $nt is not an object
3592 }
3595 }
3598 }
3601 }
3604 }
3611 }
3616 ) {
3618 }
3620 // Content model checks
3623 // can't move a page if that would change the page's content model
3628 );
3629 }
3631 // Image-specific checks
3634 }
3638 }
3646 }
3650 // This is kind of lame, won't display nice
3652 }
3657 }
3659 # The move is allowed only if (1) the target doesn't exist, or
3660 # (2) the target is a redirect to the source, and has no history
3661 # (so we can undo bad moves right after they're done).
3666 }
3672 }
3675 }
3678 }
3679 }
3682 }
3684 }
3686 /**
3687 * Check if the requested move target is a valid file move target
3688 * @param Title $nt Target title
3689 * @return array List of errors
3690 */
3696 // wfFindFile( $nt ) / wfLocalFile( $nt ) is not allowed until below
3702 }
3705 }
3706 }
3710 // From here we want to do checks on a file object, so if we can't
3711 // create one, we must return.
3713 }
3715 // wfFindFile( $nt ) / wfLocalFile( $nt ) is allowed below here
3720 }
3723 }
3725 /**
3726 * Move a title to a new location
3727 *
3728 * @param $nt Title the new title
3729 * @param bool $auth indicates whether $wgUser's permissions
3730 * should be checked
3731 * @param string $reason the reason for the move
3732 * @param bool $createRedirect Whether to create a redirect from the old title to the new title.
3733 * Ignored if the user doesn't have the suppressredirect right.
3734 * @return Mixed true on success, getUserPermissionsErrors()-like array on failure
3735 */
3740 // Auto-block user's IP if the account was "hard" blocked
3743 }
3744 // Check suppressredirect permission
3747 }
3751 // If it is a file, move it first.
3752 // It is done before all other moving stuff is done because it's hard to revert.
3760 }
3761 }
3762 // Clear RepoGroup process cache
3765 }
3767 $dbw->begin( __METHOD__ ); # If $file was a LocalFile, its transaction would have closed our own.
3771 // Do the actual move
3774 // Refresh the sortkey for this row. Be careful to avoid resetting
3775 // cl_timestamp, which may disturb time-based lists on some sites.
3780 __METHOD__
3781 );
3793 __METHOD__
3794 );
3795 }
3800 # Protect the redirect title as the title used to be...
3809 ),
3811 __METHOD__,
3813 );
3814 # Update the protection log
3823 }
3824 // @todo FIXME: $params?
3826 }
3828 # Update watchlists
3836 }
3842 }
3844 /**
3845 * Move page to a title which is either a redirect to the
3846 * source page or nonexistent
3847 *
3848 * @param $nt Title the page to move to, which should be a redirect or nonexistent
3849 * @param string $reason The reason for the move
3850 * @param bool $createRedirect Whether to leave a redirect at the old title. Does not check
3851 * if the user has the suppressredirect right
3852 * @throws MWException
3853 */
3863 }
3870 // NOTE: If this page's content model does not support redirects, $redirectContent will be null.
3873 }
3882 ) );
3889 }
3890 # Truncate for whole multibyte characters.
3903 # Delete the old redirect. We don't save it to history since
3904 # by definition if we've got here it's rather uninteresting.
3905 # We have to remove it so that the next step doesn't trigger
3906 # a conflict on the unique namespace+title index...
3910 }
3912 # Save a null revision in the page's history notifying of the move
3916 }
3920 # Change the name of the target page:
3925 ),
3927 __METHOD__
3928 );
3930 // clean up the old title before reset article id - bug 45348
3933 }
3948 }
3950 # Recreate the redirect, this time in the other direction.
3969 }
3970 }
3972 # Log the move
3975 }
3977 /**
3978 * Move this page's subpages to be subpages of $nt
3979 *
3980 * @param $nt Title Move target
3981 * @param bool $auth Whether $wgUser's permissions should be checked
3982 * @param string $reason The reason for the move
3983 * @param bool $createRedirect Whether to create redirects from the old subpages to
3984 * the new ones Ignored if the user doesn't have the 'suppressredirect' right
3985 * @return mixed array with old page titles as keys, and strings (new page titles) or
3986 * arrays (errors) as values, or an error array with numeric indices if no pages
3987 * were moved
3988 */
3991 // Check permissions
3994 }
3995 // Do the source and target namespaces support subpages?
3999 }
4003 }
4015 }
4017 // We don't know whether this function was called before
4018 // or after moving the root page, so check both
4019 // $this and $nt
4022 ) {
4023 // When moving a page to a subpage of itself,
4024 // don't move it twice
4026 }
4035 }
4036 # Bug 14385: we need makeTitleSafe because the new page names may
4037 # be longer than 255 characters.
4045 }
4046 }
4048 }
4050 /**
4051 * Checks if this page is just a one-rev redirect.
4052 * Adds lock, so don't use just for light purposes.
4053 *
4054 * @return Bool
4055 */
4061 # Is it a redirect?
4065 }
4070 __METHOD__,
4072 );
4073 # Cache some fields we may want
4077 $this->mContentModel = $row && isset( $row->page_content_model ) ? strval( $row->page_content_model ) : false;
4080 }
4081 # Does the article have a history?
4087 'page_latest != rev_id'
4088 ),
4089 __METHOD__,
4091 );
4092 # Return true if there was no history
4094 }
4096 /**
4097 * Checks if $this can be moved to a given Title
4098 * - Selects for update, so don't call it unless you mean business
4099 *
4100 * @param $nt Title the new title to check
4101 * @return Bool
4102 */
4104 # Is it an existing file?
4110 }
4111 }
4112 # Is it a redirect with no history?
4116 }
4117 # Get the article text
4121 }
4123 # Does the redirect point to the source?
4124 # Or is it a broken self-redirect, usually caused by namespace collisions?
4134 }
4136 # Fail safe (not a redirect after all. strange.)
4140 }
4141 }
4143 /**
4144 * Get categories to which this Title belongs and return an array of
4145 * categories' names.
4146 *
4147 * @return Array of parents in the form:
4148 * $parent => $currentarticle
4149 */
4159 }
4167 __METHOD__
4168 );
4172 // $data[] = Title::newFromText($wgContLang->getNsText ( NS_CATEGORY ).':'.$row->cl_to);
4174 }
4175 }
4177 }
4179 /**
4180 * Get a tree of parent categories
4181 *
4182 * @param array $children with the children in the keys, to check for circular refs
4183 * @return Array Tree of parent categories
4184 */
4192 # Circular reference
4198 }
4199 }
4200 }
4201 }
4204 }
4206 /**
4207 * Get an associative array for selecting this title from
4208 * the "page" table
4209 *
4210 * @return Array suitable for the $where parameter of DB::select()
4211 */
4214 // PK avoids secondary lookups in InnoDB, shouldn't hurt other DBs
4218 }
4219 }
4221 /**
4222 * Get the revision ID of the previous revision
4223 *
4224 * @param int $revId Revision ID. Get the revision that was before this one.
4225 * @param int $flags Title::GAID_FOR_UPDATE
4226 * @return Int|Bool Old revision ID, or FALSE if none exists
4227 */
4234 ),
4235 __METHOD__,
4237 );
4243 }
4244 }
4246 /**
4247 * Get the revision ID of the next revision
4248 *
4249 * @param int $revId Revision ID. Get the revision that was after this one.
4250 * @param int $flags Title::GAID_FOR_UPDATE
4251 * @return Int|Bool Next revision ID, or FALSE if none exists
4252 */
4259 ),
4260 __METHOD__,
4262 );
4268 }
4269 }
4271 /**
4272 * Get the first revision of the page
4273 *
4274 * @param int $flags Title::GAID_FOR_UPDATE
4275 * @return Revision|Null if page doesn't exist
4276 */
4283 __METHOD__,
4285 );
4288 }
4289 }
4291 }
4293 /**
4294 * Get the oldest revision timestamp of this page
4295 *
4296 * @param int $flags Title::GAID_FOR_UPDATE
4297 * @return String: MW timestamp
4298 */
4302 }
4304 /**
4305 * Check if this is a new page
4306 *
4307 * @return bool
4308 */
4312 }
4314 /**
4315 * Check whether the number of revisions of this page surpasses $wgDeleteRevisionsLimit
4316 *
4317 * @return bool
4318 */
4324 }
4328 }
4330 /**
4331 * Get the approximate revision count of this page.
4332 *
4333 * @return int
4334 */
4338 }
4344 }
4347 }
4349 /**
4350 * Get the number of revisions between the given revision.
4351 * Used for diffs and other things that really need it.
4352 *
4353 * @param int|Revision $old Old revision or rev ID (first before range)
4354 * @param int|Revision $new New revision or rev ID (first after range)
4355 * @return Int Number of revisions between these revisions.
4356 */
4360 }
4363 }
4366 }
4373 ),
4374 __METHOD__
4375 );
4376 }
4378 /**
4379 * Get the number of authors between the given revisions or revision IDs.
4380 * Used for diffs and other things that really need it.
4381 *
4382 * @param int|Revision $old Old revision or rev ID (first before range by default)
4383 * @param int|Revision $new New revision or rev ID (first after range by default)
4384 * @param int $limit Maximum number of authors
4385 * @param string|array $options (Optional): Single option, or an array of options:
4386 * 'include_old' Include $old in the range; $new is excluded.
4387 * 'include_new' Include $new in the range; $old is excluded.
4388 * 'include_both' Include both $old and $new in the range.
4389 * Unknown option values are ignored.
4390 * @return int Number of revision authors in the range; zero if not both revisions exist
4391 */
4395 }
4398 }
4399 // XXX: what if Revision objects are passed in, but they don't refer to this title?
4400 // Add $old->getPage() != $new->getPage() || $old->getPage() != $this->getArticleID()
4401 // in the sanity check below?
4404 }
4410 }
4413 }
4417 }
4418 // No DB query needed if $old and $new are the same or successive revisions:
4424 }
4426 }
4435 );
4437 }
4439 /**
4440 * Compare with another title.
4441 *
4442 * @param $title Title
4443 * @return Bool
4444 */
4446 // Note: === is necessary for proper matching of number-like titles.
4450 }
4452 /**
4453 * Check if this title is a subpage of another title
4454 *
4455 * @param $title Title
4456 * @return Bool
4457 */
4462 }
4464 /**
4465 * Check if page exists. For historical reasons, this function simply
4466 * checks for the existence of the title in the page table, and will
4467 * thus return false for interwiki links, special pages and the like.
4468 * If you want to know if a title can be meaningfully viewed, you should
4469 * probably call the isKnown() method instead.
4470 *
4471 * @return Bool
4472 */
4475 }
4477 /**
4478 * Should links to this title be shown as potentially viewable (i.e. as
4479 * "bluelinks"), even if there's no record by this title in the page
4480 * table?
4481 *
4482 * This function is semi-deprecated for public use, as well as somewhat
4483 * misleadingly named. You probably just want to call isKnown(), which
4484 * calls this function internally.
4485 *
4486 * (ISSUE: Most of these checks are cheap, but the file existence check
4487 * can potentially be quite expensive. Including it here fixes a lot of
4488 * existing code, but we might want to add an optional parameter to skip
4489 * it and any other expensive checks.)
4490 *
4491 * @return Bool
4492 */
4496 /**
4497 * Allows overriding default behavior for determining if a page exists.
4498 * If $isKnown is kept as null, regular checks happen. If it's
4499 * a boolean, this value is returned by the isKnown method.
4500 *
4501 * @since 1.20
4502 *
4503 * @param Title $title
4504 * @param boolean|null $isKnown
4505 */
4510 }
4514 }
4519 // file exists, possibly in a foreign repo
4522 // valid special page
4525 // selflink, possibly with fragment
4528 // known system message
4532 }
4533 }
4535 /**
4536 * Does this title refer to a page that can (or might) be meaningfully
4537 * viewed? In particular, this function may be used to determine if
4538 * links to the title should be rendered as "bluelinks" (as opposed to
4539 * "redlinks" to non-existent pages).
4540 * Adding something else to this function will cause inconsistency
4541 * since LinkHolderArray calls isAlwaysKnown() and does its own
4542 * page existence check.
4543 *
4544 * @return Bool
4545 */
4548 }
4550 /**
4551 * Does this page have source text?
4552 *
4553 * @return Boolean
4554 */
4558 }
4561 // If the page doesn't exist but is a known system message, default
4562 // message content will be displayed, same for language subpages-
4563 // Use always content language to avoid loading hundreds of languages
4564 // to get the link color.
4566 list( $name, ) = MessageCache::singleton()->figureMessage( $wgContLang->lcfirst( $this->getText() ) );
4569 }
4572 }
4574 /**
4575 * Get the default message text or false if the message doesn't exist
4576 *
4577 * @return String or false
4578 */
4584 }
4586 list( $name, $lang ) = MessageCache::singleton()->figureMessage( $wgContLang->lcfirst( $this->getText() ) );
4593 }
4594 }
4596 /**
4597 * Updates page_touched for this page; called from LinksUpdate.php
4598 *
4599 * @return Bool true if the update succeeded
4600 */
4604 }
4614 $method
4615 );
4616 } );
4619 }
4621 /**
4622 * Update page_touched timestamps and send squid purge messages for
4623 * pages linking to this title. May be sent to the job queue depending
4624 * on the number of links. Typically called on create and delete.
4625 */
4633 }
4634 }
4636 /**
4637 * Get the last touched timestamp
4638 *
4639 * @param $db DatabaseBase: optional db
4640 * @return String last-touched timestamp
4641 */
4646 }
4648 /**
4649 * Get the timestamp when this page was updated since the user last saw it.
4650 *
4651 * @param $user User
4652 * @return String|Null
4653 */
4656 // Assume current user if none given
4659 }
4660 // Check cache first
4662 // avoid isset here, as it'll return false for null entries
4665 }
4669 }
4670 // Don't cache too much!
4673 }
4681 ),
4682 __METHOD__
4683 );
4685 }
4687 /**
4688 * Generate strings used for xml 'id' names in monobook tabs
4689 *
4690 * @param string $prepend defaults to 'nstab-'
4691 * @return String XML 'id' name
4692 */
4695 // Gets the subject namespace if this title
4697 // Checks if canonical namespace name exists for namespace
4699 // Uses canonical namespace name
4702 // Uses text of namespace
4704 }
4705 // Makes namespace key lowercase
4707 // Uses main
4710 }
4711 // Changes file to image for backwards compatibility
4714 }
4716 }
4718 /**
4719 * Get all extant redirects to this Title
4720 *
4721 * @param int|Null $ns Single namespace to consider; NULL to consider all namespaces
4722 * @return Title[] Array of Title redirects to this title
4723 */
4731 'rd_from = page_id'
4732 );
4737 }
4740 }
4746 __METHOD__
4747 );
4751 }
4753 }
4755 /**
4756 * Check if this Title is a valid redirect target
4757 *
4758 * @return Bool
4759 */
4763 // invalid redirect targets are stored in a global array, but explicitly disallow Userlogout here
4766 }
4771 }
4772 }
4775 }
4777 /**
4778 * Get a backlink cache object
4779 *
4780 * @return BacklinkCache
4781 */
4784 }
4786 /**
4787 * Whether the magic words __INDEX__ and __NOINDEX__ function for this page.
4788 *
4789 * @return Boolean
4790 */
4795 ? $wgContentNamespaces
4800 }
4802 /**
4803 * Returns the raw sort key to be used for categories, with the specified
4804 * prefix. This will be fed to Collation::getSortKey() to get a
4805 * binary sortkey that can be used for actual sorting.
4806 *
4807 * @param string $prefix The prefix to be used, specified using
4808 * {{defaultsort:}} or like [[Category:Foo|prefix]]. Empty for no
4809 * prefix.
4810 * @return string
4811 */
4815 // Anything that uses this hook should only depend
4816 // on the Title object passed in, and should probably
4817 // tell the users to run updateCollations.php --force
4818 // in order to re-sort existing category relations.
4821 # Separate with a line feed, so the unprefixed part is only used as
4822 # a tiebreaker when two pages have the exact same prefix.
4823 # In UCA, tab is the only character that can sort above LF
4824 # so we strip both of them from the original prefix.
4827 }
4829 }
4831 /**
4832 * Get the language in which the content of this page is written in
4833 * wikitext. Defaults to $wgContLang, but in certain cases it can be
4834 * e.g. $wgLang (such as special pages, which are in the user language).
4835 *
4836 * @since 1.18
4837 * @return Language
4838 */
4843 // special pages are in the user language
4846 }
4849 // Note that this may depend on user settings, so the cache should be only per-request.
4850 // NOTE: ContentHandler::getPageLanguage() may need to load the content to determine the page language!
4851 // Checking $wgLanguageCode hasn't changed for the benefit of unit tests.
4857 }
4860 }
4862 /**
4863 * Get the language in which the content of this page is written when
4864 * viewed by user. Defaults to $wgContLang, but in certain cases it can be
4865 * e.g. $wgLang (such as special pages, which are in the user language).
4866 *
4867 * @since 1.20
4868 * @return Language
4869 */
4874 // If the user chooses a variant, the content is actually
4875 // in a language whose code is the variant code.
4879 }
4882 }
4884 //NOTE: can't be cached persistently, depends on user settings
4885 //NOTE: ContentHandler::getPageViewLanguage() may need to load the content to determine the page language!
4889 }
4891 /**
4892 * Get a list of rendered edit notices for this page.
4893 *
4894 * Array is keyed by the original message key, and values are rendered using parseAsBlock, so
4895 * they will already be wrapped in paragraphs.
4896 *
4897 * @since 1.21
4898 * @param int oldid Revision ID that's being edited
4899 * @return Array
4900 */
4904 # Optional notices on a per-namespace and per-page basis
4909 }
4918 }
4919 }
4921 # Even if there are no subpages in namespace, we still don't want / in MW ns.
4926 }
4927 }
4931 }
4932 }