EditResultBuilder.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
 
class EditResultBuilder {
 
    public const CONSTRUCTOR_OPTIONS = [
        'ManualRevertSearchRadius',
    ];
 
    private const REVERT_METHOD_TO_CHANGE_TAG = [
        EditResult::REVERT_UNDO => 'mw-undo',
        EditResult::REVERT_ROLLBACK => 'mw-rollback',
        EditResult::REVERT_MANUAL => 'mw-manual-revert'
    ];
 
    private $revisionRecord = null;
 
    private $isNew = false;
 
    private $originalRevisionId = false;
 
    private $originalRevision = null;
 
    private $revertMethod = null;
 
    private $newestRevertedRevId = null;
 
    private $oldestRevertedRevId = null;
 
    private $revisionStore;
 
    private $softwareTags;
 
    private $options;
 
    public function __construct(
        RevisionStore $revisionStore,
        array $softwareTags,
        ServiceOptions $options
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
 
        $this->revisionStore = $revisionStore;
        $this->softwareTags = $softwareTags;
        $this->options = $options;
    }
 
    public function buildEditResult(): EditResult {
        if ( $this->revisionRecord === null ) {
            throw new PageUpdateException(
                'Revision was not set prior to building an EditResult'
            );
        }
 
        // do a last-minute check if this was a manual revert
        $this->detectManualRevert();
 
        return new EditResult(
            $this->isNew,
            $this->originalRevisionId,
            $this->revertMethod,
            $this->oldestRevertedRevId,
            $this->newestRevertedRevId,
            $this->isExactRevert(),
            $this->isNullEdit(),
            $this->getRevertTags()
        );
    }
 
    public function setRevisionRecord( RevisionRecord $revisionRecord ) {
        $this->revisionRecord = $revisionRecord;
    }
 
    public function setIsNew( bool $isNew ) {
        $this->isNew = $isNew;
    }
 
    public function markAsRevert(
        int $revertMethod,
        int $oldestRevertedRevId,
        int $newestRevertedRevId = 0
    ) {
        if ( $oldestRevertedRevId === 0 ) {
            return;
        }
        if ( $newestRevertedRevId === 0 ) {
            $newestRevertedRevId = $oldestRevertedRevId;
        }
 
        $this->revertMethod = $revertMethod;
        $this->oldestRevertedRevId = $oldestRevertedRevId;
        $this->newestRevertedRevId = $newestRevertedRevId;
    }
 
    public function setOriginalRevisionId( $originalRevId ) {
        $this->originalRevisionId = $originalRevId;
    }
 
    private function detectManualRevert() {
        $searchRadius = $this->options->get( 'ManualRevertSearchRadius' );
        if ( !$searchRadius ||
            // we already marked this as a revert
            $this->revertMethod !== null ||
            // it's a null edit, nothing was reverted
            $this->isNullEdit() ||
            // we wouldn't be able to figure out what was the newest reverted edit
            // this also discards new pages
            !$this->revisionRecord->getParentId()
        ) {
            return;
        }
 
        $revertedToRev = $this->revisionStore->findIdenticalRevision( $this->revisionRecord, $searchRadius );
        if ( !$revertedToRev ) {
            return;
        }
        $oldestReverted = $this->revisionStore->getNextRevision(
            $revertedToRev,
            RevisionStore::READ_LATEST
        );
        if ( !$oldestReverted ) {
            return;
        }
 
        $this->setOriginalRevisionId( $revertedToRev->getId() );
        $this->markAsRevert(
            EditResult::REVERT_MANUAL,
            $oldestReverted->getId(),
            $this->revisionRecord->getParentId()
        );
    }
 
    private function getOriginalRevision(
        int $flags = RevisionStore::READ_NORMAL
    ): ?RevisionRecord {
        if ( $this->originalRevision ) {
            return $this->originalRevision;
        }
        if ( $this->originalRevisionId === false ) {
            return null;
        }
 
        $this->originalRevision = $this->revisionStore->getRevisionById(
            $this->originalRevisionId,
            $flags
        );
        return $this->originalRevision;
    }
 
    private function isExactRevert(): bool {
        if ( $this->isNew || $this->oldestRevertedRevId === null ) {
            return false;
        }
 
        if ( $this->getOriginalRevision() === null ) {
            // we can't find the original revision for some reason, better return false
            return false;
        }
 
        return $this->revisionRecord->hasSameContent( $this->getOriginalRevision() );
    }
 
    private function isNullEdit(): bool {
        if ( $this->isNew ) {
            return false;
        }
 
        return $this->getOriginalRevision() &&
            $this->originalRevisionId === $this->revisionRecord->getParentId();
    }
 
    private function getRevertTags(): array {
        if ( isset( self::REVERT_METHOD_TO_CHANGE_TAG[$this->revertMethod] ) ) {
            $revertTag = self::REVERT_METHOD_TO_CHANGE_TAG[$this->revertMethod];
            if ( in_array( $revertTag, $this->softwareTags ) ) {
                return [ $revertTag ];
            }
        }
        return [];
    }
}