| blob | 6b141b3f3271e5d83636c18bf0d9200189dcda6d |
1 <?php
2 /**
3 * File for articles
4 */
6 /**
7 * Class representing a MediaWiki article and history.
8 *
9 * See design.txt for an overview.
10 * Note: edit user interface and cache support functions have been
11 * moved to separate EditPage and HTMLFileCache classes.
12 *
13 */
15 /**@{{
16 * @private
17 */
38 /**@}}*/
40 /**
41 * Constructor and clear the article
42 * @param $title Reference to a Title object.
43 * @param $oldId Integer revision ID, null to fetch from request, zero for current
44 */
49 }
51 /**
52 * Tell the page view functions that this view was redirected
53 * from another page on the wiki.
54 * @param $from Title object.
55 */
58 }
60 /**
61 * If this page is a redirect, get its target
62 *
63 * The target will be fetched from the redirect table if possible.
64 * If this page doesn't have an entry there, call insertRedirect()
65 * @return mixed Title object, or null if this page is not a redirect
66 */
73 # Query the redirect table
78 __METHOD__
79 );
84 # This page doesn't have an entry in the redirect table
86 }
88 /**
89 * Insert an entry for this page into the redirect table.
90 *
91 * Don't call this function directly unless you know what you're doing.
92 * @return Title object
93 */
105 }
107 /**
108 * Get the Title object this page redirects to
109 *
110 * @return mixed false, Title of in-wiki target, or string with URL
111 */
116 # process if title object is valid and not special:userlogout
120 // Offsite wikis need an HTTP redirect.
121 //
122 // This can be hard to reverse and may produce loops,
123 // so they may be disabled in the site configuration.
127 }
130 // Gotta handle redirects to special pages differently:
131 // Fill the HTTP response "Location" header and ignore
132 // the rest of the page we're on.
133 //
134 // This can be hard to reverse, so they may be disabled.
137 // rolleyes
140 }
141 }
143 }
144 }
146 // No or invalid redirect
148 }
150 /**
151 * get the title object of the article
152 */
155 }
157 /**
158 * Clear the object
159 * @private
160 */
178 }
180 /**
181 * Note that getContent/loadContent do not follow redirects anymore.
182 * If you need to fetch redirectable content easily, try
183 * the shortcut in Article::followContent()
184 * FIXME
185 * @todo There are still side-effects in this!
186 * In general, you should use the Revision class, not Article,
187 * to fetch text for purposes other than page views.
188 *
189 * @return Return the text of this revision
190 */
205 }
212 }
213 }
215 /**
216 * This function returns the text of a section, specified by a number ($section).
217 * A section is text under a heading like == Heading == or \<h1\>Heading\</h1\>, or
218 * the first section before any such heading (section 0).
219 *
220 * If a section contains subsections, these are also returned.
221 *
222 * @param $text String: text to look in
223 * @param $section Integer: section number
224 * @return string text of the requested section
225 * @deprecated
226 */
230 }
232 /**
233 * @return int The oldid of the article that is to be shown, 0 for the
234 * current revision
235 */
239 }
241 }
243 /**
244 * Sets $this->mRedirectUrl to a correct URL if the query parameters are incorrect
245 *
246 * @return int The old id for the request
247 */
260 }
266 # TODO
267 }
268 }
269 # unused:
270 # $lastid = $oldid;
271 }
275 }
277 }
279 /**
280 * Load the revision (including text) into this object
281 */
285 # Query variables :P
288 # Pre-fill content with error message so that if something
289 # fails we'll have something telling us what we intended.
292 }
295 /**
296 * Fetch a page record with the given conditions
297 * @param Database $dbr
298 * @param array $conditions
299 * @private
300 */
314 );
320 __METHOD__
321 );
324 }
326 /**
327 * @param Database $dbr
328 * @param Title $title
329 */
334 }
336 /**
337 * @param Database $dbr
338 * @param int $id
339 */
342 }
344 /**
345 * Set the general counter, title etc data loaded from
346 * some source.
347 *
348 * @param object $data
349 * @private
350 */
355 }
363 # Old-fashioned restrictions.
373 }
375 }
378 }
380 /**
381 * Get text of an article from database
382 * Does *NOT* follow redirects.
383 * @param int $oldid 0 for whatever the latest revision is
384 * @return string
385 */
389 }
393 # Pre-fill content with error message so that if something
394 # fails we'll have something telling us what we intended.
398 }
406 }
411 }
418 wfDebug( __METHOD__." failed to find page data for title " . $this->mTitle->getPrefixedText() . "\n" );
420 }
422 }
427 }
428 }
430 // FIXME: Horrible, horrible! This content-loading interface just plain sucks.
431 // We should instead work with the Revision object when we need it...
446 }
448 /**
449 * Read/write accessor to select FOR UPDATE
450 *
451 * @param $x Mixed: FIXME
452 */
455 }
457 /**
458 * Get the database which should be used for reads
459 *
460 * @return Database
461 */
464 }
466 /**
467 * Get options for all SELECT statements
468 *
469 * @param $options Array: an optional options array which'll be appended to
470 * the default
471 * @return Array: options
472 */
479 }
480 }
482 }
484 /**
485 * @return int Page ID
486 */
492 }
493 }
495 /**
496 * @return bool Whether or not the page exists in the database
497 */
500 }
502 /**
503 * @return int The view count for the page
504 */
514 }
515 }
517 }
519 /**
520 * Determine whether a page would be suitable for being counted as an
521 * article in the site_stats table based on the title & its content
522 *
523 * @param $text String: text to analyze
524 * @return bool
525 */
530 return
534 }
536 /**
537 * Tests if the article text represents a redirect
538 *
539 * @param $text String: FIXME
540 * @return bool
541 */
548 }
550 }
552 /**
553 * Returns true if the currently-referenced revision is the current edit
554 * to this page (and it exists).
555 * @return bool
556 */
558 # If no oldid, this is the current version.
565 }
567 /**
568 * Loads everything except the text
569 * This isn't necessary for all uses, so it's only done if needed.
570 * @private
571 */
576 # New or non-existent articles have no user information
588 }
589 }
592 // Check if the field has been filled by ParserCache::get()
595 }
597 }
602 }
607 }
612 }
617 }
622 }
624 /**
625 * @todo Document, fixme $offset never used.
626 * @param $limit Integer: default 0.
627 * @param $offset Integer: default 0.
628 */
630 # XXX: this is expensive; cache this info somewhere.
643 GROUP BY rev_user, rev_user_text, user_real_name
653 }
657 }
659 /**
660 * This is the default action of the script: just view the page of
661 * the given title.
662 */
675 # Get variables from query string
678 # getOldID may want us to redirect somewhere else
683 }
693 # Discourage indexing of printable versions, but encourage following
699 # Honour customised robot policies for this namespace
703 }
706 # If we got diff and oldid in the query, we want to see a
707 # diff page instead of the article.
713 // DifferenceEngine directly fetched the revision:
717 // Needed to get the page's current revision
720 # Run view updates for current revision only
722 }
725 }
734 # tell wgOut that output is taken care of
739 }
740 }
742 # Should the parser cache be used?
752 }
756 // This is an internally redirected page view.
757 // We'll need a backlink to the source page for navigation.
764 // Set the fragment if one was specified in the redirect
768 }
770 }
772 // This is an externally redirected view, from some other wiki.
773 // If it was reported from a trusted site, supply a backlink.
781 }
782 }
788 // Ensure that UI elements requiring revision ID have
789 // the correct version information.
792 }
793 }
797 # Failed to load, replace text with error message
804 }
805 }
807 # Another whitelist check in case oldid is altering the title
813 }
815 # We're looking at an old revision
820 // FIXME: This would be a nice place to load the 'no such page' text.
831 // and we are allowed to see...
832 }
833 }
834 }
836 }
837 }
841 // Pages containing custom CSS or JavaScript get special treatment
845 // Give hooks a chance to customise the output
847 // Wrap the whole lot in a <pre> and don't parse
853 }
855 }
858 # Display redirect
861 # Don't overwrite the subtitle if this was an old revision
864 }
873 # Display content and save to parser cache
876 # Display content, don't attempt to save to parser cache
877 # Don't show section-edit links on old revisions... this way lies madness.
880 }
881 # Display content and don't save to parser cache
882 # With timing hack -- TS 2006-07-26
887 # Timing hack
891 }
895 }
897 }
898 }
899 /* title may have been set from the cache */
903 }
905 # check if we're displaying a [[User talk:x.x.x.x]] anonymous talk page
909 }
911 # If we have been passed an &rcid= parameter, we want to give the user a
912 # chance to mark this new article as patrolled.
913 if( !is_null( $rcid ) && $rcid != 0 && $wgUser->isAllowed( 'patrol' ) && $this->mTitle->exists() ) {
919 ) .
920 '</div>'
921 );
922 }
924 # Trackbacks
930 }
940 );
952 }
960 }
962 }
970 }
975 {
978 }
984 }
991 }
993 /**
994 * Handle action=purge
995 */
1002 }
1015 }
1016 }
1018 /**
1019 * Perform the actions of a page purging
1020 */
1023 // Invalidate the cache
1027 // Commit the transaction before the purge is sent
1031 // Send purge
1034 }
1041 }
1043 }
1045 }
1047 /**
1048 * Insert a new empty page record for this article.
1049 * This *must* be followed up by creating a revision
1050 * and running $this->updateToLatest( $rev_id );
1051 * or else the record will be left in a funky state.
1052 * Best if all done inside a transaction.
1053 *
1054 * @param Database $dbw
1055 * @return int The newly created page_id key
1056 * @private
1057 */
1081 }
1083 /**
1084 * Update the page record to point to a newly saved revision.
1085 *
1086 * @param Database $dbw
1087 * @param Revision $revision For ID number, and text used to set
1088 length and redirect status fields
1089 * @param int $lastRevision If given, will not overwrite the page field
1090 * when different from the currently set value.
1091 * Giving 0 indicates the new page flag should
1092 * be set on.
1093 * @param bool $lastRevIsRedirect If given, will optimize adding and
1094 * removing rows in redirect table.
1095 * @return bool true on success, false on failure
1096 * @private
1097 */
1098 function updateRevisionOn( &$dbw, $revision, $lastRevision = null, $lastRevIsRedirect = null ) {
1106 # An extra check against threads stepping on each other
1108 }
1117 ),
1119 __METHOD__ );
1125 }
1129 }
1131 /**
1132 * Add row to the redirect table if this is a redirect, remove otherwise.
1133 *
1134 * @param Database $dbw
1135 * @param $redirectTitle a title object pointing to the redirect target,
1136 * or NULL if this is not a redirect
1137 * @param bool $lastRevIsRedirect If given, will optimize adding and
1138 * removing rows in redirect table.
1139 * @return bool true on success, false on failure
1140 * @private
1141 */
1144 // Always update redirects (target link might have changed)
1145 // Update/Insert if we don't know if the last revision was a redirect or not
1146 // Delete if changing from redirect to non-redirect
1154 // This title is a redirect, Add/Update row in the redirect table
1159 );
1163 // This is not a redirect, remove row from redirect table
1166 }
1172 }
1175 }
1177 /**
1178 * If the given revision is newer than the currently set page_latest,
1179 * update the page record. Otherwise, do nothing.
1180 *
1181 * @param Database $dbw
1182 * @param Revision $revision
1183 */
1193 __METHOD__ );
1198 }
1202 # No or missing previous revision; mark the page as new
1205 }
1210 }
1212 /**
1213 * @return string Complete article text, or null if error
1214 */
1219 // Whole-page edit; let the text through unmolested.
1226 }
1231 }
1235 # Inserting a new section
1241 # Replacing an existing section; roll out the big guns
1244 }
1246 }
1250 }
1252 /**
1253 * @deprecated use Article::doEdit()
1254 */
1255 function insertNewArticle( $text, $summary, $isminor, $watchthis, $suppressRC=false, $comment=false, $bot=false ) {
1261 # If this is a comment, add the summary as headline
1264 }
1274 }
1280 }
1281 }
1283 }
1285 /**
1286 * @deprecated use Article::doEdit()
1287 */
1288 function updateArticle( $text, $summary, $minor, $watchthis, $forceBot = false, $sectionanchor = '' ) {
1301 }
1307 }
1308 }
1314 }
1316 }
1318 /**
1319 * Article::doEdit()
1320 *
1321 * Change an existing article or create a new article. Updates RC and all necessary caches,
1322 * optionally via the deferred update array.
1323 *
1324 * $wgUser must be set before calling this function.
1325 *
1326 * @param string $text New text
1327 * @param string $summary Edit summary
1328 * @param integer $flags bitfield:
1329 * EDIT_NEW
1330 * Article is known or assumed to be non-existent, create a new one
1331 * EDIT_UPDATE
1332 * Article is known or assumed to be pre-existing, update it
1333 * EDIT_MINOR
1334 * Mark this edit minor, if the user is allowed to do so
1335 * EDIT_SUPPRESS_RC
1336 * Do not log the change in recentchanges
1337 * EDIT_FORCE_BOT
1338 * Mark the edit a "bot" edit regardless of user rights
1339 * EDIT_DEFER_UPDATES
1340 * Defer some of the updates until the end of index.php
1341 * EDIT_AUTOSUMMARY
1342 * Fill in blank summaries with generated text where possible
1343 *
1344 * If neither EDIT_NEW nor EDIT_UPDATE is specified, the status of the article will be detected.
1345 * If EDIT_UPDATE is specified and the article doesn't exist, the function will return false. If
1346 * EDIT_NEW is specified and the article does exist, a duplicate key error will cause an exception
1347 * to be thrown from the Database. These two conditions are also possible with auto-detection due
1348 * to MediaWiki's performance-optimised locking strategy.
1349 *
1350 * @return bool success
1351 */
1364 }
1365 }
1370 {
1374 }
1376 # Silently ignore EDIT_MINOR if not allowed
1383 # Provide autosummaries if one is not provided.
1395 # Update article, but only if changed.
1397 # Make sure the revision is either completely inserted or not inserted at all
1400 }
1416 # Article gone missing
1420 }
1428 ) );
1433 # Update page
1437 /* Belated edit conflict! Run away!! */
1441 # Update recentchanges
1447 # Mark as patrolled if the user can do so
1451 }
1452 }
1455 }
1458 // Keep the same revision ID, but do some updates on it
1460 // Update page_touched, this is usually implicit in the page update
1461 // Other cache updates are done in onArticleEdit()
1463 }
1467 }
1470 # Invalidate cache of this article and all pages using this article
1471 # as a template. Partly deferred.
1474 # Update links tables, site stats, etc.
1476 }
1478 # Create new article
1480 # Set statistics members
1481 # We work out if it's countable after PST to avoid counter drift
1482 # when articles are created with {{subst:}}
1488 # Add the page record; stake our claim on this title!
1489 # This will fail with a database query exception if the article already exists
1492 # Save the revision text...
1498 ) );
1503 # Update the page record with revision data
1509 # Mark as patrolled if the user can
1510 if( ($GLOBALS['wgUseRCPatrol'] || $GLOBALS['wgUseNPPatrol']) && $wgUser->isAllowed( 'autopatrol' ) ) {
1513 }
1514 }
1518 # Update links, etc.
1521 # Clear caches
1526 }
1530 }
1535 }
1539 }
1541 /**
1542 * @deprecated wrapper for doRedirect
1543 */
1546 }
1548 /**
1549 * Output a redirect back to the article.
1550 * This is typically used after an edit.
1551 *
1552 * @param boolean $noRedir Add redirect=no
1553 * @param string $sectionAnchor section to redirect to, including "#"
1554 * @param string $extraq, extra query params
1555 */
1564 }
1566 }
1568 /**
1569 * Mark this particular edit/page as patrolled
1570 */
1575 # Check patrol config options
1580 }
1582 # If we haven't been given an rc_id value, we can't do anything
1586 {
1589 }
1592 // Only new pages can be patrolled if the general patrolling is off....???
1593 // @fixme -- is this necessary? Shouldn't we only bother controlling the
1594 // front end here?
1597 }
1599 # Check permissions
1603 {
1606 }
1608 # Handle the 'MarkPatrolled' hook
1611 }
1613 #It would be nice to see where the user had actually come from, but for now just guess
1617 # If it's left up to us, check that the user is allowed to patrol this edit
1618 # If the user has the "autopatrol" right, then we'll assume there are no
1619 # other conditions stopping them doing so
1622 # Graceful error handling, as we've done before here...
1623 # (If the recent change doesn't exist, then it doesn't matter whether
1624 # the user is allowed to patrol it or not; nothing is going to happen
1626 # The user made this edit, and can't patrol it
1627 # Tell them so, and then back off
1632 }
1633 }
1635 # Check that the revision isn't patrolled already
1636 # Prevents duplicate log entries
1638 # Mark the edit as patrolled
1642 }
1644 # Inform the user
1648 }
1650 /**
1651 * User-interface handler for the "watch" action
1652 */
1661 }
1665 }
1672 }
1675 }
1677 /**
1678 * Add this page to $wgUser's watchlist
1679 * @return bool true on successful watch operation
1680 */
1685 }
1691 }
1694 }
1696 /**
1697 * User interface handler for the "unwatch" action.
1698 */
1706 }
1710 }
1717 }
1720 }
1722 /**
1723 * Stop watching a page
1724 * @return bool true on successful unwatch
1725 */
1730 }
1736 }
1739 }
1741 /**
1742 * action=protect handler
1743 */
1747 }
1749 /**
1750 * action=unprotect handler (alias)
1751 */
1754 }
1756 /**
1757 * Update the article's restriction field, and leave a log entry.
1758 *
1759 * @param array $limit set of restriction keys
1760 * @param string $reason
1761 * @return bool true on success
1762 */
1767 if( array() != $this->mTitle->getUserPermissionsErrors( 'protect', $wgUser ) || wfReadOnly() || $id == 0 ) {
1769 }
1773 }
1775 // Take this opportunity to purge out expired restrictions
1778 # FIXME: Same limitations as described in ProtectionForm.php (line 37);
1779 # we expect a single selection, but the schema allows otherwise.
1792 # If nothing's changed, do nothing
1803 $expiry_description = ' (' . wfMsgForContent( 'protect-expiring', $wgContLang->timeanddate( $expiry, false, false ) ).')';
1804 }
1806 # Prepare a null revision to be added to the history
1812 }
1813 $comment = $wgContLang->ucfirst( wfMsgForContent( $comment_type, $this->mTitle->getPrefixedText() ) );
1816 # Check if the group level required to edit also can protect pages
1817 # Otherwise, people who cannot normally protect can "protect" pages via transclusion
1820 }
1825 }
1836 # Update restrictions table
1846 }
1847 }
1849 # Insert a null revision
1853 # Update page record
1862 );
1865 # Update the protection log
1868 $log->addEntry( $modified ? 'modify' : 'protect', $this->mTitle, trim( $reason . " [$updated]$cascade_description$expiry_description" ) );
1871 }
1877 }
1879 /**
1880 * Take an array of page restrictions and flatten it to a string
1881 * suitable for insertion into the page_restrictions field.
1882 * @param array $limit
1883 * @return string
1884 * @private
1885 */
1889 }
1895 }
1896 }
1898 }
1900 /**
1901 * Auto-generates a deletion reason
1902 * @param bool &$hasHistory Whether the page has a history
1903 */
1905 {
1908 // Get the last revision
1912 // Get the article's contents
1915 // If the page is blank, use the text from the previous revision,
1916 // which can only be blank if there's a move/import/protect dummy revision involved
1918 {
1921 {
1924 }
1925 }
1927 // Find out if there was only one contributor
1928 // Only scan the last 20 revisions
1930 $res = $dbw->select('revision', 'rev_user_text', array('rev_page' => $this->getID()), __METHOD__,
1933 // This page has no revisions, which is very weird
1937 else
1941 // Try to find a second contributor
1946 }
1947 }
1950 // Generate the summary with a '$1' placeholder
1952 // The current revision is blank and the one before is also
1953 // blank. It's just not our lucky day
1958 else
1960 }
1962 // Replace newlines with spaces to prevent uglyness
1964 // Calculate the maximum amount of chars to get
1965 // Max content length = max comment length - length of the comment (excl. $1) - '...'
1968 // Remove possible unfinished links
1970 // Now replace the '$1' placeholder
1973 }
1976 /*
1977 * UI entry point for page deletion
1978 */
1991 // Entry from drop down menu + additional comment
1995 }
1996 # Flag to hide all contents of the archived revisions
1999 # This code desperately needs to be totally rewritten
2001 # Read-only check...
2005 }
2007 # Check permissions
2013 }
2017 # Better double-check that it hasn't been deleted yet!
2024 }
2026 # Hack for big sites
2033 }
2041 }
2043 }
2045 // Generate deletion reason
2049 // If the page has a history, insert a warning
2052 $wgOut->addHTML( '<strong>' . wfMsg( 'historywarning' ) . ' ' . $skin->historyLink() . '</strong>' );
2057 }
2058 }
2061 }
2063 /**
2064 * @return bool whether or not the page surpasses $wgDeleteRevisionsLimit revisions
2065 */
2071 }
2073 }
2075 /**
2076 * @return int approximate revision count
2077 */
2080 // For an exact count...
2081 //return $dbr->selectField( 'revision', 'COUNT(*)',
2082 // array( 'rev_page' => $this->getId() ), __METHOD__ );
2085 }
2087 /**
2088 * Get the last N authors
2089 * @param int $num Number of revisions to get
2090 * @param string $revLatest The latest rev_id, selected from the master (optional)
2091 * @return array Array of authors, duplicates not removed
2092 */
2096 // First try the slave
2097 // If that doesn't have the latest revision, try the master
2106 'rev_page = page_id'
2110 ) )
2111 );
2115 }
2122 }
2128 }
2131 }
2133 /**
2134 * Output deletion confirmation dialog
2135 * @param $par string FIXME: do we need this parameter? One Call from Article::delete with '' only.
2136 * @param $reason string Prefilled reason
2137 */
2144 $wgOut->setSubtitle( wfMsg( 'delete-backlink', $wgUser->getSkin()->makeKnownLinkObj( $this->mTitle ) ) );
2150 $suppress .= Xml::checkLabel( wfMsg( 'revdelete-suppress' ), 'wpSuppress', 'wpSuppress', false, array( 'tabindex' => '2' ) );
2154 }
2156 $form = Xml::openElement( 'form', array( 'method' => 'post', 'action' => $this->mTitle->getLocalURL( 'action=delete' . $par ), 'id' => 'deleteconfirm' ) ) .
2163 "</td>
2168 "</td>
2169 </tr>
2173 "</td>
2175 Xml::input( 'wpReason', 60, $reason, array( 'type' => 'text', 'maxlength' => '255', 'tabindex' => '2', 'id' => 'wpReason' ) ) .
2176 "</td>
2177 </tr>
2178 <tr>
2179 <td></td>
2181 Xml::checkLabel( wfMsg( 'watchthis' ), 'wpWatch', 'wpWatch', $wgUser->getBoolOption( 'watchdeletion' ) || $this->mTitle->userIsWatching(), array( 'tabindex' => '3' ) ) .
2182 "</td>
2183 </tr>
2184 $suppress
2185 <tr>
2186 <td></td>
2188 Xml::submitButton( wfMsg( 'deletepage' ), array( 'name' => 'wpConfirmB', 'id' => 'wpConfirmB', 'tabindex' => '4' ) ) .
2189 "</td>
2198 $link = $skin->makeLink ( 'MediaWiki:Deletereason-dropdown', wfMsgHtml( 'delete-edit-reasonlist' ) );
2200 }
2204 }
2207 /**
2208 * Show relevant lines from the deletion log
2209 */
2213 }
2216 /**
2217 * Perform a deletion and output success or failure messages
2218 */
2239 }
2240 }
2241 }
2243 /**
2244 * Back-end article deletion
2245 * Deletes the article with database consistency, writes logs, purges caches
2246 * Returns success
2247 */
2261 }
2266 // Bitfields to further suppress the content
2269 // This should be 15...
2276 }
2279 // For now, shunt the revision data into the archive table.
2280 // Text is *not* removed from the text table; bulk storage
2281 // is left intact to avoid breaking block-compression or
2282 // immutable storage schemes.
2283 //
2284 // For backwards compatibility, note that some older archive
2285 // table entries will have ar_text and ar_flags fields still.
2286 //
2287 // In the future, we may keep revisions and mark them with
2288 // the rev_deleted field, which is reserved for this purpose.
2307 'page_id = rev_page'
2308 ), __METHOD__
2309 );
2311 # Delete restrictions for it
2314 # Fix category table counts
2320 }
2323 # Now that it's safely backed up, delete it
2329 }
2331 # If using cascading deletes, we can skip some explicit deletes
2338 # Delete outgoing links
2346 }
2348 # If using cleanup triggers, we can skip some manual deletes
2351 # Clean up recentchanges entries...
2354 __METHOD__ );
2355 }
2358 # Clear caches
2361 # Clear the cached article id so the interface doesn't act like we exist
2365 # Log the deletion, if the page was suppressed, log it at Oversight instead
2369 # Make sure logging got through
2373 }
2375 /**
2376 * Roll back the most recent consecutive set of edits to a page
2377 * from the same user; fails if there are no eligible edits to
2378 * roll back to, e.g. user is the sole contributor. This function
2379 * performs permissions checks on $wgUser, then calls commitRollback()
2380 * to do the dirty work
2381 *
2382 * @param string $fromP - Name of the user whose edits to rollback.
2383 * @param string $summary - Custom summary. Set to default summary if empty.
2384 * @param string $token - Rollback token.
2385 * @param bool $bot - If true, mark all reverted edits as bot.
2386 *
2387 * @param array $resultDetails contains result-specific array of additional values
2388 * 'alreadyrolled' : 'current' (rev)
2389 * success : 'summary' (str), 'current' (rev), 'target' (rev)
2390 *
2391 * @return array of errors, each error formatted as
2392 * array(messagekey, param1, param2, ...).
2393 * On success, the array is empty. This array can also be passed to
2394 * OutputPage::showPermissionsErrorPage().
2395 */
2400 # Check permissions
2408 }
2409 # If there were errors, bail out now
2414 }
2416 /**
2417 * Backend implementation of doRollback(), please refer there for parameter
2418 * and return value documentation
2419 *
2420 * NOTE: This function does NOT check ANY permissions, it just commits the
2421 * rollback to the DB Therefore, you should only call this function direct-
2422 * ly if you want to use custom permissions checks. If you don't, use
2423 * doRollback() instead.
2424 */
2431 }
2433 # Get the last editor
2436 # Something wrong... no page?
2438 }
2447 ));
2448 }
2450 # Get the last edit not by this guy
2460 );
2462 # No one else ever edited this page
2464 } else if( $s->rev_deleted & REVISION::DELETED_TEXT || $s->rev_deleted & REVISION::DELETED_USER ) {
2465 # Only admins can see this text
2467 }
2471 # Mark all reverted edits as bot
2473 }
2475 # Mark all reverted edits as patrolled
2477 }
2485 ), __METHOD__
2486 );
2487 }
2489 # Generate the edit summary if necessary
2492 {
2498 );
2499 }
2501 # Save
2517 );
2519 }
2521 /**
2522 * User interface for rollback operations
2523 */
2533 $details
2534 );
2539 }
2543 }
2544 if( isset( $result[0][0] ) && ( $result[0][0] == 'alreadyrolled' || $result[0][0] == 'cantrollback' ) ){
2552 $wgOut->addWikiMsgArray( 'editcomment', array( $wgUser->getSkin()->formatComment( $current->getComment() ) ), array( 'replaceafter' ) );
2553 }
2554 }
2556 }
2557 # Display permissions errors before read-only message -- there's no
2558 # point in misleading the user into thinking the inability to rollback
2559 # is only temporary.
2561 # array_diff is completely broken for arrays of arrays, sigh. Re-
2562 # move any 'readonlytext' error manually.
2567 }
2568 }
2571 }
2575 }
2585 $wgOut->addHtml( wfMsgExt( 'rollback-success', array( 'parse', 'replaceafter' ), $old, $new ) );
2587 }
2590 /**
2591 * Do standard deferred updates after page view
2592 * @private
2593 */
2603 }
2604 }
2606 # Update newtalk / watchlist notification status
2609 }
2611 /**
2612 * Prepare text which is about to be saved.
2613 * Returns a stdclass with source, pst and output members
2614 */
2616 if ( $this->mPreparedEdit && $this->mPreparedEdit->newText == $text && $this->mPreparedEdit->revid == $revid) {
2617 // Already prepared
2619 }
2632 }
2634 /**
2635 * Do standard deferred updates after page edit.
2636 * Update links tables, site stats, search index and message cache.
2637 * Every 100th edit, prune the recent changes table.
2638 *
2639 * @private
2640 * @param $text New text of the article
2641 * @param $summary Edit summary
2642 * @param $minoredit Minor edit
2643 * @param $timestamp_of_pagechange Timestamp associated with the page change
2644 * @param $newid rev_id value of the new revision
2645 * @param $changed Whether or not the content actually changed
2646 */
2647 function editUpdates( $text, $summary, $minoredit, $timestamp_of_pagechange, $newid, $changed = true ) {
2652 # Parse the text
2653 # Be careful not to double-PST: $text is usually already PST-ed once
2660 }
2662 # Save it to the parser cache
2666 }
2668 # Update the links tables
2674 // Flush old entries from the `recentchanges` table; we do this on
2675 // random requests so as to avoid an increase in writes for no good reason
2682 }
2683 }
2692 }
2699 # If this is another user's talk page, update newtalk
2700 # Don't do this if $changed = false otherwise some idiot can null-edit a
2701 # load of user talk pages and piss people off, nor if it's a minor edit
2702 # by a properly-flagged bot.
2703 if( $this->mTitle->getNamespace() == NS_USER_TALK && $shortTitle != $wgUser->getTitleKey() && $changed
2708 // An anonymous user
2711 }
2714 }
2715 }
2716 }
2720 }
2723 }
2725 /**
2726 * Perform article updates on a special page creation.
2727 *
2728 * @param Revision $rev
2729 *
2730 * @todo This is a shitty interface function. Kill it and replace the
2731 * other shitty functions like editUpdates and such so it's not needed
2732 * anymore.
2733 */
2739 }
2741 /**
2742 * Generate the navigation links when browsing through an article revisions
2743 * It shows the information as:
2744 * Revision as of \<date\>; view current revision
2745 * \<- Previous version | Next Version -\>
2746 *
2747 * @private
2748 * @param string $oldid Revision ID of this article revision
2749 */
2755 }
2770 ? $sk->makeKnownLinkObj( $this->mTitle, wfMsg( 'previousrevision' ), 'direction=prev&oldid='.$oldid )
2777 : $sk->makeKnownLinkObj( $this->mTitle, wfMsg( 'nextrevision' ), 'direction=next&oldid='.$oldid );
2786 // We don't handle top deleted edits too well
2789 // If revision was hidden from sysops
2796 // Bolden oversighted content
2799 }
2801 }
2802 # Show user links if allowed to see them. Normally they
2803 # are hidden regardless, but since we can already see the text here...
2808 ? 'revision-info-current'
2811 $r = "\n\t\t\t\t<div id=\"mw-{$infomsg}\">" . wfMsg( $infomsg, $td, $userlinks ) . "</div>\n" .
2813 "\n\t\t\t\t<div id=\"mw-revision-nav\">" . $cdel . wfMsg( 'revision-nav', $prevdiff, $prevlink, $lnk, $curdiff, $nextlink, $nextdiff ) . "</div>\n\t\t\t";
2815 }
2817 /**
2818 * This function is called right before saving the wikitext,
2819 * so we can do things like signatures and links-in-context.
2820 *
2821 * @param string $text
2822 */
2825 return $wgParser->preSaveTransform( $text, $this->mTitle, $wgUser, ParserOptions::newFromUser( $wgUser ) );
2826 }
2828 /* Caching functions */
2830 /**
2831 * checkLastModified returns true if it has taken care of all
2832 * output to the client that is necessary for this request.
2833 * (that is, it has sent a cached version of the page)
2834 */
2840 }
2852 }
2855 }
2856 }
2858 /**
2859 * Check if the page can be cached
2860 * @return bool
2861 */
2871 //check for non-standard user language; this covers uselang,
2872 //and extensions for auto-detecting user language.
2892 //extension may have reason to disable file caching on some pages.
2894 }
2897 }
2899 /**
2900 * Loads page_touched and returns a value indicating if it should be used
2901 *
2902 */
2906 }
2908 }
2910 /**
2911 * Get the page_touched field
2912 */
2914 # Ensure that page data has been loaded
2917 }
2919 }
2921 /**
2922 * Get the page_latest field
2923 */
2927 }
2929 }
2931 /**
2932 * Edit an article without doing all that other stuff
2933 * The article must already exist; link tables etc
2934 * are not updated, caches are not flushed.
2935 *
2936 * @param string $text text submitted
2937 * @param string $comment comment submitted
2938 * @param bool $minor whereas it's a minor modification
2939 */
2950 ) );
2956 }
2958 /**
2959 * Used to increment the view counter
2960 *
2961 * @static
2962 * @param integer $id article id
2963 */
2976 }
2978 # Not important enough to warrant an error page in case of failure
2985 # Most of the time (or on SQL errors), skip row count check
2988 }
3008 }
3012 }
3017 }
3019 }
3021 /**#@+
3022 * The onArticle*() functions are supposed to be a kind of hooks
3023 * which should be called whenever any of the specified actions
3024 * are done.
3025 *
3026 * This is a good place to put code to clear caches, for instance.
3027 *
3028 * This is called on page move and undelete, as well as edit
3029 * @static
3030 * @param $title_obj a title object
3031 */
3034 # The talk page isn't in the regular link tables, so we need to update manually:
3039 }
3046 }
3051 // Update existence markers on article/talk tabs...
3056 }
3063 # File cache
3067 }
3071 }
3075 }
3076 }
3078 /**
3079 * Purge caches on page update etc
3080 */
3084 // Invalidate caches of articles which include this page
3087 // Invalidate the caches of all pages which redirect here
3090 # Purge squid for this page only
3093 # Clear file cache
3097 }
3098 }
3100 /**#@-*/
3102 /**
3103 * Overriden by ImagePage class, only present here to avoid a fatal error
3104 * Called for ?action=revert
3105 */
3109 }
3111 /**
3112 * Info about this page
3113 * Called for ?action=info when $wgAllowPageInfo is on.
3114 *
3115 * @public
3116 */
3123 }
3134 // This doesn't quite make sense; the user is asking for
3135 // information about the _page_, not the message... -- RC
3139 ? 'noarticletext'
3142 }
3153 __METHOD__,
3159 $wgOut->addHTML( "<ul><li>" . wfMsg("numwatchers", $wgLang->formatNum( $numwatchers ) ) . '</li>' );
3160 $wgOut->addHTML( "<li>" . wfMsg('numedits', $wgLang->formatNum( $pageInfo['edits'] ) ) . '</li>');
3162 $wgOut->addHTML( '<li>' . wfMsg("numtalkedits", $wgLang->formatNum( $talkInfo['edits'] ) ) . '</li>');
3163 }
3164 $wgOut->addHTML( '<li>' . wfMsg("numauthors", $wgLang->formatNum( $pageInfo['authors'] ) ) . '</li>' );
3166 $wgOut->addHTML( '<li>' . wfMsg('numtalkauthors', $wgLang->formatNum( $talkInfo['authors'] ) ) . '</li>' );
3167 }
3170 }
3171 }
3173 /**
3174 * Return the total number of edits and number of unique editors
3175 * on a given page. If page does not exist, returns false.
3176 *
3177 * @param Title $title
3178 * @return array
3179 * @private
3180 */
3185 }
3195 __METHOD__,
3202 __METHOD__,
3206 }
3208 /**
3209 * Return a list of templates used by this article.
3210 * Uses the templatelinks table
3211 *
3212 * @return array Array of Title objects
3213 */
3219 }
3230 }
3231 }
3232 }
3235 }
3237 /**
3238 * Returns a list of hidden categories this page is a member of.
3239 * Uses the page_props and categorylinks tables.
3240 *
3241 * @return array Array of Title objects
3242 */
3248 }
3260 }
3261 }
3262 }
3265 }
3267 /**
3268 * Return an auto-generated summary if the text provided is a redirect.
3269 *
3270 * @param string $text The wikitext to check
3271 * @return string '' or an appropriate summary
3272 */
3277 else
3279 }
3281 /**
3282 * Return an auto-generated summary if the new text is much shorter than
3283 * the old text.
3284 *
3285 * @param string $oldtext The previous text of the page
3286 * @param string $text The submitted text of the page
3287 * @return string An appropriate autosummary, or an empty string.
3288 */
3293 #Removing more than 90% of the article
3295 $truncatedtext = $wgContLang->truncate($text, max(0, 200 - strlen(wfMsgForContent('autosumm-replace'))), '...');
3299 }
3300 }
3302 /**
3303 * Return an applicable autosummary if one exists for the given edit.
3304 * @param string $oldtext The previous text of the page.
3305 * @param string $newtext The submitted text of the page.
3306 * @param bitmask $flags A bitmask of flags submitted for the edit.
3307 * @return string An appropriate autosummary, or an empty string.
3308 */
3311 # This code is UGLY UGLY UGLY.
3312 # Somebody PLEASE come up with a more elegant way to do it.
3314 #Redirect autosummaries
3320 #Blanking autosummaries
3327 #New page autosummaries
3329 #If they're making a new article, give its text, truncated, in the summary.
3336 }
3342 }
3344 /**
3345 * Add the primary page-view wikitext to the output buffer
3346 * Saves the text into the parser cache if possible.
3347 * Updates templatelinks if it is out of date.
3348 *
3349 * @param string $text
3350 * @param bool $cache
3351 */
3365 }
3368 // templatelinks table may have become out of sync,
3369 // especially if using variable-based transclusions.
3370 // For paranoia, check if things have changed and if
3371 // so apply updates to the database. This will ensure
3372 // that cascaded protections apply as soon as the changes
3373 // are visible.
3375 # Get templates from templatelinks
3392 }
3393 }
3394 }
3396 # Get templates from parser output.
3402 }
3404 # Get the diff
3408 # Whee, link updates time.
3417 }
3418 }
3421 }
3423 /**
3424 * Update all the appropriate counts in the category table, given that
3425 * we've added the categories $added and deleted the categories $deleted.
3426 *
3427 * @param $added array The names of categories that were added
3428 * @param $deleted array The names of categories that were deleted
3429 * @return null
3430 */
3435 # First make sure the rows exist. If one of the "deleted" ones didn't
3436 # exist, we might legitimately not create it, but it's simpler to just
3437 # create it and then give it a negative value, since the value is bogus
3438 # anyway.
3439 #
3440 # Sometimes I wish we had INSERT ... ON DUPLICATE KEY UPDATE.
3443 # Okay, nothing to do
3445 }
3449 }
3460 }
3467 __METHOD__
3468 );
3469 }
3475 __METHOD__
3476 );
3477 }
3478 }
3479 }