Hooks.php

<?php
 
namespace MediaWiki\Extension\Translate\PageTranslation;
 
use Article;
use CommentStoreComment;
use Content;
use DeferredUpdates;
use Exception;
use Html;
use IContextSource;
use Language;
use LanguageCode;
use LinkBatch;
use ManualLogEntry;
use MediaWiki\Extension\Translate\Services;
use MediaWiki\Extension\Translate\SystemUsers\FuzzyBot;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Revision\MutableRevisionRecord;
use MediaWiki\Revision\RenderedRevision;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Storage\EditResult;
use MediaWiki\User\UserIdentity;
use MessageGroupStats;
use MessageHandle;
use ObjectCache;
use OutputPage;
use Parser;
use ParserOutput;
use RequestContext;
use Skin;
use SpecialPage;
use Status;
use StubUserLang;
use TextContent;
use Title;
use TranslateMetadata;
use TranslateUtils;
use User;
use Wikimedia\ScopedCallback;
use WikiPage;
use WikiPageMessageGroup;
use WikitextContent;
 
class Hooks {
    // Uuugly hacks
    public static $allowTargetEdit = false;
    // Check if job queue is running
    public static $jobQueueRunning = false;
    // Check if we are just rendering tags or such
    public static $renderingContext = false;
    // Used to communicate data between LanguageLinks and SkinTemplateGetLanguageLink hooks.
    private static $languageLinkData = [];
 
    public static function renderTagPage( $wikitextParser, &$text, $state ): void {
        if ( $text === null ) {
            // SMW is unhelpfully sending null text if source contains section tags. Do not explode.
            return;
        }
 
        self::preprocessTagPage( $wikitextParser, $text, $state );
 
        // Skip further interface message parsing
        if ( $wikitextParser->getOptions()->getInterfaceMessage() ) {
            return;
        }
 
        // For section previews, perform additional clean-up, given tags are often
        // unbalanced when we preview one section only.
        if ( $wikitextParser->getOptions()->getIsSectionPreview() ) {
            $translatablePageParser = Services::getInstance()->getTranslatablePageParser();
            $text = $translatablePageParser->cleanupTags( $text );
        }
 
        // Set display title
        $title = MediaWikiServices::getInstance()
            ->getTitleFactory()
            ->castFromPageReference( $wikitextParser->getPage() );
 
        if ( !$title ) {
            return;
        }
 
        $page = TranslatablePage::isTranslationPage( $title );
        if ( !$page ) {
            return;
        }
 
        try {
            self::$renderingContext = true;
            [ , $code ] = TranslateUtils::figureMessage( $title->getText() );
            $name = $page->getPageDisplayTitle( $code );
            if ( $name ) {
                $name = $wikitextParser->recursivePreprocess( $name );
 
                $langConv = MediaWikiServices::getInstance()->getLanguageConverterFactory()
                    ->getLanguageConverter( $wikitextParser->getTargetLanguage() );
                $name = $langConv->convert( $name );
                $wikitextParser->getOutput()->setDisplayTitle( $name );
            }
            self::$renderingContext = false;
        } catch ( Exception $e ) {
            LoggerFactory::getInstance( 'Translate' )->error(
                'T302754 Failed to set display title for page {title}',
                [
                    'title' => $title->getPrefixedDBkey(),
                    'text' => $text,
                    'pageid' => $title->getId(),
                ]
            );
 
            // Re-throw to preserve behavior
            throw $e;
        }
 
        $extensionData = [
            'languagecode' => $code,
            'messagegroupid' => $page->getMessageGroupId(),
            'sourcepagetitle' => [
                'namespace' => $page->getTitle()->getNamespace(),
                'dbkey' => $page->getTitle()->getDBkey()
            ]
        ];
 
        $wikitextParser->getOutput()->setExtensionData(
            'translate-translation-page', $extensionData
        );
 
        // Disable edit section links
        $wikitextParser->getOutput()->setExtensionData( 'Translate-noeditsection', true );
    }
 
    public static function preprocessTagPage( $wikitextParser, &$text, $state ): void {
        $translatablePageParser = Services::getInstance()->getTranslatablePageParser();
 
        if ( $translatablePageParser->containsMarkup( $text ) ) {
            try {
                $parserOutput = $translatablePageParser->parse( $text );
                // If parsing succeeds, replace text and add styles
                $text = $parserOutput->sourcePageTextForRendering(
                    $wikitextParser->getTargetLanguage()
                );
                $wikitextParser->getOutput()->addModuleStyles( [
                    'ext.translate',
                ] );
            } catch ( ParsingFailure $e ) {
                wfDebug( 'ParsingFailure caught; expected' );
            }
        } else {
            // If the text doesn't contain <translate> markup, it can still contain <tvar> in the
            // context of a Parsoid template expansion sub-pipeline. We strip these as well.
            $unit = new TranslationUnit( $text );
            $text = $unit->getTextForTrans();
        }
    }
 
    public static function onParserOutputPostCacheTransform(
        ParserOutput $out,
        &$text,
        array &$options
    ) {
        if ( $out->getExtensionData( 'Translate-noeditsection' ) ) {
            $options['enableSectionEditLinks'] = false;
        }
    }
 
