X-Git-Url: http://git.cyclocoop.org/?a=blobdiff_plain;f=includes%2FRevision.php;h=243c9c06a047711c785e5a9ae3894669bbbdf825;hb=41ac01dfc839b4f1c32a354fe37ed064b8a31585;hp=8d1200685dc64847d5c168651b85173d6881570f;hpb=804deee936326251285da7fa7176bb4a8d7511d0;p=lhc%2Fweb%2Fwiklou.git

diff --git a/includes/Revision.php b/includes/Revision.php
index 8d1200685d..243c9c06a0 100644
--- a/includes/Revision.php
+++ b/includes/Revision.php
@@ -1,8 +1,4 @@
 <?php
-/**
- * @todo document
- * @file
- */
 
 /**
  * @todo document
@@ -12,19 +8,24 @@ class Revision {
 	const DELETED_COMMENT = 2;
 	const DELETED_USER = 4;
 	const DELETED_RESTRICTED = 8;
+	// Convenience field
+	const SUPPRESSED_USER = 12;
+	// Audience options for Revision::getText()
+	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.
 	 *
-	 * @param int $id
-	 * @access public
-	 * @static
+	 * @param $id Integer
+	 * @return Revision or null
 	 */
 	public static function newFromId( $id ) {
 		return Revision::newFromConds(
 			array( 'page_id=rev_page',
-			       'rev_id' => intval( $id ) ) );
+				   'rev_id' => intval( $id ) ) );
 	}
 
 	/**
@@ -32,36 +33,116 @@ class Revision {
 	 * that's attached to a given title. If not attached
 	 * to that title, will return null.
 	 *
-	 * @param Title $title
-	 * @param int $id
-	 * @return Revision
+	 * @param $title Title
+	 * @param $id Integer (optional)
+	 * @return Revision or null
 	 */
 	public static function newFromTitle( $title, $id = 0 ) {
-		if( $id ) {
-			$matchId = intval( $id );
+		$conds = array(
+			'page_namespace' => $title->getNamespace(),
+			'page_title' 	 => $title->getDBkey()
+		);
+		if ( $id ) {
+			// Use the specified ID
+			$conds['rev_id'] = $id;
+		} elseif ( wfGetLB()->getServerCount() > 1 ) {
+			// Get the latest revision ID from the master
+			$dbw = wfGetDB( DB_MASTER );
+			$latest = $dbw->selectField( 'page', 'page_latest', $conds, __METHOD__ );
+			if ( $latest === false ) {
+				return null; // page does not exist
+			}
+			$conds['rev_id'] = $latest;
 		} else {
-			$matchId = 'page_latest';
+			// Use a join to get the latest revision
+			$conds[] = 'rev_id=page_latest';
 		}
-		return Revision::newFromConds(
-			array( "rev_id=$matchId",
-			       'page_id=rev_page',
-			       'page_namespace' => $title->getNamespace(),
-			       'page_title'     => $title->getDBkey() ) );
+		$conds[] = 'page_id=rev_page';
+		return Revision::newFromConds( $conds );
+	}
+
+	/**
+	 * 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.
+	 *
+	 * @param $revId Integer
+	 * @param $pageId Integer (optional)
+	 * @return Revision or null
+	 */
+	public static function newFromPageId( $pageId, $revId = 0 ) {
+		$conds = array( 'page_id' => $pageId );
+		if ( $revId ) {
+			$conds['rev_id'] = $revId;
+		} elseif ( wfGetLB()->getServerCount() > 1 ) {
+			// Get the latest revision ID from the master
+			$dbw = wfGetDB( DB_MASTER );
+			$latest = $dbw->selectField( 'page', 'page_latest', $conds, __METHOD__ );
+			if ( $latest === false ) {
+				return null; // page does not exist
+			}
+			$conds['rev_id'] = $latest;
+		} else {
+			$conds[] = 'rev_id = page_latest';
+		}
+		$conds[] = 'page_id=rev_page';
+		return Revision::newFromConds( $conds );
+	}
+
+	/**
+	 * 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 $row
+	 * @param $overrides array
+	 *
+	 * @return Revision
+	 */
+	public static function newFromArchiveRow( $row, $overrides = array() ) {
+		$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);
+		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 $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 Database $db
-	 * @param int $id
-	 * @access public
-	 * @static
+	 * @param $db DatabaseBase
+	 * @param $id Integer
+	 * @return Revision or null
 	 */
 	public static function loadFromId( $db, $id ) {
 		return Revision::loadFromConds( $db,
 			array( 'page_id=rev_page',
-			       'rev_id' => intval( $id ) ) );
+				   'rev_id' => intval( $id ) ) );
 	}
 
 	/**
@@ -69,34 +150,54 @@ class Revision {
 	 * that's attached to a given page. If not attached
 	 * to that page, will return null.
 	 *
-	 * @param Database $db
-	 * @param int $pageid
-	 * @param int $id
-	 * @return Revision
-	 * @access public
-	 * @static
+	 * @param $db DatabaseBase
+	 * @param $pageid Integer
+	 * @param $id Integer
+	 * @return Revision or null
 	 */
 	public static function loadFromPageId( $db, $pageid, $id = 0 ) {
-		$conds=array('page_id=rev_page','rev_page'=>intval( $pageid ), 'page_id'=>intval( $pageid ));
+		$conds = array( 'page_id=rev_page','rev_page' => intval( $pageid ), 'page_id'=>intval( $pageid ) );
 		if( $id ) {
-			$conds['rev_id']=intval($id);
+			$conds['rev_id'] = intval( $id );
 		} else {
-			$conds[]='rev_id=page_latest';
+			$conds[] = 'rev_id=page_latest';
 		}
 		return Revision::loadFromConds( $db, $conds );
 	}
 
