Revision.php

Go to the documentation of this file.

<?php
use MediaWiki\Linker\LinkTarget;
use MediaWiki\MediaWikiServices;
use MediaWiki\Revision\MutableRevisionRecord;
use MediaWiki\Revision\RevisionAccessException;
use MediaWiki\Revision\RevisionFactory;
use MediaWiki\Revision\RevisionLookup;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Storage\SqlBlobStore;
use Wikimedia\Assert\Assert;
use Wikimedia\Rdbms\IDatabase;
 
class Revision implements IDBAccessObject {
 
    private $mRecord;
 
    // Revision deletion constants
    public const DELETED_TEXT = RevisionRecord::DELETED_TEXT;
    public const DELETED_COMMENT = RevisionRecord::DELETED_COMMENT;
    public const DELETED_USER = RevisionRecord::DELETED_USER;
    public const DELETED_RESTRICTED = RevisionRecord::DELETED_RESTRICTED;
    public const SUPPRESSED_USER = RevisionRecord::SUPPRESSED_USER;
    public const SUPPRESSED_ALL = RevisionRecord::SUPPRESSED_ALL;
 
    // Audience options for accessors
    public const FOR_PUBLIC = RevisionRecord::FOR_PUBLIC;
    public const FOR_THIS_USER = RevisionRecord::FOR_THIS_USER;
    public const RAW = RevisionRecord::RAW;
 
    public const TEXT_CACHE_GROUP = SqlBlobStore::TEXT_CACHE_GROUP;
 
    private static function getRevisionStore( $wiki = false ) {
        if ( $wiki ) {
            return MediaWikiServices::getInstance()->getRevisionStoreFactory()
                ->getRevisionStore( $wiki );
        } else {
            return MediaWikiServices::getInstance()->getRevisionStore();
        }
    }
 
    private static function getRevisionLookup() {
        return MediaWikiServices::getInstance()->getRevisionLookup();
    }
 
    private static function getRevisionFactory() {
        return MediaWikiServices::getInstance()->getRevisionFactory();
    }
 
    private static function getBlobStore( $wiki = false ) {
        $store = MediaWikiServices::getInstance()
            ->getBlobStoreFactory()
            ->newSqlBlobStore( $wiki );
 
        if ( !$store instanceof SqlBlobStore ) {
            throw new RuntimeException(
                'The backwards compatibility code in Revision currently requires the BlobStore '
                . 'service to be an SqlBlobStore instance, but it is a ' . get_class( $store )
            );
        }
 
        return $store;
    }
 
    public static function newFromId( $id, $flags = 0 ) {
        wfDeprecated( __METHOD__, '1.31' );
        $rec = self::getRevisionLookup()->getRevisionById( $id, $flags );
        return $rec ? new Revision( $rec, $flags ) : null;
    }
 
    public static function newFromTitle( LinkTarget $linkTarget, $id = 0, $flags = 0 ) {
        wfDeprecated( __METHOD__, '1.31' );
        $rec = self::getRevisionLookup()->getRevisionByTitle( $linkTarget, $id, $flags );
        return $rec ? new Revision( $rec, $flags ) : null;
    }
 
    public static function newFromPageId( $pageId, $revId = 0, $flags = 0 ) {
        wfDeprecated( __METHOD__, '1.31' );
        $rec = self::getRevisionLookup()->getRevisionByPageId( $pageId, $revId, $flags );
        return $rec ? new Revision( $rec, $flags ) : null;
    }
 
    public static function newFromArchiveRow( $row, $overrides = [] ) {
        wfDeprecated( __METHOD__, '1.31' );
 
        if ( array_key_exists( 'page', $overrides ) ) {
            $overrides['page_id'] = $overrides['page'];
            unset( $overrides['page'] );
        }
 
        $title = null;
        if ( isset( $overrides['title'] ) ) {
            if ( !( $overrides['title'] instanceof Title ) ) {
                throw new MWException( 'title field override must contain a Title object.' );
            }
 
            $title = $overrides['title'];
        }
        if ( $title !== null ) {
            if ( isset( $row->ar_namespace ) && isset( $row->ar_title ) ) {
                $title = Title::makeTitle( $row->ar_namespace, $row->ar_title );
            } else {
                throw new InvalidArgumentException(
                    'A Title or ar_namespace and ar_title must be given'
                );
            }
        }
 
        $rec = self::getRevisionFactory()->newRevisionFromArchiveRow( $row, 0, $title, $overrides );
        return new Revision( $rec, self::READ_NORMAL, $title );
    }
 
