FuzzyTranslationsMaintenanceScript.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\Diagnostics;
 
use ContentHandler;
use IDBAccessObject;
use MediaWiki\CommentStore\CommentStoreComment;
use MediaWiki\Extension\Translate\SystemUsers\FuzzyBot;
use MediaWiki\Extension\Translate\Utilities\BaseMaintenanceScript;
use MediaWiki\Extension\Translate\Utilities\Utilities;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Title\Title;
use MediaWiki\User\ActorMigration;
use MediaWiki\User\User;
use MediaWiki\User\UserFactory;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\IResultWrapper;
 
class FuzzyTranslationsMaintenanceScript extends BaseMaintenanceScript {
    private ActorMigration $actorMigration;
    private UserFactory $userFactory;
    private RevisionStore $revisionStore;
    private ILoadBalancer $DBLoadBalancer;
    private WikiPageFactory $wikiPageFactory;
 
    public function __construct() {
        parent::__construct();
        $this->addDescription( 'Fuzzy bot command line script.' );
        $this->addArg(
            'arg',
            'Title pattern or username if user option is provided.'
        );
        $this->addOption(
            'really',
            '(optional) Really fuzzy, no dry-run'
        );
        $this->addOption(
            'skiplanguages',
            '(optional) Skip some languages (comma separated)',
            self::OPTIONAL,
            self::HAS_ARG
        );
        $this->addOption(
            'comment',
            '(optional) Comment for updating',
            self::OPTIONAL,
            self::HAS_ARG
        );
        $this->addOption(
            'user',
            '(optional) Fuzzy the translations made by user given as an argument.',
            self::OPTIONAL,
            self::NO_ARG
        );
        $this->requireExtension( 'Translate' );
    }
 
    private function initServices(): void {
        $mwServices = MediaWikiServices::getInstance();
        $this->actorMigration = $mwServices->getActorMigration();
        $this->userFactory = $mwServices->getUserFactory();
        $this->revisionStore = $mwServices->getRevisionStore();
        $this->DBLoadBalancer = $mwServices->getDBLoadBalancer();
        $this->wikiPageFactory = $mwServices->getWikiPageFactory();
    }
 
    public function execute(): void {
        $this->initServices();
 
        $skipLanguages = [];
        if ( $this->hasOption( 'skiplanguages' ) ) {
            $skipLanguages = array_map(
                'trim',
                explode( ',', $this->getOption( 'skiplanguages' ) )
            );
        }
 
        if ( $this->hasOption( 'user' ) ) {
            $user = $this->userFactory->newFromName( $this->getArg( 0 ) );
            $pages = $this->getPagesForUser( $user, $skipLanguages );
        } else {
            $pages = $this->getPagesForPattern( $this->getArg( 0 ), $skipLanguages );
        }
 
        $dryrun = !$this->hasOption( 'really' );
        $comment = $this->getOption( 'comment' );
        $this->fuzzyTranslations( $pages, $dryrun, $comment );
    }
 
    private function fuzzyTranslations( array $pages, bool $dryrun, ?string $comment ): void {
        $count = count( $pages );
        $this->output( "Found $count pages to update.", 'pagecount' );
 
        foreach ( $pages as [ $title, $text ] ) {
            $this->updateMessage( $title, TRANSLATE_FUZZY . $text, $dryrun, $comment );
        }
    }
 
    private function getMessageContentsFromRows( IResultWrapper $rows ): array {
        $messagesContents = [];
        $slots = $this->revisionStore->getContentBlobsForBatch( $rows, [ SlotRecord::MAIN ] )->getValue();
        foreach ( $rows as $row ) {
            $title = Title::makeTitle( $row->page_namespace, $row->page_title );
            if ( isset( $slots[$row->rev_id] ) ) {
                $text = $slots[$row->rev_id][SlotRecord::MAIN]->blob_data;
            } else {
                $content = $this->revisionStore
                    ->newRevisionFromRow( $row, IDBAccessObject::READ_NORMAL, $title )
                    ->getContent( SlotRecord::MAIN );
                $text = Utilities::getTextFromTextContent( $content );
            }
            $messagesContents[] = [ $title, $text ];
        }
        return $messagesContents;
    }
 
    private function getPagesForPattern( string $pattern, array $skipLanguages = [] ): array {
        $dbr = $this->DBLoadBalancer->getMaintenanceConnectionRef( DB_REPLICA );
 
        $conds = [
            'page_latest=rev_id',
        ];
 
        $title = Title::newFromText( $pattern );
        if ( $title->inNamespace( NS_MAIN ) ) {
            $namespace = $this->getConfig()->get( 'TranslateMessageNamespaces' );
        } else {
            $namespace = $title->getNamespace();
        }
 
        $conds['page_namespace'] = $namespace;
        $conds[] = 'page_title' . $dbr->buildLike( $title->getDBkey(), $dbr->anyString() );
 
        if ( count( $skipLanguages ) ) {
            $skiplist = $dbr->makeList( $skipLanguages );
            $conds[] = "substring_index(page_title, '/', -1) NOT IN ($skiplist)";
        }
 
        $rows = $this->revisionStore->newSelectQueryBuilder( $dbr )
            ->joinPage()
            ->where( $conds )
            ->caller( __METHOD__ )
            ->fetchResultSet();
        return $this->getMessageContentsFromRows( $rows );
    }
 
    private function getPagesForUser( User $user, array $skipLanguages = [] ): array {
        $dbr = $this->DBLoadBalancer->getMaintenanceConnectionRef( DB_REPLICA );
 
        $revWhere = $this->actorMigration->getWhere( $dbr, 'rev_user', $user );
        $conds = [
            'page_latest=rev_id',
            $revWhere['conds'],
            'page_namespace' => $this->getConfig()->get( 'TranslateMessageNamespaces' ),
            'page_title' . $dbr->buildLike( $dbr->anyString(), '/', $dbr->anyString() ),
        ];
        if ( count( $skipLanguages ) ) {
            $skiplist = $dbr->makeList( $skipLanguages );
            $conds[] = "substring_index(page_title, '/', -1) NOT IN ($skiplist)";
        }
 
        $rows = $this->revisionStore->newSelectQueryBuilder( $dbr )
            ->joinPage()
            ->joinUser()
            ->where( $conds )
            ->caller( __METHOD__ )
            ->fetchResultSet();
 
        return $this->getMessageContentsFromRows( $rows );
    }
 
    private function updateMessage( Title $title, string $text, bool $dryrun, ?string $comment = null ) {
        $this->output( "Updating {$title->getPrefixedText()}... ", $title );
 
        $documentationLanguageCode = $this->getConfig()->get( 'TranslateDocumentationLanguageCode' );
        $items = explode( '/', $title->getText(), 2 );
        if ( isset( $items[1] ) && $items[1] === $documentationLanguageCode ) {
            $this->output( 'IGNORED!', $title );
 
            return;
        }
 
        if ( $dryrun ) {
            $this->output( 'DRY RUN!', $title );
 
            return;
        }
 
        $wikiPage = $this->wikiPageFactory->newFromTitle( $title );
        $summary = CommentStoreComment::newUnsavedComment( $comment ?? 'Marking as fuzzy' );
        $content = ContentHandler::makeContent( $text, $title );
        $updater = $wikiPage->newPageUpdater( FuzzyBot::getUser() );
        $updater
            ->setContent( SlotRecord::MAIN, $content )
            ->saveRevision( $summary, EDIT_FORCE_BOT | EDIT_UPDATE );
        $status = $updater->getStatus();
 
        $this->output( $status->isOK() ? 'OK' : 'FAILED', $title );
    }
}