MediaWiki

Manuel:Revision.php/Migration

< Manual:Revision.php
This page is a translated version of the page Manual:Revision.php/Migration and the translation is 100% complete.
Languages:

Pour les extensions qui utilisent largement les objets Revision, le passage à RevisionRecord peut être difficile. Vous trouverez quelques suggestions ci-dessous.

Constructeurs

Pour remplacer l'utilisation des constructeurs statiques (Revision::newFrom*) tout en ayant toujours des objets Revision, en tant que mesure de continuité, utilisez new Revision( $revisionRecord ) avec le RevisionRecord construit à l'aide du service RevisionLookup. Les méthodes RevisionLookup rendent soit un RevisionRecord ou null, et les méthodes Revision correspondantes rendent soit Revision ou null :

Au lieu de : 

 $revision = Revision::newFromId( $id, $flags );

utilisez : 

 $revisionRecord = MediaWikiServices::getInstance()->getRevisionLookup()->getRevisionById( $ids, $flags );
 $revision = $revisionRecord ? new Revision( $revisionRecord ) : null;

Pour les autres constructeurs statiques, il suffit de remplacer getRevisionById par la méthode correspondante RevisionLookup (notez que les méthodes loadFrom* acceptent des paramètres différents de ceux de newFrom*) : 

Revision::newFromTitle -> RevisionLookup::getRevisionByTitle
Revision::newFromPageId -> RevisionLookup::getRevisionByPageId
Revision::loadFromPageId -> RevisionLookup::loadRevisionFromPageId
Revision::loadFromTitle -> RevisionLookup::loadRevisionFromTitle
Revision::loadFromTimestamp -> RevisionLookup::loadRevisionFromTimestamp

Le service RevisionFactory est utilisé pour remplacer Revision::newFromArchiveRow et Revision::newFromRow; utiliser RevisionFactory::newRevisionFromArchiveRow, et ::newRevisionFromRow (si vous appelez ::newFromRow avec un tableau, le remplacement serait RevisionFactory::newMutableRevisionFromArray, mais cette méthode est également largement dépassée - vous devriez construire un MutableRevisionRecord à la place).

Pour les utilisations directes de new Revision, soit les utilisations existantes, soit celles ajoutées maintenant, voir les notes ci-dessous concernant la suppression finale des objets constructeurs Revision.

Obtenir les révisions associées

Revision::getNext a été remplacé par RevisionLookup::getNextRevision, qui renvoie un objet RevisionRecord. De la même manière, Revision::getPrevious a été remplacé par RevisionLookup::getPreviousRevision.

Texte de la révision

Revision::getRevisionText renvoie la chaîne du contenu textuel d'une révision spécifique (basé sur une ligne de la base de données). Pour le remplacer, récupérez l'objet RevisionRecord correspondant à la rangée, puis utilisez RevisionRecord::getContent( SlotRecord::MAIN ) pour obtenir l'objet de contenu correspondant, et si ce dernier existe, utilisez Content::serialize pour obtenir le texte.

Revision::compressRevisionText peut être remplacé par SqlBlobStore::compressData. Revision::decompressRevisionText peut être remplacé par SqlBlobStore::decompressData.

Autres méthodes statiques

Les méthodes statiques suivantes sont remplacées par les méthodes non statiques : 

Revision::getQueryInfo -> RevisionStore::getQueryInfo
Revision::getArchiveQueryInfo -> RevisionStore::getArchiveQueryInfo

Revision::getParentLengths -> RevisionStore::getRevisionSizes
Revision::getTimestampFromId -> RevisionStore::getTimestampFromId
Le premier paramètre de la méthode Revision était un objet Title ignoré, la méthode RevisionStore n'accepte pas Title mais seulement l'ID correspondant avec les drapeaux de la requête.
Revision::countByPageId -> RevisionStore::countRevisionsByPageId
Revision::countByTitle -> RevisionStore::countRevisionsByTitle

Revision::userWasLastToEdit -> RevisionStore::userWasLastToEdit
Le premier paramètre de la méthode Revision était un int ou un objet IDatabase, la méthode RevisionStore nécessite un objet IDatabase. DE PLUS, la méthode RevisionStore est elle-même légèrement obsolète.

userCan