    public static function newFromRow( $row ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( is_array( $row ) ) {
            $rec = self::getRevisionFactory()->newMutableRevisionFromArray( $row );
        } else {
            $rec = self::getRevisionFactory()->newRevisionFromRow( $row );
        }
 
        return new Revision( $rec );
    }
 
    public static function loadFromPageId( $db, $pageid, $id = 0 ) {
        wfDeprecated( __METHOD__, '1.31' );
        $rec = self::getRevisionStore()->loadRevisionFromPageId( $db, $pageid, $id );
        return $rec ? new Revision( $rec ) : null;
    }
 
    public static function loadFromTitle( $db, $title, $id = 0 ) {
        wfDeprecated( __METHOD__, '1.31' );
        $rec = self::getRevisionStore()->loadRevisionFromTitle( $db, $title, $id );
        return $rec ? new Revision( $rec ) : null;
    }
 
    public static function loadFromTimestamp( $db, $title, $timestamp ) {
        wfDeprecated( __METHOD__, '1.31' );
        $rec = self::getRevisionStore()->loadRevisionFromTimestamp( $db, $title, $timestamp );
        return $rec ? new Revision( $rec ) : null;
    }
 
    public static function getQueryInfo( $options = [] ) {
        wfDeprecated( __METHOD__, '1.31' );
        return self::getRevisionStore()->getQueryInfo( $options );
    }
 
    public static function getArchiveQueryInfo() {
        wfDeprecated( __METHOD__, '1.31' );
        return self::getRevisionStore()->getArchiveQueryInfo();
    }
 
    public static function getParentLengths( $db, array $revIds ) {
        wfDeprecated( __METHOD__, '1.31' );
        return self::getRevisionStore()->getRevisionSizes( $revIds );
    }
 
    public function __construct( $row, $queryFlags = 0, Title $title = null ) {
        global $wgUser;
 
        if ( $row instanceof RevisionRecord ) {
            $this->mRecord = $row;
        } elseif ( is_array( $row ) ) {
            wfDeprecated( __METHOD__ . ' with an array', '1.31' );
            // If no user is specified, fall back to using the global user object, to stay
            // compatible with pre-1.31 behavior.
            if ( !isset( $row['user'] ) && !isset( $row['user_text'] ) ) {
                $row['user'] = $wgUser;
            }
 
            $this->mRecord = self::getRevisionFactory()->newMutableRevisionFromArray(
                $row,
                $queryFlags,
                $this->ensureTitle( $row, $queryFlags, $title )
            );
        } elseif ( is_object( $row ) ) {
            wfDeprecated( __METHOD__ . ' with an object', '1.31' );
            $this->mRecord = self::getRevisionFactory()->newRevisionFromRow(
                $row,
                $queryFlags,
                $this->ensureTitle( $row, $queryFlags, $title )
            );
        } else {
            throw new InvalidArgumentException(
                '$row must be a row object, an associative array, or a RevisionRecord'
            );
        }
 
        Assert::postcondition( $this->mRecord !== null, 'Failed to construct a RevisionRecord' );
    }
 
    private function ensureTitle( $row, $queryFlags, $title = null ) {
        if ( $title ) {
            return $title;
        }
 
        if ( is_array( $row ) ) {
            if ( isset( $row['title'] ) ) {
                if ( !( $row['title'] instanceof Title ) ) {
                    throw new MWException( 'title field must contain a Title object.' );
                }
 
                return $row['title'];
            }
 
            $pageId = $row['page'] ?? 0;
            $revId = $row['id'] ?? 0;
        } else {
            $pageId = $row->rev_page ?? 0;
            $revId = $row->rev_id ?? 0;
        }
 
        try {
            $title = self::getRevisionStore()->getTitle( $pageId, $revId, $queryFlags );
        } catch ( RevisionAccessException $ex ) {
            // construct a dummy title!
            wfLogWarning( __METHOD__ . ': ' . $ex->getMessage() );
 
            // NOTE: this Title will only be used inside RevisionRecord
            $title = Title::makeTitleSafe( NS_SPECIAL, "Badtitle/ID=$pageId" );
            $title->resetArticleID( $pageId );
        }
 
        return $title;
    }
 