    public static function fetchTranslatableTemplateAndTitle(
        ?LinkTarget $contextLink,
        ?LinkTarget $templateLink,
        bool &$skip,
        ?RevisionRecord &$revRecord
    ): void {
        if ( !$templateLink ) {
            return;
        }
 
        $templateTitle = Title::castFromLinkTarget( $templateLink );
 
        $templateTranslationPage = TranslatablePage::isTranslationPage( $templateTitle );
        if ( $templateTranslationPage ) {
            // Template is referring to a translation page, fetch it and incase it doesn't
            // exist, fetch the source fallback
            $revRecord = $templateTranslationPage->getRevisionRecordWithFallback();
            return;
        }
 
        if ( !TranslatablePage::isSourcePage( $templateTitle ) ) {
            return;
        }
 
        $translatableTemplatePage = TranslatablePage::newFromTitle( $templateTitle );
 
        if ( !( $translatableTemplatePage->supportsTransclusion() ?? false ) ) {
            // Page being transcluded does not support language aware transclusion
            return;
        }
 
        $store = MediaWikiServices::getInstance()->getRevisionStore();
 
        if ( $contextLink ) {
            // Fetch the context page language, and then check if template is present in that language
            $templateTranslationTitle = $templateTitle->getSubpage(
                Title::castFromLinkTarget( $contextLink )->getPageLanguage()->getCode()
             );
 
            if ( $templateTranslationTitle ) {
                if ( $templateTranslationTitle->exists() ) {
                    // Template is present in the context page language, fetch the revision record and return
                    $revRecord = $store->getRevisionByTitle( $templateTranslationTitle );
                } else {
                    // In case the template has not been translated to the context page language,
                    // we assign a MutableRevisionRecord in order to add a dependency, so that when
                    // it is created, the newly created page is loaded rather than the fallback
                    $revRecord = new MutableRevisionRecord( $templateTranslationTitle );
                }
                return;
            }
        }
 
        // Context page information not available OR the template translation title could not be determined.
        // Fetch and return the RevisionRecord of the template in the source language
        $sourceTemplateTitle = $templateTitle->getSubpage(
            $translatableTemplatePage->getMessageGroup()->getSourceLanguage()
        );
        if ( $sourceTemplateTitle && $sourceTemplateTitle->exists() ) {
            $revRecord = $store->getRevisionByTitle( $sourceTemplateTitle );
        }
    }
 
    public static function onPageContentLanguage( Title $title, &$pageLang ) {
        // For translation pages, parse plural, grammar etc with correct language,
        // and set the right direction
        if ( TranslatablePage::isTranslationPage( $title ) ) {
            [ , $code ] = TranslateUtils::figureMessage( $title->getText() );
            $pageLang = MediaWikiServices::getInstance()->getLanguageFactory()->getLanguage( $code );
        }
    }
 
    public static function onTitleGetEditNotices( Title $title, int $oldid, array &$notices ) {
        if ( TranslatablePage::isSourcePage( $title ) ) {
            $msg = wfMessage( 'translate-edit-tag-warning' )->inContentLanguage();
            if ( !$msg->isDisabled() ) {
                $notices['translate-tag'] = $msg->parseAsBlock();
            }
 
            $notices[] = Html::warningBox(
                wfMessage( 'tps-edit-sourcepage-text' )->parse(),
                'translate-edit-documentation'
            );
            // TECHNICALLY this would only be necessary for 1.38+, but the way the message is
            // written is also true for 1.37-; therefore it's reasonable to not add another version
            // check here.
            // The check is "we're using visual editor for WYSIWYG" (as opposed to "for wikitext
            // edition") - the message will not be displayed in that case.
            $request = RequestContext::getMain()->getRequest();
            if ( $request->getVal( 'action' ) === 'visualeditor' &&
                $request->getVal( 'paction' ) !== 'wikitext'
            ) {
                $notices[] = Html::warningBox(
                    wfMessage( 'tps-edit-sourcepage-ve-warning-limited-text' )->parse(),
                    'translate-edit-documentation'
                );
            }
        }
    }
 
    public static function onBeforePageDisplay( OutputPage $out, Skin $skin ) {
        global $wgTranslatePageTranslationULS;
 
        $title = $out->getTitle();
        $isSource = TranslatablePage::isSourcePage( $title );
        $isTranslation = TranslatablePage::isTranslationPage( $title );
 
        if ( $isSource || $isTranslation ) {
            if ( $wgTranslatePageTranslationULS ) {
                $out->addModules( 'ext.translate.pagetranslation.uls' );
            }
 
            if ( $isSource ) {
                // Adding a help notice
                $out->addModuleStyles( 'ext.translate.edit.documentation.styles' );
                $out->addModules( 'ext.translate.edit.documentation' );
            }
 
            if ( $isTranslation ) {
                // Source pages get this module via <translate>, but for translation
                // pages we need to add it manually.
                $out->addModuleStyles( 'ext.translate' );
                $out->addJsConfigVars( 'wgTranslatePageTranslation', 'translation' );
            } else {
                $out->addJsConfigVars( 'wgTranslatePageTranslation', 'source' );
            }
        }
 
        return true;
    }
 
    public static function onVisualEditorBeforeEditor( OutputPage $out, Skin $skin ) {
        return !TranslatablePage::isTranslationPage( $out->getTitle() );
    }
 
    public static function onSectionSave(
        WikiPage $wikiPage,
        User $user,
        TextContent $content,
        $summary,
        $minor,
        $flags,
        MessageHandle $handle
    ) {
        // FuzzyBot may do some duplicate work already worked on by other jobs
        if ( $user->equals( FuzzyBot::getUser() ) ) {
            return true;
        }
 
        $group = $handle->getGroup();
        if ( !$group instanceof WikiPageMessageGroup ) {
            return true;
        }
 
        // Finally we know the title and can construct a Translatable page
        $page = TranslatablePage::newFromTitle( $group->getTitle() );
 
        // Update the target translation page
        if ( !$handle->isDoc() ) {
            $code = $handle->getCode();
            DeferredUpdates::addCallableUpdate(
                function () use ( $page, $code, $user, $flags, $summary, $handle ) {
                    $unitTitle = $handle->getTitle();
                    self::updateTranslationPage( $page, $code, $user, $flags, $summary, null, $unitTitle );
                }
            );
        }
 
        return true;
    }
 
