<?php
/**
* Representation of a page version.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
*/
/**
* @todo document
*/
class Revision implements IDBAccessObject {
protected $mId;
/**
* @var int|null
*/
protected $mPage;
protected $mUserText;
protected $mOrigUserText;
protected $mUser;
protected $mMinorEdit;
protected $mTimestamp;
protected $mDeleted;
protected $mSize;
protected $mSha1;
protected $mParentId;
protected $mComment;
protected $mText;
protected $mTextId;
/**
* @var stdClass|null
*/
protected $mTextRow;
/**
* @var null|Title
*/
protected $mTitle;
protected $mCurrent;
protected $mContentModel;
protected $mContentFormat;
/**
* @var Content|null|bool
*/
protected $mContent;
/**
* @var null|ContentHandler
*/
protected $mContentHandler;
/**
* @var int
*/
protected $mQueryFlags = 0;
// Revision deletion constants
const DELETED_TEXT = 1;
const DELETED_COMMENT = 2;
const DELETED_USER = 4;
const DELETED_RESTRICTED = 8;
const SUPPRESSED_USER = 12; // convenience
// Audience options for accessors
const FOR_PUBLIC = 1;
const FOR_THIS_USER = 2;
const RAW = 3;
/**
* Load a page revision from a given revision ID number.
* Returns null if no such revision can be found.
*
* $flags include:
* Revision::READ_LATEST : Select the data from the master
* Revision::READ_LOCKING : Select & lock the data from the master
*
* @param int $id
* @param int $flags (optional)
* @return Revision|null
*/
public static function newFromId( $id, $flags = 0 ) {
return self::newFromConds( array( 'rev_id' => intval( $id ) ), $flags );
}
/**
* Load either the current, or a specified, revision
* that's attached to a given title. If not attached
* to that title, will return null.
*
* $flags include:
* Revision::READ_LATEST : Select the data from the master
* Revision::READ_LOCKING : Select & lock the data from the master
*
* @param Title $title
* @param int $id (optional)
* @param int $flags Bitfield (optional)
* @return Revision|null
*/
public static function newFromTitle( $title, $id = 0, $flags = 0 ) {
$conds = array(
'page_namespace' => $title->getNamespace(),
'page_title' => $title->getDBkey()
);
if ( $id ) {
// Use the specified ID
$conds['rev_id'] = $id;
return self::newFromConds( $conds, $flags );
} else {
// Use a join to get the latest revision
$conds[] = 'rev_id=page_latest';
$db = wfGetDB( ( $flags & self::READ_LATEST ) ? DB_MASTER : DB_SLAVE );
return self::loadFromConds( $db, $conds, $flags );
}
}
/**
* Load either the current, or a specified, revision
* that's attached to a given page ID.
* Returns null if no such revision can be found.
*
* $flags include:
* Revision::READ_LATEST : Select the data from the master (since 1.20)
* Revision::READ_LOCKING : Select & lock the data from the master
*
* @param int $pageId
* @param int $revId (optional)
* @param int $flags Bitfield (optional)
* @return Revision|null
*/
public static function newFromPageId( $pageId, $revId = 0, $flags = 0 ) {
$conds = array( 'page_id' => $pageId );
if ( $revId ) {
$conds['rev_id'] = $revId;
return self::newFromConds( $conds, $flags );
} else {
// Use a join to get the latest revision
$conds[] = 'rev_id = page_latest';
$db = wfGetDB( ( $flags & self::READ_LATEST ) ? DB_MASTER : DB_SLAVE );
return self::loadFromConds( $db, $conds, $flags );
}
}
/**
* Make a fake revision object from an archive table row. This is queried
* for permissions or even inserted (as in Special:Undelete)
* @todo FIXME: Should be a subclass for RevisionDelete. [TS]
*
* @param object $row
* @param array $overrides
*
* @throws MWException
* @return Revision
*/
public static function newFromArchiveRow( $row, $overrides = array() ) {
global $wgContentHandlerUseDB;
$attribs = $overrides + array(
'page' => isset( $row->ar_page_id ) ? $row->ar_page_id : null,
'id' => isset( $row->ar_rev_id ) ? $row->ar_rev_id : null,
'comment' => $row->ar_comment,
'user' => $row->ar_user,
'user_text' => $row->ar_user_text,
'timestamp' => $row->ar_timestamp,
'minor_edit' => $row->ar_minor_edit,
'text_id' => isset( $row->ar_text_id ) ? $row->ar_text_id : null,
'deleted' => $row->ar_deleted,
'len' => $row->ar_len,
'sha1' => isset( $row->ar_sha1 ) ? $row->ar_sha1 : null,
'content_model' => isset( $row->ar_content_model ) ? $row->ar_content_model : null,
'content_format' => isset( $row->ar_content_format ) ? $row->ar_content_format : null,
);
if ( !$wgContentHandlerUseDB ) {
unset( $attribs['content_model'] );
unset( $attribs['content_format'] );
}
if ( !isset( $attribs['title'] )
&& isset( $row->ar_namespace )
&& isset( $row->ar_title )
) {
$attribs['title'] = Title::makeTitle( $row->ar_namespace, $row->ar_title );
}
if ( isset( $row->ar_text ) && !$row->ar_text_id ) {
// Pre-1.5 ar_text row
$attribs['text'] = self::getRevisionText( $row, 'ar_' );
if ( $attribs['text'] === false ) {
throw new MWException( 'Unable to load text from archive row (possibly bug 22624)' );
}
}
return new self( $attribs );
}
/**
* @since 1.19
*
* @param object $row
* @return Revision
*/
public static function newFromRow( $row ) {
return new self( $row );
}
/**
* Load a page revision from a given revision ID number.
* Returns null if no such revision can be found.
*
* @param DatabaseBase $db
* @param int $id
* @return Revision|null
*/
public static function loadFromId( $db, $id ) {
return self::loadFromConds( $db, array( 'rev_id' => intval( $id ) ) );
}
/**
* Load either the current, or a specified, revision
* that's attached to a given page. If not attached
* to that page, will return null.
*
* @param DatabaseBase $db
* @param int $pageid
* @param int $id
* @return Revision|null
*/
public static function loadFromPageId( $db, $pageid, $id = 0 ) {
$conds = array( 'rev_page' => intval( $pageid ), 'page_id' => intval( $pageid ) );
if ( $id ) {
$conds['rev_id'] = intval( $id );
} else {
$conds[] = 'rev_id=page_latest';
}
return self::loadFromConds( $db, $conds );
}
/**
* Load either the current, or a specified, revision
* that's attached to a given page. If not attached
* to that page, will return null.
*
* @param DatabaseBase $db
* @param Title $title
* @param int $id
* @return Revision|null
*/
public static function loadFromTitle( $db, $title, $id = 0 ) {
if ( $id ) {
$matchId = intval( $id );
} else {
$matchId = 'page_latest';
}
return self::loadFromConds( $db,
array(
"rev_id=$matchId",
'page_namespace' => $title->getNamespace(),
'page_title' => $title->getDBkey()
)
);
}
/**
* Load the revision for the given title with the given timestamp.
* WARNING: Timestamps may in some circumstances not be unique,
* so this isn't the best key to use.
*
* @param DatabaseBase $db
* @param Title $title
* @param string $timestamp
* @return Revision|null
*/
public static function loadFromTimestamp( $db, $title, $timestamp ) {
return self::loadFromConds( $db,
array(
'rev_timestamp' => $db->timestamp( $timestamp ),
'page_namespace' => $title->getNamespace(),
'page_title' => $title->getDBkey()
)
);
}
/**
* Given a set of conditions, fetch a revision
*
* This method is used then a revision ID is qualified and
* will incorporate some basic slave/master fallback logic
*
* @param array $conditions
* @param int $flags (optional)
* @return Revision|null
*/
private static function newFromConds( $conditions, $flags = 0 ) {
$db = wfGetDB( ( $flags & self::READ_LATEST ) ? DB_MASTER : DB_SLAVE );
$rev = self::loadFromConds( $db, $conditions, $flags );
// Make sure new pending/committed revision are visibile later on
// within web requests to certain avoid bugs like T93866 and T94407.
if ( !$rev
&& !( $flags & self::READ_LATEST )
&& wfGetLB()->getServerCount() > 1
&& wfGetLB()->hasOrMadeRecentMasterChanges()
) {
$flags = self::READ_LATEST;
$db = wfGetDB( DB_MASTER );
$rev = self::loadFromConds( $db, $conditions, $flags );
}
if ( $rev ) {
$rev->mQueryFlags = $flags;
}
return $rev;
}
/**
* Given a set of conditions, fetch a revision from
* the given database connection.
*
* @param DatabaseBase $db
* @param array $conditions
* @param int $flags (optional)
* @return Revision|null
*/
private static function loadFromConds( $db, $conditions, $flags = 0 ) {
$res = self::fetchFromConds( $db, $conditions, $flags );
if ( $res ) {
$row = $res->fetchObject();
if ( $row ) {
$ret = new Revision( $row );
return $ret;
}
}
$ret = null;
return $ret;
}
/**
* Return a wrapper for a series of database rows to
* fetch all of a given page's revisions in turn.
* Each row can be fed to the constructor to get objects.
*
* @param Title $title
* @return ResultWrapper
*/
public static function fetchRevision( $title ) {
return self::fetchFromConds(
wfGetDB( DB_SLAVE ),
array(
'rev_id=page_latest',
'page_namespace' => $title->getNamespace(),
'page_title' => $title->getDBkey()
)
);
}
/**
* Given a set of conditions, return a ResultWrapper
* which will return matching database rows with the
* fields necessary to build Revision objects.
*
* @param DatabaseBase $db
* @param array $conditions
* @param int $flags (optional)
* @return ResultWrapper
*/
private static function fetchFromConds( $db, $conditions, $flags = 0 ) {
$fields = array_merge(
self::selectFields(),
self::selectPageFields(),
self::selectUserFields()
);
$options = array( 'LIMIT' => 1 );
if ( ( $flags & self::READ_LOCKING ) == self::READ_LOCKING ) {
$options[] = 'FOR UPDATE';
}
return $db->select(
array( 'revision', 'page', 'user' ),
$fields,
$conditions,
__METHOD__,
$options,
array( 'page' => self::pageJoinCond(), 'user' => self::userJoinCond() )
);
}
/**
* Return the value of a select() JOIN conds array for the user table.
* This will get user table rows for logged-in users.
* @since 1.19
* @return array
*/
public static function userJoinCond() {
return array( 'LEFT JOIN', array( 'rev_user != 0', 'user_id = rev_user' ) );
}
/**
* Return the value of a select() page conds array for the page table.
* This will assure that the revision(s) are not orphaned from live pages.
* @since 1.19
* @return array
*/
public static function pageJoinCond() {
return array( 'INNER JOIN', array( 'page_id = rev_page' ) );
}
/**
* Return the list of revision fields that should be selected to create
* a new revision.
* @return array
*/
public static function selectFields() {
global $wgContentHandlerUseDB;
$fields = array(
'rev_id',
'rev_page',
'rev_text_id',
'rev_timestamp',
'rev_comment',
'rev_user_text',
'rev_user',
'rev_minor_edit',
'rev_deleted',
'rev_len',
'rev_parent_id',
'rev_sha1',
);
if ( $wgContentHandlerUseDB ) {
$fields[] = 'rev_content_format';
$fields[] = 'rev_content_model';
}
return $fields;
}
/**
* Return the list of revision fields that should be selected to create
* a new revision from an archive row.
* @return array
*/
public static function selectArchiveFields() {
global $wgContentHandlerUseDB;
$fields = array(
'ar_id',
'ar_page_id',
'ar_rev_id',
'ar_text',
'ar_text_id',
'ar_timestamp',
'ar_comment',
'ar_user_text',
'ar_user',
'ar_minor_edit',
'ar_deleted',
'ar_len',
'ar_parent_id',
'ar_sha1',
);
if ( $wgContentHandlerUseDB ) {
$fields[] = 'ar_content_format';
$fields[] = 'ar_content_model';
}
return $fields;
}
/**
* Return the list of text fields that should be selected to read the
* revision text
* @return array
*/
public static function selectTextFields() {
return array(
'old_text',
'old_flags'
);
}
/**
* Return the list of page fields that should be selected from page table
* @return array
*/
public static function selectPageFields() {
return array(
'page_namespace',
'page_title',
'page_id',
'page_latest',
'page_is_redirect',
'page_len',
);
}
/**
* Return the list of user fields that should be selected from user table
* @return array
*/
public static function selectUserFields() {
return array( 'user_name' );
}
/**
* Do a batched query to get the parent revision lengths
* @param DatabaseBase $db
* @param array $revIds
* @return array
*/
public static function getParentLengths( $db, array $revIds ) {
$revLens = array();
if ( !$revIds ) {
return $revLens; // empty
}
$res = $db->select( 'revision',
array( 'rev_id', 'rev_len' ),
array( 'rev_id' => $revIds ),
__METHOD__ );
foreach ( $res as $row ) {
$revLens[$row->rev_id] = $row->rev_len;
}
return $revLens;
}
/**
* Constructor
*
* @param object|array $row Either a database row or an array
* @throws MWException
* @access private
*/
function __construct( $row ) {
if ( is_object( $row ) ) {
$this->mId = intval( $row->rev_id );
$this->mPage = intval( $row->rev_page );
$this->mTextId = intval( $row->rev_text_id );
$this->mComment = $row->rev_comment;
$this->mUser = intval( $row->rev_user );
$this->mMinorEdit = intval( $row->rev_minor_edit );
$this->mTimestamp = $row->rev_timestamp;
$this->mDeleted = intval( $row->rev_deleted );
if ( !isset( $row->rev_parent_id ) ) {
$this->mParentId = null;
} else {
$this->mParentId = intval( $row->rev_parent_id );
}
if ( !isset( $row->rev_len ) ) {
$this->mSize = null;
} else {
$this->mSize = intval( $row->rev_len );
}
if ( !isset( $row->rev_sha1 ) ) {
$this->mSha1 = null;
} else {
$this->mSha1 = $row->rev_sha1;
}
if ( isset( $row->page_latest ) ) {
$this->mCurrent = ( $row->rev_id == $row->page_latest );
$this->mTitle = Title::newFromRow( $row );
} else {
$this->mCurrent = false;
$this->mTitle = null;
}
if ( !isset( $row->rev_content_model ) ) {
$this->mContentModel = null; # determine on demand if needed
} else {
$this->mContentModel = strval( $row->rev_content_model );
}
if ( !isset( $row->rev_content_format ) ) {
$this->mContentFormat = null; # determine on demand if needed
} else {
$this->mContentFormat = strval( $row->rev_content_format );
}
// Lazy extraction...
$this->mText = null;
if ( isset( $row->old_text ) ) {
$this->mTextRow = $row;
} else {
// 'text' table row entry will be lazy-loaded
$this->mTextRow = null;
}
// Use user_name for users and rev_user_text for IPs...
$this->mUserText = null; // lazy load if left null
if ( $this->mUser == 0 ) {
$this->mUserText = $row->rev_user_text; // IP user
} elseif ( isset( $row->user_name ) ) {
$this->mUserText = $row->user_name; // logged-in user
}
$this->mOrigUserText = $row->rev_user_text;
} elseif ( is_array( $row ) ) {
// Build a new revision to be saved...
global $wgUser; // ugh
# if we have a content object, use it to set the model and type
if ( !empty( $row['content'] ) ) {
// @todo when is that set? test with external store setup! check out insertOn() [dk]
if ( !empty( $row['text_id'] ) ) {
throw new MWException( "Text already stored in external store (id {$row['text_id']}), " .
"can't serialize content object" );
}
$row['content_model'] = $row['content']->getModel();
# note: mContentFormat is initializes later accordingly
# note: content is serialized later in this method!
# also set text to null?
}
$this->mId = isset( $row['id'] ) ? intval( $row['id'] ) : null;
$this->mPage = isset( $row['page'] ) ? intval( $row['page'] ) : null;
$this->mTextId = isset( $row['text_id'] ) ? intval( $row['text_id'] ) : null;
$this->mUserText = isset( $row['user_text'] )
? strval( $row['user_text'] ) : $wgUser->getName();
$this->mUser = isset( $row['user'] ) ? intval( $row['user'] ) : $wgUser->getId();
$this->mMinorEdit = isset( $row['minor_edit'] ) ? intval( $row['minor_edit'] ) : 0;
$this->mTimestamp = isset( $row['timestamp'] )
? strval( $row['timestamp'] ) : wfTimestampNow();
$this->mDeleted = isset( $row['deleted'] ) ? intval( $row['deleted'] ) : 0;
$this->mSize = isset( $row['len'] ) ? intval( $row['len'] ) : null;
$this->mParentId = isset( $row['parent_id'] ) ? intval( $row['parent_id'] ) : null;
$this->mSha1 = isset( $row['sha1'] ) ? strval( $row['sha1'] ) : null;
$this->mContentModel = isset( $row['content_model'] )
? strval( $row['content_model'] ) : null;
$this->mContentFormat = isset( $row['content_format'] )
? strval( $row['content_format'] ) : null;
// Enforce spacing trimming on supplied text
$this->mComment = isset( $row['comment'] ) ? trim( strval( $row['comment'] ) ) : null;
$this->mText = isset( $row['text'] ) ? rtrim( strval( $row['text'] ) ) : null;
$this->mTextRow = null;
$this->mTitle = isset( $row['title'] ) ? $row['title'] : null;
// if we have a Content object, override mText and mContentModel
if ( !empty( $row['content'] ) ) {
if ( !( $row['content'] instanceof Content ) ) {
throw new MWException( '`content` field must contain a Content object.' );
}
$handler = $this->getContentHandler();
$this->mContent = $row['content'];
$this->mContentModel = $this->mContent->getModel();
$this->mContentHandler = null;
$this->mText = $handler->serializeContent( $row['content'], $this->getContentFormat() );
} elseif ( $this->mText !== null ) {
$handler = $this->getContentHandler();
$this->mContent = $handler->unserializeContent( $this->mText );
}
// If we have a Title object, make sure it is consistent with mPage.
if ( $this->mTitle && $this->mTitle->exists() ) {
if ( $this->mPage === null ) {
// if the page ID wasn't known, set it now
$this->mPage = $this->mTitle->getArticleID();
} elseif ( $this->mTitle->getArticleID() !== $this->mPage ) {
// Got different page IDs. This may be legit (e.g. during undeletion),
// but it seems worth mentioning it in the log.
wfDebug( "Page ID " . $this->mPage . " mismatches the ID " .
$this->mTitle->getArticleID() . " provided by the Title object." );
}
}
$this->mCurrent = false;
// If we still have no length, see it we have the text to figure it out
if ( !$this->mSize && $this->mContent !== null ) {
$this->mSize = $this->mContent->getSize();
}
// Same for sha1
if ( $this->mSha1 === null ) {
$this->mSha1 = $this->mText === null ? null : self::base36Sha1( $this->mText );
}
// force lazy init
$this->getContentModel();
$this->getContentFormat();
} else {
throw new MWException( 'Revision constructor passed invalid row format.' );
}
$this->mUnpatrolled = null;
}
/**
* Get revision ID
*
* @return int|null
*/
public function getId() {
return $this->mId;
}
/**
* Set the revision ID
*
* @since 1.19
* @param int $id
*/
public function setId( $id ) {
$this->mId = $id;
}
/**
* Get text row ID
*
* @return int|null
*/
public function getTextId() {
return $this->mTextId;
}
/**
* Get parent revision ID (the original previous page revision)
*
* @return int|null
*/
public function getParentId() {
return $this->mParentId;
}
/**
* Returns the length of the text in this revision, or null if unknown.
*
* @return int|null
*/
public function getSize() {
return $this->mSize;
}
/**
* Returns the base36 sha1 of the text in this revision, or null if unknown.
*
* @return string|null
*/
public function getSha1() {
return $this->mSha1;
}
/**
* Returns the title of the page associated with this entry or null.
*
* Will do a query, when title is not set and id is given.
*
* @return Title|null
*/
public function getTitle() {
if ( $this->mTitle !== null ) {
return $this->mTitle;
}
//rev_id is defined as NOT NULL, but this revision may not yet have been inserted.
if ( $this->mId !== null ) {
$dbr = wfGetDB( DB_SLAVE );
$row = $dbr->selectRow(
array( 'page', 'revision' ),
self::selectPageFields(),
array( 'page_id=rev_page',
'rev_id' => $this->mId ),
__METHOD__ );
if ( $row ) {
$this->mTitle = Title::newFromRow( $row );
}
}
if ( !$this->mTitle && $this->mPage !== null && $this->mPage > 0 ) {
$this->mTitle = Title::newFromID( $this->mPage );
}
return $this->mTitle;
}
/**
* Set the title of the revision
*
* @param Title $title
*/
public function setTitle( $title ) {
$this->mTitle = $title;
}
/**
* Get the page ID
*
* @return int|null
*/
public function getPage() {
return $this->mPage;
}
/**
* Fetch revision's user id if it's available to the specified audience.
* If the specified audience does not have access to it, zero will be
* returned.
*
* @param int $audience One of:
* Revision::FOR_PUBLIC to be displayed to all users
* Revision::FOR_THIS_USER to be displayed to the given user
* Revision::RAW get the ID regardless of permissions
* @param User $user User object to check for, only if FOR_THIS_USER is passed
* to the $audience parameter
* @return int
*/
public function getUser( $audience = self::FOR_PUBLIC, User $user = null ) {
if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
return 0;
} elseif ( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER, $user ) ) {
return 0;
} else {
return $this->mUser;
}
}
/**
* Fetch revision's user id without regard for the current user's permissions
*
* @return string
* @deprecated since 1.25, use getUser( Revision::RAW )
*/
public function getRawUser() {
wfDeprecated( __METHOD__, '1.25' );
return $this->getUser( self::RAW );
}
/**
* Fetch revision's username if it's available to the specified audience.
* If the specified audience does not have access to the username, an
* empty string will be returned.
*
* @param int $audience One of:
* Revision::FOR_PUBLIC to be displayed to all users
* Revision::FOR_THIS_USER to be displayed to the given user
* Revision::RAW get the text regardless of permissions
* @param User $user User object to check for, only if FOR_THIS_USER is passed
* to the $audience parameter
* @return string
*/
public function getUserText( $audience = self::FOR_PUBLIC, User $user = null ) {
if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
return '';
} elseif ( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER, $user ) ) {
return '';
} else {
if ( $this->mUserText === null ) {
$this->mUserText = User::whoIs( $this->mUser ); // load on demand
if ( $this->mUserText === false ) {
# This shouldn't happen, but it can if the wiki was recovered
# via importing revs and there is no user table entry yet.
$this->mUserText = $this->mOrigUserText;
}
}
return $this->mUserText;
}
}
/**
* Fetch revision's username without regard for view restrictions
*
* @return string
* @deprecated since 1.25, use getUserText( Revision::RAW )
*/
public function getRawUserText() {
wfDeprecated( __METHOD__, '1.25' );
return $this->getUserText( self::RAW );
}
/**
* Fetch revision comment if it's available to the specified audience.
* If the specified audience does not have access to the comment, an
* empty string will be returned.
*
* @param int $audience One of:
* Revision::FOR_PUBLIC to be displayed to all users
* Revision::FOR_THIS_USER to be displayed to the given user
* Revision::RAW get the text regardless of permissions
* @param User $user User object to check for, only if FOR_THIS_USER is passed
* to the $audience parameter
* @return string
*/
function getComment( $audience = self::FOR_PUBLIC, User $user = null ) {
if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_COMMENT ) ) {
return '';
} elseif ( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_COMMENT, $user ) ) {
return '';
} else {
return $this->mComment;
}
}
/**
* Fetch revision comment without regard for the current user's permissions
*
* @return string
* @deprecated since 1.25, use getComment( Revision::RAW )
*/
public function getRawComment() {
wfDeprecated( __METHOD__, '1.25' );
return $this->getComment( self::RAW );
}
/**
* @return bool
*/
public function isMinor() {
return (bool)$this->mMinorEdit;
}
/**
* @return int Rcid of the unpatrolled row, zero if there isn't one
*/
public function isUnpatrolled() {
if ( $this->mUnpatrolled !== null ) {
return $this->mUnpatrolled;
}
$rc = $this->getRecentChange();
if ( $rc && $rc->getAttribute( 'rc_patrolled' ) == 0 ) {
$this->mUnpatrolled = $rc->getAttribute( 'rc_id' );
} else {
$this->mUnpatrolled = 0;
}
return $this->mUnpatrolled;
}
/**
* Get the RC object belonging to the current revision, if there's one
*
* @since 1.22
* @return RecentChange|null
*/
public function getRecentChange() {
$dbr = wfGetDB( DB_SLAVE );
return RecentChange::newFromConds(
array(
'rc_user_text' => $this->getUserText( Revision::RAW ),
'rc_timestamp' => $dbr->timestamp( $this->getTimestamp() ),
'rc_this_oldid' => $this->getId()
),
__METHOD__
);
}
/**
* @param int $field One of DELETED_* bitfield constants
*
* @return bool
*/
public function isDeleted( $field ) {
return ( $this->mDeleted & $field ) == $field;
}
/**
* Get the deletion bitfield of the revision
*
* @return int
*/
public function getVisibility() {
return (int)$this->mDeleted;
}
/**
* Fetch revision text if it's available to the specified audience.
* If the specified audience does not have the ability to view this
* revision, an empty string will be returned.
*
* @param int $audience One of:
* Revision::FOR_PUBLIC to be displayed to all users
* Revision::FOR_THIS_USER to be displayed to the given user
* Revision::RAW get the text regardless of permissions
* @param User $user User object to check for, only if FOR_THIS_USER is passed
* to the $audience parameter
*
* @deprecated since 1.21, use getContent() instead
* @todo Replace usage in core
* @return string
*/
public function getText( $audience = self::FOR_PUBLIC, User $user = null ) {
ContentHandler::deprecated( __METHOD__, '1.21' );
$content = $this->getContent( $audience, $user );
return ContentHandler::getContentText( $content ); # returns the raw content text, if applicable
}
/**
* Fetch revision content if it's available to the specified audience.
* If the specified audience does not have the ability to view this
* revision, null will be returned.
*
* @param int $audience One of:
* Revision::FOR_PUBLIC to be displayed to all users
* Revision::FOR_THIS_USER to be displayed to $wgUser
* Revision::RAW get the text regardless of permissions
* @param User $user User object to check for, only if FOR_THIS_USER is passed
* to the $audience parameter
* @since 1.21
* @return Content|null
*/
public function getContent( $audience = self::FOR_PUBLIC, User $user = null ) {
if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_TEXT ) ) {
return null;
} elseif ( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_TEXT, $user ) ) {
return null;
} else {
return $this->getContentInternal();
}
}
/**
* Fetch revision text without regard for view restrictions
*
* @return string
*
* @deprecated since 1.21. Instead, use Revision::getContent( Revision::RAW )
* or Revision::getSerializedData() as appropriate.
*/
public function getRawText() {
ContentHandler::deprecated( __METHOD__, "1.21" );
return $this->getText( self::RAW );
}
/**
* Fetch original serialized data without regard for view restrictions
*
* @since 1.21
* @return string
*/
public function getSerializedData() {
if ( $this->mText === null ) {
$this->mText = $this->loadText();
}
return $this->mText;
}
/**
* Gets the content object for the revision (or null on failure).
*
* Note that for mutable Content objects, each call to this method will return a
* fresh clone.
*
* @since 1.21
* @return Content|null The Revision's content, or null on failure.
*/
protected function getContentInternal() {
if ( $this->mContent === null ) {
// Revision is immutable. Load on demand:
if ( $this->mText === null ) {
$this->mText = $this->loadText();
}
if ( $this->mText !== null && $this->mText !== false ) {
// Unserialize content
$handler = $this->getContentHandler();
$format = $this->getContentFormat();
$this->mContent = $handler->unserializeContent( $this->mText, $format );
}
}
// NOTE: copy() will return $this for immutable content objects
return $this->mContent ? $this->mContent->copy() : null;
}
/**
* Returns the content model for this revision.
*
* If no content model was stored in the database, the default content model for the title is
* used to determine the content model to use. If no title is know, CONTENT_MODEL_WIKITEXT
* is used as a last resort.
*
* @return string The content model id associated with this revision,
* see the CONTENT_MODEL_XXX constants.
**/
public function getContentModel() {
if ( !$this->mContentModel ) {
$title = $this->getTitle();
if ( $title ) {
$this->mContentModel = ContentHandler::getDefaultModelFor( $title );
} else {
$this->mContentModel = CONTENT_MODEL_WIKITEXT;
}
assert( !empty( $this->mContentModel ) );
}
return $this->mContentModel;
}
/**
* Returns the content format for this revision.
*
* If no content format was stored in the database, the default format for this
* revision's content model is returned.
*
* @return string The content format id associated with this revision,
* see the CONTENT_FORMAT_XXX constants.
**/
public function getContentFormat() {
if ( !$this->mContentFormat ) {
$handler = $this->getContentHandler();
$this->mContentFormat = $handler->getDefaultFormat();
assert( !empty( $this->mContentFormat ) );
}
return $this->mContentFormat;
}
/**
* Returns the content handler appropriate for this revision's content model.
*
* @throws MWException
* @return ContentHandler
*/
public function getContentHandler() {
if ( !$this->mContentHandler ) {
$model = $this->getContentModel();
$this->mContentHandler = ContentHandler::getForModelID( $model );
$format = $this->getContentFormat();
if ( !$this->mContentHandler->isSupportedFormat( $format ) ) {
throw new MWException( "Oops, the content format $format is not supported for "
. "this content model, $model" );
}
}
return $this->mContentHandler;
}
/**
* @return string
*/
public function getTimestamp() {
return wfTimestamp( TS_MW, $this->mTimestamp );
}
/**
* @return bool
*/
public function isCurrent() {
return $this->mCurrent;
}
/**
* Get previous revision for this title
*
* @return Revision|null
*/
public function getPrevious() {
if ( $this->getTitle() ) {
$prev = $this->getTitle()->getPreviousRevisionID( $this->getId() );
if ( $prev ) {
return self::newFromTitle( $this->getTitle(), $prev );
}
}
return null;
}
/**
* Get next revision for this title
*
* @return Revision|null
*/
public function getNext() {
if ( $this->getTitle() ) {
$next = $this->getTitle()->getNextRevisionID( $this->getId() );
if ( $next ) {
return self::newFromTitle( $this->getTitle(), $next );
}
}
return null;
}
/**
* Get previous revision Id for this page_id
* This is used to populate rev_parent_id on save
*
* @param DatabaseBase $db
* @return int
*/
private function getPreviousRevisionId( $db ) {
if ( $this->mPage === null ) {
return 0;
}
# Use page_latest if ID is not given
if ( !$this->mId ) {
$prevId = $db->selectField( 'page', 'page_latest',
array( 'page_id' => $this->mPage ),
__METHOD__ );
} else {
$prevId = $db->selectField( 'revision', 'rev_id',
array( 'rev_page' => $this->mPage, 'rev_id < ' . $this->mId ),
__METHOD__,
array( 'ORDER BY' => 'rev_id DESC' ) );
}
return intval( $prevId );
}
/**
* Get revision text associated with an old or archive row
* $row is usually an object from wfFetchRow(), both the flags and the text
* field must be included.
*
* @param stdClass $row The text data
* @param string $prefix Table prefix (default 'old_')
* @param string|bool $wiki The name of the wiki to load the revision text from
* (same as the the wiki $row was loaded from) or false to indicate the local
* wiki (this is the default). Otherwise, it must be a symbolic wiki database
* identifier as understood by the LoadBalancer class.
* @return string Text the text requested or false on failure
*/
public static function getRevisionText( $row, $prefix = 'old_', $wiki = false ) {
# Get data
$textField = $prefix . 'text';
$flagsField = $prefix . 'flags';
if ( isset( $row->$flagsField ) ) {
$flags = explode( ',', $row->$flagsField );
} else {
$flags = array();
}
if ( isset( $row->$textField ) ) {
$text = $row->$textField;
} else {
return false;
}
# Use external methods for external objects, text in table is URL-only then
if ( in_array( 'external', $flags ) ) {
$url = $text;
$parts = explode( '://', $url, 2 );
if ( count( $parts ) == 1 || $parts[1] == '' ) {
return false;
}
$text = ExternalStore::fetchFromURL( $url, array( 'wiki' => $wiki ) );
}
// If the text was fetched without an error, convert it
if ( $text !== false ) {
$text = self::decompressRevisionText( $text, $flags );
}
return $text;
}
/**
* If $wgCompressRevisions is enabled, we will compress data.
* The input string is modified in place.
* Return value is the flags field: contains 'gzip' if the
* data is compressed, and 'utf-8' if we're saving in UTF-8
* mode.
*
* @param mixed $text Reference to a text
* @return string
*/
public static function compressRevisionText( &$text ) {
global $wgCompressRevisions;
$flags = array();
# Revisions not marked this way will be converted
# on load if $wgLegacyCharset is set in the future.
$flags[] = 'utf-8';
if ( $wgCompressRevisions ) {
if ( function_exists( 'gzdeflate' ) ) {
$deflated = gzdeflate( $text );
if ( $deflated === false ) {
wfLogWarning( __METHOD__ . ': gzdeflate() failed' );
} else {
$text = $deflated;
$flags[] = 'gzip';
}
} else {
wfDebug( __METHOD__ . " -- no zlib support, not compressing\n" );
}
}
return implode( ',', $flags );
}
/**
* Re-converts revision text according to it's flags.
*
* @param mixed $text Reference to a text
* @param array $flags Compression flags
* @return string|bool Decompressed text, or false on failure
*/
public static function decompressRevisionText( $text, $flags ) {
if ( in_array( 'gzip', $flags ) ) {
# Deal with optional compression of archived pages.
# This can be done periodically via maintenance/compressOld.php, and
# as pages are saved if $wgCompressRevisions is set.
$text = gzinflate( $text );
if ( $text === false ) {
wfLogWarning( __METHOD__ . ': gzinflate() failed' );
return false;
}
}
if ( in_array( 'object', $flags ) ) {
# Generic compressed storage
$obj = unserialize( $text );
if ( !is_object( $obj ) ) {
// Invalid object
return false;
}
$text = $obj->getText();
}
global $wgLegacyEncoding;
if ( $text !== false && $wgLegacyEncoding
&& !in_array( 'utf-8', $flags ) && !in_array( 'utf8', $flags )
) {
# Old revisions kept around in a legacy encoding?
# Upconvert on demand.
# ("utf8" checked for compatibility with some broken
# conversion scripts 2008-12-30)
global $wgContLang;
$text = $wgContLang->iconv( $wgLegacyEncoding, 'UTF-8', $text );
}
return $text;
}
/**
* Insert a new revision into the database, returning the new revision ID
* number on success and dies horribly on failure.
*
* @param DatabaseBase $dbw (master connection)
* @throws MWException
* @return int
*/
public function insertOn( $dbw ) {
global $wgDefaultExternalStore, $wgContentHandlerUseDB;
$this->checkContentModel();
$data = $this->mText;
$flags = self::compressRevisionText( $data );
# Write to external storage if required
if ( $wgDefaultExternalStore ) {
// Store and get the URL
$data = ExternalStore::insertToDefault( $data );
if ( !$data ) {
throw new MWException( "Unable to store text to external storage" );
}
if ( $flags ) {
$flags .= ',';
}
$flags .= 'external';
}
# Record the text (or external storage URL) to the text table
if ( $this->mTextId === null ) {
$old_id = $dbw->nextSequenceValue( 'text_old_id_seq' );
$dbw->insert( 'text',
array(
'old_id' => $old_id,
'old_text' => $data,
'old_flags' => $flags,
), __METHOD__
);
$this->mTextId = $dbw->insertId();
}
if ( $this->mComment === null ) {
$this->mComment = "";
}
# Record the edit in revisions
$rev_id = $this->mId !== null
? $this->mId
: $dbw->nextSequenceValue( 'revision_rev_id_seq' );
$row = array(
'rev_id' => $rev_id,
'rev_page' => $this->mPage,
'rev_text_id' => $this->mTextId,
'rev_comment' => $this->mComment,
'rev_minor_edit' => $this->mMinorEdit ? 1 : 0,
'rev_user' => $this->mUser,
'rev_user_text' => $this->mUserText,
'rev_timestamp' => $dbw->timestamp( $this->mTimestamp ),
'rev_deleted' => $this->mDeleted,
'rev_len' => $this->mSize,
'rev_parent_id' => $this->mParentId === null
? $this->getPreviousRevisionId( $dbw )
: $this->mParentId,
'rev_sha1' => $this->mSha1 === null
? Revision::base36Sha1( $this->mText )
: $this->mSha1,
);
if ( $wgContentHandlerUseDB ) {
//NOTE: Store null for the default model and format, to save space.
//XXX: Makes the DB sensitive to changed defaults.
// Make this behavior optional? Only in miser mode?
$model = $this->getContentModel();
$format = $this->getContentFormat();
$title = $this->getTitle();
if ( $title === null ) {
throw new MWException( "Insufficient information to determine the title of the "
. "revision's page!" );
}
$defaultModel = ContentHandler::getDefaultModelFor( $title );
$defaultFormat = ContentHandler::getForModelID( $defaultModel )->getDefaultFormat();
$row['rev_content_model'] = ( $model === $defaultModel ) ? null : $model;
$row['rev_content_format'] = ( $format === $defaultFormat ) ? null : $format;
}
$dbw->insert( 'revision', $row, __METHOD__ );
$this->mId = $rev_id !== null ? $rev_id : $dbw->insertId();
// Assertion to try to catch T92046
if ( (int)$this->mId === 0 ) {
throw new UnexpectedValueException(
'After insert, Revision mId is ' . var_export( $this->mId, 1 ) . ': ' .
var_export( $row, 1 )
);
}
Hooks::run( 'RevisionInsertComplete', array( &$this, $data, $flags ) );
return $this->mId;
}
protected function checkContentModel() {
global $wgContentHandlerUseDB;
$title = $this->getTitle(); //note: may return null for revisions that have not yet been inserted.
$model = $this->getContentModel();
$format = $this->getContentFormat();
$handler = $this->getContentHandler();
if ( !$handler->isSupportedFormat( $format ) ) {
$t = $title->getPrefixedDBkey();
throw new MWException( "Can't use format $format with content model $model on $t" );
}
if ( !$wgContentHandlerUseDB && $title ) {
// if $wgContentHandlerUseDB is not set,
// all revisions must use the default content model and format.
$defaultModel = ContentHandler::getDefaultModelFor( $title );
$defaultHandler = ContentHandler::getForModelID( $defaultModel );
$defaultFormat = $defaultHandler->getDefaultFormat();
if ( $this->getContentModel() != $defaultModel ) {
$t = $title->getPrefixedDBkey();
throw new MWException( "Can't save non-default content model with "
. "\$wgContentHandlerUseDB disabled: model is $model, "
. "default for $t is $defaultModel" );
}
if ( $this->getContentFormat() != $defaultFormat ) {
$t = $title->getPrefixedDBkey();
throw new MWException( "Can't use non-default content format with "
. "\$wgContentHandlerUseDB disabled: format is $format, "
. "default for $t is $defaultFormat" );
}
}
$content = $this->getContent( Revision::RAW );
if ( !$content || !$content->isValid() ) {
$t = $title->getPrefixedDBkey();
throw new MWException( "Content of $t is not valid! Content model is $model" );
}
}
/**
* Get the base 36 SHA-1 value for a string of text
* @param string $text
* @return string
*/
public static function base36Sha1( $text ) {
return wfBaseConvert( sha1( $text ), 16, 36, 31 );
}
/**
* Lazy-load the revision's text.
* Currently hardcoded to the 'text' table storage engine.
*
* @return string|bool The revision's text, or false on failure
*/
protected function loadText() {
// Caching may be beneficial for massive use of external storage
global $wgRevisionCacheExpiry, $wgMemc;
$textId = $this->getTextId();
$key = wfMemcKey( 'revisiontext', 'textid', $textId );
if ( $wgRevisionCacheExpiry ) {
$text = $wgMemc->get( $key );
if ( is_string( $text ) ) {
wfDebug( __METHOD__ . ": got id $textId from cache\n" );
return $text;
}
}
// If we kept data for lazy extraction, use it now...
if ( $this->mTextRow !== null ) {
$row = $this->mTextRow;
$this->mTextRow = null;
} else {
$row = null;
}
if ( !$row ) {
// Text data is immutable; check slaves first.
$dbr = wfGetDB( DB_SLAVE );
$row = $dbr->selectRow( 'text',
array( 'old_text', 'old_flags' ),
array( 'old_id' => $textId ),
__METHOD__ );
}
// Fallback to the master in case of slave lag. Also use FOR UPDATE if it was
// used to fetch this revision to avoid missing the row due to REPEATABLE-READ.
$forUpdate = ( $this->mQueryFlags & self::READ_LOCKING == self::READ_LOCKING );
if ( !$row && ( $forUpdate || wfGetLB()->getServerCount() > 1 ) ) {
$dbw = wfGetDB( DB_MASTER );
$row = $dbw->selectRow( 'text',
array( 'old_text', 'old_flags' ),
array( 'old_id' => $textId ),
__METHOD__,
$forUpdate ? array( 'FOR UPDATE' ) : array() );
}
if ( !$row ) {
wfDebugLog( 'Revision', "No text row with ID '$textId' (revision {$this->getId()})." );
}
$text = self::getRevisionText( $row );
if ( $row && $text === false ) {
wfDebugLog( 'Revision', "No blob for text row '$textId' (revision {$this->getId()})." );
}
# No negative caching -- negative hits on text rows may be due to corrupted slave servers
if ( $wgRevisionCacheExpiry && $text !== false ) {
$wgMemc->set( $key, $text, $wgRevisionCacheExpiry );
}
return $text;
}
/**
* Create a new null-revision for insertion into a page's
* history. This will not re-save the text, but simply refer
* to the text from the previous version.
*
* Such revisions can for instance identify page rename
* operations and other such meta-modifications.
*
* @param DatabaseBase $dbw
* @param int $pageId ID number of the page to read from
* @param string $summary Revision's summary
* @param bool $minor Whether the revision should be considered as minor
* @param User|null $user User object to use or null for $wgUser
* @return Revision|null Revision or null on error
*/
public static function newNullRevision( $dbw, $pageId, $summary, $minor, $user = null ) {
global $wgContentHandlerUseDB, $wgContLang;
$fields = array( 'page_latest', 'page_namespace', 'page_title',
'rev_text_id', 'rev_len', 'rev_sha1' );
if ( $wgContentHandlerUseDB ) {
$fields[] = 'rev_content_model';
$fields[] = 'rev_content_format';
}
$current = $dbw->selectRow(
array( 'page', 'revision' ),
$fields,
array(
'page_id' => $pageId,
'page_latest=rev_id',
),
__METHOD__ );
if ( $current ) {
if ( !$user ) {
global $wgUser;
$user = $wgUser;
}
// Truncate for whole multibyte characters
$summary = $wgContLang->truncate( $summary, 255 );
$row = array(
'page' => $pageId,
'user_text' => $user->getName(),
'user' => $user->getId(),
'comment' => $summary,
'minor_edit' => $minor,
'text_id' => $current->rev_text_id,
'parent_id' => $current->page_latest,
'len' => $current->rev_len,
'sha1' => $current->rev_sha1
);
if ( $wgContentHandlerUseDB ) {
$row['content_model'] = $current->rev_content_model;
$row['content_format'] = $current->rev_content_format;
}
$row['title'] = Title::makeTitle( $current->page_namespace, $current->page_title );
$revision = new Revision( $row );
} else {
$revision = null;
}
return $revision;
}
/**
* Determine if the current user is allowed to view a particular
* field of this revision, if it's marked as deleted.
*
* @param int $field One of self::DELETED_TEXT,
* self::DELETED_COMMENT,
* self::DELETED_USER
* @param User|null $user User object to check, or null to use $wgUser
* @return bool
*/
public function userCan( $field, User $user = null ) {
return self::userCanBitfield( $this->mDeleted, $field, $user );
}
/**
* Determine if the current user is allowed to view a particular
* field of this revision, if it's marked as deleted. This is used
* by various classes to avoid duplication.
*
* @param int $bitfield Current field
* @param int $field One of self::DELETED_TEXT = File::DELETED_FILE,
* self::DELETED_COMMENT = File::DELETED_COMMENT,
* self::DELETED_USER = File::DELETED_USER
* @param User|null $user User object to check, or null to use $wgUser
* @param Title|null $title A Title object to check for per-page restrictions on,
* instead of just plain userrights
* @return bool
*/
public static function userCanBitfield( $bitfield, $field, User $user = null,
Title $title = null
) {
if ( $bitfield & $field ) { // aspect is deleted
if ( $user === null ) {
global $wgUser;
$user = $wgUser;
}
if ( $bitfield & self::DELETED_RESTRICTED ) {
$permissions = array( 'suppressrevision', 'viewsuppressed' );
} elseif ( $field & self::DELETED_TEXT ) {
$permissions = array( 'deletedtext' );
} else {
$permissions = array( 'deletedhistory' );
}
$permissionlist = implode( ', ', $permissions );
if ( $title === null ) {
wfDebug( "Checking for $permissionlist due to $field match on $bitfield\n" );
return call_user_func_array( array( $user, 'isAllowedAny' ), $permissions );
} else {
$text = $title->getPrefixedText();
wfDebug( "Checking for $permissionlist on $text due to $field match on $bitfield\n" );
foreach ( $permissions as $perm ) {
if ( $title->userCan( $perm, $user ) ) {
return true;
}
}
return false;
}
} else {
return true;
}
}
/**
* Get rev_timestamp from rev_id, without loading the rest of the row
*
* @param Title $title
* @param int $id
* @return string|bool False if not found
*/
static function getTimestampFromId( $title, $id, $flags = 0 ) {
$db = ( $flags & self::READ_LATEST )
? wfGetDB( DB_MASTER )
: wfGetDB( DB_SLAVE );
// Casting fix for databases that can't take '' for rev_id
if ( $id == '' ) {
$id = 0;
}
$conds = array( 'rev_id' => $id );
$conds['rev_page'] = $title->getArticleID();
$timestamp = $db->selectField( 'revision', 'rev_timestamp', $conds, __METHOD__ );
return ( $timestamp !== false ) ? wfTimestamp( TS_MW, $timestamp ) : false;
}
/**
* Get count of revisions per page...not very efficient
*
* @param DatabaseBase $db
* @param int $id Page id
* @return int
*/
static function countByPageId( $db, $id ) {
$row = $db->selectRow( 'revision', array( 'revCount' => 'COUNT(*)' ),
array( 'rev_page' => $id ), __METHOD__ );
if ( $row ) {
return $row->revCount;
}
return 0;
}
/**
* Get count of revisions per page...not very efficient
*
* @param DatabaseBase $db
* @param Title $title
* @return int
*/
static function countByTitle( $db, $title ) {
$id = $title->getArticleID();
if ( $id ) {
return self::countByPageId( $db, $id );
}
return 0;
}
/**
* Check if no edits were made by other users since
* the time a user started editing the page. Limit to
* 50 revisions for the sake of performance.
*
* @since 1.20
* @deprecated since 1.24
*
* @param DatabaseBase|int $db The Database to perform the check on. May be given as a
* Database object or a database identifier usable with wfGetDB.
* @param int $pageId The ID of the page in question
* @param int $userId The ID of the user in question
* @param string $since Look at edits since this time
*
* @return bool True if the given user was the only one to edit since the given timestamp
*/
public static function userWasLastToEdit( $db, $pageId, $userId, $since ) {
if ( !$userId ) {
return false;
}
if ( is_int( $db ) ) {
$db = wfGetDB( $db );
}
$res = $db->select( 'revision',
'rev_user',
array(
'rev_page' => $pageId,
'rev_timestamp > ' . $db->addQuotes( $db->timestamp( $since ) )
),
__METHOD__,
array( 'ORDER BY' => 'rev_timestamp ASC', 'LIMIT' => 50 ) );
foreach ( $res as $row ) {
if ( $row->rev_user != $userId ) {
return false;
}
}
return true;
}
}