    public function getRevisionRecord() {
        return $this->mRecord;
    }
 
    public function getId() {
        return $this->mRecord->getId();
    }
 
    public function setId( $id ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( $this->mRecord instanceof MutableRevisionRecord ) {
            $this->mRecord->setId( intval( $id ) );
        } else {
            throw new MWException( __METHOD__ . ' is not supported on this instance' );
        }
    }
 
    public function setUserIdAndName( $id, $name ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( $this->mRecord instanceof MutableRevisionRecord ) {
            $user = User::newFromAnyId( intval( $id ), $name, null );
            $this->mRecord->setUser( $user );
        } else {
            throw new MWException( __METHOD__ . ' is not supported on this instance' );
        }
    }
 
    private function getMainSlotRaw() {
        if ( !$this->mRecord->hasSlot( SlotRecord::MAIN ) ) {
            return null;
        }
 
        return $this->mRecord->getSlot( SlotRecord::MAIN, RevisionRecord::RAW );
    }
 
    public function getTextId() {
        wfDeprecated( __METHOD__, '1.31' );
        $slot = $this->getMainSlotRaw();
        return $slot && $slot->hasAddress()
            ? self::getBlobStore()->getTextIdFromAddress( $slot->getAddress() )
            : null;
    }
 
    public function getParentId() {
        wfDeprecated( __METHOD__, '1.31' );
        return $this->mRecord->getParentId();
    }
 
    public function getSize() {
        wfDeprecated( __METHOD__, '1.31' );
        try {
            return $this->mRecord->getSize();
        } catch ( RevisionAccessException $ex ) {
            return null;
        }
    }
 
    public function getSha1() {
        wfDeprecated( __METHOD__, '1.31' );
        try {
            return $this->mRecord->getSha1();
        } catch ( RevisionAccessException $ex ) {
            return null;
        }
    }
 
    public function getTitle() {
        $linkTarget = $this->mRecord->getPageAsLinkTarget();
        return Title::newFromLinkTarget( $linkTarget );
    }
 
    public function setTitle( $title ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( !$title->equals( $this->getTitle() ) ) {
            throw new InvalidArgumentException(
                $title->getPrefixedText()
                    . ' is not the same as '
                    . $this->mRecord->getPageAsLinkTarget()->__toString()
            );
        }
    }
 
    public function getPage() {
        wfDeprecated( __METHOD__, '1.31' );
        return $this->mRecord->getPageId();
    }
 
    public function getUser( $audience = self::FOR_PUBLIC, User $user = null ) {
        if ( $audience === self::FOR_THIS_USER && !$user ) {
            wfDeprecated(
                __METHOD__ . ' using FOR_THIS_USER without a user',
                '1.35'
            );
            global $wgUser;
            $user = $wgUser;
        }
 
        $user = $this->mRecord->getUser( $audience, $user );
        return $user ? $user->getId() : 0;
    }
 
    public function getUserText( $audience = self::FOR_PUBLIC, User $user = null ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( $audience === self::FOR_THIS_USER && !$user ) {
            global $wgUser;
            $user = $wgUser;
        }
 
        $user = $this->mRecord->getUser( $audience, $user );
        return $user ? $user->getName() : '';
    }
 
    public function getComment( $audience = self::FOR_PUBLIC, User $user = null ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( $audience === self::FOR_THIS_USER && !$user ) {
            global $wgUser;
            $user = $wgUser;
        }
 
        $comment = $this->mRecord->getComment( $audience, $user );
        return $comment === null ? null : $comment->text;
    }
 
    public function isMinor() {
        wfDeprecated( __METHOD__, '1.31' );
        return $this->mRecord->isMinor();
    }
 
