RevisionSlotsUpdate.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use Content;
use MediaWiki\Revision\MutableRevisionSlots;
use MediaWiki\Revision\RevisionAccessException;
use MediaWiki\Revision\RevisionSlots;
use MediaWiki\Revision\SlotRecord;
 
class RevisionSlotsUpdate {
 
    private $modifiedSlots = [];
 
    private $removedRoles = [];
 
    public static function newFromRevisionSlots(
        RevisionSlots $newSlots,
        RevisionSlots $parentSlots = null
    ) {
        $modified = $newSlots->getSlots();
        $removed = [];
 
        if ( $parentSlots ) {
            foreach ( $parentSlots->getSlots() as $role => $slot ) {
                if ( !isset( $modified[$role] ) ) {
                    $removed[] = $role;
                } elseif ( $slot->hasSameContent( $modified[$role] ) ) {
                    // Unset slots that had the same content in the parent revision from $modified.
                    unset( $modified[$role] );
                }
            }
        }
 
        return new RevisionSlotsUpdate( $modified, $removed );
    }
 
    public static function newFromContent( array $newContent, RevisionSlots $parentSlots = null ) {
        $modified = [];
 
        foreach ( $newContent as $role => $content ) {
            $slot = SlotRecord::newUnsaved( $role, $content );
 
            if ( $parentSlots
                && $parentSlots->hasSlot( $role )
                && $slot->hasSameContent( $parentSlots->getSlot( $role ) )
            ) {
                // Skip slots that had the same content in the parent revision from $modified.
                continue;
            }
 
            $modified[$role] = $slot;
        }
 
        return new RevisionSlotsUpdate( $modified );
    }
 
    public function __construct( array $modifiedSlots = [], array $removedRoles = [] ) {
        foreach ( $modifiedSlots as $slot ) {
            $this->modifySlot( $slot );
        }
 
        foreach ( $removedRoles as $role ) {
            $this->removeSlot( $role );
        }
    }
 
    public function getModifiedRoles() {
        return array_keys( $this->modifiedSlots );
    }
 
    public function getRemovedRoles() {
        return array_keys( $this->removedRoles );
    }
 
    public function getTouchedRoles() {
        return array_merge( $this->getModifiedRoles(), $this->getRemovedRoles() );
    }
 
    public function modifySlot( SlotRecord $slot ) {
        $role = $slot->getRole();
 
        // XXX: We should perhaps require this to be an unsaved slot!
        unset( $this->removedRoles[$role] );
        $this->modifiedSlots[$role] = $slot;
    }
 
    public function modifyContent( $role, Content $content ) {
        $slot = SlotRecord::newUnsaved( $role, $content );
        $this->modifySlot( $slot );
    }
 
    public function removeSlot( $role ) {
        unset( $this->modifiedSlots[$role] );
        $this->removedRoles[$role] = true;
    }
 
    public function getModifiedSlot( $role ) {
        if ( isset( $this->modifiedSlots[$role] ) ) {
            return $this->modifiedSlots[$role];
        } else {
            throw new RevisionAccessException(
                'No such slot: {role}',
                [ 'role' => $role ]
            );
        }
    }
 
    public function isModifiedSlot( $role ) {
        return isset( $this->modifiedSlots[$role] );
    }
 
    public function isRemovedSlot( $role ) {
        return isset( $this->removedRoles[$role] );
    }
 
    public function hasSameUpdates( RevisionSlotsUpdate $other ) {
        // NOTE: use != not !==, since the order of entries is not significant!
 
        if ( $this->getModifiedRoles() != $other->getModifiedRoles() ) {
            return false;
        }
 
        if ( $this->getRemovedRoles() != $other->getRemovedRoles() ) {
            return false;
        }
 
        foreach ( $this->getModifiedRoles() as $role ) {
            $s = $this->getModifiedSlot( $role );
            $t = $other->getModifiedSlot( $role );
 
            if ( !$s->hasSameContent( $t ) ) {
                return false;
            }
        }
 
        return true;
    }
 
    public function apply( MutableRevisionSlots $slots ) {
        foreach ( $this->getModifiedRoles() as $role ) {
            $slots->setSlot( $this->getModifiedSlot( $role ) );
        }
 
        foreach ( $this->getRemovedRoles() as $role ) {
            $slots->removeSlot( $role );
        }
    }
 
}