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

diff --git a/includes/Revision.php b/includes/Revision.php
index 7938d88a8d..243c9c06a0 100644
--- a/includes/Revision.php
+++ b/includes/Revision.php
@@ -1,8 +1,4 @@
 <?php
-/**
- * @todo document
- * @file
- */
 
 /**
  * @todo document
@@ -12,7 +8,8 @@ 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;
@@ -22,14 +19,13 @@ class Revision {
 	 * 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 ) ) );
 	}
 
 	/**
@@ -37,14 +33,14 @@ 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 ) {
-		$conds = array( 
-			'page_namespace' => $title->getNamespace(), 
-			'page_title' => $title->getDBkey()
+		$conds = array(
+			'page_namespace' => $title->getNamespace(),
+			'page_title' 	 => $title->getDBkey()
 		);
 		if ( $id ) {
 			// Use the specified ID
@@ -53,6 +49,9 @@ class Revision {
 			// 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 {
 			// Use a join to get the latest revision
@@ -62,19 +61,88 @@ class Revision {
 		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 ) ) );
 	}
 
 	/**
@@ -82,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 ) {
@@ -120,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() ) );
 	}
 
 	/**
@@ -130,31 +218,27 @@ 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 ) && wfGetLB()->getServerCount() > 1 ) {
@@ -168,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 );
@@ -193,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
+	 * @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
-	 * @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' ) );
 	}
 
 	/**
@@ -230,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,
 			__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',
@@ -270,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() {
@@ -281,6 +339,7 @@ class Revision {
 			'old_flags'
 		);
 	}
+
 	/**
 	 * Return the list of page fields that should be selected from page table
 	 */
