| blob | 64852284521d2feaf4aff261b92e8314e6a2f52b |
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()
86 // @}
89 /**
90 * Constructor
91 */
94 /**
95 * Create a new Title from a prefixed DB key
96 *
97 * @param $key String the database key, which has underscores
98 * instead of spaces, possibly including namespace and
99 * interwiki prefixes
100 * @return Title, or NULL on an error
101 */
109 }
110 }
112 /**
113 * Create a new Title from text, such as what one would find in a link. De-
114 * codes any HTML entities in the text.
115 *
116 * @param $text String the link text; spaces, prefixes, and an
117 * initial ':' indicating the main namespace are accepted.
118 * @param $defaultNamespace Int the namespace to use if none is speci-
119 * fied by a prefix. If you want to force a specific namespace even if
120 * $text might begin with a namespace prefix, use makeTitle() or
121 * makeTitleSafe().
122 * @return Title, or null on an error.
123 */
127 }
129 /**
130 * Wiki pages often contain multiple links to the same page.
131 * Title normalization and parsing can become expensive on
132 * pages with many links, so we can save a little time by
133 * caching them.
134 *
135 * In theory these are value objects and won't get changed...
136 */
139 }
141 # Convert things like é ā or 〗 into normalized (bug 14952) text
152 # Avoid memory leaks on mass operations...
155 }
158 }
163 }
164 }
166 /**
167 * THIS IS NOT THE FUNCTION YOU WANT. Use Title::newFromText().
168 *
169 * Example of wrong and broken code:
170 * $title = Title::newFromURL( $wgRequest->getVal( 'title' ) );
171 *
172 * Example of right code:
173 * $title = Title::newFromText( $wgRequest->getVal( 'title' ) );
174 *
175 * Create a new Title from URL-encoded text. Ensures that
176 * the given title's length does not exceed the maximum.
177 *
178 * @param $url String the title, as might be taken from a URL
179 * @return Title the new object, or NULL on an error
180 */
185 # For compatibility with old buggy URLs. "+" is usually not valid in titles,
186 # but some URLs used it as a space replacement and they still come
187 # from some external search tools.
190 }
197 }
198 }
200 /**
201 * Create a new Title from an article ID
202 *
203 * @param $id Int the page_id corresponding to the Title to create
204 * @param $flags Int use Title::GAID_FOR_UPDATE to use master
205 * @return Title the new object, or NULL on an error
206 */
214 }
216 }
218 /**
219 * Make an array of titles from an array of IDs
220 *
221 * @param $ids Array of Int Array of IDs
222 * @return Array of Titles
223 */
227 }
235 ),
237 __METHOD__
238 );
243 }
245 }
247 /**
248 * Make a Title object from a DB row
249 *
250 * @param $row Object database row (needs at least page_title,page_namespace)
251 * @return Title corresponding Title
252 */
257 }
259 /**
260 * Load Title object fields from a DB row.
261 * If false is given, the title will be treated as non-existing.
262 *
263 * @param $row Object|bool database row
264 */
280 }
281 }
283 /**
284 * Create a new Title from a namespace index and a DB key.
285 * It's assumed that $ns and $title are *valid*, for instance when
286 * they came directly from the database or a special page name.
287 * For convenience, spaces are converted to underscores so that
288 * eg user_text fields can be used directly.
289 *
290 * @param $ns Int the namespace of the article
291 * @param $title String the unprefixed database key form
292 * @param $fragment String the link fragment (after the "#")
293 * @param $interwiki String the interwiki prefix
294 * @return Title the new object
295 */
306 }
308 /**
309 * Create a new Title from a namespace index and a DB key.
310 * The parameters will be checked for validity, which is a bit slower
311 * than makeTitle() but safer for user-provided data.
312 *
313 * @param $ns Int the namespace of the article
314 * @param $title String database key form
315 * @param $fragment String the link fragment (after the "#")
316 * @param $interwiki String interwiki prefix
317 * @return Title the new object, or NULL on an error
318 */
326 }
327 }
329 /**
330 * Create a new Title for the Main Page
331 *
332 * @return Title the new object
333 */
336 // Don't give fatal errors if the message is broken
339 }
341 }
343 /**
344 * Extract a redirect destination from a string and return the
345 * Title, or null if the text doesn't contain a valid redirect
346 * This will only return the very next target, useful for
347 * the redirect table and other checks that don't need full recursion
348 *
349 * @param $text String: Text with possible redirect
350 * @return Title: The corresponding Title
351 */
354 }
356 /**
357 * Extract a redirect destination from a string and return the
358 * Title, or null if the text doesn't contain a valid redirect
359 * This will recurse down $wgMaxRedirects times or until a non-redirect target is hit
360 * in order to provide (hopefully) the Title of the final destination instead of another redirect
361 *
362 * @param $text String Text with possible redirect
363 * @return Title
364 */
368 }
370 /**
371 * Extract a redirect destination from a string and return an
372 * array of Titles, or null if the text doesn't contain a valid redirect
373 * The last element in the array is the final destination after all redirects
374 * have been resolved (up to $wgMaxRedirects times)
375 *
376 * @param $text String Text with possible redirect
377 * @return Array of Titles, with the destination last
378 */
384 }
385 // recursive check to follow double redirects
394 }
395 // Redirects to some special pages are not permitted
397 // the new title passes the checks, so make that our current title so that further recursion can be checked
402 }
403 }
405 }
407 /**
408 * Really extract the redirect destination
409 * Do not call this function directly, use one of the newFromRedirect* functions above
410 *
411 * @param $text String Text with possible redirect
412 * @return Title
413 */
417 //redirects are disabled, so quit early
419 }
423 // Extract the first link and see if it's usable
424 // Ensure that it really does come directly after #REDIRECT
425 // Some older redirects included a colon, so don't freak about that!
428 // Strip preceding colon used to "escape" categories, etc.
429 // and URL-decode links
431 // Match behavior of inline link parsing here;
433 }
435 // If the title is a redirect to bad special pages or is invalid, return null
438 }
440 }
441 }
443 }
445 /**
446 * Get the prefixed DB key associated with an ID
447 *
448 * @param $id Int the page_id of the article
449 * @return Title an object representing the article, or NULL if no such article was found
450 */
458 __METHOD__
459 );
462 }
466 }
468 /**
469 * Get a regex character class describing the legal characters in a link
470 *
471 * @return String the list of characters, not delimited
472 */
476 }
478 /**
479 * Returns a simple regex that will match on characters and sequences invalid in titles.
480 * Note that this doesn't pick up many things that could be wrong with titles, but that
481 * replacing this regex with something valid will make many titles valid.
482 *
483 * @return String regex string
484 */
488 # Matching titles will be held as illegal.
490 # Any character not allowed is forbidden...
492 # URL percent encoding sequences interfere with the ability
493 # to round-trip titles -- you can't link to them consistently.
495 # XML/HTML character references produce similar issues.
500 }
503 }
505 /**
506 * Get a string representation of a title suitable for
507 * including in a search index
508 *
509 * @param $ns Int a namespace index
510 * @param $title String text-form main part
511 * @return String a stripped-down title string ready for the search index
512 */
521 # Handle 's, s'
529 }
531 }
533 /**
534 * Make a prefixed DB key from a DB key and a namespace index
535 *
536 * @param $ns Int numerical representation of the namespace
537 * @param $title String the DB key form the title
538 * @param $fragment String The link fragment (after the "#")
539 * @param $interwiki String The interwiki prefix
540 * @return String the prefixed form of the title
541 */
549 }
552 }
554 }
556 /**
557 * Escape a text fragment, say from a link, for a URL
558 *
559 * @param $fragment string containing a URL or link fragment (after the "#")
560 * @return String: escaped string
561 */
563 # Note that we don't urlencode the fragment. urlencoded Unicode
564 # fragments appear not to work in IE (at least up to 7) or in at least
565 # one version of Opera 9.x. The W3C validator, for one, doesn't seem
566 # to care if they aren't encoded.
568 }
570 /**
571 * Callback for usort() to do title sorts by (namespace, title)
572 *
573 * @param $a Title
574 * @param $b Title
575 *
576 * @return Integer: result of string comparison, or namespace comparison
577 */
583 }
584 }
586 /**
587 * Determine whether the object refers to a page within
588 * this project.
589 *
590 * @return Bool TRUE if this is an in-project interwiki link or a wikilink, FALSE otherwise
591 */
597 }
598 }
600 /**
601 * Is this Title interwiki?
602 *
603 * @return Bool
604 */
607 }
609 /**
610 * Get the interwiki prefix (or null string)
611 *
612 * @return String Interwiki prefix
613 */
616 }
618 /**
619 * Determine whether the object refers to a page within
620 * this project and is transcludable.
621 *
622 * @return Bool TRUE if this is transcludable
623 */
627 }
630 }
632 /**
633 * Returns the DB name of the distant wiki which owns the object.
634 *
635 * @return String the DB name
636 */
640 }
643 }
645 /**
646 * Get the text form (spaces not underscores) of the main part
647 *
648 * @return String Main part of the title
649 */
652 }
654 /**
655 * Get the URL-encoded form of the main part
656 *
657 * @return String Main part of the title, URL-encoded
658 */
661 }
663 /**
664 * Get the main part with underscores
665 *
666 * @return String: Main part of the title, with underscores
667 */
670 }
672 /**
673 * Get the DB key with the initial letter case as specified by the user
674 *
675 * @return String DB key
676 */
679 }
681 /**
682 * Get the namespace index, i.e. one of the NS_xxxx constants.
683 *
684 * @return Integer: Namespace index
685 */
688 }
690 /**
691 * Get the namespace text
692 *
693 * @return String: Namespace text
694 */
699 // This probably shouldn't even happen. ohh man, oh yuck.
700 // But for interwiki transclusion it sometimes does.
701 // Shit. Shit shit shit.
702 //
703 // Use the canonical namespaces if possible to try to
704 // resolve a foreign namespace.
707 }
708 }
710 // Strip off subpages
716 }
722 }
725 }
727 /**
728 * Get the namespace text of the subject (rather than talk) page
729 *
730 * @return String Namespace text
731 */
735 }
737 /**
738 * Get the namespace text of the talk page
739 *
740 * @return String Namespace text
741 */
745 }
747 /**
748 * Could this title have a corresponding talk page?
749 *
750 * @return Bool TRUE or FALSE
751 */
754 }
756 /**
757 * Is this in a namespace that allows actual pages?
758 *
759 * @return Bool
760 * @internal note -- uses hardcoded namespace index instead of constants
761 */
764 }
766 /**
767 * Can this title be added to a user's watchlist?
768 *
769 * @return Bool TRUE or FALSE
770 */
773 }
775 /**
776 * Returns true if this is a special page.
777 *
778 * @return boolean
779 */
782 }
784 /**
785 * Returns true if this title resolves to the named special page
786 *
787 * @param $name String The special page name
788 * @return boolean
789 */
795 }
796 }
798 }
800 /**
801 * If the Title refers to a special page alias which is not the local default, resolve
802 * the alias, and localise the name as necessary. Otherwise, return $this
803 *
804 * @return Title
805 */
813 }
814 }
815 }
817 }
819 /**
820 * Returns true if the title is inside the specified namespace.
821 *
822 * Please make use of this instead of comparing to getNamespace()
823 * This function is much more resistant to changes we may make
824 * to namespaces than code that makes direct comparisons.
825 * @param $ns int The namespace
826 * @return bool
827 * @since 1.19
828 */
831 }
833 /**
834 * Returns true if the title is inside one of the specified namespaces.
835 *
836 * @param ...$namespaces The namespaces to check for
837 * @return bool
838 * @since 1.19
839 */
844 }
849 }
850 }
853 }
855 /**
856 * Returns true if the title has the same subject namespace as the
857 * namespace specified.
858 * For example this method will take NS_USER and return true if namespace
859 * is either NS_USER or NS_USER_TALK since both of them have NS_USER
860 * as their subject namespace.
861 *
862 * This is MUCH simpler than individually testing for equivilance
863 * against both NS_USER and NS_USER_TALK, and is also forward compatible.
864 * @since 1.19
865 * @return bool
866 */
869 }
871 /**
872 * Is this Title in a namespace which contains content?
873 * In other words, is this a content page, for the purposes of calculating
874 * statistics, etc?
875 *
876 * @return Boolean
877 */
880 }
882 /**
883 * Would anybody with sufficient privileges be able to move this page?
884 * Some pages just aren't movable.
885 *
886 * @return Bool TRUE or FALSE
887 */
890 // Interwiki title or immovable namespace. Hooks don't get to override here
892 }
897 }
899 /**
900 * Is this the mainpage?
901 * @note Title::newFromText seams to be sufficiently optimized by the title
902 * cache that we don't need to over-optimize by doing direct comparisons and
903 * acidentally creating new bugs where $title->equals( Title::newFromText() )
904 * ends up reporting something differently than $title->isMainPage();
905 *
906 * @since 1.18
907 * @return Bool
908 */
911 }
913 /**
914 * Is this a subpage?
915 *
916 * @return Bool
917 */
922 }
924 /**
925 * Is this a conversion table for the LanguageConverter?
926 *
927 * @return Bool
928 */
932 }
934 /**
935 * Does that page contain wikitext, or it is JS, CSS or whatever?
936 *
937 * @return Bool
938 */
943 }
945 /**
946 * Could this page contain custom CSS or JavaScript, based
947 * on the title?
948 *
949 * @return Bool
950 */
956 }
958 /**
959 * Is this a .css or .js subpage of a user page?
960 * @return Bool
961 */
963 return ( NS_USER == $this->mNamespace and preg_match( "/\\/.*\\.(?:css|js)$/", $this->mTextform ) );
964 }
966 /**
967 * Trim down a .css or .js subpage title to get the corresponding skin name
968 *
969 * @return string containing skin name from .css or .js subpage title
970 */
978 }
980 /**
981 * Is this a .css subpage of a user page?
982 *
983 * @return Bool
984 */
987 }
989 /**
990 * Is this a .js subpage of a user page?
991 *
992 * @return Bool
993 */
996 }
998 /**
999 * Is this a talk page of some sort?
1000 *
1001 * @return Bool
1002 */
1005 }
1007 /**
1008 * Get a Title object associated with the talk page of this article
1009 *
1010 * @return Title the object for the talk page
1011 */
1014 }
1016 /**
1017 * Get a title object associated with the subject page of this
1018 * talk page
1019 *
1020 * @return Title the object for the subject page
1021 */
1023 // Is this the same title?
1027 }
1029 }
1031 /**
1032 * Get the default namespace index, for when there is no namespace
1033 *
1034 * @return Int Default namespace index
1035 */
1038 }
1040 /**
1041 * Get title for search index
1042 *
1043 * @return String a stripped-down title string ready for the
1044 * search index
1045 */
1048 }
1050 /**
1051 * Get the Title fragment (i.e.\ the bit after the #) in text form
1052 *
1053 * @return String Title fragment
1054 */
1057 }
1059 /**
1060 * Get the fragment in URL form, including the "#" character if there is one
1061 * @return String Fragment in URL form
1062 */
1068 }
1069 }
1071 /**
1072 * Set the fragment for this title. Removes the first character from the
1073 * specified fragment before setting, so it assumes you're passing it with
1074 * an initial "#".
1075 *
1076 * Deprecated for public use, use Title::makeTitle() with fragment parameter.
1077 * Still in active use privately.
1078 *
1079 * @param $fragment String text
1080 */
1083 }
1085 /**
1086 * Prefix some arbitrary text with the namespace or interwiki prefix
1087 * of this object
1088 *
1089 * @param $name String the text
1090 * @return String the prefixed text
1091 * @private
1092 */
1097 }
1101 }
1103 }
1105 /**
1106 * Get the prefixed database key form
1107 *
1108 * @return String the prefixed title, with underscores and
1109 * any interwiki and namespace prefixes
1110 */
1115 }
1117 /**
1118 * Get the prefixed title with spaces.
1119 * This is the form usually used for display
1120 *
1121 * @return String the prefixed title, with spaces
1122 */
1124 // @todo FIXME: Bad usage of empty() ?
1129 }
1131 }
1133 /**
1134 * Return a string representation of this title
1135 *
1136 * @return String representation of this title
1137 */
1140 }
1142 /**
1143 * Get the prefixed title with spaces, plus any fragment
1144 * (part beginning with '#')
1145 *
1146 * @return String the prefixed title, with spaces and the fragment, including '#'
1147 */
1152 }
1154 }
1156 /**
1157 * Get the base page name, i.e. the leftmost part before any slashes
1158 *
1159 * @return String Base name
1160 */
1164 }
1167 # Don't discard the real title if there's no subpage involved
1170 }
1172 }
1174 /**
1175 * Get the lowest-level subpage name, i.e. the rightmost part after any slashes
1176 *
1177 * @return String Subpage name
1178 */
1182 }
1185 }
1187 /**
1188 * Get the HTML-escaped displayable text form.
1189 * Used for the title field in <a> tags.
1190 *
1191 * @return String the text, including any prefixes
1192 */
1196 }
1198 /**
1199 * Get a URL-encoded form of the subpage text
1200 *
1201 * @return String URL-encoded subpage name
1202 */
1207 }
1209 /**
1210 * Get a URL-encoded title (not an actual URL) including interwiki
1211 *
1212 * @return String the URL-encoded form
1213 */
1218 }
1220 /**
1221 * Helper to fix up the get{Local,Full,Link,Canonical}URL args
1222 * get{Canonical,Full,Link,Local}URL methods accepted an optional
1223 * second argument named variant. This was deprecated in favor
1224 * of passing an array of option with a "variant" key
1225 * Once $query2 is removed for good, this helper can be dropped
1226 * andthe wfArrayToCGI moved to getLocalURL();
1227 *
1228 * @since 1.19 (r105919)
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 * @return String the URL
1412 */
1416 }
1418 /**
1419 * Get an HTML-escaped version of the URL form, suitable for
1420 * using in a link, including the server name and fragment
1421 *
1422 * See getLocalURL for the arguments.
1423 *
1424 * @see self::getLocalURL
1425 * @return String the URL
1426 */
1430 }
1432 /**
1433 * Get the URL form for an internal link.
1434 * - Used in various Squid-related code, in case we have a different
1435 * internal hostname for the server from the exposed one.
1436 *
1437 * This uses $wgInternalServer to qualify the path, or $wgServer
1438 * if $wgInternalServer is not set. If the server variable used is
1439 * protocol-relative, the URL will be expanded to http://
1440 *
1441 * See getLocalURL for the arguments.
1442 *
1443 * @see self::getLocalURL
1444 * @return String the URL
1445 */
1453 }
1455 /**
1456 * Get the URL for a canonical link, for use in things like IRC and
1457 * e-mail notifications. Uses $wgCanonicalServer and the
1458 * GetCanonicalURL hook.
1459 *
1460 * NOTE: Unlike getInternalURL(), the canonical URL includes the fragment
1461 *
1462 * See getLocalURL for the arguments.
1463 *
1464 * @see self::getLocalURL
1465 * @return string The URL
1466 * @since 1.18
1467 */
1470 $url = wfExpandUrl( $this->getLocalURL( $query ) . $this->getFragmentForURL(), PROTO_CANONICAL );
1473 }
1475 /**
1476 * HTML-escaped version of getCanonicalURL()
1477 *
1478 * See getLocalURL for the arguments.
1479 *
1480 * @see self::getLocalURL
1481 * @since 1.18
1482 * @return string
1483 */
1487 }
1489 /**
1490 * Get the edit URL for this Title
1491 *
1492 * @return String the URL, or a null string if this is an
1493 * interwiki link
1494 */
1498 }
1502 }
1504 /**
1505 * Is $wgUser watching this page?
1506 *
1507 * @return Bool
1508 */
1517 }
1518 }
1520 }
1522 /**
1523 * Can $wgUser read this page?
1524 *
1525 * @deprecated in 1.19; use userCan(), quickUserCan() or getUserPermissionsErrors() instead
1526 * @return Bool
1527 * @todo fold these checks into userCan()
1528 */
1532 }
1534 /**
1535 * Can $user perform $action on this page?
1536 * This skips potentially expensive cascading permission checks
1537 * as well as avoids expensive error formatting
1538 *
1539 * Suitable for use for nonessential UI controls in common cases, but
1540 * _not_ for functional access control.
1541 *
1542 * May provide false positives, but should never provide a false negative.
1543 *
1544 * @param $action String action that permission needs to be checked for
1545 * @param $user User to check (since 1.19); $wgUser will be used if not
1546 * provided.
1547 * @return Bool
1548 */
1551 }
1553 /**
1554 * Can $user perform $action on this page?
1555 *
1556 * @param $action String action that permission needs to be checked for
1557 * @param $user User to check (since 1.19); $wgUser will be used if not
1558 * provided.
1559 * @param $doExpensiveQueries Bool Set this to false to avoid doing
1560 * unnecessary queries.
1561 * @return Bool
1562 */
1567 }
1568 return !count( $this->getUserPermissionsErrorsInternal( $action, $user, $doExpensiveQueries, true ) );
1569 }
1571 /**
1572 * Can $user perform $action on this page?
1573 *
1574 * @todo FIXME: This *does not* check throttles (User::pingLimiter()).
1575 *
1576 * @param $action String action that permission needs to be checked for
1577 * @param $user User to check
1578 * @param $doExpensiveQueries Bool Set this to false to avoid doing unnecessary
1579 * queries by skipping checks for cascading protections and user blocks.
1580 * @param $ignoreErrors Array of Strings Set this to a list of message keys
1581 * whose corresponding errors may be ignored.
1582 * @return Array of arguments to wfMsg to explain permissions problems.
1583 */
1584 public function getUserPermissionsErrors( $action, $user, $doExpensiveQueries = true, $ignoreErrors = array() ) {
1587 // Remove the errors being ignored.
1593 }
1594 }
1597 }
1599 /**
1600 * Permissions checks that fail most often, and which are easiest to test.
1601 *
1602 * @param $action String the action to check
1603 * @param $user User user to check
1604 * @param $errors Array list of current errors
1605 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1606 * @param $short Boolean short circuit on first error
1607 *
1608 * @return Array list of errors
1609 */
1610 private function checkQuickPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1615 }
1619 // Show user page-specific message only if the user can move other pages
1621 }
1623 // Check if user is allowed to move files if it's a file
1626 }
1629 // User can't move anything
1634 }
1638 }
1640 // custom message if logged-in users without any special rights can move
1644 }
1645 }
1648 // User can't move anything
1652 // Show user page-specific message only if the user can move other pages
1654 }
1657 }
1660 }
1662 /**
1663 * Add the resulting error code to the errors array
1664 *
1665 * @param $errors Array list of current errors
1666 * @param $result Mixed result of errors
1667 *
1668 * @return Array list of errors
1669 */
1672 // A single array representing an error
1675 // A nested array representing multiple errors
1678 // A string representing a message-id
1681 // a generic "We don't want them to do that"
1683 }
1685 }
1687 /**
1688 * Check various permission hooks
1689 *
1690 * @param $action String the action to check
1691 * @param $user User user to check
1692 * @param $errors Array list of current errors
1693 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1694 * @param $short Boolean short circuit on first error
1695 *
1696 * @return Array list of errors
1697 */
1698 private function checkPermissionHooks( $action, $user, $errors, $doExpensiveQueries, $short ) {
1699 // Use getUserPermissionsErrors instead
1703 }
1704 // Check getUserPermissionsErrors hook
1707 }
1708 // Check getUserPermissionsErrorsExpensive hook
1710 !wfRunHooks( 'getUserPermissionsErrorsExpensive', array( &$this, &$user, $action, &$result ) ) ) {
1712 }
1715 }
1717 /**
1718 * Check permissions on special pages & namespaces
1719 *
1720 * @param $action String the action to check
1721 * @param $user User user to check
1722 * @param $errors Array list of current errors
1723 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1724 * @param $short Boolean short circuit on first error
1725 *
1726 * @return Array list of errors
1727 */
1728 private function checkSpecialsAndNSPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1729 # Only 'createaccount' and 'execute' can be performed on
1730 # special pages, which don't actually exist in the DB.
1734 }
1736 # Check $wgNamespaceProtection for restricted namespaces
1742 }
1745 }
1747 /**
1748 * Check CSS/JS sub-page permissions
1749 *
1750 * @param $action String the action to check
1751 * @param $user User user to check
1752 * @param $errors Array list of current errors
1753 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1754 * @param $short Boolean short circuit on first error
1755 *
1756 * @return Array list of errors
1757 */
1758 private function checkCSSandJSPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1759 # Protect css/js subpages of user pages
1760 # XXX: this might be better using restrictions
1761 # XXX: right 'editusercssjs' is deprecated, for backward compatibility only
1768 }
1769 }
1772 }
1774 /**
1775 * Check against page_restrictions table requirements on this
1776 * page. The user must possess all required rights for this
1777 * action.
1778 *
1779 * @param $action String the action to check
1780 * @param $user User user to check
1781 * @param $errors Array list of current errors
1782 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1783 * @param $short Boolean short circuit on first error
1784 *
1785 * @return Array list of errors
1786 */
1787 private function checkPageRestrictions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1789 // Backwards compatibility, rewrite sysop -> protect
1792 }
1794 // Users with 'editprotected' permission can edit protected pages
1795 // without cascading option turned on.
1798 {
1800 }
1801 }
1802 }
1805 }
1807 /**
1808 * Check restrictions on cascading pages.
1809 *
1810 * @param $action String the action to check
1811 * @param $user User to check
1812 * @param $errors Array list of current errors
1813 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1814 * @param $short Boolean short circuit on first error
1815 *
1816 * @return Array list of errors
1817 */
1818 private function checkCascadingSourcesRestrictions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1820 # We /could/ use the protection level on the source page, but it's
1821 # fairly ugly as we have to establish a precedence hierarchy for pages
1822 # included by multiple cascade-protected pages. So just restrict
1823 # it to people with 'protect' permission, as they could remove the
1824 # protection anyway.
1826 # Cascading protection depends on more than this page...
1827 # Several cascading protected pages may include this page...
1828 # Check each cascading level
1829 # This is only for protection restrictions, not for all actions
1838 }
1839 }
1840 }
1841 }
1844 }
1846 /**
1847 * Check action permissions not already checked in checkQuickPermissions
1848 *
1849 * @param $action String the action to check
1850 * @param $user User to check
1851 * @param $errors Array list of current errors
1852 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1853 * @param $short Boolean short circuit on first error
1854 *
1855 * @return Array list of errors
1856 */
1857 private function checkActionPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1861 if ( count( $this->getUserPermissionsErrorsInternal( 'edit', $user, $doExpensiveQueries, true ) ) ) {
1862 // If they can't edit, they shouldn't protect.
1864 }
1870 }
1873 {
1874 $errors[] = array( 'titleprotected', User::whoIs( $title_protection['pt_user'] ), $title_protection['pt_reason'] );
1875 }
1876 }
1878 // Check for immobile pages
1880 // Specific message for this case
1883 // Less specific message for rarer cases
1885 }
1891 }
1895 {
1897 }
1898 }
1900 }
1902 /**
1903 * Check that the user isn't blocked from editting.
1904 *
1905 * @param $action String the action to check
1906 * @param $user User to check
1907 * @param $errors Array list of current errors
1908 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1909 * @param $short Boolean short circuit on first error
1910 *
1911 * @return Array list of errors
1912 */
1914 // Account creation blocks handled at userlogin.
1915 // Unblocking handled in SpecialUnblock
1918 }
1924 }
1927 // Don't block the user from editing their own talk page unless they've been
1928 // explicitly blocked from that too.
1932 // This is from OutputPage::blockedPage
1933 // Copied at r23888 by werdna
1939 }
1946 }
1956 }
1960 $errors[] = array( ( $block->mAuto ? 'autoblockedtext' : 'blockedtext' ), $link, $reason, $ip, $name,
1962 }
1965 }
1967 /**
1968 * Check that the user is allowed to read this page.
1969 *
1970 * @param $action String the action to check
1971 * @param $user User to check
1972 * @param $errors Array list of current errors
1973 * @param $doExpensiveQueries Boolean whether or not to perform expensive queries
1974 * @param $short Boolean short circuit on first error
1975 *
1976 * @return Array list of errors
1977 */
1978 private function checkReadPermissions( $action, $user, $errors, $doExpensiveQueries, $short ) {
1982 # Initialize the $useShortcut boolean, to determine if we can skip quite a bit of code below
1986 # Not a public wiki, so no shortcut
1989 /**
1990 * Iterate through each group with permissions being revoked (key not included since we don't care
1991 * what the group name is), then check if the read permission is being revoked. If it is, then
1992 * we don't use the shortcut below since the user might not be able to read, even though anon
1993 * reading is allowed.
1994 */
1997 # We might be removing the read right from the user, so no shortcut
2000 }
2001 }
2002 }
2003 }
2007 # Shortcut for public wikis, allows skipping quite a bit of code
2010 # If the user is allowed to read pages, he is allowed to read all pages
2015 ) {
2016 # Always grant access to the login page.
2017 # Even anons need to be able to log in.
2020 # Time to check the whitelist
2021 # Only do these checks is there's something to check against
2025 // Check for explicit whitelisting with and without underscores
2026 if ( in_array( $name, $wgWhitelistRead, true ) || in_array( $dbName, $wgWhitelistRead, true ) ) {
2029 # Old settings might have the title prefixed with
2030 # a colon for main-namespace pages
2033 }
2035 # If it's a special page, ditch the subpage bit and check again
2042 }
2043 }
2044 }
2045 }
2048 # If the title is not whitelisted, give extensions a chance to do so...
2052 }
2053 }
2056 }
2058 /**
2059 * Get a description array when the user doesn't have the right to perform
2060 * $action (i.e. when User::isAllowed() returns false)
2061 *
2062 * @param $action String the action to check
2063 * @param $short Boolean short circuit on first error
2064 * @return Array list of errors
2065 */
2067 // We avoid expensive display logic for quickUserCan's and such
2070 }
2081 );
2084 }
2085 }
2087 /**
2088 * Can $user perform $action on this page? This is an internal function,
2089 * which checks ONLY that previously checked by userCan (i.e. it leaves out
2090 * checks on wfReadOnly() and blocks)
2091 *
2092 * @param $action String action that permission needs to be checked for
2093 * @param $user User to check
2094 * @param $doExpensiveQueries Bool Set this to false to avoid doing unnecessary queries.
2095 * @param $short Bool Set this to true to stop after the first permission error.
2096 * @return Array of arrays of the arguments to wfMsg to explain permissions problems.
2097 */
2098 protected function getUserPermissionsErrorsInternal( $action, $user, $doExpensiveQueries = true, $short = false ) {
2101 # Read has special handling
2106 );
2116 'checkUserBlock'
2117 );
2118 }
2125 }
2129 }
2131 /**
2132 * Protect css subpages of user pages: can $wgUser edit
2133 * this page?
2134 *
2135 * @deprecated in 1.19; will be removed in 1.20. Use getUserPermissionsErrors() instead.
2136 * @return Bool
2137 */
2143 }
2145 /**
2146 * Protect js subpages of user pages: can $wgUser edit
2147 * this page?
2148 *
2149 * @deprecated in 1.19; will be removed in 1.20. Use getUserPermissionsErrors() instead.
2150 * @return Bool
2151 */
2157 }
2159 /**
2160 * Get a filtered list of all restriction types supported by this wiki.
2161 * @param bool $exists True to get all restriction types that apply to
2162 * titles that do exist, False for all restriction types that apply to
2163 * titles that do not exist
2164 * @return array
2165 */
2170 # Remove the create restriction for existing titles
2173 # Only the create and upload restrictions apply to non-existing titles
2175 }
2177 }
2179 /**
2180 * Returns restriction types for the current Title
2181 *
2182 * @return array applicable restriction types
2183 */
2187 }
2192 # Remove the upload restriction for non-file titles
2194 }
2202 }
2204 /**
2205 * Is this title subject to title protection?
2206 * Title protection is the one applied against creation of such title.
2207 *
2208 * @return Mixed An associative array representing any existent title
2209 * protection, or false if there's none.
2210 */
2212 // Can't protect pages in special namespaces
2215 }
2217 // Can't protect pages that exist.
2220 }
2226 __METHOD__ );
2228 // fetchRow returns false if there are no rows.
2230 }
2232 }
2234 /**
2235 * Update the title protection status
2236 *
2237 * @deprecated in 1.19; will be removed in 1.20. Use WikiPage::doUpdateRestrictions() instead.
2238 * @param $create_perm String Permission required for creation
2239 * @param $reason String Reason for protection
2240 * @param $expiry String Expiry timestamp
2241 * @return boolean true
2242 */
2255 }
2257 /**
2258 * Remove any title protection due to page existing
2259 */
2266 __METHOD__
2267 );
2269 }
2271 /**
2272 * Is this page "semi-protected" - the *only* protection is autoconfirm?
2273 *
2274 * @param $action String Action to check (default: edit)
2275 * @return Bool
2276 */
2284 }
2285 }
2287 # Not protected
2289 }
2292 # If it doesn't exist, it can't be protected
2294 }
2295 }
2297 /**
2298 * Does the title correspond to a protected article?
2299 *
2300 * @param $action String the action the page is protected from,
2301 * by default checks all actions.
2302 * @return Bool
2303 */
2309 # Special pages have inherent protection
2312 }
2314 # Check regular protection levels
2321 }
2322 }
2323 }
2324 }
2327 }
2329 /**
2330 * Determines if $user is unable to edit this page because it has been protected
2331 * by $wgNamespaceProtection.
2332 *
2333 * @param $user User object to check permissions
2334 * @return Bool
2335 */
2343 }
2344 }
2345 }
2347 }
2349 /**
2350 * Cascading protection: Return true if cascading restrictions apply to this page, false if not.
2351 *
2352 * @return Bool If the page is subject to cascading restrictions.
2353 */
2357 }
2359 /**
2360 * Cascading protection: Get the source of any cascading restrictions on this page.
2361 *
2362 * @param $getPages Bool Whether or not to retrieve the actual pages
2363 * that the restrictions have come from.
2364 * @return Mixed Array of Title objects of the pages from which cascading restrictions
2365 * have come, false for none, or true if such restrictions exist, but $getPages
2366 * was not set. The restriction array is an array of each type, each of which
2367 * contains a array of unique groups.
2368 */
2377 }
2389 );
2397 );
2398 }
2407 }
2423 # Add groups needed for each restriction type if its not already there
2424 # Make sure this restriction type still exists
2428 }
2433 }
2436 }
2438 // Trigger lazy purge of expired restrictions from the db
2440 }
2441 }
2444 }
2451 }
2455 }
2457 /**
2458 * Accessor/initialisation for mRestrictions
2459 *
2460 * @param $action String action that permission needs to be checked for
2461 * @return Array of Strings the array of groups allowed to edit this article
2462 */
2466 }
2470 }
2472 /**
2473 * Get the expiry time for the restriction against a given action
2474 *
2475 * @return String|Bool 14-char timestamp, or 'infinity' if the page is protected forever
2476 * or not protected at all, or false if the action is not recognised.
2477 */
2481 }
2482 return isset( $this->mRestrictionsExpiry[$action] ) ? $this->mRestrictionsExpiry[$action] : false;
2483 }
2485 /**
2486 * Returns cascading restrictions for the current article
2487 *
2488 * @return Boolean
2489 */
2493 }
2496 }
2498 /**
2499 * Loads a string into mRestrictions array
2500 *
2501 * @param $res Resource restrictions as an SQL result.
2502 * @param $oldFashionedRestrictions String comma-separated list of page
2503 * restrictions from page table (pre 1.10)
2504 */
2510 }
2513 }
2515 /**
2516 * Compiles list of active page restrictions from both page table (pre 1.10)
2517 * and page_restrictions table for this existing page.
2518 * Public for usage by LiquidThreads.
2519 *
2520 * @param $rows array of db result objects
2521 * @param $oldFashionedRestrictions string comma-separated list of page
2522 * restrictions from page table (pre 1.10)
2523 */
2533 }
2537 # Backwards-compatibility: also load the restrictions from the page record (old format).
2542 }
2549 // old old format should be treated as edit/move restriction
2554 }
2555 }
2559 }
2562 # Current system - load second to make them override.
2566 # Cycle through all the restrictions.
2569 // Don't take care of restrictions types that aren't allowed
2573 // This code should be refactored, now that it's being used more generally,
2574 // But I don't really see any harm in leaving it in Block for now -werdna
2577 // Only apply the restrictions if they haven't expired!
2584 // Trigger a lazy purge of expired restrictions
2586 }
2587 }
2591 }
2592 }
2595 }
2597 /**
2598 * Load restrictions from the page_restrictions table
2599 *
2600 * @param $oldFashionedRestrictions String comma-separated list of page
2601 * restrictions from page table (pre 1.10)
2602 */
2613 __METHOD__
2614 );
2625 // Apply the restrictions
2631 }
2634 }
2636 }
2637 }
2638 }
2640 /**
2641 * Flush the protection cache in this object and force reload from the database.
2642 * This is used when updating protection from WikiPage::doUpdateRestrictions().
2643 */
2647 }
2649 /**
2650 * Purge expired restrictions from the page_restrictions table
2651 */
2657 __METHOD__
2658 );
2663 __METHOD__
2664 );
2665 }
2667 /**
2668 * Does this have subpages? (Warning, usually requires an extra DB query.)
2669 *
2670 * @return Bool
2671 */
2674 # Duh
2676 }
2678 # We dynamically add a member variable for the purpose of this method
2679 # alone to cache the result. There's no point in having it hanging
2680 # around uninitialized in every Title object; therefore we only add it
2681 # if needed and don't declare it statically.
2684 }
2689 }
2691 }
2693 /**
2694 * Get all subpages of this page.
2695 *
2696 * @param $limit Int maximum number of subpages to fetch; -1 for no limit
2697 * @return mixed TitleArray, or empty array if this page's namespace
2698 * doesn't allow subpages
2699 */
2703 }
2711 }
2716 __METHOD__,
2717 $options
2718 )
2719 );
2720 }
2722 /**
2723 * Is there a version of this page in the deletion archive?
2724 *
2725 * @return Int the number of archived revisions
2726 */
2735 __METHOD__
2736 );
2740 __METHOD__
2741 );
2742 }
2743 }
2745 }
2747 /**
2748 * Is there a version of this page in the deletion archive?
2749 *
2750 * @return Boolean
2751 */
2755 }
2759 __METHOD__
2760 );
2764 __METHOD__
2765 );
2766 }
2768 }
2770 /**
2771 * Get the article ID for this Title from the link cache,
2772 * adding it if necessary
2773 *
2774 * @param $flags Int a bit field; may be Title::GAID_FOR_UPDATE to select
2775 * for update
2776 * @return Int the ID
2777 */
2781 }
2791 }
2792 }
2794 }
2796 /**
2797 * Is this an article that is a redirect page?
2798 * Uses link cache, adding it if necessary
2799 *
2800 * @param $flags Int a bit field; may be Title::GAID_FOR_UPDATE to select for update
2801 * @return Bool
2802 */
2806 }
2807 # Calling getArticleID() loads the field from cache as needed
2810 }
2815 }
2817 /**
2818 * What is the length of this page?
2819 * Uses link cache, adding it if necessary
2820 *
2821 * @param $flags Int a bit field; may be Title::GAID_FOR_UPDATE to select for update
2822 * @return Int
2823 */
2827 }
2828 # Calling getArticleID() loads the field from cache as needed
2831 }
2836 }
2838 /**
2839 * What is the page_latest field for this page?
2840 *
2841 * @param $flags Int a bit field; may be Title::GAID_FOR_UPDATE to select for update
2842 * @return Int or 0 if the page doesn't exist
2843 */
2847 }
2848 # Calling getArticleID() loads the field from cache as needed
2851 }
2856 }
2858 /**
2859 * This clears some fields in this object, and clears any associated
2860 * keys in the "bad links" section of the link cache.
2861 *
2862 * - This is called from WikiPage::doEdit() and WikiPage::insertOn() to allow
2863 * loading of the new page_id. It's also called from
2864 * WikiPage::doDeleteArticle()
2865 *
2866 * @param $newid Int the new Article ID
2867 */
2876 }
2883 }
2885 /**
2886 * Capitalize a text string for a title if it belongs to a namespace that capitalizes
2887 *
2888 * @param $text String containing title to capitalize
2889 * @param $ns int namespace index, defaults to NS_MAIN
2890 * @return String containing capitalized title
2891 */
2899 }
2900 }
2902 /**
2903 * Secure and split - main initialisation function for this object
2904 *
2905 * Assumes that mDbkeyform has been set, and is urldecoded
2906 * and uses underscores, but not otherwise munged. This function
2907 * removes illegal characters, splits off the interwiki and
2908 * namespace prefixes, sets the other forms, and canonicalizes
2909 * everything.
2910 *
2911 * @return Bool true on success
2912 */
2916 # Initialisation
2922 # Strip Unicode bidi override characters.
2923 # Sometimes they slip into cut-n-pasted page titles, where the
2924 # override chars get included in list displays.
2927 # Clean up whitespace
2928 # Note: use of the /u option on preg_replace here will cause
2929 # input with invalid UTF-8 sequences to be nullified out in PHP 5.2.x,
2930 # conveniently disabling them.
2931 $dbkey = preg_replace( '/[ _\xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}]+/u', '_', $dbkey );
2936 }
2939 # Contained illegal UTF-8 sequences or forbidden Unicode chars.
2941 }
2945 # Initial colon indicates main namespace rather than specified default
2946 # but should not create invalid {ns,title} pairs such as {0,Project:Foo}
2951 }
2953 # Namespace or interwiki prefix
2961 # Ordinary namespace
2964 # For Talk:X pages, check if X has a "namespace" prefix
2967 # Disallow Talk:File:x type titles...
2970 # Disallow Talk:Interwiki:x type titles...
2972 }
2973 }
2976 # Can't make a local interwiki link to an interwiki link.
2977 # That's just crazy!
2979 }
2981 # Interwiki link
2985 # Redundant interwiki prefix to the local wiki
2988 {
2990 # Can't have an empty self-link
2992 }
2995 # Do another namespace split...
2997 }
2999 # If there's an initial colon after the interwiki, that also
3000 # resets the default namespace
3004 }
3005 }
3006 # If there's no recognized interwiki or namespace,
3007 # then let the colon expression be part of the title.
3008 }
3012 # We already know that some pages won't be in the database!
3015 }
3020 # remove whitespace again: prevents "Foo_bar_#"
3021 # becoming "Foo_bar_"
3023 }
3025 # Reject illegal characters.
3029 }
3031 # Pages with "/./" or "/../" appearing in the URLs will often be un-
3032 # reachable due to the way web browsers deal with 'relative' URLs.
3033 # Also, they conflict with subpage syntax. Forbid them explicitly.
3042 {
3044 }
3046 # Magic tilde sequences? Nu-uh!
3049 }
3051 # Limit the size of titles to 255 bytes. This is typically the size of the
3052 # underlying database field. We make an exception for special pages, which
3053 # don't need to be stored in the database, and may edge over 255 bytes due
3054 # to subpage syntax for long titles, e.g. [[Special:Block/Long name]]
3057 {
3059 }
3061 # Normally, all wiki links are forced to have an initial capital letter so [[foo]]
3062 # and [[Foo]] point to the same place. Don't force it for interwikis, since the
3063 # other site might be case-sensitive.
3067 }
3069 # Can't make a link to a namespace alone... "empty" local links can only be
3070 # self-links with a fragment identifier.
3073 }
3075 // Allow IPv6 usernames to start with '::' by canonicalizing IPv6 titles.
3076 // IP names are not allowed for accounts, and can only be referring to
3077 // edits from the IP. Given '::' abbreviations and caps/lowercaps,
3078 // there are numerous ways to present the same IP. Having sp:contribs scan
3079 // them all is silly and having some show the edits and others not is
3080 // inconsistent. Same for talk/userpages. Keep them normalized instead.
3085 // Any remaining initial :s are illegal.
3088 }
3090 # Fill fields
3097 }
3099 /**
3100 * Get an array of Title objects linking to this Title
3101 * Also stores the IDs in the link cache.
3102 *
3103 * WARNING: do not use this function on arbitrary user-supplied titles!
3104 * On heavily-used templates it will max out the memory.
3105 *
3106 * @param $options Array: may be FOR UPDATE
3107 * @param $table String: table name
3108 * @param $prefix String: fields prefix
3109 * @return Array of Title objects linking here
3110 */
3116 }
3120 array( 'page_namespace', 'page_title', 'page_id', 'page_len', 'page_is_redirect', 'page_latest' ),
3125 __METHOD__,
3126 $options
3127 );
3137 }
3138 }
3139 }
3141 }
3143 /**
3144 * Get an array of Title objects using this Title as a template
3145 * Also stores the IDs in the link cache.
3146 *
3147 * WARNING: do not use this function on arbitrary user-supplied titles!
3148 * On heavily-used templates it will max out the memory.
3149 *
3150 * @param $options Array: may be FOR UPDATE
3151 * @return Array of Title the Title objects linking here
3152 */
3155 }
3157 /**
3158 * Get an array of Title objects linked from this Title
3159 * Also stores the IDs in the link cache.
3160 *
3161 * WARNING: do not use this function on arbitrary user-supplied titles!
3162 * On heavily-used templates it will max out the memory.
3163 *
3164 * @param $options Array: may be FOR UPDATE
3165 * @param $table String: table name
3166 * @param $prefix String: fields prefix
3167 * @return Array of Title objects linking here
3168 */
3172 # If the page doesn't exist; there can't be any link from this page
3175 }
3181 }
3188 array( $namespaceFiled, $titleField, 'page_id', 'page_len', 'page_is_redirect', 'page_latest' ),
3190 __METHOD__,
3192 array( 'page' => array( 'LEFT JOIN', array( "page_namespace=$namespaceFiled", "page_title=$titleField" ) ) )
3193 );
3205 }
3207 }
3208 }
3209 }
3211 }
3213 /**
3214 * Get an array of Title objects used on this Title as a template
3215 * Also stores the IDs in the link cache.
3216 *
3217 * WARNING: do not use this function on arbitrary user-supplied titles!
3218 * On heavily-used templates it will max out the memory.
3219 *
3220 * @param $options Array: may be FOR UPDATE
3221 * @return Array of Title the Title objects used here
3222 */
3225 }
3227 /**
3228 * Get an array of Title objects referring to non-existent articles linked from this page
3229 *
3230 * @todo check if needed (used only in SpecialBrokenRedirects.php, and should use redirect table in this case)
3231 * @return Array of Title the Title objects
3232 */
3235 # All links from article ID 0 are false positives
3237 }
3245 'page_namespace IS NULL'
3246 ),
3252 )
3253 )
3254 );
3259 }
3261 }
3264 /**
3265 * Get a list of URLs to purge from the Squid cache when this
3266 * page changes
3267 *
3268 * @return Array of String the URLs
3269 */
3276 );
3278 // purge variant urls as well
3283 }
3284 }
3287 }
3289 /**
3290 * Purge all applicable Squid URLs
3291 */
3298 }
3299 }
3301 /**
3302 * Move this page without authentication
3303 *
3304 * @param $nt Title the new page Title
3305 * @return Mixed true on success, getUserPermissionsErrors()-like array on failure
3306 */
3309 }
3311 /**
3312 * Check whether a given move operation would be valid.
3313 * Returns true if ok, or a getUserPermissionsErrors()-like array otherwise
3314 *
3315 * @param $nt Title the new title
3316 * @param $auth Bool indicates whether $wgUser's permissions
3317 * should be checked
3318 * @param $reason String is the log summary of the move, used for spam checking
3319 * @return Mixed True on success, getUserPermissionsErrors()-like array on failure
3320 */
3326 // Normally we'd add this to $errors, but we'll get
3327 // lots of syntax errors if $nt is not an object
3329 }
3332 }
3335 }
3338 }
3341 }
3348 }
3353 }
3355 // Image-specific checks
3358 }
3362 }
3370 }
3374 // This is kind of lame, won't display nice
3376 }
3381 }
3383 # The move is allowed only if (1) the target doesn't exist, or
3384 # (2) the target is a redirect to the source, and has no history
3385 # (so we can undo bad moves right after they're done).
3390 }
3396 }
3397 }
3400 }
3402 }
3404 /**
3405 * Check if the requested move target is a valid file move target
3406 * @param Title $nt Target title
3407 * @return array List of errors
3408 */
3414 // wfFindFile( $nt ) / wfLocalFile( $nt ) is not allowed until below
3420 }
3423 }
3424 }
3428 // From here we want to do checks on a file object, so if we can't
3429 // create one, we must return.
3431 }
3433 // wfFindFile( $nt ) / wfLocalFile( $nt ) is allowed below here
3438 }
3441 }
3443 /**
3444 * Move a title to a new location
3445 *
3446 * @param $nt Title the new title
3447 * @param $auth Bool indicates whether $wgUser's permissions
3448 * should be checked
3449 * @param $reason String the reason for the move
3450 * @param $createRedirect Bool Whether to create a redirect from the old title to the new title.
3451 * Ignored if the user doesn't have the suppressredirect right.
3452 * @return Mixed true on success, getUserPermissionsErrors()-like array on failure
3453 */
3458 // Auto-block user's IP if the account was "hard" blocked
3461 }
3463 // If it is a file, move it first.
3464 // It is done before all other moving stuff is done because it's hard to revert.
3472 }
3473 }
3474 // Clear RepoGroup process cache
3477 }
3483 // Do the actual move
3486 # @todo FIXME: What about the File we have already moved?
3489 }
3491 // Refresh the sortkey for this row. Be careful to avoid resetting
3492 // cl_timestamp, which may disturb time-based lists on some sites.
3497 __METHOD__
3498 );
3510 __METHOD__
3511 );
3512 }
3517 # Protect the redirect title as the title used to be...
3526 ),
3528 __METHOD__,
3530 );
3531 # Update the protection log
3533 $comment = wfMsgForContent( 'prot_1movedto2', $this->getPrefixedText(), $nt->getPrefixedText() );
3536 }
3537 // @todo FIXME: $params?
3539 }
3541 # Update watchlists
3549 }
3555 }
3557 /**
3558 * Move page to a title which is either a redirect to the
3559 * source page or nonexistent
3560 *
3561 * @param $nt Title the page to move to, which should be a redirect or nonexistent
3562 * @param $reason String The reason for the move
3563 * @param $createRedirect Bool Whether to leave a redirect at the old title. Ignored
3564 * if the user doesn't have the suppressredirect right
3565 */
3575 }
3586 ) );
3593 }
3594 # Truncate for whole multibyte characters.
3607 # Delete the old redirect. We don't save it to history since
3608 # by definition if we've got here it's rather uninteresting.
3609 # We have to remove it so that the next step doesn't trigger
3610 # a conflict on the unique namespace+title index...
3614 }
3616 # Save a null revision in the page's history notifying of the move
3620 }
3623 # Change the name of the target page:
3628 ),
3630 __METHOD__
3631 );
3643 # Recreate the redirect, this time in the other direction.
3663 }
3664 }
3666 # Log the move
3669 }
3671 /**
3672 * Move this page's subpages to be subpages of $nt
3673 *
3674 * @param $nt Title Move target
3675 * @param $auth bool Whether $wgUser's permissions should be checked
3676 * @param $reason string The reason for the move
3677 * @param $createRedirect bool Whether to create redirects from the old subpages to
3678 * the new ones Ignored if the user doesn't have the 'suppressredirect' right
3679 * @return mixed array with old page titles as keys, and strings (new page titles) or
3680 * arrays (errors) as values, or an error array with numeric indices if no pages
3681 * were moved
3682 */
3685 // Check permissions
3688 }
3689 // Do the source and target namespaces support subpages?
3693 }
3697 }
3709 }
3711 // We don't know whether this function was called before
3712 // or after moving the root page, so check both
3713 // $this and $nt
3716 {
3717 // When moving a page to a subpage of itself,
3718 // don't move it twice
3720 }
3729 }
3730 # Bug 14385: we need makeTitleSafe because the new page names may
3731 # be longer than 255 characters.
3739 }
3740 }
3742 }
3744 /**
3745 * Checks if this page is just a one-rev redirect.
3746 * Adds lock, so don't use just for light purposes.
3747 *
3748 * @return Bool
3749 */
3752 # Is it a redirect?
3756 __METHOD__,
3758 );
3759 # Cache some fields we may want
3765 }
3766 # Does the article have a history?
3772 'page_latest != rev_id'
3773 ),
3774 __METHOD__,
3776 );
3777 # Return true if there was no history
3779 }
3781 /**
3782 * Checks if $this can be moved to a given Title
3783 * - Selects for update, so don't call it unless you mean business
3784 *
3785 * @param $nt Title the new title to check
3786 * @return Bool
3787 */
3789 # Is it an existing file?
3795 }
3796 }
3797 # Is it a redirect with no history?
3801 }
3802 # Get the article text
3806 }
3808 # Does the redirect point to the source?
3809 # Or is it a broken self-redirect, usually caused by namespace collisions?
3818 }
3820 # Fail safe
3823 }
3825 }
3827 /**
3828 * Get categories to which this Title belongs and return an array of
3829 * categories' names.
3830 *
3831 * @return Array of parents in the form:
3832 * $parent => $currentarticle
3833 */
3843 }
3850 ),
3851 __METHOD__,
3853 );
3857 // $data[] = Title::newFromText($wgContLang->getNSText ( NS_CATEGORY ).':'.$row->cl_to);
3859 }
3860 }
3862 }
3864 /**
3865 * Get a tree of parent categories
3866 *
3867 * @param $children Array with the children in the keys, to check for circular refs
3868 * @return Array Tree of parent categories
3869 */
3877 # Circular reference
3883 }
3884 }
3885 }
3886 }
3889 }
3891 /**
3892 * Get an associative array for selecting this title from
3893 * the "page" table
3894 *
3895 * @return Array suitable for the $where parameter of DB::select()
3896 */
3899 // PK avoids secondary lookups in InnoDB, shouldn't hurt other DBs
3903 }
3904 }
3906 /**
3907 * Get the revision ID of the previous revision
3908 *
3909 * @param $revId Int Revision ID. Get the revision that was before this one.
3910 * @param $flags Int Title::GAID_FOR_UPDATE
3911 * @return Int|Bool Old revision ID, or FALSE if none exists
3912 */
3919 ),
3920 __METHOD__,
3922 );
3923 }
3925 /**
3926 * Get the revision ID of the next revision
3927 *
3928 * @param $revId Int Revision ID. Get the revision that was after this one.
3929 * @param $flags Int Title::GAID_FOR_UPDATE
3930 * @return Int|Bool Next revision ID, or FALSE if none exists
3931 */
3938 ),
3939 __METHOD__,
3941 );
3942 }
3944 /**
3945 * Get the first revision of the page
3946 *
3947 * @param $flags Int Title::GAID_FOR_UPDATE
3948 * @return Revision|Null if page doesn't exist
3949 */
3956 __METHOD__,
3958 );
3961 }
3962 }
3964 }
3966 /**
3967 * Get the oldest revision timestamp of this page
3968 *
3969 * @param $flags Int Title::GAID_FOR_UPDATE
3970 * @return String: MW timestamp
3971 */
3975 }
3977 /**
3978 * Check if this is a new page
3979 *
3980 * @return bool
3981 */
3985 }
3987 /**
3988 * Check whether the number of revisions of this page surpasses $wgDeleteRevisionsLimit
3989 *
3990 * @return bool
3991 */
3997 }
4001 }
4003 /**
4004 * Get the approximate revision count of this page.
4005 *
4006 * @return int
4007 */
4011 }
4017 }
4020 }
4022 /**
4023 * Get the number of revisions between the given revision.
4024 * Used for diffs and other things that really need it.
4025 *
4026 * @param $old int|Revision Old revision or rev ID (first before range)
4027 * @param $new int|Revision New revision or rev ID (first after range)
4028 * @return Int Number of revisions between these revisions.
4029 */
4033 }
4036 }
4039 }
4046 ),
4047 __METHOD__
4048 );
4049 }
4051 /**
4052 * Get the number of authors between the given revision IDs.
4053 * Used for diffs and other things that really need it.
4054 *
4055 * @param $old int|Revision Old revision or rev ID (first before range)
4056 * @param $new int|Revision New revision or rev ID (first after range)
4057 * @param $limit Int Maximum number of authors
4058 * @return Int Number of revision authors between these revisions.
4059 */
4063 }
4066 }
4069 }
4078 );
4080 }
4082 /**
4083 * Compare with another title.
4084 *
4085 * @param $title Title
4086 * @return Bool
4087 */
4089 // Note: === is necessary for proper matching of number-like titles.
4093 }
4095 /**
4096 * Check if this title is a subpage of another title
4097 *
4098 * @param $title Title
4099 * @return Bool
4100 */
4105 }
4107 /**
4108 * Check if page exists. For historical reasons, this function simply
4109 * checks for the existence of the title in the page table, and will
4110 * thus return false for interwiki links, special pages and the like.
4111 * If you want to know if a title can be meaningfully viewed, you should
4112 * probably call the isKnown() method instead.
4113 *
4114 * @return Bool
4115 */
4118 }
4120 /**
4121 * Should links to this title be shown as potentially viewable (i.e. as
4122 * "bluelinks"), even if there's no record by this title in the page
4123 * table?
4124 *
4125 * This function is semi-deprecated for public use, as well as somewhat
4126 * misleadingly named. You probably just want to call isKnown(), which
4127 * calls this function internally.
4128 *
4129 * (ISSUE: Most of these checks are cheap, but the file existence check
4130 * can potentially be quite expensive. Including it here fixes a lot of
4131 * existing code, but we might want to add an optional parameter to skip
4132 * it and any other expensive checks.)
4133 *
4134 * @return Bool
4135 */
4139 /**
4140 * Allows overriding default behaviour for determining if a page exists.
4141 * If $isKnown is kept as null, regular checks happen. If it's
4142 * a boolean, this value is returned by the isKnown method.
4143 *
4144 * @since 1.20
4145 *
4146 * @param Title $title
4147 * @param boolean|null $isKnown
4148 */
4153 }
4157 }
4162 // file exists, possibly in a foreign repo
4165 // valid special page
4168 // selflink, possibly with fragment
4171 // known system message
4175 }
4176 }
4178 /**
4179 * Does this title refer to a page that can (or might) be meaningfully
4180 * viewed? In particular, this function may be used to determine if
4181 * links to the title should be rendered as "bluelinks" (as opposed to
4182 * "redlinks" to non-existent pages).
4183 * Adding something else to this function will cause inconsistency
4184 * since LinkHolderArray calls isAlwaysKnown() and does its own
4185 * page existence check.
4186 *
4187 * @return Bool
4188 */
4191 }
4193 /**
4194 * Does this page have source text?
4195 *
4196 * @return Boolean
4197 */
4201 }
4204 // If the page doesn't exist but is a known system message, default
4205 // message content will be displayed, same for language subpages-
4206 // Use always content language to avoid loading hundreds of languages
4207 // to get the link color.
4209 list( $name, $lang ) = MessageCache::singleton()->figureMessage( $wgContLang->lcfirst( $this->getText() ) );
4212 }
4215 }
4217 /**
4218 * Get the default message text or false if the message doesn't exist
4219 *
4220 * @return String or false
4221 */
4227 }
4229 list( $name, $lang ) = MessageCache::singleton()->figureMessage( $wgContLang->lcfirst( $this->getText() ) );
4236 }
4237 }
4239 /**
4240 * Updates page_touched for this page; called from LinksUpdate.php
4241 *
4242 * @return Bool true if the update succeded
4243 */
4247 }
4253 __METHOD__
4254 );
4257 }
4259 /**
4260 * Update page_touched timestamps and send squid purge messages for
4261 * pages linking to this title. May be sent to the job queue depending
4262 * on the number of links. Typically called on create and delete.
4263 */
4271 }
4272 }
4274 /**
4275 * Get the last touched timestamp
4276 *
4277 * @param $db DatabaseBase: optional db
4278 * @return String last-touched timestamp
4279 */
4284 }
4286 /**
4287 * Get the timestamp when this page was updated since the user last saw it.
4288 *
4289 * @param $user User
4290 * @return String|Null
4291 */
4294 // Assume current user if none given
4297 }
4298 // Check cache first
4300 // avoid isset here, as it'll return false for null entries
4303 }
4306 }
4307 // Don't cache too much!
4310 }
4317 ),
4318 __METHOD__
4319 );
4321 }
4323 /**
4324 * Generate strings used for xml 'id' names in monobook tabs
4325 *
4326 * @param $prepend string defaults to 'nstab-'
4327 * @return String XML 'id' name
4328 */
4331 // Gets the subject namespace if this title
4333 // Checks if cononical namespace name exists for namespace
4335 // Uses canonical namespace name
4338 // Uses text of namespace
4340 }
4341 // Makes namespace key lowercase
4343 // Uses main
4346 }
4347 // Changes file to image for backwards compatibility
4350 }
4352 }
4354 /**
4355 * Get all extant redirects to this Title
4356 *
4357 * @param $ns Int|Null Single namespace to consider; NULL to consider all namespaces
4358 * @return Array of Title redirects to this title
4359 */
4367 'rd_from = page_id'
4368 );
4371 }
4377 __METHOD__
4378 );
4382 }
4384 }
4386 /**
4387 * Check if this Title is a valid redirect target
4388 *
4389 * @return Bool
4390 */
4394 // invalid redirect targets are stored in a global array, but explicity disallow Userlogout here
4397 }
4402 }
4403 }
4406 }
4408 /**
4409 * Get a backlink cache object
4410 *
4411 * @return BacklinkCache
4412 */
4416 }
4418 }
4420 /**
4421 * Whether the magic words __INDEX__ and __NOINDEX__ function for this page.
4422 *
4423 * @return Boolean
4424 */
4429 ? $wgContentNamespaces
4434 }
4436 /**
4437 * Returns the raw sort key to be used for categories, with the specified
4438 * prefix. This will be fed to Collation::getSortKey() to get a
4439 * binary sortkey that can be used for actual sorting.
4440 *
4441 * @param $prefix string The prefix to be used, specified using
4442 * {{defaultsort:}} or like [[Category:Foo|prefix]]. Empty for no
4443 * prefix.
4444 * @return string
4445 */
4449 // Anything that uses this hook should only depend
4450 // on the Title object passed in, and should probably
4451 // tell the users to run updateCollations.php --force
4452 // in order to re-sort existing category relations.
4455 # Separate with a line feed, so the unprefixed part is only used as
4456 # a tiebreaker when two pages have the exact same prefix.
4457 # In UCA, tab is the only character that can sort above LF
4458 # so we strip both of them from the original prefix.
4461 }
4463 }
4465 /**
4466 * Get the language in which the content of this page is written.
4467 * Defaults to $wgContLang, but in certain cases it can be e.g.
4468 * $wgLang (such as special pages, which are in the user language).
4469 *
4470 * @since 1.18
4471 * @return object Language
4472 */
4476 // special pages are in the user language
4479 // css/js should always be LTR and is, in fact, English
4482 // Parse mediawiki messages with correct target language
4485 }
4487 // If nothing special, it should be in the wiki content language
4489 // Hook at the end because we don't want to override the above stuff
4492 }
4493 }