    private static function updateTranslationPage(
        TranslatablePage $page,
        string $code,
        User $user,
        int $flags,
        string $summary,
        ?string $triggerAction = null,
        ?Title $unitTitle = null
    ): void {
        $source = $page->getTitle();
        $target = $source->getSubpage( $code );
        $mwInstance = MediaWikiServices::getInstance();
 
        // We don't know and don't care
        $flags &= ~EDIT_NEW & ~EDIT_UPDATE;
 
        // Update the target page
        $unitTitleText = $unitTitle ? $unitTitle->getPrefixedText() : null;
        $job = RenderTranslationPageJob::newJob( $target, $triggerAction, $unitTitleText );
        $job->setUser( $user );
        $job->setSummary( $summary );
        $job->setFlags( $flags );
        $mwInstance->getJobQueueGroup()->push( $job );
 
        // Invalidate caches so that language bar is up-to-date
        $pages = $page->getTranslationPages();
        $wikiPageFactory = $mwInstance->getWikiPageFactory();
        foreach ( $pages as $title ) {
            if ( $title->equals( $target ) ) {
                // Handled by the RenderTranslationPageJob
                continue;
            }
 
            $wikiPage = $wikiPageFactory->newFromTitle( $title );
            $wikiPage->doPurge();
        }
        $sourceWikiPage = $wikiPageFactory->newFromTitle( $source );
        $sourceWikiPage->doPurge();
    }
 
    public static function languages( $data, $params, $parser ) {
        global $wgPageTranslationLanguageList;
 
        if ( $wgPageTranslationLanguageList === 'sidebar-only' ) {
            return '';
        }
 
        self::$renderingContext = true;
        $context = new ScopedCallback( static function () {
            self::$renderingContext = false;
        } );
 
        // Add a dummy language link that is removed in self::addLanguageLinks.
        if ( $wgPageTranslationLanguageList === 'sidebar-fallback' ) {
            $parser->getOutput()->addLanguageLink( 'x-pagetranslation-tag' );
        }
 
        $currentTitle = $parser->getTitle();
        $pageStatus = self::getTranslatablePageStatus( $currentTitle );
        if ( !$pageStatus ) {
            return '';
        }
 
        $page = $pageStatus[ 'page' ];
        $status = $pageStatus[ 'languages' ];
        $pageTitle = $page->getTitle();
 
        // Sort by language code, which seems to be the only sane method
        ksort( $status );
 
        // This way the parser knows to fragment the parser cache by language code
        $userLang = $parser->getOptions()->getUserLangObj();
        $userLangCode = $userLang->getCode();
        // Should call $page->getMessageGroup()->getSourceLanguage(), but
        // group is sometimes null on WMF during page moves, reason unknown.
        // This should do the same thing for now.
        $sourceLanguage = $pageTitle->getPageLanguage()->getCode();
 
        $languages = [];
        $langFactory = MediaWikiServices::getInstance()->getLanguageFactory();
        foreach ( $status as $code => $percent ) {
            // Get autonyms (null)
            $name = TranslateUtils::getLanguageName( $code, null );
 
            // Add links to other languages
            $suffix = ( $code === $sourceLanguage ) ? '' : "/$code";
            $targetTitleString = $pageTitle->getDBkey() . $suffix;
            $subpage = Title::makeTitle( $pageTitle->getNamespace(), $targetTitleString );
 
            $classes = [];
            if ( $code === $userLangCode ) {
                $classes[] = 'mw-pt-languages-ui';
            }
 
            $linker = $parser->getLinkRenderer();
            $lang = $langFactory->getLanguage( $code );
            if ( $currentTitle->equals( $subpage ) ) {
                $classes[] = 'mw-pt-languages-selected';
                $classes = array_merge( $classes, self::tpProgressIcon( (float)$percent ) );
                $attribs = [
                    'class' => $classes,
                    'lang' => $lang->getHtmlCode(),
                    'dir' => $lang->getDir(),
                ];
 
                $contents = Html::Element( 'span', $attribs, $name );
            } elseif ( $subpage->isKnown() ) {
                $pagename = $page->getPageDisplayTitle( $code );
                if ( !is_string( $pagename ) ) {
                    $pagename = $subpage->getPrefixedText();
                }
 
                $classes = array_merge( $classes, self::tpProgressIcon( (float)$percent ) );
 
                $title = wfMessage( 'tpt-languages-nonzero' )
                    ->inLanguage( $userLang )
                    ->params( $pagename )
                    ->numParams( 100 * $percent )
                    ->text();
                $attribs = [
                    'title' => $title,
                    'class' => $classes,
                    'lang' => $lang->getHtmlCode(),
                    'dir' => $lang->getDir(),
                ];
 
                $contents = $linker->makeKnownLink( $subpage, $name, $attribs );
            } else {
                /* When language is included because it is a priority language,
                 * but translation does not yet exists, link directly to the
                 * translation view. */
                $specialTranslateTitle = SpecialPage::getTitleFor( 'Translate' );
                $params = [
                    'group' => $page->getMessageGroupId(),
                    'language' => $code,
                    'task' => 'view'
                ];
 
                $classes[] = 'new'; // For red link color
 
                $attribs = [
                    'title' => wfMessage( 'tpt-languages-zero' )->inLanguage( $userLang )->text(),
                    'class' => $classes,
                    'lang' => $lang->getHtmlCode(),
                    'dir' => $lang->getDir(),
                ];
                $contents = $linker->makeKnownLink( $specialTranslateTitle, $name, $attribs, $params );
            }
            $languages[ $name ] = Html::rawElement( 'li', [], $contents );
        }
 
        // Sort languages by autonym
        ksort( $languages );
        $languages = array_values( $languages );
        $languages = implode( "\n", $languages );
 
        $out = Html::openElement( 'div', [
            'class' => 'mw-pt-languages noprint',
            'lang' => $userLang->getHtmlCode(),
            'dir' => $userLang->getDir()
        ] );
        $out .= Html::rawElement( 'div', [ 'class' => 'mw-pt-languages-label' ],
            wfMessage( 'tpt-languages-legend' )->inLanguage( $userLang )->escaped()
        );
        $out .= Html::rawElement(
            'ul',
            [ 'class' => 'mw-pt-languages-list' ],
            $languages
        );
        $out .= Html::closeElement( 'div' );
 
        $parser->getOutput()->addModuleStyles( [
            'ext.translate.tag.languages',
        ] );
 
        return $out;
    }
 