@@ -293,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 );
@@ -308,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->mTitle->resetArticleID( $this->mPage );
+				$this->mTitle = Title::newFromRow( $row );
 			} else {
 				$this->mCurrent = false;
 				$this->mTitle = null;
@@ -359,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;
@@ -379,7 +440,8 @@ class Revision {
 
 	/**
 	 * Get text row ID
-	 * @return int
+	 *
+	 * @return Integer
 	 */
 	public function getTextId() {
 		return $this->mTextId;
@@ -387,7 +449,8 @@ class Revision {
 
 	/**
 	 * Get parent revision ID (the original previous page revision)
-	 * @return int
+	 *
+	 * @return Integer
 	 */
 	public function getParentId() {
 		return $this->mParentId;
@@ -395,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;
@@ -403,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;
@@ -433,7 +499,8 @@ class Revision {
 
 	/**
 	 * Get the page ID
-	 * @return int
+	 *
+	 * @return Integer
 	 */
 	public function getPage() {
 		return $this->mPage;
@@ -441,16 +508,16 @@ class Revision {
 
 	/**
 	 * 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 
+	 * If the specified audience does not have access to it, zero will be
 	 * returned.
 	 *
-	 * @param integer $audience One of:
+	 * @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 int
+	 * @return Integer
 	 */
 	public function getUser( $audience = self::FOR_PUBLIC ) {
 		if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
@@ -464,7 +531,8 @@ 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;
@@ -472,10 +540,10 @@ class Revision {
 
 	/**
 	 * Fetch revision's username if it's available to the specified audience.
-	 * If the specified audience does not have access to the username, an 
+	 * If the specified audience does not have access to the username, an
 	 * empty string will be returned.
 	 *
-	 * @param integer $audience One of:
+	 * @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
@@ -484,9 +552,9 @@ class Revision {
 	 */
 	public function getUserText( $audience = self::FOR_PUBLIC ) {
 		if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_USER ) ) {
-			return "";
+			return '';
 		} elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_USER ) ) {
-			return "";
+			return '';
 		} else {
 			return $this->mUserText;
 		}
@@ -494,7 +562,8 @@ class Revision {
 
 	/**
 	 * Fetch revision's username without regard for view restrictions
-	 * @return string
+	 *
+	 * @return String
 	 */
 	public function getRawUserText() {
 		return $this->mUserText;
@@ -502,21 +571,21 @@ class Revision {
 
 	/**
 	 * Fetch revision comment if it's available to the specified audience.
-	 * If the specified audience does not have access to the comment, an 
+	 * If the specified audience does not have access to the comment, an
 	 * empty string will be returned.
 	 *
-	 * @param integer $audience One of:
+	 * @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
+	 * @return String
 	 */
 	function getComment( $audience = self::FOR_PUBLIC ) {
 		if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_COMMENT ) ) {
-			return "";
+			return '';
 		} elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_COMMENT ) ) {
-			return "";
+			return '';
 		} else {
 			return $this->mComment;
 		}
@@ -524,52 +593,76 @@ 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;
 	}
-	
+
 	/**
 	 * 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 
+	 * If the specified audience does not have the ability to view this
 	 * revision, an empty string will be returned.
 	 *
-	 * @param integer $audience One of:
+	 * @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
+	 * @return String
 	 */
 	public function getText( $audience = self::FOR_PUBLIC ) {
 		if( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_TEXT ) ) {
-			return "";
+			return '';
 		} elseif( $audience == self::FOR_THIS_USER && !$this->userCan( self::DELETED_TEXT ) ) {
-			return "";
+			return '';
 		} else {
 			return $this->getRawText();
 		}
@@ -577,14 +670,19 @@ class Revision {
 
 	/**
 	 * 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 ) ) {
@@ -595,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;
@@ -610,7 +708,8 @@ class Revision {
 
 	/**
 	 * Get previous revision for this title
-	 * @return Revision
+	 *
+	 * @return Revision or null
 	 */
 	public function getPrevious() {
 		if( $this->getTitle() ) {
@@ -623,7 +722,9 @@ class Revision {
 	}
 
 	/**
-	 * @return Revision
+	 * Get next revision for this title
+	 *
+	 * @return Revision or null
 	 */
 	public function getNext() {
 		if( $this->getTitle() ) {
@@ -638,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
@@ -656,7 +758,7 @@ class Revision {
 				__METHOD__,
 				array( 'ORDER BY' => 'rev_id DESC' ) );
 		}
-		return intval($prevId);
+		return intval( $prevId );
 	}
 
 	/**
@@ -664,9 +766,9 @@ class Revision {
 	  * $row is usually an object from wfFetchRow(), both the flags and the text
 	  * field must be included
 	  *
-	  * @param object $row The text data
-	  * @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__ );
@@ -690,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
@@ -720,13 +822,15 @@ class Revision {
 			}
 
 			global $wgLegacyEncoding;
-			if( $wgLegacyEncoding && !in_array( 'utf-8', $flags ) && !in_array( 'utf8', $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.
 				# ("utf8" checked for compatibility with some broken
 				#  conversion scripts 2008-12-30)
-				global $wgInputEncoding, $wgContLang;
-				$text = $wgContLang->iconv( $wgLegacyEncoding, $wgInputEncoding, $text );
+				global $wgContLang;
+				$text = $wgContLang->iconv( $wgLegacyEncoding, 'UTF-8', $text );
 			}
 		}
 		wfProfileOut( __METHOD__ );
@@ -740,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;
@@ -766,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;
@@ -792,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,
@@ -803,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,
@@ -818,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;
 	}
@@ -835,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;
 			}
@@ -861,7 +974,7 @@ 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() ),
@@ -870,7 +983,7 @@ class Revision {
 
 		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() ),
@@ -897,11 +1010,11 @@ 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__ );
@@ -935,38 +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 Title $title
-	 * @param integer $id
+	 *
+	 * @param $title Title
+	 * @param $id Integer
+	 * @return String
 	 */
 	static function getTimestampFromId( $title, $id ) {
-		$dbr = wfGetDB( DB_SLAVE );
+		$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 && 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 );
@@ -974,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',
@@ -988,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();
@@ -999,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 );