MessageHandle.php

Go to the documentation of this file.

<?php
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroups;
use MediaWiki\Extension\Translate\MessageGroupProcessing\RevTagStore;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
 
class MessageHandle {
    protected $title;
    protected $key;
    protected $code;
    protected $groupIds;
 
    public function __construct( LinkTarget $title ) {
        $this->title = $title;
    }
 
    public function isMessageNamespace() {
        global $wgTranslateMessageNamespaces;
        $namespace = $this->title->getNamespace();
 
        return in_array( $namespace, $wgTranslateMessageNamespaces );
    }
 
    public function figureMessage() {
        if ( $this->key === null ) {
            // Check if this is a valid message first
            $this->key = $this->title->getDBkey();
            $known = MessageIndex::singleton()->getGroupIds( $this ) !== [];
 
            $pos = strrpos( $this->key, '/' );
            if ( $known || $pos === false ) {
                $this->code = '';
            } else {
                // For keys like Foo/, substr returns false instead of ''
                $this->code = (string)( substr( $this->key, $pos + 1 ) );
                $this->key = substr( $this->key, 0, $pos );
            }
        }
 
        return [ $this->key, $this->code ];
    }
 
    public function getKey() {
        $this->figureMessage();
 
        return $this->key;
    }
 
    public function getCode() {
        $this->figureMessage();
 
        return $this->code;
    }
 
    public function getEffectiveLanguage() {
        $code = $this->getCode();
        $mwInstance = MediaWikiServices::getInstance();
        if ( !$mwInstance->getLanguageNameUtils()->isKnownLanguageTag( $code ) ||
            $this->isDoc()
        ) {
            return $mwInstance->getContentLanguage();
        }
 
        return $mwInstance->getLanguageFactory()->getLanguage( $code );
    }
 
    public function isDoc() {
        global $wgTranslateDocumentationLanguageCode;
 
        return $this->getCode() === $wgTranslateDocumentationLanguageCode;
    }
 
    public function isPageTranslation() {
        return $this->title->inNamespace( NS_TRANSLATIONS );
    }
 
    public function getGroupIds() {
        if ( $this->groupIds === null ) {
            $this->groupIds = MessageIndex::singleton()->getGroupIds( $this );
        }
 
        return $this->groupIds;
    }
 
    public function getGroup() {
        $ids = $this->getGroupIds();
        if ( !isset( $ids[0] ) ) {
            throw new BadMethodCallException( 'called before isValid' );
        }
 
        return MessageGroups::getGroup( $ids[0] );
    }
 
    public function isValid() {
        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( 'Translate' );
            $logger->warning(
                '[MessageHandle] MessageIndex is out of date. Page {pagename} refers to ' .
                'unknown group {messagegroup}',
                [
                    'pagename' => $this->getTitle()->getPrefixedText(),
                    'messagegroup' => $groups[0],
                ]
            );
 
            // Schedule a job in the job queue (with deduplication)
            $job = MessageIndexRebuildJob::newJob();
            MediaWikiServices::getInstance()->getJobQueueGroup()->push( $job );
 
            return false;
        }
 
        return true;
    }
 
    public function getTitle() {
        return Title::newFromLinkTarget( $this->title );
    }
 
    public function getTitleForLanguage( $code ) {
        return Title::makeTitle(
            $this->title->getNamespace(),
            $this->getKey() . "/$code"
        );
    }
 
    public function getTitleForBase() {
        return Title::makeTitle(
            $this->title->getNamespace(),
            $this->getKey()
        );
    }
 
    public static function hasFuzzyString( $text ) {
        return str_contains( $text, TRANSLATE_FUZZY );
    }
 
    public static function makeFuzzyString( string $text ): string {
        return self::hasFuzzyString( $text ) ? $text : TRANSLATE_FUZZY . $text;
    }
 
    public function isFuzzy() {
        $dbr = wfGetDB( DB_REPLICA );
 
        $tables = [ 'page', 'revtag' ];
        $field = 'rt_type';
        $conds = [
            'page_namespace' => $this->title->getNamespace(),
            'page_title' => $this->title->getDBkey(),
            'rt_type' => RevTagStore::FUZZY_TAG,
            'page_id=rt_page',
            'page_latest=rt_revision'
        ];
 
        $res = $dbr->selectField( $tables, $field, $conds, __METHOD__ );
 
        return $res !== false;
    }
 
    public function getInternalKey(): string {
        $nsInfo = MediaWikiServices::getInstance()->getNamespaceInfo();
        $contentLanguage = MediaWikiServices::getInstance()->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";
    }
}