    private static function tpProgressIcon( float $percent ) {
        $classes = [ 'mw-pt-progress' ];
        $percent *= 100;
        if ( $percent < 20 ) {
            $classes[] = 'mw-pt-progress--stub';
        } elseif ( $percent < 40 ) {
            $classes[] = 'mw-pt-progress--low';
        } elseif ( $percent < 60 ) {
            $classes[] = 'mw-pt-progress--med';
        } elseif ( $percent < 80 ) {
            $classes[] = 'mw-pt-progress--high';
        } else {
            $classes[] = 'mw-pt-progress--complete';
        }
        return $classes;
    }
 
    private static function getTranslatablePageStatus( Title $title ) {
        // Check if this is a source page or a translation page
        $page = TranslatablePage::newFromTitle( $title );
        if ( $page->getMarkedTag() === null ) {
            $page = TranslatablePage::isTranslationPage( $title );
        }
 
        if ( $page === false || $page->getMarkedTag() === null ) {
            return null;
        }
 
        $status = $page->getTranslationPercentages();
        if ( !$status ) {
            return null;
        }
 
        // If priority languages have been set always show those languages
        $priorityLangs = TranslateMetadata::get( $page->getMessageGroupId(), 'prioritylangs' );
        $priorityForce = TranslateMetadata::get( $page->getMessageGroupId(), 'priorityforce' );
        $filter = null;
        if ( (string)$priorityLangs !== '' ) {
            $filter = array_flip( explode( ',', $priorityLangs ) );
        }
        if ( $filter !== null ) {
            // If translation is restricted to some languages, only show them
            if ( $priorityForce === 'on' ) {
                // Do not filter the source language link
                $filter[$page->getMessageGroup()->getSourceLanguage()] = true;
                $status = array_intersect_key( $status, $filter );
            }
            foreach ( $filter as $langCode => $value ) {
                if ( !isset( $status[$langCode] ) ) {
                    // We need to show all priority languages even if no translation started
                    $status[$langCode] = 0;
                }
            }
        }
 
        return [
            'page' => $page,
            'languages' => $status
        ];
    }
 
    public static function addLanguageLinks( Title $title, array &$languageLinks ) {
        global $wgPageTranslationLanguageList;
 
        $hasLanguagesTag = false;
        foreach ( $languageLinks as $index => $name ) {
            if ( $name === 'x-pagetranslation-tag' ) {
                $hasLanguagesTag = true;
                unset( $languageLinks[ $index ] );
            }
        }
 
        if ( $wgPageTranslationLanguageList === 'tag-only' ) {
            return;
        }
 
        if ( $wgPageTranslationLanguageList === 'sidebar-fallback' && $hasLanguagesTag ) {
            return;
        }
 
        // $wgPageTranslationLanguageList === 'sidebar-always' OR 'sidebar-only'
 
        $status = self::getTranslatablePageStatus( $title );
        if ( !$status ) {
            return;
        }
 
        self::$renderingContext = true;
        $context = new ScopedCallback( static function () {
            self::$renderingContext = false;
        } );
 
        $page = $status[ 'page' ];
        $languages = $status[ 'languages' ];
        $mwServices = MediaWikiServices::getInstance();
        $en = $mwServices->getLanguageFactory()->getLanguage( 'en' );
 
        $newLanguageLinks = [];
 
        // Batch the Title::exists queries used below
        $lb = new LinkBatch();
        foreach ( array_keys( $languages ) as $code ) {
            $title = $page->getTitle()->getSubpage( $code );
            $lb->addObj( $title );
        }
        $lb->execute();
        $languageNameUtils = $mwServices->getLanguageNameUtils();
        foreach ( $languages as $code => $percentage ) {
            $title = $page->getTitle()->getSubpage( $code );
            $key = "x-pagetranslation:{$title->getPrefixedText()}";
            $translatedName = $page->getPageDisplayTitle( $code ) ?: $title->getPrefixedText();
 
            if ( $title->exists() ) {
                $href = $title->getLocalURL();
                $classes = self::tpProgressIcon( (float)$percentage );
                $title = wfMessage( 'tpt-languages-nonzero' )
                    ->params( $translatedName )
                    ->numParams( 100 * $percentage );
            } else {
                $href = SpecialPage::getTitleFor( 'Translate' )->getLocalURL( [
                    'group' => $page->getMessageGroupId(),
                    'language' => $code,
                ] );
                $classes = [ 'mw-pt-progress--none' ];
                $title = wfMessage( 'tpt-languages-zero' );
            }
 
            self::$languageLinkData[ $key ] = [
                'href' => $href,
                'language' => $code,
                'percentage' => $percentage,
                'classes' => $classes,
                'autonym' => $en->ucfirst( $languageNameUtils->getLanguageName( $code ) ),
                'title' => $title,
            ];
 
            $newLanguageLinks[ $key ] = self::$languageLinkData[ $key ][ 'autonym' ];
        }
 
        asort( $newLanguageLinks );
        $languageLinks = array_merge( array_keys( $newLanguageLinks ), $languageLinks );
    }
 
