MessageHandle.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\MessageLoading;
 
use BadMethodCallException;
use MediaWiki\Extension\Translate\LogNames;
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroups;
use MediaWiki\Extension\Translate\MessageGroupProcessing\RevTagStore;
use MediaWiki\Extension\Translate\Services;
use MediaWiki\Language\Language;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use MediaWiki\Title\Title;
use MessageGroup;
use RuntimeException;
 
class MessageHandle {
    private LinkTarget $title;
    private ?string $key = null;
    private ?string $languageCode = null;
    private ?array $groupIds = null;
    private MessageIndex $messageIndex;
 
    public function __construct( LinkTarget $title ) {
        $this->title = $title;
        $this->messageIndex = Services::getInstance()->getMessageIndex();
    }
 
    public function isMessageNamespace(): bool {
        global $wgTranslateMessageNamespaces;
        $namespace = $this->title->getNamespace();
 
        return in_array( $namespace, $wgTranslateMessageNamespaces );
    }
 
    public function figureMessage(): array {
        if ( $this->key === null ) {
            // Check if this is a valid message first
            $this->key = $this->title->getDBkey();
            $known = $this->messageIndex->getGroupIds( $this ) !== [];
 
            $pos = strrpos( $this->key, '/' );
            if ( $known || $pos === false ) {
                $this->languageCode = '';
            } else {
                $this->languageCode = substr( $this->key, $pos + 1 );
                $this->key = substr( $this->key, 0, $pos );
            }
        }
 
        return [ $this->key, $this->languageCode ];
    }
 
    public function getKey(): string {
        $this->figureMessage();
 
        return $this->key;
    }
 
    public function getCode(): string {
        $this->figureMessage();
 
        return $this->languageCode;
    }
 
    public function getEffectiveLanguage(): Language {
        $code = $this->getCode();
        $mwServices = MediaWikiServices::getInstance();
        if ( !$mwServices->getLanguageNameUtils()->isKnownLanguageTag( $code ) ||
            $this->isDoc()
        ) {
            return $mwServices->getContentLanguage();
        }
 
        return $mwServices->getLanguageFactory()->getLanguage( $code );
    }
 
    public function isDoc(): bool {
        global $wgTranslateDocumentationLanguageCode;
 
        return $this->getCode() === $wgTranslateDocumentationLanguageCode;
    }
 
    public function isPageTranslation(): bool {
        return $this->title->inNamespace( NS_TRANSLATIONS );
    }
 
    public function getGroupIds() {
        if ( $this->groupIds === null ) {
            $this->groupIds = $this->messageIndex->getGroupIds( $this );
        }
 
        return $this->groupIds;
    }
 
    public function getGroup(): ?MessageGroup {
        $ids = $this->getGroupIds();
        if ( !isset( $ids[0] ) ) {
            throw new BadMethodCallException( 'called before isValid' );
        }
        return MessageGroups::getGroup( $ids[0] );
    }
 
    public function isValid(): bool {
        static $jobHasBeenScheduled = false;
 
        if ( !$this->isMessageNamespace() ) {
            return false;
        }
 
        $groups = $this->getGroupIds();
        if ( !$groups ) {
            return false;
        }
 
        // Do another check that the group actually exists
        $group = $this->getGroup();
        if ( !$group ) {
            $logger = LoggerFactory::getInstance( LogNames::MAIN );
            $logger->warning(
                '[MessageHandle] MessageIndex is out of date. Page {pagename} refers to ' .
                'unknown group {messagegroup}',
                [
                    'pagename' => $this->getTitle()->getPrefixedText(),
                    'messagegroup' => $groups[0],
                    'exception' => new RuntimeException(),
                    'hasJobBeenScheduled' => $jobHasBeenScheduled
                ]
            );
 
            if ( !$jobHasBeenScheduled ) {
                // Schedule a job in the job queue (with deduplication)
                $job = RebuildMessageIndexJob::newJob( __METHOD__ );
                MediaWikiServices::getInstance()->getJobQueueGroup()->lazyPush( $job );
                $jobHasBeenScheduled = true;
            }
 
            return false;
        }
 
        return true;
    }
 
