| blob | 3140f026442225a79874dc05920ffe3f874328b6 |
1 <?php
2 /**
3 * See title.txt
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 */
23 /**
24 * Represents a title within MediaWiki.
25 * Optionally may contain an interwiki designation or namespace.
26 * @note This class can fetch various kinds of data from the database;
27 * however, it does so inefficiently.
28 *
29 * @internal documentation reviewed 15 Mar 2010
30 */
32 /** @name Static cache variables */
33 // @{
35 // @}
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 // @{
69 var $mCascadeRestriction; ///< Cascade restrictions on this page to included templates and images?
77 # Don't change the following default, NS_MAIN is hardcoded in several
78 # places. See bug 696.
80 # Zero except in {{transclusion}} tags
81 var $mWatched = null; // /< Is $wgUser watching this page? null if unfilled, accessed through userIsWatching()
87 // @}
90 /**
91 * Constructor
92 */
95 /**
96 * Create a new Title from a prefixed DB key
97 *
98 * @param $key String 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 $text String the link text; spaces, prefixes, and an
118 * initial ':' indicating the main namespace are accepted.
119 * @param $defaultNamespace Int the namespace to use if none is speci-
120 * fied 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 }
131 /**
132 * Wiki pages often contain multiple links to the same page.
133 * Title normalization and parsing can become expensive on
134 * pages with many links, so we can save a little time by
135 * caching them.
136 *
137 * In theory these are value objects and won't get changed...
138 */
141 }
143 # Convert things like é ā or 〗 into normalized (bug 14952) text
154 # Avoid memory leaks on mass operations...
157 }
160 }
165 }
166 }
168 /**
169 * THIS IS NOT THE FUNCTION YOU WANT. Use Title::newFromText().
170 *
171 * Example of wrong and broken code:
172 * $title = Title::newFromURL( $wgRequest->getVal( 'title' ) );
173 *
174 * Example of right code:
175 * $title = Title::newFromText( $wgRequest->getVal( 'title' ) );
176 *
177 * Create a new Title from URL-encoded text. Ensures that
178 * the given title's length does not exceed the maximum.
179 *
180 * @param $url String the title, as might be taken from a URL
181 * @return Title the new object, or NULL on an error
182 */
186 # For compatibility with old buggy URLs. "+" is usually not valid in titles,
187 # but some URLs used it as a space replacement and they still come
188 # from some external search tools.
191 }
198 }
199 }
201 /**
202 * Create a new Title from an article ID
203 *
204 * @param $id Int the page_id corresponding to the Title to create
205 * @param $flags Int use Title::GAID_FOR_UPDATE to use master
206 * @return Title the new object, or NULL on an error
207 */
215 }
217 }
219 /**
220 * Make an array of titles from an array of IDs
221 *
222 * @param $ids Array of Int Array of IDs
223 * @return Array of Titles
224 */
228 }
236 ),
238 __METHOD__
239 );
244 }
246 }
248 /**
249 * Make a Title object from a DB row
250 *
251 * @param $row Object database row (needs at least page_title,page_namespace)
252 * @return Title corresponding Title
253 */
258 }
260 /**
261 * Load Title object fields from a DB row.
262 * If false is given, the title will be treated as non-existing.
263 *
264 * @param $row Object|bool database row
265 */
281 }
282 }
284 /**
285 * Create a new Title from a namespace index and a DB key.
286 * It's assumed that $ns and $title are *valid*, for instance when
287 * they came directly from the database or a special page name.
288 * For convenience, spaces are converted to underscores so that
289 * eg user_text fields can be used directly.
290 *
291 * @param $ns Int the namespace of the article
292 * @param $title String the unprefixed database key form
293 * @param $fragment String the link fragment (after the "#")
294 * @param $interwiki String the interwiki prefix
295 * @return Title the new object
296 */
307 }
309 /**
310 * Create a new Title from a namespace index and a DB key.
311 * The parameters will be checked for validity, which is a bit slower
312 * than makeTitle() but safer for user-provided data.
313 *
314 * @param $ns Int the namespace of the article
315 * @param $title String database key form
316 * @param $fragment String the link fragment (after the "#")
317 * @param $interwiki String interwiki prefix
318 * @return Title the new object, or NULL on an error
319 */
323 }
331 }
332 }
334 /**
335 * Create a new Title for the Main Page
336 *
337 * @return Title the new object
338 */
341 // Don't give fatal errors if the message is broken
344 }
346 }
348 /**
349 * Extract a redirect destination from a string and return the
350 * Title, or null if the text doesn't contain a valid redirect
351 * This will only return the very next target, useful for
352 * the redirect table and other checks that don't need full recursion
353 *
354 * @param $text String: Text with possible redirect
355 * @return Title: The corresponding Title
356 */
359 }
361 /**
362 * Extract a redirect destination from a string and return the
363 * Title, or null if the text doesn't contain a valid redirect
364 * This will recurse down $wgMaxRedirects times or until a non-redirect target is hit
365 * in order to provide (hopefully) the Title of the final destination instead of another redirect
366 *
367 * @param $text String Text with possible redirect
368 * @return Title
369 */
373 }
375 /**
376 * Extract a redirect destination from a string and return an
377 * array of Titles, or null if the text doesn't contain a valid redirect
378 * The last element in the array is the final destination after all redirects
379 * have been resolved (up to $wgMaxRedirects times)
380 *
381 * @param $text String Text with possible redirect
382 * @return Array of Titles, with the destination last
383 */
389 }
390 // recursive check to follow double redirects
399 }
400 // Redirects to some special pages are not permitted
402 // the new title passes the checks, so make that our current title so that further recursion can be checked
407 }
408 }
410 }
412 /**
413 * Really extract the redirect destination
414 * Do not call this function directly, use one of the newFromRedirect* functions above
415 *
416 * @param $text String Text with possible redirect
417 * @return Title
418 */
422 //redirects are disabled, so quit early
424 }
428 // Extract the first link and see if it's usable
429 // Ensure that it really does come directly after #REDIRECT
430 // Some older redirects included a colon, so don't freak about that!
433 // Strip preceding colon used to "escape" categories, etc.
434 // and URL-decode links
436 // Match behavior of inline link parsing here;
438 }
440 // If the title is a redirect to bad special pages or is invalid, return null
443 }
445 }
446 }
448 }
450 /**
451 * Get the prefixed DB key associated with an ID
452 *
453 * @param $id Int the page_id of the article
454 * @return Title an object representing the article, or NULL if no such article was found
455 */
463 __METHOD__
464 );
467 }
471 }
473 /**
474 * Get a regex character class describing the legal characters in a link
475 *
476 * @return String the list of characters, not delimited
477 */
481 }
483 /**
484 * Returns a simple regex that will match on characters and sequences invalid in titles.
485 * Note that this doesn't pick up many things that could be wrong with titles, but that
486 * replacing this regex with something valid will make many titles valid.
487 *
488 * @return String regex string
489 */
493 # Matching titles will be held as illegal.
495 # Any character not allowed is forbidden...
497 # URL percent encoding sequences interfere with the ability
498 # to round-trip titles -- you can't link to them consistently.
500 # XML/HTML character references produce similar issues.
505 }
508 }
510 /**
511 * Get a string representation of a title suitable for
512 * including in a search index
513 *
514 * @param $ns Int a namespace index
515 * @param $title String text-form main part
516 * @return String a stripped-down title string ready for the search index
517 */
526 # Handle 's, s'
534 }
536 }
538 /**
539 * Make a prefixed DB key from a DB key and a namespace index
540 *
541 * @param $ns Int numerical representation of the namespace
542 * @param $title String the DB key form the title
543 * @param $fragment String The link fragment (after the "#")
544 * @param $interwiki String The interwiki prefix
545 * @return String the prefixed form of the title
546 */
554 }
557 }
559 }
561 /**
562 * Escape a text fragment, say from a link, for a URL
563 *
564 * @param $fragment string containing a URL or link fragment (after the "#")
565 * @return String: escaped string
566 */
568 # Note that we don't urlencode the fragment. urlencoded Unicode
569 # fragments appear not to work in IE (at least up to 7) or in at least
570 # one version of Opera 9.x. The W3C validator, for one, doesn't seem
571 # to care if they aren't encoded.
573 }
575 /**
576 * Callback for usort() to do title sorts by (namespace, title)
577 *
578 * @param $a Title
579 * @param $b Title
580 *
581 * @return Integer: result of string comparison, or namespace comparison
582 */
588 }
589 }
591 /**
592 * Determine whether the object refers to a page within
593 * this project.
594 *
595 * @return Bool TRUE if this is an in-project interwiki link or a wikilink, FALSE otherwise
596 */
602 }
603 }
605 /**
606 * Is this Title interwiki?
607 *
608 * @return Bool
609 */
612 }
614 /**
615 * Get the interwiki prefix (or null string)
616 *
617 * @return String Interwiki prefix
618 */
621 }
623 /**
624 * Determine whether the object refers to a page within
625 * this project and is transcludable.
626 *
627 * @return Bool TRUE if this is transcludable
628 */
632 }
635 }
637 /**
638 * Returns the DB name of the distant wiki which owns the object.
639 *
640 * @return String the DB name
641 */
645 }
648 }
650 /**
651 * Get the text form (spaces not underscores) of the main part
652 *
653 * @return String Main part of the title
654 */
657 }
659 /**
660 * Get the URL-encoded form of the main part
661 *
662 * @return String Main part of the title, URL-encoded
663 */
666 }
668 /**
669 * Get the main part with underscores
670 *
671 * @return String: Main part of the title, with underscores
672 */
675 }
677 /**
678 * Get the DB key with the initial letter case as specified by the user
679 *
680 * @return String DB key
681 */
684 }
686 /**
687 * Get the namespace index, i.e. one of the NS_xxxx constants.
688 *
689 * @return Integer: Namespace index
690 */
693 }
695 /**
696 * Get the namespace text
697 *
698 * @return String: Namespace text
699 */
704 // This probably shouldn't even happen. ohh man, oh yuck.
705 // But for interwiki transclusion it sometimes does.
706 // Shit. Shit shit shit.
707 //
708 // Use the canonical namespaces if possible to try to
709 // resolve a foreign namespace.
712 }
713 }
719 }
722 }
724 /**
725 * Get the namespace text of the subject (rather than talk) page
726 *
727 * @return String Namespace text
728 */
732 }
734 /**
735 * Get the namespace text of the talk page
736 *
737 * @return String Namespace text
738 */
742 }
744 /**
745 * Could this title have a corresponding talk page?
746 *
747 * @return Bool TRUE or FALSE
748 */
751 }
753 /**
754 * Is this in a namespace that allows actual pages?
755 *
756 * @return Bool
757 * @internal note -- uses hardcoded namespace index instead of constants
758 */
761 }
763 /**
764 * Can this title be added to a user's watchlist?
765 *
766 * @return Bool TRUE or FALSE
767 */
770 }
772 /**
773 * Returns true if this is a special page.
774 *
775 * @return boolean
776 */
779 }
781 /**
782 * Returns true if this title resolves to the named special page
783 *
784 * @param $name String The special page name
785 * @return boolean
786 */
792 }
793 }
795 }
797 /**
798 * If the Title refers to a special page alias which is not the local default, resolve
799 * the alias, and localise the name as necessary. Otherwise, return $this
800 *
801 * @return Title
802 */
810 }
811 }
812 }
814 }
816 /**
817 * Returns true if the title is inside the specified namespace.
818 *
819 * Please make use of this instead of comparing to getNamespace()
820 * This function is much more resistant to changes we may make
821 * to namespaces than code that makes direct comparisons.
822 * @param $ns int The namespace
823 * @return bool
824 * @since 1.19
825 */
828 }
830 /**
831 * Returns true if the title is inside one of the specified namespaces.
832 *
833 * @param ...$namespaces The namespaces to check for
834 * @return bool
835 * @since 1.19
836 */
841 }
846 }
847 }
850 }
852 /**
853 * Returns true if the title has the same subject namespace as the
854 * namespace specified.
855 * For example this method will take NS_USER and return true if namespace
856 * is either NS_USER or NS_USER_TALK since both of them have NS_USER
857 * as their subject namespace.
858 *
859 * This is MUCH simpler than individually testing for equivilance
860 * against both NS_USER and NS_USER_TALK, and is also forward compatible.
861 * @since 1.19
862 * @param $ns int
863 * @return bool
864 */
867 }
869 /**
870 * Is this Title in a namespace which contains content?
871 * In other words, is this a content page, for the purposes of calculating
872 * statistics, etc?
873 *
874 * @return Boolean
875 */
878 }
880 /**
881 * Would anybody with sufficient privileges be able to move this page?
882 * Some pages just aren't movable.
883 *
884 * @return Bool TRUE or FALSE
885 */
888 // Interwiki title or immovable namespace. Hooks don't get to override here
890 }
895 }
897 /**
898 * Is this the mainpage?
899 * @note Title::newFromText seams to be sufficiently optimized by the title
900 * cache that we don't need to over-optimize by doing direct comparisons and
901 * acidentally creating new bugs where $title->equals( Title::newFromText() )
902 * ends up reporting something differently than $title->isMainPage();
903 *
904 * @since 1.18
905 * @return Bool
906 */
909 }
911 /**
912 * Is this a subpage?
913 *
914 * @return Bool
915 */
920 }
922 /**
923 * Is this a conversion table for the LanguageConverter?
924 *
925 * @return Bool
926 */
930 }
932 /**
933 * Does that page contain wikitext, or it is JS, CSS or whatever?
934 *
935 * @return Bool
936 */
941 }
943 /**
944 * Could this page contain custom CSS or JavaScript, based
945 * on the title?
946 *
947 * @return Bool
948 */
954 }
956 /**
957 * Is this a .css or .js subpage of a user page?
958 * @return Bool
959 */
961 return ( NS_USER == $this->mNamespace and preg_match( "/\\/.*\\.(?:css|js)$/", $this->mTextform ) );
962 }
964 /**
965 * Trim down a .css or .js subpage title to get the corresponding skin name
966 *
967 * @return string containing skin name from .css or .js subpage title
968 */
976 }
978 /**
979 * Is this a .css subpage of a user page?
980 *
981 * @return Bool
982 */
985 }
987 /**
988 * Is this a .js subpage of a user page?
989 *
990 * @return Bool
991 */
994 }
996 /**
997 * Is this a talk page of some sort?
998 *
999 * @return Bool
1000 */
1003 }
1005 /**
1006 * Get a Title object associated with the talk page of this article
1007 *
1008 * @return Title the object for the talk page
1009 */
1012 }
1014 /**
1015 * Get a title object associated with the subject page of this
1016 * talk page
1017 *
1018 * @return Title the object for the subject page
1019 */
1021 // Is this the same title?
1025 }
1027 }
1029 /**
1030 * Get the default namespace index, for when there is no namespace
1031 *
1032 * @return Int Default namespace index
1033 */
1036 }
1038 /**
1039 * Get title for search index
1040 *
1041 * @return String a stripped-down title string ready for the
1042 * search index
1043 */
1046 }
1048 /**
1049 * Get the Title fragment (i.e.\ the bit after the #) in text form
1050 *
1051 * @return String Title fragment
1052 */
1055 }
1057 /**
1058 * Get the fragment in URL form, including the "#" character if there is one
1059 * @return String Fragment in URL form
1060 */
1066 }
1067 }
1069 /**
1070 * Set the fragment for this title. Removes the first character from the
1071 * specified fragment before setting, so it assumes you're passing it with
1072 * an initial "#".
1073 *
1074 * Deprecated for public use, use Title::makeTitle() with fragment parameter.
1075 * Still in active use privately.
1076 *
1077 * @param $fragment String text
1078 */
1081 }
1083 /**
1084 * Prefix some arbitrary text with the namespace or interwiki prefix
1085 * of this object
1086 *
1087 * @param $name String the text
1088 * @return String the prefixed text
1089 * @private
1090 */
1095 }
1099 }
1101 }
1103 /**
1104 * Get the prefixed database key form
1105 *
1106 * @return String the prefixed title, with underscores and
1107 * any interwiki and namespace prefixes
1108 */
1113 }
1115 /**
1116 * Get the prefixed title with spaces.
1117 * This is the form usually used for display
1118 *
1119 * @return String the prefixed title, with spaces
1120 */
1122 // @todo FIXME: Bad usage of empty() ?
1127 }
1129 }
1131 /**
1132 * Return a string representation of this title
1133 *
1134 * @return String representation of this title
1135 */
1138 }
1140 /**
1141 * Get the prefixed title with spaces, plus any fragment
1142 * (part beginning with '#')
1143 *
1144 * @return String the prefixed title, with spaces and the fragment, including '#'
1145 */
1150 }
1152 }
1154 /**
1155 * Get the base page name, i.e. the leftmost part before any slashes
1156 *
1157 * @return String Base name
1158 */
1162 }
1165 # Don't discard the real title if there's no subpage involved
1168 }
1170 }
1172 /**
1173 * Get the lowest-level subpage name, i.e. the rightmost part after any slashes
1174 *
1175 * @return String Subpage name
1176 */
1180 }
1183 }
1185 /**
1186 * Get the HTML-escaped displayable text form.
1187 * Used for the title field in <a> tags.
1188 *
1189 * @return String the text, including any prefixes
1190 */
1194 }
1196 /**
1197 * Get a URL-encoded form of the subpage text
1198 *
1199 * @return String URL-encoded subpage name
1200 */
1205 }
1207 /**
1208 * Get a URL-encoded title (not an actual URL) including interwiki
1209 *
1210 * @return String the URL-encoded form
1211 */
1216 }
1218 /**
1219 * Helper to fix up the get{Local,Full,Link,Canonical}URL args
1220 * get{Canonical,Full,Link,Local}URL methods accepted an optional
1221 * second argument named variant. This was deprecated in favor
1222 * of passing an array of option with a "variant" key
1223 * Once $query2 is removed for good, this helper can be dropped
1224 * andthe wfArrayToCGI moved to getLocalURL();
1225 *
1226 * @since 1.19 (r105919)
1227 * @param $query
1228 * @param $query2 bool
1229 * @return String
1230 */
1233 wfDeprecated( "Title::get{Canonical,Full,Link,Local} method called with a second parameter is deprecated. Add your parameter to an array passed as the first parameter.", "1.19" );
1234 }
1237 }
1240 // $query2 is a string, we will consider this to be
1241 // a deprecated $variant argument and add it to the query
1245 }
1246 // If we have $query content add a & to it first
1249 }
1250 // Now append the queries together
1252 }
1254 }
1256 /**
1257 * Get a real URL referring to this title, with interwiki link and
1258 * fragment
1259 *
1260 * See getLocalURL for the arguments.
1261 *
1262 * @see self::getLocalURL
1263 * @return String the URL
1264 */
1268 # Hand off all the decisions on urls to getLocalURL
1271 # Expand the url to make it a full url. Note that getLocalURL has the
1272 # potential to output full urls for a variety of reasons, so we use
1273 # wfExpandUrl instead of simply prepending $wgServer
1276 # Finally, add the fragment.
1281 }
1283 /**
1284 * Get a URL with no fragment or server name. If this page is generated
1285 * with action=render, $wgServer is prepended.
1286 *
1288 * @param $query string|array an optional query string,
1289 * not used for interwiki links. Can be specified as an associative array as well,
1290 * e.g., array( 'action' => 'edit' ) (keys and values will be URL-escaped).
1291 * Some query patterns will trigger various shorturl path replacements.
1292 * @param $query2 Mixed: An optional secondary query array. This one MUST
1293 * be an array. If a string is passed it will be interpreted as a deprecated
1294 * variant argument and urlencoded into a variant= argument.
1295 * This second query argument will be added to the $query
1296 * The second parameter is deprecated since 1.19. Pass it as a key,value
1297 * pair in the first parameter array instead.
1298 *
1299 * @return String the URL
1300 */
1310 # Can this actually happen? Interwikis shouldn't be parsed.
1311 # Yes! It can in interwiki transclusion. But... it probably shouldn't.
1313 }
1328 {
1334 }
1338 }
1339 }
1340 }
1346 {
1349 // Only do the variant replacement if the given variant is a valid
1350 // variant for the page's language.
1353 }
1354 }
1359 }
1361 }
1362 }
1366 // @todo FIXME: This causes breakage in various places when we
1367 // actually expected a local URL and end up with dupe prefixes.
1370 }
1371 }
1374 }
1376 /**
1377 * Get a URL that's the simplest URL that will be valid to link, locally,
1378 * to the current Title. It includes the fragment, but does not include
1379 * the server unless action=render is used (or the link is external). If
1380 * there's a fragment but the prefixed text is empty, we just return a link
1381 * to the fragment.
1382 *
1383 * The result obviously should not be URL-escaped, but does need to be
1384 * HTML-escaped if it's being output in HTML.
1385 *
1386 * See getLocalURL for the arguments.
1387 *
1388 * @see self::getLocalURL
1389 * @return String the URL
1390 */
1399 }
1402 }
1404 /**
1405 * Get an HTML-escaped version of the URL form, suitable for
1406 * using in a link, without a server name or fragment
1407 *
1408 * See getLocalURL for the arguments.
1409 *
1410 * @see self::getLocalURL
1411 * @param $query string
1412 * @param $query2 bool|string
1413 * @return String the URL
1414 */
1418 }
1420 /**
1421 * Get an HTML-escaped version of the URL form, suitable for
1422 * using in a link, including the server name and fragment
1423 *
1424 * See getLocalURL for the arguments.
1425 *
1426 * @see self::getLocalURL
1427 * @return String the URL
1428 */
1432 }
1434 /**
1435 * Get the URL form for an internal link.
1436 * - Used in various Squid-related code, in case we have a different
1437 * internal hostname for the server from the exposed one.
1438 *
1439 * This uses $wgInternalServer to qualify the path, or $wgServer
1440 * if $wgInternalServer is not set. If the server variable used is
1441 * protocol-relative, the URL will be expanded to http://
1442 *
1443 * See getLocalURL for the arguments.
1444 *
1445 * @see self::getLocalURL
1446 * @return String the URL
1447 */
1455 }
1457 /**
1458 * Get the URL for a canonical link, for use in things like IRC and
1459 * e-mail notifications. Uses $wgCanonicalServer and the
1460 * GetCanonicalURL hook.
1461 *
1462 * NOTE: Unlike getInternalURL(), the canonical URL includes the fragment
1463 *
1464 * See getLocalURL for the arguments.
1465 *
1466 * @see self::getLocalURL
1467 * @return string The URL
1468 * @since 1.18
1469 */
1472 $url = wfExpandUrl( $this->getLocalURL( $query ) . $this->getFragmentForURL(), PROTO_CANONICAL );
1475 }
1477 /**
1478 * HTML-escaped version of getCanonicalURL()
1479 *
1480 * See getLocalURL for the arguments.
1481 *
1482 * @see self::getLocalURL
1483 * @since 1.18
1484 * @return string
1485 */
1489 }
1491 /**
1492 * Get the edit URL for this Title
1493 *
1494 * @return String the URL, or a null string if this is an
1495 * interwiki link
1496 */
1500 }
1504 }
1506 /**
1507 * Is $wgUser watching this page?
1508 *
1509 * @return Bool
1510 */
1519 }
1520 }
1522 }
1524 /**
1525 * Can $wgUser read this page?
1526 *
1527 * @deprecated in 1.19; use userCan(), quickUserCan() or getUserPermissionsErrors() instead
1528 * @return Bool
1529 * @todo fold these checks into userCan()
1530 */
1534 }
1536 /**
1537 * Can $user perform $action on this page?
1538 * This skips potentially expensive cascading permission checks
1539 * as well as avoids expensive error formatting
1540 *
1541 * Suitable for use for nonessential UI controls in common cases, but
1542 * _not_ for functional access control.
1543 *
1544 * May provide false positives, but should never provide a false negative.
1545 *
1546 * @param $action String action that permission needs to be checked for
1547 * @param $user User to check (since 1.19); $wgUser will be used if not
1548 * provided.
1549 * @return Bool
1550 */
1553 }
1555 /**
1556 * Can $user perform $action on this page?
1557 *
1558 * @param $action String action that permission needs to be checked for
1559 * @param $user User to check (since 1.19); $wgUser will be used if not
1560 * provided.
1561 * @param $doExpensiveQueries Bool Set this to false to avoid doing
1562 * unnecessary queries.
1563 * @return Bool
1564 */
1569 }
1570 return !count( $this->getUserPermissionsErrorsInternal( $action, $user, $doExpensiveQueries, true ) );
1571 }
1573 /**
1574 * Can $user perform $action on this page?
1575 *
1576 * @todo FIXME: This *does not* check throttles (User::pingLimiter()).
1577 *
1578 * @param $action String action that permission needs to be checked for
1579 * @param $user User to check
1580 * @param $doExpensiveQueries Bool Set this to false to avoid doing unnecessary
1581 * queries by skipping checks for cascading protections and user blocks.
1582 * @param $ignoreErrors Array of Strings Set this to a list of message keys
1583 * whose corresponding errors may be ignored.
1584 * @return Array of arguments to wfMsg to explain permissions problems.
1585 */
1586 public function getUserPermissionsErrors( $action, $user, $doExpensiveQueries = true, $ignoreErrors = array() ) {
1589 // Remove the errors being ignored.
1595 }
1596 }
1599 }
1601 /**
1602 * Permissions checks that fail most often, and which are easiest to test.
1603 *
1604 * @param $action String the action to check
1605 * @param $user User user to check
1606 * @param $errors Array list of current errors
1607 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1608 * @param $short Boolean short circuit on first error
1609 *
1610 * @return Array list of errors
1611 */
1612 private function checkQuickPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1617 }
1621 // Show user page-specific message only if the user can move other pages
1623 }
1625 // Check if user is allowed to move files if it's a file
1628 }
1631 // User can't move anything
1636 }
1640 }
1642 // custom message if logged-in users without any special rights can move
1646 }
1647 }
1650 // User can't move anything
1654 // Show user page-specific message only if the user can move other pages
1656 }
1659 }
1662 }
1664 /**
1665 * Add the resulting error code to the errors array
1666 *
1667 * @param $errors Array list of current errors
1668 * @param $result Mixed result of errors
1669 *
1670 * @return Array list of errors
1671 */
1674 // A single array representing an error
1677 // A nested array representing multiple errors
1680 // A string representing a message-id
1683 // a generic "We don't want them to do that"
1685 }
1687 }
1689 /**
1690 * Check various permission hooks
1691 *
1692 * @param $action String the action to check
1693 * @param $user User user to check
1694 * @param $errors Array list of current errors
1695 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1696 * @param $short Boolean short circuit on first error
1697 *
1698 * @return Array list of errors
1699 */
1700 private function checkPermissionHooks( $action, $user, $errors, $doExpensiveQueries, $short ) {
1701 // Use getUserPermissionsErrors instead
1705 }
1706 // Check getUserPermissionsErrors hook
1709 }
1710 // Check getUserPermissionsErrorsExpensive hook
1712 !wfRunHooks( 'getUserPermissionsErrorsExpensive', array( &$this, &$user, $action, &$result ) ) ) {
1714 }
1717 }
1719 /**
1720 * Check permissions on special pages & namespaces
1721 *
1722 * @param $action String the action to check
1723 * @param $user User user to check
1724 * @param $errors Array list of current errors
1725 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1726 * @param $short Boolean short circuit on first error
1727 *
1728 * @return Array list of errors
1729 */
1730 private function checkSpecialsAndNSPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1731 # Only 'createaccount' and 'execute' can be performed on
1732 # special pages, which don't actually exist in the DB.
1736 }
1738 # Check $wgNamespaceProtection for restricted namespaces
1744 }
1747 }
1749 /**
1750 * Check CSS/JS sub-page permissions
1751 *
1752 * @param $action String the action to check
1753 * @param $user User user to check
1754 * @param $errors Array list of current errors
1755 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1756 * @param $short Boolean short circuit on first error
1757 *
1758 * @return Array list of errors
1759 */
1760 private function checkCSSandJSPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1761 # Protect css/js subpages of user pages
1762 # XXX: this might be better using restrictions
1763 # XXX: right 'editusercssjs' is deprecated, for backward compatibility only
1770 }
1771 }
1774 }
1776 /**
1777 * Check against page_restrictions table requirements on this
1778 * page. The user must possess all required rights for this
1779 * action.
1780 *
1781 * @param $action String the action to check
1782 * @param $user User user to check
1783 * @param $errors Array list of current errors
1784 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1785 * @param $short Boolean short circuit on first error
1786 *
1787 * @return Array list of errors
1788 */
1789 private function checkPageRestrictions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1791 // Backwards compatibility, rewrite sysop -> protect
1794 }
1796 // Users with 'editprotected' permission can edit protected pages
1797 // without cascading option turned on.
1800 {
1802 }
1803 }
1804 }
1807 }
1809 /**
1810 * Check restrictions on cascading pages.
1811 *
1812 * @param $action String the action to check
1813 * @param $user User to check
1814 * @param $errors Array list of current errors
1815 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1816 * @param $short Boolean short circuit on first error
1817 *
1818 * @return Array list of errors
1819 */
1820 private function checkCascadingSourcesRestrictions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1822 # We /could/ use the protection level on the source page, but it's
1823 # fairly ugly as we have to establish a precedence hierarchy for pages
1824 # included by multiple cascade-protected pages. So just restrict
1825 # it to people with 'protect' permission, as they could remove the
1826 # protection anyway.
1828 # Cascading protection depends on more than this page...
1829 # Several cascading protected pages may include this page...
1830 # Check each cascading level
1831 # This is only for protection restrictions, not for all actions
1840 }
1841 }
1842 }
1843 }
1846 }
1848 /**
1849 * Check action permissions not already checked in checkQuickPermissions
1850 *
1851 * @param $action String the action to check
1852 * @param $user User to check
1853 * @param $errors Array list of current errors
1854 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1855 * @param $short Boolean short circuit on first error
1856 *
1857 * @return Array list of errors
1858 */
1859 private function checkActionPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1863 if ( count( $this->getUserPermissionsErrorsInternal( 'edit', $user, $doExpensiveQueries, true ) ) ) {
1864 // If they can't edit, they shouldn't protect.
1866 }
1872 }
1875 {
1876 $errors[] = array( 'titleprotected', User::whoIs( $title_protection['pt_user'] ), $title_protection['pt_reason'] );
1877 }
1878 }
1880 // Check for immobile pages
1882 // Specific message for this case
1885 // Less specific message for rarer cases
1887 }
1893 }
1897 {
1899 }
1900 }
1902 }
1904 /**
1905 * Check that the user isn't blocked from editting.
1906 *
1907 * @param $action String the action to check
1908 * @param $user User to check
1909 * @param $errors Array list of current errors
1910 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1911 * @param $short Boolean short circuit on first error
1912 *
1913 * @return Array list of errors
1914 */
1916 // Account creation blocks handled at userlogin.
1917 // Unblocking handled in SpecialUnblock
1920 }
1926 }
1929 // Don't block the user from editing their own talk page unless they've been
1930 // explicitly blocked from that too.
1934 // This is from OutputPage::blockedPage
1935 // Copied at r23888 by werdna
1941 }
1948 }
1958 }
1962 $errors[] = array( ( $block->mAuto ? 'autoblockedtext' : 'blockedtext' ), $link, $reason, $ip, $name,
1964 }
1967 }
1969 /**
1970 * Check that the user is allowed to read this page.
1971 *
1972 * @param $action String the action to check
1973 * @param $user User to check
1974 * @param $errors Array list of current errors
1975 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1976 * @param $short Boolean short circuit on first error
1977 *
1978 * @return Array list of errors
1979 */
1980 private function checkReadPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1984 # Initialize the $useShortcut boolean, to determine if we can skip quite a bit of code below
1988 # Not a public wiki, so no shortcut
1991 /**
1992 * Iterate through each group with permissions being revoked (key not included since we don't care
1993 * what the group name is), then check if the read permission is being revoked. If it is, then
1994 * we don't use the shortcut below since the user might not be able to read, even though anon
1995 * reading is allowed.
1996 */
1999 # We might be removing the read right from the user, so no shortcut
2002 }
2003 }
2004 }
2005 }
2009 # Shortcut for public wikis, allows skipping quite a bit of code
2012 # If the user is allowed to read pages, he is allowed to read all pages
2017 ) {
2018 # Always grant access to the login page.
2019 # Even anons need to be able to log in.
2022 # Time to check the whitelist
2023 # Only do these checks is there's something to check against
2027 // Check for explicit whitelisting with and without underscores
2028 if ( in_array( $name, $wgWhitelistRead, true ) || in_array( $dbName, $wgWhitelistRead, true ) ) {
2031 # Old settings might have the title prefixed with
2032 # a colon for main-namespace pages
2035 }
2037 # If it's a special page, ditch the subpage bit and check again
2044 }
2045 }
2046 }
2047 }
2050 # If the title is not whitelisted, give extensions a chance to do so...
2054 }
2055 }
2058 }
2060 /**
2061 * Get a description array when the user doesn't have the right to perform
2062 * $action (i.e. when User::isAllowed() returns false)
2063 *
2064 * @param $action String the action to check
2065 * @param $short Boolean short circuit on first error
2066 * @return Array list of errors
2067 */
2069 // We avoid expensive display logic for quickUserCan's and such
2072 }
2083 );
2086 }
2087 }
2089 /**
2090 * Can $user perform $action on this page? This is an internal function,
2091 * which checks ONLY that previously checked by userCan (i.e. it leaves out
2092 * checks on wfReadOnly() and blocks)
2093 *
2094 * @param $action String action that permission needs to be checked for
2095 * @param $user User to check
2096 * @param $doExpensiveQueries Bool Set this to false to avoid doing unnecessary queries.
2097 * @param $short Bool Set this to true to stop after the first permission error.
2098 * @return Array of arrays of the arguments to wfMsg to explain permissions problems.
2099 */
2100 protected function getUserPermissionsErrorsInternal( $action, $user, $doExpensiveQueries = true, $short = false ) {
2103 # Read has special handling
2108 );
2118 'checkUserBlock'
2119 );
2120 }
2127 }
2131 }
2133 /**
2134 * Protect css subpages of user pages: can $wgUser edit
2135 * this page?
2136 *
2137 * @deprecated in 1.19; will be removed in 1.20. Use getUserPermissionsErrors() instead.
2138 * @return Bool
2139 */
2145 }
2147 /**
2148 * Protect js subpages of user pages: can $wgUser edit
2149 * this page?
2150 *
2151 * @deprecated in 1.19; will be removed in 1.20. Use getUserPermissionsErrors() instead.
2152 * @return Bool
2153 */
2159 }
2161 /**
2162 * Get a filtered list of all restriction types supported by this wiki.
2163 * @param bool $exists True to get all restriction types that apply to
2164 * titles that do exist, False for all restriction types that apply to
2165 * titles that do not exist
2166 * @return array
2167 */
2172 # Remove the create restriction for existing titles
2175 # Only the create and upload restrictions apply to non-existing titles
2177 }
2179 }
2181 /**
2182 * Returns restriction types for the current Title
2183 *
2184 * @return array applicable restriction types
2185 */
2189 }
2194 # Remove the upload restriction for non-file titles
2196 }
2204 }
2206 /**
2207 * Is this title subject to title protection?
2208 * Title protection is the one applied against creation of such title.
2209 *
2210 * @return Mixed An associative array representing any existent title
2211 * protection, or false if there's none.
2212 */
2214 // Can't protect pages in special namespaces
2217 }
2219 // Can't protect pages that exist.
2222 }
2228 __METHOD__ );
2230 // fetchRow returns false if there are no rows.
2232 }
2234 }
2236 /**
2237 * Update the title protection status
2238 *
2239 * @deprecated in 1.19; will be removed in 1.20. Use WikiPage::doUpdateRestrictions() instead.
2240 * @param $create_perm String Permission required for creation
2241 * @param $reason String Reason for protection
2242 * @param $expiry String Expiry timestamp
2243 * @return boolean true
2244 */
2257 }
2259 /**
2260 * Remove any title protection due to page existing
2261 */
2268 __METHOD__
2269 );
2271 }
2273 /**
2274 * Is this page "semi-protected" - the *only* protection is autoconfirm?
2275 *
2276 * @param $action String Action to check (default: edit)
2277 * @return Bool
2278 */
2286 }
2287 }
2289 # Not protected
2291 }
2294 # If it doesn't exist, it can't be protected
2296 }
2297 }
2299 /**
2300 * Does the title correspond to a protected article?
2301 *
2302 * @param $action String the action the page is protected from,
2303 * by default checks all actions.
2304 * @return Bool
2305 */
2311 # Special pages have inherent protection
2314 }
2316 # Check regular protection levels
2323 }
2324 }
2325 }
2326 }
2329 }
2331 /**
2332 * Determines if $user is unable to edit this page because it has been protected
2333 * by $wgNamespaceProtection.
2334 *
2335 * @param $user User object to check permissions
2336 * @return Bool
2337 */
2345 }
2346 }
2347 }
2349 }
2351 /**
2352 * Cascading protection: Return true if cascading restrictions apply to this page, false if not.
2353 *
2354 * @return Bool If the page is subject to cascading restrictions.
2355 */
2359 }
2361 /**
2362 * Cascading protection: Get the source of any cascading restrictions on this page.
2363 *
2364 * @param $getPages Bool Whether or not to retrieve the actual pages
2365 * that the restrictions have come from.
2366 * @return Mixed Array of Title objects of the pages from which cascading restrictions
2367 * have come, false for none, or true if such restrictions exist, but $getPages
2368 * was not set. The restriction array is an array of each type, each of which
2369 * contains a array of unique groups.
2370 */
2379 }
2391 );
2399 );
2400 }
2409 }
2425 # Add groups needed for each restriction type if its not already there
2426 # Make sure this restriction type still exists
2430 }
2435 }
2438 }
2440 // Trigger lazy purge of expired restrictions from the db
2442 }
2443 }
2446 }
2453 }
2457 }
2459 /**
2460 * Accessor/initialisation for mRestrictions
2461 *
2462 * @param $action String action that permission needs to be checked for
2463 * @return Array of Strings the array of groups allowed to edit this article
2464 */
2468 }
2472 }
2474 /**
2475 * Get the expiry time for the restriction against a given action
2476 *
2477 * @param $action
2478 * @return String|Bool 14-char timestamp, or 'infinity' if the page is protected forever
2479 * or not protected at all, or false if the action is not recognised.
2480 */
2484 }
2485 return isset( $this->mRestrictionsExpiry[$action] ) ? $this->mRestrictionsExpiry[$action] : false;
2486 }
2488 /**
2489 * Returns cascading restrictions for the current article
2490 *
2491 * @return Boolean
2492 */
2496 }
2499 }
2501 /**
2502 * Loads a string into mRestrictions array
2503 *
2504 * @param $res Resource restrictions as an SQL result.
2505 * @param $oldFashionedRestrictions String comma-separated list of page
2506 * restrictions from page table (pre 1.10)
2507 */
2513 }
2516 }
2518 /**
2519 * Compiles list of active page restrictions from both page table (pre 1.10)
2520 * and page_restrictions table for this existing page.
2521 * Public for usage by LiquidThreads.
2522 *
2523 * @param $rows array of db result objects
2524 * @param $oldFashionedRestrictions string comma-separated list of page
2525 * restrictions from page table (pre 1.10)
2526 */
2536 }
2540 # Backwards-compatibility: also load the restrictions from the page record (old format).
2545 }
2552 // old old format should be treated as edit/move restriction
2557 }
2558 }
2562 }
2565 # Current system - load second to make them override.
2569 # Cycle through all the restrictions.
2572 // Don't take care of restrictions types that aren't allowed
2576 // This code should be refactored, now that it's being used more generally,
2577 // But I don't really see any harm in leaving it in Block for now -werdna
2580 // Only apply the restrictions if they haven't expired!
2587 // Trigger a lazy purge of expired restrictions
2589 }
2590 }
2594 }
2595 }
2598 }
2600 /**
2601 * Load restrictions from the page_restrictions table
2602 *
2603 * @param $oldFashionedRestrictions String comma-separated list of page
2604 * restrictions from page table (pre 1.10)
2605 */
2616 __METHOD__
2617 );
2628 // Apply the restrictions
2634 }
2637 }
2639 }
2640 }
2641 }
2643 /**
2644 * Flush the protection cache in this object and force reload from the database.
2645 * This is used when updating protection from WikiPage::doUpdateRestrictions().
2646 */
2650 }
2652 /**
2653 * Purge expired restrictions from the page_restrictions table
2654 */
2660 __METHOD__
2661 );
2666 __METHOD__
2667 );
2668 }
2670 /**
2671 * Does this have subpages? (Warning, usually requires an extra DB query.)
2672 *
2673 * @return Bool
2674 */
2677 # Duh
2679 }
2681 # We dynamically add a member variable for the purpose of this method
2682 # alone to cache the result. There's no point in having it hanging
2683 # around uninitialized in every Title object; therefore we only add it
2684 # if needed and don't declare it statically.
2687 }
2692 }
2694 }
2696 /**
2697 * Get all subpages of this page.
2698 *
2699 * @param $limit Int maximum number of subpages to fetch; -1 for no limit
2700 * @return mixed TitleArray, or empty array if this page's namespace
2701 * doesn't allow subpages
2702 */
2706 }
2714 }
2719 __METHOD__,
2720 $options
2721 )
2722 );
2723 }
2725 /**
2726 * Is there a version of this page in the deletion archive?
2727 *
2728 * @return Int the number of archived revisions
2729 */
2738 __METHOD__
2739 );
2743 __METHOD__
2744 );
2745 }
2746 }
2748 }
2750 /**
2751 * Is there a version of this page in the deletion archive?
2752 *
2753 * @return Boolean
2754 */
2758 }
2762 __METHOD__
2763 );
2767 __METHOD__
2768 );
2769 }
2771 }
2773 /**
2774 * Get the article ID for this Title from the link cache,
2775 * adding it if necessary
2776 *
2777 * @param $flags Int a bit field; may be Title::GAID_FOR_UPDATE to select
2778 * for update
2779 * @return Int the ID
2780 */
2784 }
2794 }
2795 }
2797 }
2799 /**
2800 * Is this an article that is a redirect page?
2801 * Uses link cache, adding it if necessary
2802 *
2803 * @param $flags Int a bit field; may be Title::GAID_FOR_UPDATE to select for update
2804 * @return Bool
2805 */
2809 }
2810 # Calling getArticleID() loads the field from cache as needed
2813 }
2818 }
2820 /**
2821 * What is the length of this page?
2822 * Uses link cache, adding it if necessary
2823 *
2824 * @param $flags Int a bit field; may be Title::GAID_FOR_UPDATE to select for update
2825 * @return Int
2826 */
2830 }
2831 # Calling getArticleID() loads the field from cache as needed
2834 }
2839 }
2841 /**
2842 * What is the page_latest field for this page?
2843 *
2844 * @param $flags Int a bit field; may be Title::GAID_FOR_UPDATE to select for update
2845 * @return Int or 0 if the page doesn't exist
2846 */
2850 }
2851 # Calling getArticleID() loads the field from cache as needed
2854 }
2859 }
2861 /**
2862 * This clears some fields in this object, and clears any associated
2863 * keys in the "bad links" section of the link cache.
2864 *
2865 * - This is called from WikiPage::doEdit() and WikiPage::insertOn() to allow
2866 * loading of the new page_id. It's also called from
2867 * WikiPage::doDeleteArticle()
2868 *
2869 * @param $newid Int the new Article ID
2870 */
2879 }
2886 }
2888 /**
2889 * Capitalize a text string for a title if it belongs to a namespace that capitalizes
2890 *
2891 * @param $text String containing title to capitalize
2892 * @param $ns int namespace index, defaults to NS_MAIN
2893 * @return String containing capitalized title
2894 */
2902 }
2903 }
2905 /**
2906 * Secure and split - main initialisation function for this object
2907 *
2908 * Assumes that mDbkeyform has been set, and is urldecoded
2909 * and uses underscores, but not otherwise munged. This function
2910 * removes illegal characters, splits off the interwiki and
2911 * namespace prefixes, sets the other forms, and canonicalizes
2912 * everything.
2913 *
2914 * @return Bool true on success
2915 */
2919 # Initialisation
2925 # Strip Unicode bidi override characters.
2926 # Sometimes they slip into cut-n-pasted page titles, where the
2927 # override chars get included in list displays.
2930 # Clean up whitespace
2931 # Note: use of the /u option on preg_replace here will cause
2932 # input with invalid UTF-8 sequences to be nullified out in PHP 5.2.x,
2933 # conveniently disabling them.
2934 $dbkey = preg_replace( '/[ _\xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}]+/u', '_', $dbkey );
2939 }
2942 # Contained illegal UTF-8 sequences or forbidden Unicode chars.
2944 }
2948 # Initial colon indicates main namespace rather than specified default
2949 # but should not create invalid {ns,title} pairs such as {0,Project:Foo}
2954 }
2956 # Namespace or interwiki prefix
2964 # Ordinary namespace
2967 # For Talk:X pages, check if X has a "namespace" prefix
2970 # Disallow Talk:File:x type titles...
2973 # Disallow Talk:Interwiki:x type titles...
2975 }
2976 }
2979 # Can't make a local interwiki link to an interwiki link.
2980 # That's just crazy!
2982 }
2984 # Interwiki link
2988 # Redundant interwiki prefix to the local wiki
2991 {
2993 # Can't have an empty self-link
2995 }
2998 # Do another namespace split...
3000 }
3002 # If there's an initial colon after the interwiki, that also
3003 # resets the default namespace
3007 }
3008 }
3009 # If there's no recognized interwiki or namespace,
3010 # then let the colon expression be part of the title.
3011 }
3015 # We already know that some pages won't be in the database!
3018 }
3023 # remove whitespace again: prevents "Foo_bar_#"
3024 # becoming "Foo_bar_"
3026 }
3028 # Reject illegal characters.
3032 }
3034 # Pages with "/./" or "/../" appearing in the URLs will often be un-
3035 # reachable due to the way web browsers deal with 'relative' URLs.
3036 # Also, they conflict with subpage syntax. Forbid them explicitly.
3045 {
3047 }
3049 # Magic tilde sequences? Nu-uh!
3052 }
3054 # Limit the size of titles to 255 bytes. This is typically the size of the
3055 # underlying database field. We make an exception for special pages, which
3056 # don't need to be stored in the database, and may edge over 255 bytes due
3057 # to subpage syntax for long titles, e.g. [[Special:Block/Long name]]
3060 {
3062 }
3064 # Normally, all wiki links are forced to have an initial capital letter so [[foo]]
3065 # and [[Foo]] point to the same place. Don't force it for interwikis, since the
3066 # other site might be case-sensitive.
3070 }
3072 # Can't make a link to a namespace alone... "empty" local links can only be
3073 # self-links with a fragment identifier.
3076 }
3078 // Allow IPv6 usernames to start with '::' by canonicalizing IPv6 titles.
3079 // IP names are not allowed for accounts, and can only be referring to
3080 // edits from the IP. Given '::' abbreviations and caps/lowercaps,
3081 // there are numerous ways to present the same IP. Having sp:contribs scan
3082 // them all is silly and having some show the edits and others not is
3083 // inconsistent. Same for talk/userpages. Keep them normalized instead.
3088 // Any remaining initial :s are illegal.
3091 }
3093 # Fill fields
3100 }
3102 /**
3103 * Get an array of Title objects linking to this Title
3104 * Also stores the IDs in the link cache.
3105 *
3106 * WARNING: do not use this function on arbitrary user-supplied titles!
3107 * On heavily-used templates it will max out the memory.
3108 *
3109 * @param $options Array: may be FOR UPDATE
3110 * @param $table String: table name
3111 * @param $prefix String: fields prefix
3112 * @return Array of Title objects linking here
3113 */
3119 }
3123 array( 'page_namespace', 'page_title', 'page_id', 'page_len', 'page_is_redirect', 'page_latest' ),
3128 __METHOD__,
3129 $options
3130 );
3140 }
3141 }
3142 }
3144 }
3146 /**
3147 * Get an array of Title objects using this Title as a template
3148 * Also stores the IDs in the link cache.
3149 *
3150 * WARNING: do not use this function on arbitrary user-supplied titles!
3151 * On heavily-used templates it will max out the memory.
3152 *
3153 * @param $options Array: may be FOR UPDATE
3154 * @return Array of Title the Title objects linking here
3155 */
3158 }
3160 /**
3161 * Get an array of Title objects linked from this Title
3162 * Also stores the IDs in the link cache.
3163 *
3164 * WARNING: do not use this function on arbitrary user-supplied titles!
3165 * On heavily-used templates it will max out the memory.
3166 *
3167 * @param $options Array: may be FOR UPDATE
3168 * @param $table String: table name
3169 * @param $prefix String: fields prefix
3170 * @return Array of Title objects linking here
3171 */
3175 # If the page doesn't exist; there can't be any link from this page
3178 }
3184 }
3191 array( $namespaceFiled, $titleField, 'page_id', 'page_len', 'page_is_redirect', 'page_latest' ),
3193 __METHOD__,
3195 array( 'page' => array( 'LEFT JOIN', array( "page_namespace=$namespaceFiled", "page_title=$titleField" ) ) )
3196 );
3208 }
3210 }
3211 }
3212 }
3214 }
3216 /**
3217 * Get an array of Title objects used on this Title as a template
3218 * Also stores the IDs in the link cache.
3219 *
3220 * WARNING: do not use this function on arbitrary user-supplied titles!
3221 * On heavily-used templates it will max out the memory.
3222 *
3223 * @param $options Array: may be FOR UPDATE
3224 * @return Array of Title the Title objects used here
3225 */
3228 }
3230 /**
3231 * Get an array of Title objects referring to non-existent articles linked from this page
3232 *
3233 * @todo check if needed (used only in SpecialBrokenRedirects.php, and should use redirect table in this case)
3234 * @return Array of Title the Title objects
3235 */
3238 # All links from article ID 0 are false positives
3240 }
3248 'page_namespace IS NULL'
3249 ),
3255 )
3256 )
3257 );
3262 }
3264 }
3267 /**
3268 * Get a list of URLs to purge from the Squid cache when this
3269 * page changes
3270 *
3271 * @return Array of String the URLs
3272 */
3279 );
3281 // purge variant urls as well
3286 }
3287 }
3290 }
3292 /**
3293 * Purge all applicable Squid URLs
3294 */
3301 }
3302 }
3304 /**
3305 * Move this page without authentication
3306 *
3307 * @param $nt Title the new page Title
3308 * @return Mixed true on success, getUserPermissionsErrors()-like array on failure
3309 */
3312 }
3314 /**
3315 * Check whether a given move operation would be valid.
3316 * Returns true if ok, or a getUserPermissionsErrors()-like array otherwise
3317 *
3318 * @param $nt Title the new title
3319 * @param $auth Bool indicates whether $wgUser's permissions
3320 * should be checked
3321 * @param $reason String is the log summary of the move, used for spam checking
3322 * @return Mixed True on success, getUserPermissionsErrors()-like array on failure
3323 */
3329 // Normally we'd add this to $errors, but we'll get
3330 // lots of syntax errors if $nt is not an object
3332 }
3335 }
3338 }
3341 }
3344 }
3351 }
3356 }
3358 // Image-specific checks
3361 }
3365 }
3373 }
3377 // This is kind of lame, won't display nice
3379 }
3384 }
3386 # The move is allowed only if (1) the target doesn't exist, or
3387 # (2) the target is a redirect to the source, and has no history
3388 # (so we can undo bad moves right after they're done).
3393 }
3399 }
3400 }
3403 }
3405 }
3407 /**
3408 * Check if the requested move target is a valid file move target
3409 * @param Title $nt Target title
3410 * @return array List of errors
3411 */
3417 // wfFindFile( $nt ) / wfLocalFile( $nt ) is not allowed until below
3423 }
3426 }
3427 }
3431 // From here we want to do checks on a file object, so if we can't
3432 // create one, we must return.
3434 }
3436 // wfFindFile( $nt ) / wfLocalFile( $nt ) is allowed below here
3441 }
3444 }
3446 /**
3447 * Move a title to a new location
3448 *
3449 * @param $nt Title the new title
3450 * @param $auth Bool indicates whether $wgUser's permissions
3451 * should be checked
3452 * @param $reason String the reason for the move
3453 * @param $createRedirect Bool Whether to create a redirect from the old title to the new title.
3454 * Ignored if the user doesn't have the suppressredirect right.
3455 * @return Mixed true on success, getUserPermissionsErrors()-like array on failure
3456 */
3461 // Auto-block user's IP if the account was "hard" blocked
3464 }
3466 // If it is a file, move it first.
3467 // It is done before all other moving stuff is done because it's hard to revert.
3475 }
3476 }
3477 // Clear RepoGroup process cache
3480 }
3482 $dbw->begin( __METHOD__ ); # If $file was a LocalFile, its transaction would have closed our own.
3486 // Do the actual move
3489 # @todo FIXME: What about the File we have already moved?
3492 }
3494 // Refresh the sortkey for this row. Be careful to avoid resetting
3495 // cl_timestamp, which may disturb time-based lists on some sites.
3500 __METHOD__
3501 );
3513 __METHOD__
3514 );
3515 }
3520 # Protect the redirect title as the title used to be...
3529 ),
3531 __METHOD__,
3533 );
3534 # Update the protection log
3536 $comment = wfMsgForContent( 'prot_1movedto2', $this->getPrefixedText(), $nt->getPrefixedText() );
3539 }
3540 // @todo FIXME: $params?
3542 }
3544 # Update watchlists
3552 }
3558 }
3560 /**
3561 * Move page to a title which is either a redirect to the
3562 * source page or nonexistent
3563 *
3564 * @param $nt Title the page to move to, which should be a redirect or nonexistent
3565 * @param $reason String The reason for the move
3566 * @param $createRedirect Bool Whether to leave a redirect at the old title. Ignored
3567 * if the user doesn't have the suppressredirect right
3568 */
3578 }
3589 ) );
3596 }
3597 # Truncate for whole multibyte characters.
3609 # Delete the old redirect. We don't save it to history since
3610 # by definition if we've got here it's rather uninteresting.
3611 # We have to remove it so that the next step doesn't trigger
3612 # a conflict on the unique namespace+title index...
3616 }
3618 # Save a null revision in the page's history notifying of the move
3622 }
3625 # Change the name of the target page:
3630 ),
3632 __METHOD__
3633 );
3647 }
3649 # Recreate the redirect, this time in the other direction.
3669 }
3670 }
3672 # Log the move
3675 }
3677 /**
3678 * Move this page's subpages to be subpages of $nt
3679 *
3680 * @param $nt Title Move target
3681 * @param $auth bool Whether $wgUser's permissions should be checked
3682 * @param $reason string The reason for the move
3683 * @param $createRedirect bool Whether to create redirects from the old subpages to
3684 * the new ones Ignored if the user doesn't have the 'suppressredirect' right
3685 * @return mixed array with old page titles as keys, and strings (new page titles) or
3686 * arrays (errors) as values, or an error array with numeric indices if no pages
3687 * were moved
3688 */
3691 // Check permissions
3694 }
3695 // Do the source and target namespaces support subpages?
3699 }
3703 }
3715 }
3717 // We don't know whether this function was called before
3718 // or after moving the root page, so check both
3719 // $this and $nt
3722 {
3723 // When moving a page to a subpage of itself,
3724 // don't move it twice
3726 }
3735 }
3736 # Bug 14385: we need makeTitleSafe because the new page names may
3737 # be longer than 255 characters.
3745 }
3746 }
3748 }
3750 /**
3751 * Checks if this page is just a one-rev redirect.
3752 * Adds lock, so don't use just for light purposes.
3753 *
3754 * @return Bool
3755 */
3758 # Is it a redirect?
3762 __METHOD__,
3764 );
3765 # Cache some fields we may want
3771 }
3772 # Does the article have a history?
3778 'page_latest != rev_id'
3779 ),
3780 __METHOD__,
3782 );
3783 # Return true if there was no history
3785 }
3787 /**
3788 * Checks if $this can be moved to a given Title
3789 * - Selects for update, so don't call it unless you mean business
3790 *
3791 * @param $nt Title the new title to check
3792 * @return Bool
3793 */
3795 # Is it an existing file?
3801 }
3802 }
3803 # Is it a redirect with no history?
3807 }
3808 # Get the article text
3812 }
3814 # Does the redirect point to the source?
3815 # Or is it a broken self-redirect, usually caused by namespace collisions?
3824 }
3826 # Fail safe
3829 }
3831 }
3833 /**
3834 * Get categories to which this Title belongs and return an array of
3835 * categories' names.
3836 *
3837 * @return Array of parents in the form:
3838 * $parent => $currentarticle
3839 */
3849 }
3856 ),
3857 __METHOD__,
3859 );
3863 // $data[] = Title::newFromText($wgContLang->getNSText ( NS_CATEGORY ).':'.$row->cl_to);
3865 }
3866 }
3868 }
3870 /**
3871 * Get a tree of parent categories
3872 *
3873 * @param $children Array with the children in the keys, to check for circular refs
3874 * @return Array Tree of parent categories
3875 */
3883 # Circular reference
3889 }
3890 }
3891 }
3892 }
3895 }
3897 /**
3898 * Get an associative array for selecting this title from
3899 * the "page" table
3900 *
3901 * @return Array suitable for the $where parameter of DB::select()
3902 */
3905 // PK avoids secondary lookups in InnoDB, shouldn't hurt other DBs
3909 }
3910 }
3912 /**
3913 * Get the revision ID of the previous revision
3914 *
3915 * @param $revId Int Revision ID. Get the revision that was before this one.
3916 * @param $flags Int Title::GAID_FOR_UPDATE
3917 * @return Int|Bool Old revision ID, or FALSE if none exists
3918 */
3925 ),
3926 __METHOD__,
3928 );
3934 }
3935 }
3937 /**
3938 * Get the revision ID of the next revision
3939 *
3940 * @param $revId Int Revision ID. Get the revision that was after this one.
3941 * @param $flags Int Title::GAID_FOR_UPDATE
3942 * @return Int|Bool Next revision ID, or FALSE if none exists
3943 */
3950 ),
3951 __METHOD__,
3953 );
3959 }
3960 }
3962 /**
3963 * Get the first revision of the page
3964 *
3965 * @param $flags Int Title::GAID_FOR_UPDATE
3966 * @return Revision|Null if page doesn't exist
3967 */
3974 __METHOD__,
3976 );
3979 }
3980 }
3982 }
3984 /**
3985 * Get the oldest revision timestamp of this page
3986 *
3987 * @param $flags Int Title::GAID_FOR_UPDATE
3988 * @return String: MW timestamp
3989 */
3993 }
3995 /**
3996 * Check if this is a new page
3997 *
3998 * @return bool
3999 */
4003 }
4005 /**
4006 * Check whether the number of revisions of this page surpasses $wgDeleteRevisionsLimit
4007 *
4008 * @return bool
4009 */
4015 }
4019 }
4021 /**
4022 * Get the approximate revision count of this page.
4023 *
4024 * @return int
4025 */
4029 }
4035 }
4038 }
4040 /**
4041 * Get the number of revisions between the given revision.
4042 * Used for diffs and other things that really need it.
4043 *
4044 * @param $old int|Revision Old revision or rev ID (first before range)
4045 * @param $new int|Revision New revision or rev ID (first after range)
4046 * @return Int Number of revisions between these revisions.
4047 */
4051 }
4054 }
4057 }
4064 ),
4065 __METHOD__
4066 );
4067 }
4069 /**
4070 * Get the number of authors between the given revision IDs.
4071 * Used for diffs and other things that really need it.
4072 *
4073 * @param $old int|Revision Old revision or rev ID (first before range)
4074 * @param $new int|Revision New revision or rev ID (first after range)
4075 * @param $limit Int Maximum number of authors
4076 * @return Int Number of revision authors between these revisions.
4077 */
4081 }
4084 }
4087 }
4096 );
4098 }
4100 /**
4101 * Compare with another title.
4102 *
4103 * @param $title Title
4104 * @return Bool
4105 */
4107 // Note: === is necessary for proper matching of number-like titles.
4111 }
4113 /**
4114 * Check if this title is a subpage of another title
4115 *
4116 * @param $title Title
4117 * @return Bool
4118 */
4123 }
4125 /**
4126 * Check if page exists. For historical reasons, this function simply
4127 * checks for the existence of the title in the page table, and will
4128 * thus return false for interwiki links, special pages and the like.
4129 * If you want to know if a title can be meaningfully viewed, you should
4130 * probably call the isKnown() method instead.
4131 *
4132 * @return Bool
4133 */
4136 }
4138 /**
4139 * Should links to this title be shown as potentially viewable (i.e. as
4140 * "bluelinks"), even if there's no record by this title in the page
4141 * table?
4142 *
4143 * This function is semi-deprecated for public use, as well as somewhat
4144 * misleadingly named. You probably just want to call isKnown(), which
4145 * calls this function internally.
4146 *
4147 * (ISSUE: Most of these checks are cheap, but the file existence check
4148 * can potentially be quite expensive. Including it here fixes a lot of
4149 * existing code, but we might want to add an optional parameter to skip
4150 * it and any other expensive checks.)
4151 *
4152 * @return Bool
4153 */
4157 /**
4158 * Allows overriding default behaviour for determining if a page exists.
4159 * If $isKnown is kept as null, regular checks happen. If it's
4160 * a boolean, this value is returned by the isKnown method.
4161 *
4162 * @since 1.20
4163 *
4164 * @param Title $title
4165 * @param boolean|null $isKnown
4166 */
4171 }
4175 }
4180 // file exists, possibly in a foreign repo
4183 // valid special page
4186 // selflink, possibly with fragment
4189 // known system message
4193 }
4194 }
4196 /**
4197 * Does this title refer to a page that can (or might) be meaningfully
4198 * viewed? In particular, this function may be used to determine if
4199 * links to the title should be rendered as "bluelinks" (as opposed to
4200 * "redlinks" to non-existent pages).
4201 * Adding something else to this function will cause inconsistency
4202 * since LinkHolderArray calls isAlwaysKnown() and does its own
4203 * page existence check.
4204 *
4205 * @return Bool
4206 */
4209 }
4211 /**
4212 * Does this page have source text?
4213 *
4214 * @return Boolean
4215 */
4219 }
4222 // If the page doesn't exist but is a known system message, default
4223 // message content will be displayed, same for language subpages-
4224 // Use always content language to avoid loading hundreds of languages
4225 // to get the link color.
4227 list( $name, $lang ) = MessageCache::singleton()->figureMessage( $wgContLang->lcfirst( $this->getText() ) );
4230 }
4233 }
4235 /**
4236 * Get the default message text or false if the message doesn't exist
4237 *
4238 * @return String or false
4239 */
4245 }
4247 list( $name, $lang ) = MessageCache::singleton()->figureMessage( $wgContLang->lcfirst( $this->getText() ) );
4254 }
4255 }
4257 /**
4258 * Updates page_touched for this page; called from LinksUpdate.php
4259 *
4260 * @return Bool true if the update succeded
4261 */
4265 }
4271 __METHOD__
4272 );
4275 }
4277 /**
4278 * Update page_touched timestamps and send squid purge messages for
4279 * pages linking to this title. May be sent to the job queue depending
4280 * on the number of links. Typically called on create and delete.
4281 */
4289 }
4290 }
4292 /**
4293 * Get the last touched timestamp
4294 *
4295 * @param $db DatabaseBase: optional db
4296 * @return String last-touched timestamp
4297 */
4302 }
4304 /**
4305 * Get the timestamp when this page was updated since the user last saw it.
4306 *
4307 * @param $user User
4308 * @return String|Null
4309 */
4312 // Assume current user if none given
4315 }
4316 // Check cache first
4318 // avoid isset here, as it'll return false for null entries
4321 }
4324 }
4325 // Don't cache too much!
4328 }
4336 ),
4337 __METHOD__
4338 );
4340 }
4342 /**
4343 * Generate strings used for xml 'id' names in monobook tabs
4344 *
4345 * @param $prepend string defaults to 'nstab-'
4346 * @return String XML 'id' name
4347 */
4350 // Gets the subject namespace if this title
4352 // Checks if cononical namespace name exists for namespace
4354 // Uses canonical namespace name
4357 // Uses text of namespace
4359 }
4360 // Makes namespace key lowercase
4362 // Uses main
4365 }
4366 // Changes file to image for backwards compatibility
4369 }
4371 }
4373 /**
4374 * Get all extant redirects to this Title
4375 *
4376 * @param $ns Int|Null Single namespace to consider; NULL to consider all namespaces
4377 * @return Array of Title redirects to this title
4378 */
4386 'rd_from = page_id'
4387 );
4390 }
4396 __METHOD__
4397 );
4401 }
4403 }
4405 /**
4406 * Check if this Title is a valid redirect target
4407 *
4408 * @return Bool
4409 */
4413 // invalid redirect targets are stored in a global array, but explicity disallow Userlogout here
4416 }
4421 }
4422 }
4425 }
4427 /**
4428 * Get a backlink cache object
4429 *
4430 * @return BacklinkCache
4431 */
4435 }
4437 }
4439 /**
4440 * Whether the magic words __INDEX__ and __NOINDEX__ function for this page.
4441 *
4442 * @return Boolean
4443 */
4448 ? $wgContentNamespaces
4453 }
4455 /**
4456 * Returns the raw sort key to be used for categories, with the specified
4457 * prefix. This will be fed to Collation::getSortKey() to get a
4458 * binary sortkey that can be used for actual sorting.
4459 *
4460 * @param $prefix string The prefix to be used, specified using
4461 * {{defaultsort:}} or like [[Category:Foo|prefix]]. Empty for no
4462 * prefix.
4463 * @return string
4464 */
4468 // Anything that uses this hook should only depend
4469 // on the Title object passed in, and should probably
4470 // tell the users to run updateCollations.php --force
4471 // in order to re-sort existing category relations.
4474 # Separate with a line feed, so the unprefixed part is only used as
4475 # a tiebreaker when two pages have the exact same prefix.
4476 # In UCA, tab is the only character that can sort above LF
4477 # so we strip both of them from the original prefix.
4480 }
4482 }
4484 /**
4485 * Get the language in which the content of this page is written.
4486 * Defaults to $wgContLang, but in certain cases it can be e.g.
4487 * $wgLang (such as special pages, which are in the user language).
4488 *
4489 * @since 1.18
4490 * @return Language
4491 */
4495 // special pages are in the user language
4498 // css/js should always be LTR and is, in fact, English
4501 // Parse mediawiki messages with correct target language
4504 }
4506 // If nothing special, it should be in the wiki content language
4508 // Hook at the end because we don't want to override the above stuff
4511 }
4512 }