    public static function formatLanguageLink(
        array &$link,
        Title $linkTitle,
        Title $pageTitle,
        OutputPage $out
    ) {
        if ( substr( $link[ 'text' ], 0, 18 ) !== 'x-pagetranslation:' ) {
            return;
        }
 
        if ( !isset( self::$languageLinkData[ $link[ 'text' ] ] ) ) {
            return;
        }
 
        $data = self::$languageLinkData[ $link[ 'text' ] ];
 
        $link[ 'class' ] .= ' ' . implode( ' ', $data[ 'classes' ] );
        $link[ 'href' ] = $data[ 'href' ];
        $link[ 'text' ] = $data[ 'autonym' ];
        $link[ 'title' ] = $data[ 'title' ]->inLanguage( $out->getLanguage()->getCode() )->text();
        $link[ 'lang'] = LanguageCode::bcp47( $data[ 'language' ] );
        $link[ 'hreflang'] = LanguageCode::bcp47( $data[ 'language' ] );
 
        $out->addModuleStyles( 'ext.translate.tag.languages' );
    }
 
    public static function tpSyntaxCheckForEditContent(
        $context,
        $content,
        $status,
        $summary
    ) {
        $syntaxErrorStatus = self::tpSyntaxError( $context->getTitle(), $content );
 
        if ( $syntaxErrorStatus ) {
            $status->merge( $syntaxErrorStatus );
            return $syntaxErrorStatus->isGood();
        }
 
        return true;
    }
 
    private static function tpSyntaxError( ?PageIdentity $page, ?Content $content ): ?Status {
        // T163254: Ignore translation markup on non-wikitext pages
        if ( !$content instanceof WikitextContent || !$page ) {
            return null;
        }
 
        $text = $content->getText();
 
        // See T154500
        $text = str_replace( [ "\r\n", "\r" ], "\n", rtrim( $text ) );
        $status = Status::newGood();
        $parser = Services::getInstance()->getTranslatablePageParser();
        if ( $parser->containsMarkup( $text ) ) {
            try {
                $parser->parse( $text );
            } catch ( ParsingFailure $e ) {
                $status->fatal( ...( $e->getMessageSpecification() ) );
            }
        }
 
        return $status;
    }
 
    public static function tpSyntaxCheck(
        RenderedRevision $renderedRevision,
        UserIdentity $user,
        CommentStoreComment $summary,
        $flags,
        Status $hookStatus
    ) {
        $content = $renderedRevision->getRevision()->getContent( SlotRecord::MAIN );
 
        $status = self::tpSyntaxError(
            $renderedRevision->getRevision()->getPage(),
            $content
        );
 
        if ( $status ) {
            $hookStatus->merge( $status );
            return $status->isGood();
        }
 
        return true;
    }
 
    public static function addTranstagAfterSave(
        WikiPage $wikiPage,
        UserIdentity $userIdentity,
        string $summary,
        int $flags,
        RevisionRecord $revisionRecord,
        EditResult $editResult
    ) {
        $content = $wikiPage->getContent();
 
        // T163254: Disable page translation on non-wikitext pages
        if ( $content instanceof WikitextContent ) {
            $text = $content->getText();
        } else {
            // Not applicable
            return true;
        }
 
        $parser = Services::getInstance()->getTranslatablePageParser();
        if ( $parser->containsMarkup( $text ) ) {
            // Add the ready tag
            $page = TranslatablePage::newFromTitle( $wikiPage->getTitle() );
            $page->addReadyTag( $revisionRecord->getId() );
        }
 
        return true;
    }
 
    public static function updateTranstagOnNullRevisions( RevisionRecord $rev ) {
        $parentId = $rev->getParentId();
        if ( $parentId === 0 || $parentId === null ) {
            // No parent, bail out.
            return;
        }
 
        $prevRev = MediaWikiServices::getInstance()
            ->getRevisionLookup()
            ->getRevisionById( $parentId );
 
        if ( !$prevRev || !$rev->hasSameContent( $prevRev ) ) {
            // Not a null revision, bail out.
            return;
        }
 
        $title = Title::newFromLinkTarget( $rev->getPageAsLinkTarget() );
        $bundleFactory = Services::getInstance()->getTranslatableBundleFactory();
        $bundle = $bundleFactory->getBundle( $title );
 
        if ( $bundle ) {
            $bundleStore = $bundleFactory->getStore( $bundle );
            $bundleStore->handleNullRevisionInsert( $bundle, $rev );
        }
    }
 
    public static function onGetUserPermissionsErrorsExpensive(
        Title $title,
        User $user,
        $action,
        &$result
    ) {
        $handle = new MessageHandle( $title );
 
        // Check only when someone tries to create translation units.
        // Allow editing units that become orphaned in regular use, so that
        // people can delete them or fix links or other issues in them.
        if ( $action !== 'create' || !$handle->isPageTranslation() ) {
            return true;
        }
 
        $isValid = true;
        $groupId = null;
 
        if ( $handle->isValid() ) {
            $groupId = $handle->getGroup()->getId();
        } else {
            // Sometimes the message index can be out of date. Either the rebuild job failed or
            // it just hasn't finished yet. Do a secondary check to make sure we are not
            // inconveniencing translators for no good reason.
            // See https://phabricator.wikimedia.org/T221119
            MediaWikiServices::getInstance()->getStatsdDataFactory()
                ->increment( 'translate.slow_translatable_page_check' );
            $translatablePage = self::checkTranslatablePageSlow( $title );
            if ( $translatablePage ) {
                $groupId = $translatablePage->getMessageGroupId();
            } else {
                $isValid = false;
            }
        }
 
        if ( $isValid ) {
            $error = self::getTranslationRestrictions( $handle, $groupId );
            $result = $error ?: $result;
            return $error === [];
        }
 
        // Don't allow editing invalid messages that do not belong to any translatable page
        LoggerFactory::getInstance( 'Translate' )->info(
            'Unknown translation page: {title}',
            [ 'title' => $title->getPrefixedDBkey() ]
        );
        $result = [ 'tpt-unknown-page' ];
        return false;
    }
 