    public function isUnpatrolled() {
        wfDeprecated( __METHOD__, '1.31' );
        return self::getRevisionStore()->getRcIdIfUnpatrolled( $this->mRecord );
    }
 
    public function getRecentChange( $flags = 0 ) {
        wfDeprecated( __METHOD__, '1.31' );
        return self::getRevisionStore()->getRecentChange( $this->mRecord, $flags );
    }
 
    public function isDeleted( $field ) {
        wfDeprecated( __METHOD__, '1.31' );
        return $this->mRecord->isDeleted( $field );
    }
 
    public function getVisibility() {
        wfDeprecated( __METHOD__, '1.31' );
        return $this->mRecord->getVisibility();
    }
 
    public function getContent( $audience = self::FOR_PUBLIC, User $user = null ) {
        wfDeprecated( __METHOD__, '1.31' );
 
        global $wgUser;
 
        if ( $audience === self::FOR_THIS_USER && !$user ) {
            $user = $wgUser;
        }
 
        try {
            return $this->mRecord->getContent( SlotRecord::MAIN, $audience, $user );
        }
        catch ( RevisionAccessException $e ) {
            return null;
        }
    }
 
    public function getSerializedData() {
        wfDeprecated( __METHOD__, '1.31' );
        $slot = $this->getMainSlotRaw();
        return $slot ? $slot->getContent()->serialize() : '';
    }
 
    public function getContentModel() {
        wfDeprecated( __METHOD__, '1.31' );
 
        $slot = $this->getMainSlotRaw();
 
        if ( $slot ) {
            return $slot->getModel();
        } else {
            $slotRoleRegistry = MediaWikiServices::getInstance()->getSlotRoleRegistry();
            $slotRoleHandler = $slotRoleRegistry->getRoleHandler( SlotRecord::MAIN );
            return $slotRoleHandler->getDefaultModel( $this->getTitle() );
        }
    }
 
    public function getContentFormat() {
        wfDeprecated( __METHOD__, '1.31' );
 
        $slot = $this->getMainSlotRaw();
        $format = $slot ? $this->getMainSlotRaw()->getFormat() : null;
 
        if ( $format === null ) {
            // if no format was stored along with the blob, fall back to default format
            $format = $this->getContentHandler()->getDefaultFormat();
        }
 
        return $format;
    }
 
    public function getContentHandler() {
        wfDeprecated( __METHOD__, '1.31' );
 
        return MediaWikiServices::getInstance()
            ->getContentHandlerFactory()
            ->getContentHandler( $this->getContentModel() );
    }
 
    public function getTimestamp() {
        wfDeprecated( __METHOD__, '1.31' );
        return $this->mRecord->getTimestamp();
    }
 
    public function isCurrent() {
        wfDeprecated( __METHOD__, '1.31' );
        return $this->mRecord->isCurrent();
    }
 
    public function getPrevious() {
        wfDeprecated( __METHOD__, '1.31' );
        $rec = self::getRevisionLookup()->getPreviousRevision( $this->mRecord );
        return $rec ? new Revision( $rec, self::READ_NORMAL, $this->getTitle() ) : null;
    }
 
    public function getNext() {
        wfDeprecated( __METHOD__, '1.31' );
        $rec = self::getRevisionLookup()->getNextRevision( $this->mRecord );
        return $rec ? new Revision( $rec, self::READ_NORMAL, $this->getTitle() ) : null;
    }
 
    public static function getRevisionText( $row, $prefix = 'old_', $wiki = false ) {
        wfDeprecated( __METHOD__, '1.32' );
 
        if ( !$row ) {
            return false;
        }
 
        $textField = $prefix . 'text';
 
        if ( isset( $row->$textField ) ) {
            throw new LogicException(
                'Cannot use ' . __METHOD__ . ' with the ' . $textField . ' field since 1.35.'
            );
        }
 
        // Missing text field, we are probably looking at the MCR-enabled DB schema.
        $store = self::getRevisionStore( $wiki );
        $rev = $prefix === 'ar_'
            ? $store->newRevisionFromArchiveRow( $row )
            : $store->newRevisionFromRow( $row );
 
        $content = $rev->getContent( SlotRecord::MAIN );
        return $content ? $content->serialize() : false;
    }
 