Revision::userCanBitfield peut être remplacé par RevisionRecord::userCanBitfield et Revision::userCan peut être remplacé par RevisionRecord::userCanBitfield avec le champ de bits étant l'int renvoyé par RevisionRecord::getVisibility.

Les deux méthodes de Revision se repliaient sur $wgUser si aucun objet user n'était fourni; RevisionRecord::userCanBitfield nécessite de passer un User.

Méthodes correspondantes de Revision et RevisionRecord

Les méthodes suivantes Revision peuvent être remplacées par les méthodes identiques RevisionRecord (bien que certaines aient des noms différents). Dès qu'un objet Revision est disponible dans une classe ou une fonction donnée, vous pouvez récupérer immédiatement le RevisionRecord correspondant via Revision::getRevisionRecord et utiliser progressivement RevisionRecord à la place de Revision : 

Revision::getId -> RevisionRecord::getId
Revision::getParentId -> RevisionRecord::getParentId
Revision::getPage -> RevisionRecord::getPageId
Revision::isMinor -> RevisionRecord::isMinor
Revision::isDeleted -> RevisionRecord::isDeleted
Revision::getVisibility -> RevisionRecord::getVisibility
Revision::getTimestamp -> RevisionRecord::getTimestamp
Revision::isCurrent -> RevisionRecord::isCurrent

Les méthodes Revision suivantes peuvent être remplacées par les méthodes identiques RevisionRecord MAIS, tandis que les méthodes Revision rendent null si la valeur est inconnue, les méthodes RevisionRecord déclenchent des exceptions RevisionAccessException : 

Revision::getSize -> RevisionRecord::getSize
Revision::getSha1 -> RevisionRecord::getSha1

Revision::getTitle renvoie l'objet Title correspondant à la révision. Son remplacement RevisionRecord::getPageAsLinkTarget, renvoie un LinkTarget au lieu de Title. Si un objet complet Title est nécessaire, utilisez Title::newFromLinkTarget.

Information basée sur le public