    private static function checkTranslatablePageSlow( LinkTarget $unit ): ?TranslatablePage {
        $parts = TranslatablePage::parseTranslationUnit( $unit );
        $translationPageTitle = Title::newFromText(
            $parts[ 'sourcepage' ] . '/' . $parts[ 'language' ]
        );
        if ( !$translationPageTitle ) {
            return null;
        }
 
        $translatablePage = TranslatablePage::isTranslationPage( $translationPageTitle );
        if ( !$translatablePage ) {
            return null;
        }
 
        $factory = Services::getInstance()->getTranslationUnitStoreFactory();
        $store = $factory->getReader( $translatablePage->getTitle() );
        $units = $store->getNames();
 
        if ( !in_array( $parts[ 'section' ], $units ) ) {
            return null;
        }
 
        return $translatablePage;
    }
 
    private static function getTranslationRestrictions( MessageHandle $handle, $groupId ) {
        global $wgTranslateDocumentationLanguageCode;
 
        // Allow adding message documentation even when translation is restricted
        if ( $handle->getCode() === $wgTranslateDocumentationLanguageCode ) {
            return [];
        }
 
        // Check if anything is prevented for the group in the first place
        $force = TranslateMetadata::get( $groupId, 'priorityforce' );
        if ( $force !== 'on' ) {
            return [];
        }
 
        // And finally check whether the language is in the inclusion list
        $languages = TranslateMetadata::get( $groupId, 'prioritylangs' );
        $filter = array_flip( explode( ',', $languages ) );
        if ( !isset( $filter[$handle->getCode()] ) ) {
            $reason = TranslateMetadata::get( $groupId, 'priorityreason' );
            if ( $reason ) {
                return [ 'tpt-translation-restricted', $reason ];
            }
 
            return [ 'tpt-translation-restricted-no-reason' ];
        }
 
        return [];
    }
 
    public static function preventDirectEditing( Title $title, User $user, $action, &$result ) {
        if ( self::$allowTargetEdit ) {
            return true;
        }
 
        $inclusionList = [
            'read', 'delete', 'undelete', 'deletedtext', 'deletedhistory',
            'deleterevision', 'suppressrevision', 'viewsuppressed', // T286884
            'review', // FlaggedRevs
            'patrol', // T151172
        ];
        if ( in_array( $action, $inclusionList ) ) {
            return true;
        }
 
        $page = TranslatablePage::isTranslationPage( $title );
        if ( $page !== false && $page->getMarkedTag() ) {
            [ , $code ] = TranslateUtils::figureMessage( $title->getText() );
            $mwService = MediaWikiServices::getInstance();
 
            if ( method_exists( $mwService, 'getUrlUtils' ) ) {
                $translationUrl = $mwService->getUrlUtils()->expand(
                    $page->getTranslationUrl( $code ), PROTO_RELATIVE
                );
            } else {
                // < MW 1.39
                $translationUrl = wfExpandUrl( $page->getTranslationUrl( $code ), PROTO_RELATIVE );
            }
 
            $result = [
                'tpt-target-page',
                ':' . $page->getTitle()->getPrefixedText(),
                // This url shouldn't get cached
                $translationUrl
            ];
 
            return false;
        }
 
        return true;
    }
 
    public static function disableDelete( $article, $out, &$reason ) {
        $title = $article->getTitle();
        $bundle = Services::getInstance()->getTranslatableBundleFactory()->getBundle( $title );
        $isDeletableBundle = $bundle && $bundle->isDeletable();
        if ( $isDeletableBundle || TranslatablePage::isTranslationPage( $title ) ) {
            $new = SpecialPage::getTitleFor(
                'PageTranslationDeletePage',
                $title->getPrefixedText()
            );
            $out->redirect( $new->getFullURL() );
        }
 
        return true;
    }
 
    public static function translatablePageHeader( $article, &$outputDone, &$pcache ) {
        if ( $article->getOldID() ) {
            return true;
        }
 
        $transPage = TranslatablePage::isTranslationPage( $article->getTitle() );
        $context = $article->getContext();
        if ( $transPage ) {
            self::translationPageHeader( $context, $transPage );
        } else {
            // Check for pages that are tagged or marked
            self::sourcePageHeader( $context );
        }
 
        return true;
    }
 
    private static function sourcePageHeader( IContextSource $context ) {
        $linker = MediaWikiServices::getInstance()->getLinkRenderer();
 
        $language = $context->getLanguage();
        $title = $context->getTitle();
 
        $page = TranslatablePage::newFromTitle( $title );
 
        $marked = $page->getMarkedTag();
        $ready = $page->getReadyTag();
        $latest = $title->getLatestRevID();
 
        $actions = [];
        if ( $marked && $context->getUser()->isAllowed( 'translate' ) ) {
            $actions[] = self::getTranslateLink( $context, $page, null );
        }
 
        $hasChanges = $ready === $latest && $marked !== $latest;
        if ( $hasChanges ) {
            $diffUrl = $title->getFullURL( [ 'oldid' => $marked, 'diff' => $latest ] );
 
            if ( $context->getUser()->isAllowed( 'pagetranslation' ) ) {
                $pageTranslation = SpecialPage::getTitleFor( 'PageTranslation' );
                $params = [ 'target' => $title->getPrefixedText(), 'do' => 'mark' ];
 
                if ( $marked === null ) {
                    // This page has never been marked
                    $linkDesc = $context->msg( 'translate-tag-markthis' )->text();
                    $actions[] = $linker->makeKnownLink( $pageTranslation, $linkDesc, [], $params );
                } else {
                    $markUrl = $pageTranslation->getFullURL( $params );
                    $actions[] = $context->msg( 'translate-tag-markthisagain', $diffUrl, $markUrl )
                        ->parse();
                }
            } else {
                $actions[] = $context->msg( 'translate-tag-hasnew', $diffUrl )->parse();
            }
        }
 
        if ( !count( $actions ) ) {
            return;
        }
 
        $header = Html::rawElement(
            'div',
            [
                'class' => 'mw-pt-translate-header noprint nomobile',
                'dir' => $language->getDir(),
                'lang' => $language->getHtmlCode(),
            ],
            $language->semicolonList( $actions )
        );
 
        $context->getOutput()->addHTML( $header );
    }
 