    public function getTitle(): Title {
        return Title::newFromLinkTarget( $this->title );
    }
 
    public function getTitleForLanguage( string $languageCode ): Title {
        return Title::makeTitle(
            $this->title->getNamespace(),
            $this->getKey() . "/$languageCode"
        );
    }
 
    public function getTitleForBase(): Title {
        return Title::makeTitle(
            $this->title->getNamespace(),
            $this->getKey()
        );
    }
 
    public static function hasFuzzyString( string $text ): bool {
        return str_contains( $text, TRANSLATE_FUZZY );
    }
 
    public static function makeFuzzyString( string $text ): string {
        return self::hasFuzzyString( $text ) ? $text : TRANSLATE_FUZZY . $text;
    }
 
    public function isFuzzy(): bool {
        $dbr = MediaWikiServices::getInstance()->getDBLoadBalancer()->getConnection( DB_REPLICA );
 
        $res = $dbr->newSelectQueryBuilder()
            ->select( 'rt_type' )
            ->from( 'page' )
            ->join( 'revtag', null, [
                'page_id=rt_page',
                'page_latest=rt_revision',
                'rt_type' => RevTagStore::FUZZY_TAG,
            ] )
            ->where( [
                'page_namespace' => $this->title->getNamespace(),
                'page_title' => $this->title->getDBkey(),
            ] )
            ->caller( __METHOD__ )
            ->fetchField();
 
        return $res !== false;
    }
 
    public function getInternalKey(): string {
        $mwServices = MediaWikiServices::getInstance();
        $nsInfo = $mwServices->getNamespaceInfo();
        $contentLanguage = $mwServices->getContentLanguage();
 
        $key = $this->getKey();
        $group = $this->getGroup();
        $groupKeys = $group->getKeys();
 
        if ( in_array( $key, $groupKeys, true ) ) {
            return $key;
        }
 
        $namespace = $this->title->getNamespace();
        if ( $nsInfo->isCapitalized( $namespace ) ) {
            $lowercaseKey = $contentLanguage->lcfirst( $key );
            if ( in_array( $lowercaseKey, $groupKeys, true ) ) {
                return $lowercaseKey;
            }
        }
 
        // Brute force all the keys to find the one. This one should always find a match
        // if there is one.
        foreach ( $groupKeys as $haystackKey ) {
            $normalizedHaystackKey = Title::makeTitleSafe( $namespace, $haystackKey )->getDBkey();
            if ( $normalizedHaystackKey === $key ) {
                return $haystackKey;
            }
        }
 
        return "BUG:$key";
    }
 
    public function needsFuzzy( string $text ): bool {
        // Docs are exempt for checks
        if ( $this->isDoc() ) {
            return false;
        }
 
        // Check for explicit tag.
        if ( self::hasFuzzyString( $text ) ) {
            return true;
        }
 
        // Not all groups have validators
        $group = $this->getGroup();
        $validator = $group->getValidator();
 
        // no validator set
        if ( !$validator ) {
            return false;
        }
 
        $code = $this->getCode();
        $key = $this->getKey();
        $en = $group->getMessage( $key, $group->getSourceLanguage() );
        $message = new FatMessage( $key, $en );
        // Take the contents from edit field as a translation.
        $message->setTranslation( $text );
        if ( $message->rawDefinition() === null ) {
            // This should NOT happen, but add a check since it seems to be happening
            // See: https://phabricator.wikimedia.org/T255669
            LoggerFactory::getInstance( LogNames::MAIN )->warning(
                'Message definition is empty! Title: {title}, group: {group}, key: {key}',
                [
                    'title' => $this->getTitle()->getPrefixedText(),
                    'group' => $group->getId(),
                    'key' => $key
                ]
            );
            return false;
        }
 
        $validationResult = $validator->quickValidate( $message, $code );
        return $validationResult->hasIssues();
    }
}