+	/**
+	 * Stores the origin wiki of a revision in case it is a foreign wiki
+	 */
+	function setWikiID( $wikiID ) {
+		$this->mWikiID = $wikiID;
+	}
+
+	/**
+	 * Load the current revision of a given page of a foreign wiki.
+	 * The WikiID is stored for further use, such as loadText() and getTimestampFromId()
+	 */
+	public static function loadFromTitleForeignWiki( $wikiID, $title ) {
+		$dbr = wfGetDB( DB_SLAVE, array(), $wikiID );
+
+		$revision = self::loadFromTitle( $dbr, $title );
+
+		if( $revision ) {
+			$revision->setWikiID( $wikiID );
+		}
+
+		return $revision;
+
+	}
+
 	/**
 	 * 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 Database $db
-	 * @param Title $title
-	 * @param int $id
-	 * @return Revision
-	 * @access public
-	 * @static
+	 * @param $db DatabaseBase
+	 * @param $title Title
+	 * @param $id Integer
+	 * @return Revision or null
 	 */
 	public static function loadFromTitle( $db, $title, $id = 0 ) {
 		if( $id ) {
@@ -107,9 +208,9 @@ class Revision {
 		return Revision::loadFromConds(
 			$db,
 			array( "rev_id=$matchId",
-			       'page_id=rev_page',
-			       'page_namespace' => $title->getNamespace(),
-			       'page_title'     => $title->getDBkey() ) );
+				   'page_id=rev_page',
+				   'page_namespace' => $title->getNamespace(),
+				   'page_title'     => $title->getDBkey() ) );
 	}
 
 	/**
@@ -117,34 +218,30 @@ class Revision {
 	 * WARNING: Timestamps may in some circumstances not be unique,
 	 * so this isn't the best key to use.
 	 *
-	 * @param Database $db
-	 * @param Title $title
-	 * @param string $timestamp
-	 * @return Revision
-	 * @access public
-	 * @static
+	 * @param $db DatabaseBase
+	 * @param $title Title
+	 * @param $timestamp String
+	 * @return Revision or null
 	 */
 	public static function loadFromTimestamp( $db, $title, $timestamp ) {
 		return Revision::loadFromConds(
 			$db,
 			array( 'rev_timestamp'  => $db->timestamp( $timestamp ),
-			       'page_id=rev_page',
-			       'page_namespace' => $title->getNamespace(),
-			       'page_title'     => $title->getDBkey() ) );
+				   'page_id=rev_page',
+				   'page_namespace' => $title->getNamespace(),
+				   'page_title'     => $title->getDBkey() ) );
 	}
 
 	/**
 	 * Given a set of conditions, fetch a revision.
 	 *
-	 * @param array $conditions
-	 * @return Revision
-	 * @access private
-	 * @static
+	 * @param $conditions Array
+	 * @return Revision or null
 	 */