    private static function getTranslateLink(
        IContextSource $context,
        TranslatablePage $page,
        ?string $langCode
    ): string {
        $linker = MediaWikiServices::getInstance()->getLinkRenderer();
 
        return $linker->makeKnownLink(
                SpecialPage::getTitleFor( 'Translate' ),
                $context->msg( 'translate-tag-translate-link-desc' )->text(),
                [],
                [
                    'group' => $page->getMessageGroupId(),
                    'language' => $langCode,
                    'action' => 'page',
                    'filter' => '',
                ]
            );
    }
 
    private static function translationPageHeader( IContextSource $context, TranslatablePage $page ) {
        global $wgTranslateKeepOutdatedTranslations;
 
        $title = $context->getTitle();
        if ( !$title->exists() ) {
            return;
        }
 
        [ , $code ] = TranslateUtils::figureMessage( $title->getText() );
 
        // Get the translation percentage
        $pers = $page->getTranslationPercentages();
        $per = 0;
        if ( isset( $pers[$code] ) ) {
            $per = $pers[$code] * 100;
        }
 
        $language = $context->getLanguage();
        $output = $context->getOutput();
 
        if ( $page->getSourceLanguageCode() === $code ) {
            // If we are on the source language page, link to translate for user's language
            $msg = self::getTranslateLink( $context, $page, $language->getCode() );
        } else {
            $mwService = MediaWikiServices::getInstance();
 
            if ( method_exists( $mwService, 'getUrlUtils' ) ) {
                $translationUrl = $mwService->getUrlUtils()->expand(
                    $page->getTranslationUrl( $code ), PROTO_RELATIVE
                );
            } else {
                // < MW 1.39
                $translationUrl = wfExpandUrl( $page->getTranslationUrl( $code ), PROTO_RELATIVE );
            }
 
            $msg = $context->msg( 'tpt-translation-intro',
                $translationUrl,
                ':' . $page->getTitle()->getPrefixedText(),
                $language->formatNum( $per )
            )->parse();
        }
 
        $header = Html::rawElement(
            'div',
            [
                'class' => 'mw-pt-translate-header noprint',
                'dir' => $language->getDir(),
                'lang' => $language->getHtmlCode(),
            ],
            $msg
        );
 
        $output->addHTML( $header );
 
        if ( $wgTranslateKeepOutdatedTranslations ) {
            $groupId = $page->getMessageGroupId();
            // This is already calculated and cached by above call to getTranslationPercentages
            $stats = MessageGroupStats::forItem( $groupId, $code );
            if ( $stats[MessageGroupStats::FUZZY] ) {
                // Only show if there is fuzzy messages
                $wrap = Html::rawElement(
                    'div',
                    [
                        'class' => 'mw-pt-translate-header',
                        'dir' => $language->getDir(),
                        'lang' => $language->getHtmlCode()
                    ],
                    '<span class="mw-translate-fuzzy">$1</span>'
                );
 
                $output->wrapWikiMsg( $wrap, [ 'tpt-translation-intro-fuzzy' ] );
            }
        }
    }
 
    public static function replaceMovePage( &$list ) {
        $movePageSpec = $list['Movepage'] ?? null;
 
        // This should never happen, but apparently is happening? See: T296568
        if ( $movePageSpec === null ) {
            return true;
        }
 
        $list['Movepage'] = [
            'class' => MoveTranslatableBundleSpecialPage::class,
            'services' => [
                'ObjectFactory',
                'PermissionManager',
                'Translate:TranslatableBundleMover',
                'Translate:TranslatableBundleFactory'
            ],
            'args' => [
                $movePageSpec
            ]
        ];
 
        return true;
    }
 
    public static function lockedPagesCheck( Title $title, User $user, $action, &$result ) {
        if ( $action === 'read' ) {
            return true;
        }
 
        $cache = ObjectCache::getInstance( CACHE_ANYTHING );
        $key = $cache->makeKey( 'pt-lock', sha1( $title->getPrefixedText() ) );
        if ( $cache->get( $key ) === 'locked' ) {
            $result = [ 'pt-locked-page' ];
 
            return false;
        }
 
        return true;
    }
 
