EditResultBuilder.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use MediaWiki\Config\ServiceOptions;
use MediaWiki\MainConfigNames;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use Wikimedia\Assert\Assert;
 
class EditResultBuilder {
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::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 $revertAfterRevId = 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'
            );
        }
 
        // If we don't know the original revision ID, but know which one was undone, try to find out
        $this->guessOriginalRevisionId();
 
        // 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 $newestRevertedRevId,
        ?int $revertAfterRevId = null
    ) {
        Assert::parameter(
            in_array(
                $revertMethod,
                [ EditResult::REVERT_UNDO, EditResult::REVERT_ROLLBACK, EditResult::REVERT_MANUAL ]
            ),
            '$revertMethod',
            'must be one of REVERT_UNDO, REVERT_ROLLBACK, REVERT_MANUAL'
        );
        $this->revertAfterRevId = $revertAfterRevId;
 
        if ( $newestRevertedRevId ) {
            $this->revertMethod = $revertMethod;
            $this->newestRevertedRevId = $newestRevertedRevId;
            $revertAfterRevision = $revertAfterRevId ?
                $this->revisionStore->getRevisionById( $revertAfterRevId ) :
                null;
            $oldestRevertedRev = $revertAfterRevision ?
                $this->revisionStore->getNextRevision( $revertAfterRevision ) : null;
            if ( $oldestRevertedRev ) {
                $this->oldestRevertedRevId = $oldestRevertedRev->getId();
            } else {
                // Can't find the oldest reverted revision.
                // Oh well, just mark the one we know was undone.
                $this->oldestRevertedRevId = $this->newestRevertedRevId;
            }
        }
    }
 
    public function setOriginalRevision( $originalRevision ) {
        if ( $originalRevision instanceof RevisionRecord ) {
            $this->originalRevision = $originalRevision;
            $this->originalRevisionId = $originalRevision->getId();
        } else {
            $this->originalRevisionId = $originalRevision ?? false;
            $this->originalRevision = null; // Will be lazy-loaded.
        }
    }
 
    private function detectManualRevert() {
        $searchRadius = $this->options->get( MainConfigNames::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 );
        if ( !$oldestReverted ) {
            return;
        }
 
        $this->setOriginalRevision( $revertedToRev );
        $this->revertMethod = EditResult::REVERT_MANUAL;
        $this->oldestRevertedRevId = $oldestReverted->getId();
        $this->newestRevertedRevId = $this->revisionRecord->getParentId();
        $this->revertAfterRevId = $revertedToRev->getId();
    }
 
    private function guessOriginalRevisionId() {
        if ( !$this->originalRevisionId ) {
            if ( $this->revertAfterRevId ) {
                $this->setOriginalRevision( $this->revertAfterRevId );
            } elseif ( $this->newestRevertedRevId ) {
                // Try finding the original revision ID by assuming it's the one before the edit
                // that is being reverted.
                $undidRevision = $this->revisionStore->getRevisionById( $this->newestRevertedRevId );
                if ( $undidRevision ) {
                    $originalRevision = $this->revisionStore->getPreviousRevision( $undidRevision );
                    if ( $originalRevision ) {
                        $this->setOriginalRevision( $originalRevision );
                    }
                }
            }
        }
 
        // Make sure original revision's content is the same as
        // the new content and save the original revision ID.
        if ( $this->getOriginalRevision() &&
            !$this->getOriginalRevision()->hasSameContent( $this->revisionRecord )
        ) {
            $this->setOriginalRevision( false );
        }
    }
 
    private function getOriginalRevision(): ?RevisionRecord {
        if ( $this->originalRevision ) {
            return $this->originalRevision;
        }
        if ( !$this->originalRevisionId ) {
            return null;
        }
 
        $this->originalRevision = $this->revisionStore->getRevisionById( $this->originalRevisionId );
        return $this->originalRevision;
    }
 
    private function isExactRevert(): bool {
        if ( $this->isNew || $this->oldestRevertedRevId === null ) {
            return false;
        }
 
        $originalRevision = $this->getOriginalRevision();
        if ( !$originalRevision ) {
            // we can't find the original revision for some reason, better return false
            return false;
        }
 
        return $this->revisionRecord->hasSameContent( $originalRevision );
    }
 
    private function isNullEdit(): bool {
        if ( $this->isNew ) {
            return false;
        }
 
        return $this->getOriginalRevision() &&
            $this->originalRevisionId === $this->revisionRecord->getParentId();
    }
 
    private function getRevertTags(): array {
        if ( $this->revertMethod !== null ) {
            $revertTag = self::REVERT_METHOD_TO_CHANGE_TAG[$this->revertMethod];
            if ( in_array( $revertTag, $this->softwareTags ) ) {
                return [ $revertTag ];
            }
        }
        return [];
    }
}