    public static function compressRevisionText( &$text ) {
        wfDeprecated( __METHOD__, '1.31' );
        return self::getBlobStore()->compressData( $text );
    }
 
    public static function decompressRevisionText( $text, $flags ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( $text === false ) {
            // Text failed to be fetched; nothing to do
            return false;
        }
 
        return self::getBlobStore()->decompressData( $text, $flags );
    }
 
    public function insertOn( $dbw ) {
        wfDeprecated( __METHOD__, '1.31' );
 
        global $wgUser;
 
        // Note that $this->mRecord->getId() will typically return null here, but not always,
        // e.g. not when restoring a revision.
 
        if ( $this->mRecord->getUser( RevisionRecord::RAW ) === null ) {
            if ( $this->mRecord instanceof MutableRevisionRecord ) {
                $this->mRecord->setUser( $wgUser );
            } else {
                throw new MWException( 'Cannot insert revision with no associated user.' );
            }
        }
 
        $rec = self::getRevisionStore()->insertRevisionOn( $this->mRecord, $dbw );
 
        $this->mRecord = $rec;
        Assert::postcondition( $this->mRecord !== null, 'Failed to acquire a RevisionRecord' );
 
        return $rec->getId();
    }
 
    public static function base36Sha1( $text ) {
        wfDeprecated( __METHOD__, '1.31' );
        return SlotRecord::base36Sha1( $text );
    }
 
    public static function newNullRevision( $dbw, $pageId, $summary, $minor, $user = null ) {
        wfDeprecated( __METHOD__, '1.35' );
 
        if ( !$user ) {
            global $wgUser;
            $user = $wgUser;
        }
 
        $comment = CommentStoreComment::newUnsavedComment( $summary, null );
 
        $title = Title::newFromID( $pageId, Title::READ_LATEST );
        if ( $title === null ) {
            return null;
        }
 
        $rec = self::getRevisionStore()->newNullRevision( $dbw, $title, $comment, $minor, $user );
 
        return $rec ? new Revision( $rec ) : null;
    }
 
    public function userCan( $field, User $user = null ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( !$user ) {
            global $wgUser;
            $user = $wgUser;
        }
        return RevisionRecord::userCanBitfield( $this->mRecord->getVisibility(), $field, $user );
    }
 
    public static function userCanBitfield( $bitfield, $field, User $user = null,
        Title $title = null
    ) {
        wfDeprecated( __METHOD__, '1.31' );
        if ( !$user ) {
            global $wgUser;
            $user = $wgUser;
        }
 
        return RevisionRecord::userCanBitfield( $bitfield, $field, $user, $title );
    }
 
    public static function getTimestampFromId( $title, $id, $flags = 0 ) {
        wfDeprecated( __METHOD__, '1.35' );
        return self::getRevisionStore()->getTimestampFromId( $id, $flags );
    }
 
    public static function countByPageId( $db, $id ) {
        wfDeprecated( __METHOD__, '1.31' );
        return self::getRevisionStore()->countRevisionsByPageId( $db, $id );
    }
 
    public static function countByTitle( $db, $title ) {
        wfDeprecated( __METHOD__, '1.31' );
        return self::getRevisionStore()->countRevisionsByTitle( $db, $title );
    }
 
    public static function userWasLastToEdit( $db, $pageId, $userId, $since ) {
        wfDeprecated( __METHOD__, '1.24' );
        if ( is_int( $db ) ) {
            $db = wfGetDB( $db );
        }
 
        return self::getRevisionStore()->userWasLastToEdit( $db, $pageId, $userId, $since );
    }
 
    public static function newKnownCurrent( IDatabase $db, $pageIdOrTitle, $revId = 0 ) {
        wfDeprecated( __METHOD__, '1.31' );
        $title = $pageIdOrTitle instanceof Title
            ? $pageIdOrTitle
            : Title::newFromID( $pageIdOrTitle );
 
        if ( !$title ) {
            return false;
        }
 
        $record = self::getRevisionLookup()->getKnownCurrentRevision( $title, $revId );
        return $record ? new Revision( $record ) : false;
    }
}