    public static function replaceSubtitle( &$subpages, ?Skin $skin, OutputPage $out ) {
        $linker = MediaWikiServices::getInstance()->getLinkRenderer();
 
        $isTranslationPage = TranslatablePage::isTranslationPage( $out->getTitle() );
        if ( !$isTranslationPage
            && !TranslatablePage::isSourcePage( $out->getTitle() )
        ) {
            return true;
        }
 
        // Copied from Skin::subPageSubtitle()
        $nsInfo = MediaWikiServices::getInstance()->getNamespaceInfo();
        if (
            $out->isArticle() &&
            $nsInfo->hasSubpages( $out->getTitle()->getNamespace() )
        ) {
            $ptext = $out->getTitle()->getPrefixedText();
            if ( strpos( $ptext, '/' ) !== false ) {
                $links = explode( '/', $ptext );
                array_pop( $links );
                if ( $isTranslationPage ) {
                    // Also remove language code page
                    array_pop( $links );
                }
                $c = 0;
                $growinglink = '';
                $display = '';
                $lang = $skin->getLanguage();
 
                foreach ( $links as $link ) {
                    $growinglink .= $link;
                    $display .= $link;
                    $linkObj = Title::newFromText( $growinglink );
 
                    if ( is_object( $linkObj ) && $linkObj->isKnown() ) {
                        $getlink = $linker->makeKnownLink(
                            SpecialPage::getTitleFor( 'MyLanguage', $growinglink ),
                            $display
                        );
 
                        $c++;
 
                        if ( $c > 1 ) {
                            $subpages .= $lang->getDirMarkEntity() . $skin->msg( 'pipe-separator' )->escaped();
                        } else {
                            $subpages .= '&lt; ';
                        }
 
                        $subpages .= $getlink;
                        $display = '';
                    } else {
                        $display .= '/';
                    }
 
                    $growinglink .= '/';
                }
            }
 
            return false;
        }
 
        return true;
    }
 
    public static function translateTab( Skin $skin, array &$tabs ) {
        $title = $skin->getTitle();
        $handle = new MessageHandle( $title );
        $code = $handle->getCode();
        $page = TranslatablePage::isTranslationPage( $title );
        if ( !$page ) {
            return true;
        }
        // The source language has a subpage too, but cannot be translated
        if ( $page->getSourceLanguageCode() === $code ) {
            return true;
        }
 
        if ( isset( $tabs['views']['edit'] ) ) {
            $tabs['views']['edit']['text'] = $skin->msg( 'tpt-tab-translate' )->text();
            $tabs['views']['edit']['href'] = $page->getTranslationUrl( $code );
        }
 
        return true;
    }
 
    public static function onMovePageTranslationUnits(
        LinkTarget $oldLinkTarget,
        LinkTarget $newLinkTarget,
        UserIdentity $userIdentity,
        int $oldid,
        int $newid,
        string $reason,
        RevisionRecord $revisionRecord
    ) {
        $user = MediaWikiServices::getInstance()->getUserFactory()->newFromUserIdentity( $userIdentity );
        // MoveTranslatableBundleJob takes care of handling updates because it performs
        // a lot of moves at once. As a performance optimization, skip this hook if
        // we detect moves from that job. As there isn't a good way to pass information
        // to this hook what originated the move, we use some heuristics.
        if ( defined( 'MEDIAWIKI_JOB_RUNNER' ) && $user->equals( FuzzyBot::getUser() ) ) {
            return;
        }
 
        $oldTitle = Title::newFromLinkTarget( $oldLinkTarget );
        $newTitle = Title::newFromLinkTarget( $newLinkTarget );
        $groupLast = null;
        foreach ( [ $oldTitle, $newTitle ] as $title ) {
            $handle = new MessageHandle( $title );
            if ( !$handle->isValid() ) {
                continue;
            }
 
            // Documentation pages are never translation pages
            if ( $handle->isDoc() ) {
                continue;
            }
 
            $group = $handle->getGroup();
            if ( !$group instanceof WikiPageMessageGroup ) {
                continue;
            }
 
            $language = $handle->getCode();
 
            // Ignore pages such as Translations:Page/unit without language code
            if ( (string)$language === '' ) {
                continue;
            }
 
            // Update the page only once if source and destination units
            // belong to the same page
            if ( $group !== $groupLast ) {
                $groupLast = $group;
                $page = TranslatablePage::newFromTitle( $group->getTitle() );
                self::updateTranslationPage( $page, $language, $user, 0, $reason );
            }
        }
    }
 
    public static function onDeleteTranslationUnit(
        WikiPage $unit,
        User $user,
        $reason,
        $id,
        $content,
        $logEntry
    ) {
        // Do the update. In case job queue is doing the work, the update is not done here
        if ( self::$jobQueueRunning ) {
            return;
        }
 
        $title = $unit->getTitle();
 
        $handle = new MessageHandle( $title );
        if ( !$handle->isValid() ) {
            return;
        }
 
        $group = $handle->getGroup();
        if ( !$group instanceof WikiPageMessageGroup ) {
            return;
        }
 
        $target = $group->getTitle();
        $langCode = $handle->getCode();
        $fname = __METHOD__;
 
        $dbw = MediaWikiServices::getInstance()->getDBLoadBalancer()->getConnection( DB_PRIMARY );
        $callback = function () use (
            $dbw,
            $target,
            $handle,
            $langCode,
            $user,
            $reason,
            $fname
        ) {
            $translationPageTitle = $target->getSubpage( $langCode );
            // Do a more thorough check for the translation page in case the translation page is deleted in a
            // different transaction.
            if ( !$translationPageTitle || !$translationPageTitle->exists( Title::READ_LATEST ) ) {
                return;
            }
 
            $dbw->startAtomic( $fname );
 
            $page = TranslatablePage::newFromTitle( $target );
 
            MessageGroupStats::forItem(
                $page->getMessageGroupId(),
                $langCode,
                MessageGroupStats::FLAG_NO_CACHE
            );
 
            if ( !$handle->isDoc() ) {
                $unitTitle = $handle->getTitle();
                // Assume that $user and $reason for the first deletion is the same for all
                self::updateTranslationPage(
                    $page, $langCode, $user, 0, $reason, RenderTranslationPageJob::ACTION_DELETE, $unitTitle
                );
            }
 
            $dbw->endAtomic( $fname );
        };
 
        $dbw->onTransactionCommitOrIdle( $callback, __METHOD__ );
    }
}