La classe Revision possédaient plusieurs méthodes acceptant un public spécifique pour lequel une valeur (identifiant et nom d'utilisateur qui a fait les modifications, résumé des modifications utilisé ou contenu de la révision) était basée sur la possibilité pour le public de voir les informations (puisque la révision a peut-être été supprimée).

Les constantes utilisées pour spécifier un public sont identiques dans les classes Revision et RevisionRecord : 

Revision::FOR_PUBLIC -> RevisionRecord::FOR_PUBLIC
Revision::FOR_THIS_USER -> RevisionRecord::FOR_THIS_USER
Revision::RAW -> RevisionRecord::RAW

Substitutions :

  • Revision::getUser renvoyait l'identifiant de l'utilisateur qui a modifié, ou 0, et Revision::getUserText renvoyait le nom d'utilisateur ou une chaîne vide. Ils ont été remplacés par RevisionRecord::getUser, qui renvoie un objet UserIdentity si le public spécifié peut voir l'information, ou null sinon. Pour obtenir l'identifiant de l'utilisateur, utilisez UserIdentity::getId et UserIdentity::getName pour le nom d'utilisateur.
  • Revision::getComment a renvoyé le résumé de modification de la révision (en tant que chaîne de caractères) ou null. Il a été remplacé par RevisionRecord::getComment, NEANMOINS au lieu d'une chaîne de caractères, RevisionRecord::getComment renvoie un CommentStoreComment.
  • Revision::getContent renvoyait le contenu de l'emplacement (slot) principal de la révision, ou nul. Il a été remplacé par RevisionRecord::getContent, NEANMOINS la méthode RevisionRecord exige de spécifier l'emplacement pour lequel le contenu doit être récupéré. Utiliser SlotRecord::MAIN pour retrouver le comportement de la méthode Revision. DE PLUS, la méthode RevisionRecord peut générer une exception RevisionAccessException, que la méthode Revision a silencieusement converti en null.
Lorsque le public spécifié pour ::getUser, ::getUserText, ::getComment, ou ::getContent était FOR_THIS_USER, et qu'aucun deuxième paramètre n'avait été passé avec l'utilisateur, les méthodes Revision se repliaient sur l'utilisation de $wgUser. Les méthodes RevisionRecord n'ont pas de tel repli, et génèreront une exception InvalidArgumentException si vous essayez d'utiliser FOR_THIS_USER sans passer de User.

Gestion du contenu

Dans le cadre de la migration vers les révisions à contenu multiple, il n'existe plus de modèle ou de format à contenu unique pour une révision, mais il existe plutôt des modèles de contenu et des formats pour chaque emplacement.

  • Revision::getContentModel renvoyait soit chaîne pour le modèle de contenu de l'emplacement principal de la révision (SlotRecord::MAIN) : soit le modèle défini, soit le modèle par défaut. Pour le remplacer, obtenir l'emplacement principal de RevisionRecord et utiliser SlotRecord::getModel. Si la révision n'a pas d'emplacement principal, se replier sur le modèle par défaut pour le titre. Utiliser le service SlotRoleRegistry pour obtenir SlotRoleHandler pour le rôle correspondant (dans ce cas SlotRecord::MAIN), puis utiliser SlotRoleHandler::getDefaultModel.
  • Revision::getContentFormat a renvoyé une chaîne pour le format du contenu de l'emplacement principal de la révision, ou s'est replié sur le format par défaut du modèle de contenu. Pour le remplacer, obtenir l'emplacement principal de RevisionRecord et utiliser SlotRecord::getFormat. Si la révision n'a pas d'emplacement principal, ou si SlotRecord::getFormat renvoie null, repliez-vous sur le format par défaut du modèle de contenu en utilisant ContentHandler::getDefaultFormat et le ContentHandler correspondant.
  • Revision::getContentHandler renvoyait l'objet ContentHandler correspondant. Utiliser ContentHandlerFactory::getContentHandler avec le modèle de contenu correspondant comme remplacement.

Initialiser les informations de révision

  • Revision::setId n'était pris en charge que si l'objet Revision correspondait à MutableRevisionRecord. Elle peut être remplacée par MutableRevisionRecord::setId.
  • Revision::setUserIdAndName n'était pris en charge que si l'objet Revision correspondait à MutableRevisionRecord. Elle peut être remplacée par MutableRevisionRecord::setUser.
La méthode MutableRevisionRecord nécessite un objet UserIdentity, plutôt qu'un nom et un identifiant d'utilisateur.
  • Revision::setTitle n'était pas pris en charge et générait une exception si elle était appelée avec un titre différent de celui déjà défini pour la révision.

Divers

Revision::getTextId -> utiliser SlotRecord::getContentAddress pour récupérer une adresse de contenu réelle, ou RevisionRecord::hasSameContent pour comparer le contenu
Revision::isUnpatrolled -> RevisionStore::getRcIdIfUnpatrolled
Revision::getRecentChange -> RevisionStore::getRecentChange
Revision::getSerializedData -> utiliser SlotRecord::getContent pour récupérer un objet de contenu et Content::serialize pour le formulaire sérialisé
Revision::insertOn -> RevisionStore::insertRevisionOn
Revision::base36Sha1 -> SlotRecord::base36Sha1
Revision::newNullRevision -> RevisionStore::newNullRevision
Revision::newKnownCurrent -> RevisionLookup::getKnownCurrentRevision

Constructeurs

Pour l'utilisation de new Revision, il existe plusieurs possibilités de remplacement :

  • Si Revision a été construit avec RevisionRecord, utiliser directement ce dernier simplement
  • Si Revision a été construit avec un tableau, utiliser MutableRevisionRecord - construisez-le manuellement et initialisez les différents champs.
Si ni les champs user ni user_text n'ont été définis, la classe Revision revient à utiliser $wgUser; MutableRevisionRecord n'inclut pas de tel repli, et si aucun utilisateur n'est fourni, l'objet n'aura tout simplement pas d'ensemble d'utilisateurs.
  • Si Revision a été construit avec un objet, utilisez RevisionFactory::newRevisionFromRow

Accroches

Un certain nombre d'accroches qui utilisaient les objets Revision en paramètre sont devenues subitement obsolètes en 1.35 puis ont été supprimées en 1.37. Le guide suivant est une base pour remplacer l'utilisation de ces accroches, en mettant l'accent sur la manipulation des objets RevisionRecord à la place de Revision. Notez que les accroches de remplacement peuvent inclure d'autres changements ainsi que la conversion de Revision en RevisionRecord, et les exemples de code ci-dessous convertissent simplement tout le reste lorsque cela est possible (par exemple, le cast d'un objet UserIdentity pour revenir à un objet User) - cela ajoutera une dette technique et devra être correctement abordée en actualisant réellement le code dans le gestionnaire d'accroches pour utiliser les nouveaux objets. Pour simplifier, le code ci-dessous suppose que toutes les déclarations use correspondantes sont déjà incluses. Les morceaux de code de remplacement des accroches ne comprennent pas la mise à jour réelle utilisant les objets Revision pour utiliser RevisionRecord; voir les notes ci-dessus pour savoir comment faire cela.

Les accroches UndeleteShowRevision et UserRetrieveNewTalks ont été supprimées sans équivalent.

Remplacement des accroches
Ancien code Nouveau code 
/**
 * @param Title $title
 * @param Revision $revision
 * @param int|null $oldPageID
 * @return bool|void
 */
public function onArticleRevisionUndeleted(
	$title,
	$revision,
	$oldPageID
) { ... }

/**
 * @param RevisionRecord $revisionRecord
 * @param ?int $oldPageID
 * @return bool|void
 */
public function onRevisionUndeleted(
	$revisionRecord,
	$oldPageID
) {
	$title = Title::newFromLinkTarget( $revisionRecord->getPageAsLinkTarget() );
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * @param WikiPage $wikiPage
 * @param User $user
 * @param Revision $revision Révision cible de la page annulée
 * @param Revision $current Révision annulée
 * @return bool|void
 */
public function onArticleRollbackComplete(
	$wikiPage,
	$user,
	$revision,
	$current
) { ... }

/**
 * @param WikiPage $wikiPage
 * @param UserIdentity $userIdentity
 * @param RevisionRecord $revisionRecord RevisionRecord pour la révision 
 *   page cible de l'annulation
 * @param RevisionRecord $currentRevRecord RevisionRecord de la révision annulée
 * @return bool|void
 */
public function onRollbackComplete(
	$wikiPage,
	$userIdentity,
	$revisionRecord,
	$currentRevRecord
) {
	$user = User::newFromIdentity( $userIdentity );
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * @param Revision $newRev
 * @param string[] &$links
 * @param Revision|null $oldRev
 * @param User $user
 * @return bool|void
 */
public function onDiffRevisionTools(
	$newRev,
	&$links,
	$oldRev,
	$user
) { ... }

/**
 * @param RevisionRecord $newRevRecord
 * @param string[] &$links
 * @param RevisionRecord|null $oldRevRecord
 * @param UserIdentity $userIdentity
 * @return bool|void
 */
public function onDiffTools(
	$newRevRecord,
	&$links,
	$oldRevRecord,
	$userIdentity
) {
	$user = User::newFromIdentity( $userIdentity );
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * @param DifferenceEngine $diff
 * @param Revision|null $oldRev Ancienne révision (peut valoir null/invalid)
 * @param Revision $newRev Nouveau ''Revision'' pour l'article
 * @return bool|void
 */
public function onDiffViewHeader(
	$diff,
	$oldRev,
	$newRev
) { ... }

/**
 * @param DifferenceEngine $differenceEngine
 * @return bool|void
 */
public function onDifferenceEngineViewHeader( $differenceEngine ) {
	$oldRevRecord = $differenceEngine->getOldRevision();
	$newRevRecord = $differenceEngine->getNewRevision();
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * @param Revision $rev
 * @param string[] &$links
 * @param Revision|null $prevRev
 * @param User $user
 * @return bool|void
 */
public function onHistoryRevisionTools(
	$rev,
	&$links,
	$prevRev,
	$user
) { ... }

/**
 * @param RevisionRecord $revRecord
 * @param string[] &$links
 * @param RevisionRecord|null $prevRevRecord
 * @param UserIdentity $userIdentity
 * @return bool|void
 */
public function onHistoryTools(
	$revRecord,
	&$links,
	$prevRevRecord,
	$userIdentity
) {
	$user = User::newFromIdentity( $userIdentity );
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * @param WikiPage $wikiPage
 * @param Revision $revision
 * @param int|bool $originalRevId
 * @param User $user
 * @param string[] &$tags
 * @return bool|void
 */
public function onNewRevisionFromEditComplete(
	$wikiPage,
	$revision,
	$originalRevId,
	$user,
	&$tags
) { ... }

/**
 * @param WikiPage $wikiPage
 * @param RevisionRecord $revisionRecord
 * @param int|bool $originalRevId
 * @param UserIdentity $userIdentity
 * @param string[] &$tags
 * @return bool|void
 */
public function onRevisionFromEditComplete(
	$wikiPage,
	$revisionRecord,
	$originalRevId,
	$userIdentity,
	&$tags
) {
	$user = User::newFromIdentity( $userIdentity );
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * Accroche appelée pour créer les nouvelles pages
 * @param WikiPage $wikiPage
 * @param User $user
 * @param Content $content
 * @param string $summary
 * @param bool $isMinor
 * @param null $isWatch (N'est plus utilisé)
 * @param null $section (N'est plus utilisé)
 * @param int $flags Drapeaux à passer WikiPage::doEditContent()
 * @param Revision $revision Nouveau ''Revision'' pour l'article
 * @return bool|void
 */
public function onPageContentInsertComplete(
	$wikiPage,
	$user,
	$content,
	$summary,
	$isMinor,
	$isWatch,
	$section,
	$flags,
	$revision
) { ... }

/**
 * @param WikiPage $wikiPage
 * @param UserIdentity $userIdentity
 * @param string $summary
 * @param int $flags Flags passed to WikiPage::doEditContent()
 * @param RevisionRecord $revisionRecord Nouveau ''Revision'' pour l'article
 * @param EditResult $editResult
 * @return bool|void
 */
public function onPageSaveComplete(
	$wikiPage,
	$userIdentity,
	$summary,
	$flags,
	$revisionRecord,
	$editResult
) {
	// L'ancienne accroche n'était appelée que lorsque de la création des nouvelles pages,
	// mais l'accroche de remplacement est également appelée pour modifier les pages existantes
	if ( !( $flags & EDIT_NEW ) ) {
		// Pas une nouvelle page
		return;
	}
	$user = User::newFromIdentity( $userIdentity );
	$content = $revisionRecord->getContent( SlotRecord::MAIN, RevisionRecord::RAW );
	$isMinor = $flags & EDIT_MINOR;
	// Pas de support pour recréer $isWatch et $section, ils n'étaient pas utilisés
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de $2
	...
}

/**
 * Accroche appelée pour créer les nouvelles pages et modifier les pages existantes
 * @param WikiPage $wikiPage
 * @param User $user
 * @param Content $content
 * @param string $summary
 * @param bool $isMinor
 * @param null $isWatch (N'est plus utilisé)
 * @param null $section (N'est plus utilisé)
 * @param int $flags Drapeaux à transférer WikiPage::doEditContent()
 * @param Revision $revision Nouveau ''Revision'' pour l'article
 * @param Status $status Objet ''Status'' à renvoyer doEditContent().
 * @param int|bool $originalRevId
 * @param int $undidRevId Rev ID (ou 0) que cette modification a annulé
 * @return bool|void
 */
public function onPageContentSaveComplete(
	$wikiPage,
	$user,
	$content,
	$summary,
	$isMinor,
	$isWatch,
	$section,
	$flags,
	$revision,
	$status,
	$originalRevId,
	$undidRevId
) { ... }

/**
 * @param WikiPage $wikiPage
 * @param UserIdentity $userIdentity
 * @param string $summary
 * @param int $flags Drapeaux à transférer WikiPage::doEditContent()
 * @param RevisionRecord $revisionRecord Nouveau ''RevisionRecord'' pour l'article
 * @param EditResult $editResult
 * @return bool|void
 */
public function onPageSaveComplete(
	$wikiPage,
	$userIdentity,
	$summary,
	$flags,
	$revisionRecord,
	$editResult
) {
	$user = User::newFromIdentity( $userIdentity );
	$content = $revisionRecord->getContent( SlotRecord::MAIN, RevisionRecord::RAW );
	$isMinor = $flags & EDIT_MINOR;
	// Aucun support pour recréer $isWatch et $section, ils n'étaient pas utilisés
	// CORRIGEZ MOI, aucune idée sur la façon de recréer $status ni s'il est nécessaire
	$originalRevId = $editResult->getOriginalRevisionId();
	$undidRevId = $editResult->getUndidRevId();
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * @param Parser|bool $parser Objet analyseur ou ''false''
 * @param Title $title Objet ''Title'' du modèle à rechercher
 * @param Revision $rev objet ''Revision'' du modèle
 * @param string|bool|null &$text texte de transclusion du modèle ou faux ou nul
 * @param array &$deps Tableau des dépendances du modèle avec les clés de 
 *   ''title'', ''page_id'' et ''rev_id''
 * @return bool|void
 */
public function onParserFetchTemplate(
	$parser,
	$title,
	$rev,
	&$text,
	&$deps
) { ... }

/**
 * @param ?LinkTarget $contextTitle titre de la page principale s'il existe
 * @param LinkTarget $title lien du modèle (du wikicode littéral)
 * @param bool &$skip Sauter ce modèle et le lier ?
 * @param ?RevisionRecord &$revRecord enregistrement de la révision désirée
 * @return bool|void True ou aucune valeur de retour pour continuer ou false pour annuler
 */
public function onBeforeParserFetchTemplateRevisionRecord(
	?LinkTarget $contextTitle,
	LinkTarget $title,
	bool &$skip,
	?RevisionRecord &$revRecord
) {
	// CORRIGEZ je n'ai pas d'idée sur la manière de gérer les différences entre ces accroches :(
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * @param Revision $revision
 * @param null $data OBSOLETE! Toujours null !
 * @param null $flags OBSOLETE! Toujours null !
 * @return bool|void
 */
public function onRevisionInsertComplete(
	$revision,
	$data,
	$flags
) { ... }

/**
 * @param RevisionRecord $revisionRecord
 * @return bool|void
 */
public function onRevisionRecordInserted( $revisionRecord ) {
	// Aucun support pour recréer $data and $flags,
ils n'étaient pas utilisés
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * Page move post-commit
 * @param Title $oldTitle
 * @param Title $newTitle
 * @param User $user
 * @param int $pageid
 * @param int $redirid
 * @param string $reason
 * @param Revision $revision
 * @return bool|void
*/
public function onTitleMoveComplete(
	$oldTitle,
	$newTitle,
	$user,
	$pageid,
	$redirid,
	$reason,
	$revision
) { ... }

/**
 * Page move post-commit
 * @param LinkTarget $oldLinkTarget
 * @param LinkTarget $newLlinkTarget
 * @param UserIdentity $userIdentity
 * @param int $pageid
 * @param int $redirid
 * @param string $reason
 * @param RevisionRecord $revisionRecord
 * @return bool|void
 */
public function onPageMoveComplete(
	$oldLinkTarget,
	$newLinkTarget,
	$userIdentity,
	$pageid,
	$redirid,
	$reason,
	$revisionRecord
) {
	$oldTitle = Title::newFromLinkTarget( $oldLinkTarget );
	$newTitle = Title::newFromLinkTarget( $newLinkTarget );
	$user = User::newFromIdentity( $userIdentity );
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}

/**
 * Page move pre-commit
 * @param Title $oldTitle
 * @param Title $newTitle
 * @param User $user
 * @param int $pageid
 * @param int $redirid
 * @param string $reason
 * @param Revision $revision
 * @return bool|void
 */
public function onTitleMoveCompleting(
	$oldTitle,
	$newTitle,
	$user,
	$pageid,
	$redirid,
	$reason,
	$revision
) { ... }

/**
 * Page move pre-commit
 * @param LinkTarget $oldLinkTarget
 * @param LinkTarget $newLinkTarget
 * @param UserIdentity $userIdentiy
 * @param int $pageid
 * @param int $redirid
 * @param string $reason
 * @param RevisionRecord $revisionRecord
 * @return bool|void
 */
public function onPageMoveCompleting(
	$oldLinkTarget,
	$newLinkTarget,
	$userIdentity,
	$pageid,
	$redirid,
	$reason,
	$revisionRecord
) {
	$oldTitle = Title::newFromLinkTarget( $oldLinkTarget );
	$newTitle = Title::newFromLinkTarget( $newLinkTarget );
	$user = User::newFromIdentity( $userIdentity );
	// maintenant mettre à jour l'utilisation de RevisionRecord au lieu de Revision
	...
}
Retrieved from "https://www.mediawiki.org/w/index.php?title=Manual:Revision.php/Migration/fr&oldid=6269930"