-	private static function newFromConds( $conditions ) {
+	public static function newFromConds( $conditions ) {
 		$db = wfGetDB( DB_SLAVE );
 		$row = Revision::loadFromConds( $db, $conditions );
-		if( is_null( $row ) ) {
+		if( is_null( $row ) && wfGetLB()->getServerCount() > 1 ) {
 			$dbw = wfGetDB( DB_MASTER );
 			$row = Revision::loadFromConds( $dbw, $conditions );
 		}
@@ -155,11 +252,9 @@ class Revision {
 	 * Given a set of conditions, fetch a revision from
 	 * the given database connection.
 	 *
-	 * @param Database $db
-	 * @param array $conditions
-	 * @return Revision
-	 * @access private
-	 * @static
+	 * @param $db DatabaseBase
+	 * @param $conditions Array
+	 * @return Revision or null
 	 */
 	private static function loadFromConds( $db, $conditions ) {
 		$res = Revision::fetchFromConds( $db, $conditions );
@@ -180,36 +275,16 @@ class Revision {
 	 * 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
-	 * @access public
-	 * @static
-	 */
-	public static function fetchAllRevisions( $title ) {
-		return Revision::fetchFromConds(
-			wfGetDB( DB_SLAVE ),
-			array( 'page_namespace' => $title->getNamespace(),
-			       'page_title'     => $title->getDBkey(),
-			       'page_id=rev_page' ) );
-	}
-
-	/**
-	 * 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
+	 * @param $title Title
 	 * @return ResultWrapper
-	 * @access public
-	 * @static
 	 */
 	public static function fetchRevision( $title ) {
 		return Revision::fetchFromConds(
 			wfGetDB( DB_SLAVE ),
 			array( 'rev_id=page_latest',
-			       'page_namespace' => $title->getNamespace(),
-			       'page_title'     => $title->getDBkey(),
-			       'page_id=rev_page' ) );
+				   'page_namespace' => $title->getNamespace(),
+				   'page_title'     => $title->getDBkey(),
+				   'page_id=rev_page' ) );
 	}
 
 	/**
@@ -217,32 +292,28 @@ class Revision {
 	 * which will return matching database rows with the
 	 * fields necessary to build Revision objects.
 	 *
-	 * @param Database $db
-	 * @param array $conditions
+	 * @param $db DatabaseBase
+	 * @param $conditions Array
 	 * @return ResultWrapper
-	 * @access private
-	 * @static
 	 */
 	private static function fetchFromConds( $db, $conditions ) {
 		$fields = self::selectFields();
 		$fields[] = 'page_namespace';
 		$fields[] = 'page_title';
 		$fields[] = 'page_latest';
-		$res = $db->select(
+		return $db->select(
 			array( 'page', 'revision' ),
 			$fields,
 			$conditions,
-			'Revision::fetchRow',
+			__METHOD__,
 			array( 'LIMIT' => 1 ) );
-		$ret = $db->resultObject( $res );
-		return $ret;
 	}
 
 	/**
 	 * Return the list of revision fields that should be selected to create
 	 * a new revision.
 	 */
-	static function selectFields() {
+	public static function selectFields() {
 		return array(
 			'rev_id',
 			'rev_page',
@@ -257,9 +328,9 @@ class Revision {
 			'rev_parent_id'
 		);
 	}
-	
+
 	/**
-	 * Return the list of text fields that should be selected to read the 
+	 * Return the list of text fields that should be selected to read the
 	 * revision text
 	 */
 	static function selectTextFields() {
@@ -268,6 +339,7 @@ class Revision {
 			'old_flags'
 		);
 	}
+
 	/**
 	 * Return the list of page fields that should be selected from page table
 	 */
@@ -280,10 +352,12 @@ class Revision {
 	}
 
 	/**
-	 * @param object $row
+	 * Constructor
+	 *
+	 * @param $row Mixed: either a database row or an array
 	 * @access private
 	 */
-	function Revision( $row ) {
+	function __construct( $row ) {
 		if( is_object( $row ) ) {
 			$this->mId        = intval( $row->rev_id );
 			$this->mPage      = intval( $row->rev_page );
@@ -295,20 +369,21 @@ class Revision {
 			$this->mTimestamp =         $row->rev_timestamp;
 			$this->mDeleted   = intval( $row->rev_deleted );
 
-			if( !isset( $row->rev_parent_id ) )
+			if( !isset( $row->rev_parent_id ) ) {
 				$this->mParentId = is_null($row->rev_parent_id) ? null : 0;
-			else
+			} else {
 				$this->mParentId  = intval( $row->rev_parent_id );
+			}
 
-			if( !isset( $row->rev_len ) || is_null( $row->rev_len ) )
+			if( !isset( $row->rev_len ) || is_null( $row->rev_len ) ) {
 				$this->mSize = null;
-			else
+			} else {
 				$this->mSize = intval( $row->rev_len );
+			}
 
 			if( isset( $row->page_latest ) ) {
-				$this->mCurrent   = ( $row->rev_id == $row->page_latest );
-				$this->mTitle     = Title::makeTitle( $row->page_namespace,
-				                                      $row->page_title );
+				$this->mCurrent = ( $row->rev_id == $row->page_latest );
+				$this->mTitle = Title::newFromRow( $row );
 			} else {
 				$this->mCurrent = false;
 				$this->mTitle = null;
@@ -346,19 +421,18 @@ class Revision {
 			$this->mCurrent   = false;
 			# If we still have no len_size, see it we have the text to figure it out
 			if ( !$this->mSize )
-				$this->mSize      = is_null($this->mText) ? null : strlen($this->mText);
+				$this->mSize      = is_null( $this->mText ) ? null : strlen( $this->mText );
 		} else {
 			throw new MWException( 'Revision constructor passed invalid row format.' );
 		}
+		$this->mUnpatrolled = null;
+		$this->mWikiID = false;
 	}
 
-	/**#@+
-	 * @access public
-	 */
-
 	/**
 	 * Get revision ID
-	 * @return int
+	 *
+	 * @return Integer
 	 */
 	public function getId() {
 		return $this->mId;
@@ -366,7 +440,8 @@ class Revision {
 
 	/**
 	 * Get text row ID
-	 * @return int
+	 *
+	 * @return Integer
 	 */
 	public function getTextId() {
 		return $this->mTextId;
@@ -374,7 +449,8 @@ class Revision {
 
 	/**
 	 * Get parent revision ID (the original previous page revision)
-	 * @return int
+	 *
+	 * @return Integer
 	 */
 	public function getParentId() {
 		return $this->mParentId;
@@ -382,7 +458,8 @@ class Revision {
 
 	/**
 	 * Returns the length of the text in this revision, or null if unknown.
-	 * @return int
+	 *
+	 * @return Integer
 	 */
 	public function getSize() {
 		return $this->mSize;
@@ -390,29 +467,31 @@ class Revision {
 
 	/**
 	 * Returns the title of the page associated with this entry.
+	 *
 	 * @return Title
 	 */
 	public function getTitle() {
 		if( isset( $this->mTitle ) ) {
 			return $this->mTitle;
 		}
-		$dbr = wfGetDB( DB_SLAVE );
+		$dbr = wfGetDB( DB_SLAVE, array(), $this->mWikiID );
+
 		$row = $dbr->selectRow(
 			array( 'page', 'revision' ),
 			array( 'page_namespace', 'page_title' ),
 			array( 'page_id=rev_page',
-			       'rev_id' => $this->mId ),
+				   'rev_id' => $this->mId ),
 			'Revision::getTitle' );
 		if( $row ) {
-			$this->mTitle = Title::makeTitle( $row->page_namespace,
-			                                  $row->page_title );
+			$this->mTitle = Title::makeTitle( $row->page_namespace, $row->page_title );
 		}
 		return $this->mTitle;
 	}
 
 	/**
 	 * Set the title of the revision
-	 * @param Title $title
+	 *
+	 * @param $title Title
 	 */
 	public function setTitle( $title ) {
 		$this->mTitle = $title;
@@ -420,20 +499,30 @@ class Revision {
 
 	/**
 	 * Get the page ID
-	 * @return int
+	 *
+	 * @return Integer
 	 */
 	public function getPage() {
 		return $this->mPage;
 	}
 
 	/**
-	 * Fetch revision's user id if it's available to all users
-	 * @return int
+	 * 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 $audience Integer: one of:
+	 *      Revision::FOR_PUBLIC       to be displayed to all users
+	 *      Revision::FOR_THIS_USER    to be displayed to $wgUser
+	 *      Revision::RAW              get the ID regardless of permissions
+	 *
+	 *
+	 * @return Integer
 	 */
-	public function getUser( $isPublic = true ) {
-		if( $isPublic && $this->isDeleted( self::DELETED_USER ) ) {
+	public function getUser( $audience = self::FOR_PUBLIC ) {
+		if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
 			return 0;
-		} else if( !$this->userCan( self::DELETED_USER ) ) {
+		} elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER ) ) {
 			return 0;
 		} else {
 			return $this->mUser;
@@ -442,21 +531,30 @@ class Revision {
 
 	/**
 	 * Fetch revision's user id without regard for the current user's permissions
-	 * @return string
+	 *
+	 * @return String
 	 */
 	public function getRawUser() {
 		return $this->mUser;
 	}
 
 	/**
-	 * Fetch revision's username if it's available to all users
+	 * 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 $audience Integer: 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
+	 *
 	 * @return string
 	 */
-	public function getUserText( $isPublic = true ) {
-		if( $isPublic && $this->isDeleted( self::DELETED_USER ) ) {
-			return "";
-		} else if( !$this->userCan( self::DELETED_USER ) ) {
-			return "";
+	public function getUserText( $audience = self::FOR_PUBLIC ) {
+		if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
+			return '';
+		} elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER ) ) {
+			return '';
 		} else {
 			return $this->mUserText;
 		}
@@ -464,21 +562,30 @@ class Revision {
 
 	/**
 	 * Fetch revision's username without regard for view restrictions
-	 * @return string
+	 *
+	 * @return String
 	 */
 	public function getRawUserText() {
 		return $this->mUserText;
 	}
 
 	/**
-	 * Fetch revision comment if it's available to all users
-	 * @return string
+	 * 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 $audience Integer: 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
+	 *
+	 * @return String
 	 */
-	function getComment( $isPublic = true ) {
-		if( $isPublic && $this->isDeleted( self::DELETED_COMMENT ) ) {
-			return "";
-		} else if( !$this->userCan( self::DELETED_COMMENT ) ) {
-			return "";
+	function getComment( $audience = self::FOR_PUBLIC ) {
+		if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_COMMENT ) ) {
+			return '';
+		} elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_COMMENT ) ) {
+			return '';
 		} else {
 			return $this->mComment;
 		}
@@ -486,44 +593,96 @@ class Revision {
 
 	/**
 	 * Fetch revision comment without regard for the current user's permissions
-	 * @return string
+	 *
+	 * @return String
 	 */
 	public function getRawComment() {
 		return $this->mComment;
 	}
 
 	/**
-	 * @return bool
+	 * @return Boolean
 	 */
 	public function isMinor() {
 		return (bool)$this->mMinorEdit;
 	}
 
 	/**
-	 * int $field one of DELETED_* bitfield constants
-	 * @return bool
+	 * @return Integer rcid of the unpatrolled row, zero if there isn't one
+	 */
+	public function isUnpatrolled() {
+		if( $this->mUnpatrolled !== null ) {
+			return $this->mUnpatrolled;
+		}
+		$dbr = wfGetDB( DB_SLAVE, array(), $this->mWikiID );
+		$this->mUnpatrolled = $dbr->selectField( 'recentchanges',
+			'rc_id',
+			array( // Add redundant user,timestamp condition so we can use the existing index
+				'rc_user_text'  => $this->getRawUserText(),
+				'rc_timestamp'  => $dbr->timestamp( $this->getTimestamp() ),
+				'rc_this_oldid' => $this->getId(),
+				'rc_patrolled'  => 0
+			),
+			__METHOD__
+		);
+		return (int)$this->mUnpatrolled;
+	}
+
+	/**
+	 * @param $field int one of DELETED_* bitfield constants
+	 *
+	 * @return Boolean
 	 */
 	public function isDeleted( $field ) {
-		return ($this->mDeleted & $field) == $field;
+		return ( $this->mDeleted & $field ) == $field;
 	}
 
 	/**
-	 * Fetch revision text if it's available to all users
-	 * @return string
+	 * 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 $audience Integer: 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
+	 *
+	 * @return String
 	 */
-	public function getText( $isPublic = true ) {
-		if( $isPublic && $this->isDeleted( self::DELETED_TEXT ) ) {
-			return "";
-		} else if( !$this->userCan( self::DELETED_TEXT ) ) {
-			return "";
+	public function getText( $audience = self::FOR_PUBLIC ) {
+		if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_TEXT ) ) {
+			return '';
+		} elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_TEXT ) ) {
+			return '';
 		} else {
 			return $this->getRawText();
 		}
 	}
 
+	/**
+	 * Alias for getText(Revision::FOR_THIS_USER)
+	 *
+	 * @deprecated since 1.17
+	 * @return String
+	 */
+	public function revText() {
+		wfDeprecated( __METHOD__ );
+		return $this->getText( self::FOR_THIS_USER );
+	}
+
 	/**
 	 * Fetch revision text without regard for view restrictions
-	 * @return string
+	 *
+	 * @return String
 	 */
 	public function getRawText() {
 		if( is_null( $this->mText ) ) {
@@ -534,14 +693,14 @@ class Revision {
 	}
 
 	/**
-	 * @return string
+	 * @return String
 	 */
 	public function getTimestamp() {
-		return wfTimestamp(TS_MW, $this->mTimestamp);
+		return wfTimestamp( TS_MW, $this->mTimestamp );
 	}
 
 	/**
-	 * @return bool
+	 * @return Boolean
 	 */
 	public function isCurrent() {
 		return $this->mCurrent;
@@ -549,7 +708,8 @@ class Revision {
 
 	/**
 	 * Get previous revision for this title
-	 * @return Revision
+	 *
+	 * @return Revision or null
 	 */
 	public function getPrevious() {
 		if( $this->getTitle() ) {
@@ -562,7 +722,9 @@ class Revision {
 	}
 
 	/**
-	 * @return Revision
+	 * Get next revision for this title
+	 *
+	 * @return Revision or null
 	 */
 	public function getNext() {
 		if( $this->getTitle() ) {
@@ -577,11 +739,12 @@ class Revision {
 	/**
 	 * Get previous revision Id for this page_id
 	 * This is used to populate rev_parent_id on save
-	 * @param Database $db
-	 * @return int
+	 *
+	 * @param $db DatabaseBase
+	 * @return Integer
 	 */
 	private function getPreviousRevisionId( $db ) {
-		if( is_null($this->mPage) ) {
+		if( is_null( $this->mPage ) ) {
 			return 0;
 		}
 		# Use page_latest if ID is not given
@@ -595,7 +758,7 @@ class Revision {
 				__METHOD__,
 				array( 'ORDER BY' => 'rev_id DESC' ) );
 		}
-		return intval($prevId);
+		return intval( $prevId );
 	}
 
 	/**
@@ -603,9 +766,9 @@ class Revision {
 	  * $row is usually an object from wfFetchRow(), both the flags and the text
 	  * field must be included
 	  *
-	  * @param integer $row Id of a row
-	  * @param string $prefix table prefix (default 'old_')
-	  * @return string $text|false the text requested
+	  * @param $row Object: the text data
+	  * @param $prefix String: table prefix (default 'old_')
+	  * @return String: text the text requested or false on failure
 	  */
 	public static function getRevisionText( $row, $prefix = 'old_' ) {
 		wfProfileIn( __METHOD__ );
@@ -629,13 +792,13 @@ class Revision {
 
 		# Use external methods for external objects, text in table is URL-only then
 		if ( in_array( 'external', $flags ) ) {
-			$url=$text;
-			@list(/* $proto */,$path)=explode('://',$url,2);
-			if ($path=="") {
+			$url = $text;
+			$parts = explode( '://', $url, 2 );
+			if( count( $parts ) == 1 || $parts[1] == '' ) {
 				wfProfileOut( __METHOD__ );
 				return false;
 			}
-			$text=ExternalStore::fetchFromURL($url);
+			$text = ExternalStore::fetchFromURL( $url );
 		}
 
 		// If the text was fetched without an error, convert it
@@ -659,11 +822,15 @@ class Revision {
 			}
 
 			global $wgLegacyEncoding;
-			if( $wgLegacyEncoding && !in_array( 'utf-8', $flags ) ) {
+			if( $text !== false && $wgLegacyEncoding
+				&& !in_array( 'utf-8', $flags ) && !in_array( 'utf8', $flags ) )
+			{
 				# Old revisions kept around in a legacy encoding?
 				# Upconvert on demand.
-				global $wgInputEncoding, $wgContLang;
-				$text = $wgContLang->iconv( $wgLegacyEncoding, $wgInputEncoding, $text );
+				# ("utf8" checked for compatibility with some broken
+				#  conversion scripts 2008-12-30)
+				global $wgContLang;
+				$text = $wgContLang->iconv( $wgLegacyEncoding, 'UTF-8', $text );
 			}
 		}
 		wfProfileOut( __METHOD__ );
@@ -677,8 +844,8 @@ class Revision {
 	 * data is compressed, and 'utf-8' if we're saving in UTF-8
 	 * mode.
 	 *
-	 * @param mixed $text reference to a text
-	 * @return string
+	 * @param $text Mixed: reference to a text
+	 * @return String
 	 */
 	public static function compressRevisionText( &$text ) {
 		global $wgCompressRevisions;
@@ -703,8 +870,8 @@ class Revision {
 	 * Insert a new revision into the database, returning the new revision ID
 	 * number on success and dies horribly on failure.
 	 *
-	 * @param Database $dbw
-	 * @return int
+	 * @param $dbw DatabaseBase: (master connection)
+	 * @return Integer
 	 */
 	public function insertOn( $dbw ) {
 		global $wgDefaultExternalStore;
@@ -717,7 +884,7 @@ class Revision {
 		# Write to external storage if required
 		if( $wgDefaultExternalStore ) {
 			// Store and get the URL
-			$data = ExternalStore::randomInsert( $data );
+			$data = ExternalStore::insertToDefault( $data );
 			if( !$data ) {
 				throw new MWException( "Unable to store text to external storage" );
 			}
@@ -729,7 +896,7 @@ class Revision {
 
 		# Record the text (or external storage URL) to the text table
 		if( !isset( $this->mTextId ) ) {
-			$old_id = $dbw->nextSequenceValue( 'text_old_id_val' );
+			$old_id = $dbw->nextSequenceValue( 'text_old_id_seq' );
 			$dbw->insert( 'text',
 				array(
 					'old_id'    => $old_id,
@@ -740,10 +907,12 @@ class Revision {
 			$this->mTextId = $dbw->insertId();
 		}
 
+		if ( $this->mComment === null ) $this->mComment = "";
+
 		# Record the edit in revisions
 		$rev_id = isset( $this->mId )
 			? $this->mId
-			: $dbw->nextSequenceValue( 'rev_rev_id_val' );
+			: $dbw->nextSequenceValue( 'revision_rev_id_seq' );
 		$dbw->insert( 'revision',
 			array(
 				'rev_id'         => $rev_id,
@@ -755,15 +924,16 @@ class Revision {
 				'rev_user_text'  => $this->mUserText,
 				'rev_timestamp'  => $dbw->timestamp( $this->mTimestamp ),
 				'rev_deleted'    => $this->mDeleted,
-				'rev_len'	     => $this->mSize,
-				'rev_parent_id'  => $this->mParentId ? $this->mParentId : $this->getPreviousRevisionId( $dbw )
+				'rev_len'        => $this->mSize,
+				'rev_parent_id'  => is_null($this->mParentId) ?
+					$this->getPreviousRevisionId( $dbw ) : $this->mParentId
 			), __METHOD__
 		);
 
-		$this->mId = !is_null($rev_id) ? $rev_id : $dbw->insertId();
-		
+		$this->mId = !is_null( $rev_id ) ? $rev_id : $dbw->insertId();
+
 		wfRunHooks( 'RevisionInsertComplete', array( &$this, $data, $flags ) );
-		
+
 		wfProfileOut( __METHOD__ );
 		return $this->mId;
 	}
@@ -772,17 +942,23 @@ class Revision {
 	 * Lazy-load the revision's text.
 	 * Currently hardcoded to the 'text' table storage engine.
 	 *
-	 * @return string
+	 * @return String
 	 */
-	private function loadText() {
+	protected function loadText() {
 		wfProfileIn( __METHOD__ );
 
 		// Caching may be beneficial for massive use of external storage
 		global $wgRevisionCacheExpiry, $wgMemc;
-		$key = wfMemcKey( 'revisiontext', 'textid', $this->getTextId() );
+		$textId = $this->getTextId();
+		if( isset( $this->mWikiID ) && $this->mWikiID !== false ) {
+			$key = wfForeignMemcKey( $this->mWikiID, null, 'revisiontext', 'textid', $textId );
+		} else {
+		$key = wfMemcKey( 'revisiontext', 'textid', $textId );
+		}
 		if( $wgRevisionCacheExpiry ) {
 			$text = $wgMemc->get( $key );
 			if( is_string( $text ) ) {
+				wfDebug( __METHOD__ . ": got id $textId from cache\n" );
 				wfProfileOut( __METHOD__ );
 				return $text;
 			}
@@ -798,16 +974,16 @@ class Revision {
 
 		if( !$row ) {
 			// Text data is immutable; check slaves first.
-			$dbr = wfGetDB( DB_SLAVE );
+			$dbr = wfGetDB( DB_SLAVE, array(), $this->mWikiID );
 			$row = $dbr->selectRow( 'text',
 				array( 'old_text', 'old_flags' ),
 				array( 'old_id' => $this->getTextId() ),
 				__METHOD__ );
 		}
 
-		if( !$row ) {
+		if( !$row && wfGetLB()->getServerCount() > 1 ) {
 			// Possible slave lag!
-			$dbw = wfGetDB( DB_MASTER );
+			$dbw = wfGetDB( DB_MASTER, array(), $this->mWikiID );
 			$row = $dbw->selectRow( 'text',
 				array( 'old_text', 'old_flags' ),
 				array( 'old_id' => $this->getTextId() ),
@@ -834,18 +1010,18 @@ class Revision {
 	 * Such revisions can for instance identify page rename
 	 * operations and other such meta-modifications.
 	 *
-	 * @param Database $dbw
-	 * @param int      $pageId ID number of the page to read from
-	 * @param string   $summary
-	 * @param bool     $minor
-	 * @return Revision
+	 * @param $dbw DatabaseBase
+	 * @param $pageId Integer: ID number of the page to read from
+	 * @param $summary String: revision's summary
+	 * @param $minor Boolean: whether the revision should be considered as minor
+	 * @return Revision|null on error
 	 */
 	public static function newNullRevision( $dbw, $pageId, $summary, $minor ) {
 		wfProfileIn( __METHOD__ );
 
 		$current = $dbw->selectRow(
 			array( 'page', 'revision' ),
-			array( 'page_latest', 'rev_text_id' ),
+			array( 'page_latest', 'rev_text_id', 'rev_len' ),
 			array(
 				'page_id' => $pageId,
 				'page_latest=rev_id',
@@ -858,7 +1034,8 @@ class Revision {
 				'comment'    => $summary,
 				'minor_edit' => $minor,
 				'text_id'    => $current->rev_text_id,
-				'parent_id'  => $current->page_latest
+				'parent_id'  => $current->page_latest,
+				'len'        => $current->rev_len
 				) );
 		} else {
 			$revision = null;
@@ -871,40 +1048,64 @@ class 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
-	 * @return bool
+	 *
+	 * @param $field Integer:one of self::DELETED_TEXT,
+	 *                              self::DELETED_COMMENT,
+	 *                              self::DELETED_USER
+	 * @return Boolean
 	 */
 	public function userCan( $field ) {
-		if( ( $this->mDeleted & $field ) == $field ) {
+		return self::userCanBitfield( $this->mDeleted, $field );
+	}
+
+	/**
+	 * 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 $bitfield Integer: current field
+	 * @param $field Integer: one of self::DELETED_TEXT = File::DELETED_FILE,
+	 *                               self::DELETED_COMMENT = File::DELETED_COMMENT,
+	 *                               self::DELETED_USER = File::DELETED_USER
+	 * @return Boolean
+	 */
+	public static function userCanBitfield( $bitfield, $field ) {
+		if( $bitfield & $field ) { // aspect is deleted
 			global $wgUser;
-			$permission = ( $this->mDeleted & self::DELETED_RESTRICTED ) == self::DELETED_RESTRICTED
-				? 'suppressrevision'
-				: 'deleterevision';
-			wfDebug( "Checking for $permission due to $field match on $this->mDeleted\n" );
+			if ( $bitfield & self::DELETED_RESTRICTED ) {
+				$permission = 'suppressrevision';
+			} elseif ( $field & self::DELETED_TEXT ) {
+				$permission = 'deletedtext';
+			} else {
+				$permission = 'deletedhistory';
+			}
+			wfDebug( "Checking for $permission due to $field match on $bitfield\n" );
 			return $wgUser->isAllowed( $permission );
 		} else {
 			return true;
 		}
 	}
 
-
 	/**
 	 * Get rev_timestamp from rev_id, without loading the rest of the row
-	 * @param integer $id
-	 * @param integer $pageid, optional
+	 *
+	 * @param $title Title
+	 * @param $id Integer
+	 * @return String
 	 */
-	static function getTimestampFromId( $id, $pageId = 0 ) {
-		$dbr = wfGetDB( DB_SLAVE );
-		$conds = array( 'rev_id' => $id );
-		if( $pageId ) {
-			$conds['rev_page'] = $pageId;
+	static function getTimestampFromId( $title, $id ) {
+		$wikiId = wfWikiID();
+		$dbr = wfGetDB( DB_SLAVE, array(), $wikiId );
+		// Casting fix for DB2
+		if ( $id == '' ) {
+			$id = 0;
 		}
+		$conds = array( 'rev_id' => $id );
+		$conds['rev_page'] = $title->getArticleId();
 		$timestamp = $dbr->selectField( 'revision', 'rev_timestamp', $conds, __METHOD__ );
-		if ( $timestamp === false ) {
+		if ( $timestamp === false && wfGetLB()->getServerCount() > 1 ) {
 			# Not in slave, try master
-			$dbw = wfGetDB( DB_MASTER );
+			$dbw = wfGetDB( DB_MASTER, array(), $wikiId );
 			$timestamp = $dbw->selectField( 'revision', 'rev_timestamp', $conds, __METHOD__ );
 		}
 		return wfTimestamp( TS_MW, $timestamp );
@@ -912,8 +1113,10 @@ class Revision {
 
 	/**
 	 * Get count of revisions per page...not very efficient
-	 * @param Database $db
-	 * @param int $id, page id
+	 *
+	 * @param $db DatabaseBase
+	 * @param $id Integer: page id
+	 * @return Integer
 	 */
 	static function countByPageId( $db, $id ) {
 		$row = $db->selectRow( 'revision', 'COUNT(*) AS revCount',
@@ -926,8 +1129,10 @@ class Revision {
 
 	/**
 	 * Get count of revisions per page...not very efficient
-	 * @param Database $db
-	 * @param Title $title
+	 *
+	 * @param $db DatabaseBase
+	 * @param $title Title
+	 * @return Integer
 	 */
 	static function countByTitle( $db, $title ) {
 		$id = $title->getArticleId();
@@ -937,11 +1142,3 @@ class Revision {
 		return 0;
 	}
 }
-
-/**
- * Aliases for backwards compatibility with 1.6
- */
-define( 'MW_REV_DELETED_TEXT', Revision::DELETED_TEXT );
-define( 'MW_REV_DELETED_COMMENT', Revision::DELETED_COMMENT );
-define( 'MW_REV_DELETED_USER', Revision::DELETED_USER );
-define( 'MW_REV_DELETED_RESTRICTED', Revision::DELETED_RESTRICTED );