TranslateUtils.php

Go to the documentation of this file.

<?php
use MediaWiki\Extension\Translate\PageTranslation\Hooks as PageTranslationHooks;
use MediaWiki\MediaWikiServices;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\SlotRecord;
 
class TranslateUtils {
    public static function title( $message, $code, $ns = NS_MEDIAWIKI ) {
        // Cache some amount of titles for speed.
        static $cache = [];
        $key = $ns . ':' . $message;
 
        if ( !isset( $cache[$key] ) ) {
            $cache[$key] = Title::capitalize( $message, $ns );
        }
 
        if ( $code ) {
            return $cache[$key] . '/' . $code;
        } else {
            return $cache[$key];
        }
    }
 
    public static function figureMessage( $text ) {
        $pos = strrpos( $text, '/' );
        $code = substr( $text, $pos + 1 );
        $key = substr( $text, 0, $pos );
 
        return [ $key, $code ];
    }
 
    public static function getMessageContent( $key, $language, $namespace = NS_MEDIAWIKI ) {
        $title = self::title( $key, $language, $namespace );
        $data = self::getContents( [ $title ], $namespace );
 
        return $data[$title][0] ?? null;
    }
 
    public static function getContents( $titles, $namespace ) {
        $dbr = wfGetDB( DB_REPLICA );
        $revStore = MediaWikiServices::getInstance()->getRevisionStore();
        $titleContents = [];
 
        $query = $revStore->getQueryInfo( [ 'page', 'user' ] );
        $rows = $dbr->select(
            $query['tables'],
            $query['fields'],
            [
                'page_namespace' => $namespace,
                'page_title' => $titles,
                'page_latest=rev_id',
            ],
            __METHOD__,
            [],
            $query['joins']
        );
 
        $revisions = $revStore->newRevisionsFromBatch( $rows, [
            'slots' => true,
            'content' => true
        ] )->getValue();
 
        foreach ( $rows as $row ) {
            $rev = $revisions[$row->rev_id];
            if ( $rev ) {
                $content = $rev->getContent( SlotRecord::MAIN );
                if ( $content ) {
                    $titleContents[$row->page_title] = [
                        $content->getText(),
                        $row->rev_user_text
                    ];
                }
            }
        }
 
        $rows->free();
 
        return $titleContents;
    }
 
    public static function getContentForTitle( Title $title, $addFuzzy = false ): ?string {
        $store = MediaWikiServices::getInstance()->getRevisionStore();
        $revision = $store->getRevisionByTitle( $title );
 
        if ( $revision === null ) {
            return null;
        }
 
        $content = $revision->getContent( SlotRecord::MAIN );
        $wiki = ( $content instanceof TextContent ) ? $content->getText() : null;
 
        // Either unexpected content type, or the revision content is hidden
        if ( $wiki === null ) {
            return null;
        }
 
        if ( $addFuzzy ) {
            $handle = new MessageHandle( $title );
            if ( $handle->isFuzzy() ) {
                $wiki = TRANSLATE_FUZZY . str_replace( TRANSLATE_FUZZY, '', $wiki );
            }
        }
 
        return $wiki;
    }
 
    public static function translationChanges(
        $hours = 24, $bots = false, $ns = null, array $extraFields = []
    ) {
        global $wgTranslateMessageNamespaces;
 
        $dbr = wfGetDB( DB_REPLICA );
 
        $hours = (int)$hours;
        $cutoff_unixtime = time() - ( $hours * 3600 );
        $cutoff = $dbr->timestamp( $cutoff_unixtime );
 
        $conds = [
            'rc_timestamp >= ' . $dbr->addQuotes( $cutoff ),
            'rc_namespace' => $ns ?: $wgTranslateMessageNamespaces,
        ];
        if ( $bots ) {
            $conds['rc_bot'] = 0;
        }
 
        $res = $dbr->select(
            [ 'recentchanges', 'actor' ],
            array_merge( [
                'rc_namespace', 'rc_title', 'rc_timestamp',
                'rc_user_text' => 'actor_name',
            ], $extraFields ),
            $conds,
            __METHOD__,
            [],
            [ 'actor' => [ 'JOIN', 'actor_id=rc_actor' ] ]
        );
        $rows = iterator_to_array( $res );
 
        // Calculate 'lang', then sort by it and rc_timestamp
        foreach ( $rows as &$row ) {
            $pos = strrpos( $row->rc_title, '/' );
            $row->lang = $pos === false ? $row->rc_title : substr( $row->rc_title, $pos + 1 );
        }
        unset( $row );
 
        usort( $rows, static function ( $a, $b ) {
            $x = strcmp( $a->lang, $b->lang );
            if ( !$x ) {
                // descending order
                $x = strcmp(
                    wfTimestamp( TS_MW, $b->rc_timestamp ),
                    wfTimestamp( TS_MW, $a->rc_timestamp )
                );
            }
            return $x;
        } );
 
        return $rows;
    }
 
    /* Some other helpers for output */
 
    public static function getLanguageName( $code, $language = 'en' ) {
        $languages = self::getLanguageNames( $language );
        return $languages[$code] ?? $code;
    }
 
    public static function languageSelector( $language, $selectedId ) {
        $selector = self::getLanguageSelector( $language );
        $selector->setDefault( $selectedId );
        $selector->setAttribute( 'id', 'language' );
        $selector->setAttribute( 'name', 'language' );
 
        return $selector->getHTML();
    }
 
    public static function getLanguageSelector( $language, $labelOption = false ) {
        $languages = self::getLanguageNames( $language );
        ksort( $languages );
 
        $selector = new XmlSelect();
        if ( $labelOption !== false ) {
            $selector->addOption( $labelOption, '-' );
        }
 
        foreach ( $languages as $code => $name ) {
            $selector->addOption( "$code - $name", $code );
        }
 
        return $selector;
    }
 
    public static function getLanguageNames( $code ) {
        $languageNames = MediaWikiServices::getInstance()->getLanguageNameUtils()->getLanguageNames( $code );
 
        $deprecatedCodes = LanguageCode::getDeprecatedCodeMapping();
        foreach ( array_keys( $deprecatedCodes ) as $deprecatedCode ) {
            unset( $languageNames[ $deprecatedCode ] );
        }
 
        Hooks::run( 'TranslateSupportedLanguages', [ &$languageNames, $code ] );
 
        return $languageNames;
    }
 
    public static function messageKeyToGroup( $namespace, $key ) {
        $groups = self::messageKeyToGroups( $namespace, $key );
 
        return count( $groups ) ? $groups[0] : null;
    }
 
    public static function messageKeyToGroups( $namespace, $key ) {
        $mi = MessageIndex::singleton()->retrieve();
        $normkey = self::normaliseKey( $namespace, $key );
 
        if ( isset( $mi[$normkey] ) ) {
            return (array)$mi[$normkey];
        } else {
            return [];
        }
    }
 
    public static function normaliseKey( $namespace, $key ) {
        $key = lcfirst( $key );
 
        return strtr( "$namespace:$key", ' ', '_' );
    }
 
    public static function fieldset( $legend, $contents, array $attributes = [] ) {
        return Xml::openElement( 'fieldset', $attributes ) .
            Xml::tags( 'legend', null, $legend ) . $contents .
            Xml::closeElement( 'fieldset' );
    }
 
    public static function convertWhiteSpaceToHTML( $message ) {
        $msg = htmlspecialchars( $message );
        $msg = preg_replace( '/^ /m', '&#160;', $msg );
        $msg = preg_replace( '/ $/m', '&#160;', $msg );
        $msg = preg_replace( '/  /', '&#160; ', $msg );
        $msg = str_replace( "\n", '<br />', $msg );
 
        return $msg;
    }
 
    public static function assetPath( $path ) {
        global $wgExtensionAssetsPath;
        return "$wgExtensionAssetsPath/Translate/$path";
    }
 
    public static function cacheFile( $filename ) {
        global $wgTranslateCacheDirectory, $wgCacheDirectory;
 
        if ( $wgTranslateCacheDirectory !== false ) {
            $dir = $wgTranslateCacheDirectory;
        } elseif ( $wgCacheDirectory !== false ) {
            $dir = $wgCacheDirectory;
        } else {
            throw new MWException( "\$wgCacheDirectory must be configured" );
        }
 
        return "$dir/$filename";
    }
 
    public static function getPlaceholder() {
        static $i = 0;
 
        return "\x7fUNIQ" . dechex( mt_rand( 0, 0x7fffffff ) ) .
            dechex( mt_rand( 0, 0x7fffffff ) ) . '-' . $i++;
    }
 
    public static function getIcon( MessageGroup $g, $size ) {
        $icon = $g->getIcon();
        if ( substr( $icon, 0, 7 ) !== 'wiki://' ) {
            return null;
        }
 
        $formats = [];
 
        $filename = substr( $icon, 7 );
        $file = MediaWikiServices::getInstance()->getRepoGroup()->findFile( $filename );
        if ( !$file ) {
            wfWarn( "Unknown message group icon file $icon" );
 
            return null;
        }
 
        if ( $file->isVectorized() ) {
            $formats['vector'] = $file->getFullUrl();
        }
 
        $formats['raster'] = $file->createThumb( $size, $size );
 
        return $formats;
    }
 
    public static function getSafeReadDB() {
        $lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
        $index = self::shouldReadFromPrimary() ? DB_PRIMARY : DB_REPLICA;
 
        return $lb->getConnectionRef( $index );
    }
 
    public static function shouldReadFromPrimary() {
        $lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
        // Parsing APIs need POST for payloads but are read-only, so avoid spamming
        // the primary then. No good way to check this at the moment...
        if ( PageTranslationHooks::$renderingContext ) {
            return false;
        }
 
        return PHP_SAPI === 'cli' ||
            RequestContext::getMain()->getRequest()->wasPosted() ||
            $lb->hasOrMadeRecentPrimaryChanges();
    }
 
    public static function getEditorUrl( MessageHandle $handle ) {
        if ( !$handle->isValid() ) {
            return $handle->getTitle()->getLocalURL( [ 'action' => 'edit' ] );
        }
 
        $title = MediaWikiServices::getInstance()
            ->getSpecialPageFactory()->getPage( 'Translate' )->getPageTitle();
        return $title->getFullURL( [
            'showMessage' => $handle->getInternalKey(),
            'group' => $handle->getGroup()->getId(),
            'language' => $handle->getCode(),
        ] );
    }
 
    public static function serialize( $value ) {
        return serialize( $value );
    }
 
    public static function deserialize( $str, $opts = [ 'allowed_classes' => false ] ) {
        return unserialize( $str, $opts );
    }
 
    public static function getVersion(): string {
        // Avoid parsing JSON multiple time per request
        static $version = null;
        if ( $version === null ) {
            $version = json_decode( file_get_contents( __DIR__ . '/extension.json' ) )->version;
        }
        return $version;
    }
 
    public static function allowsSubpages( Title $title ): bool {
        $mwInstance = MediaWikiServices::getInstance();
        $namespaceInfo = $mwInstance->getNamespaceInfo();
        return $namespaceInfo->hasSubpages( $title->getNamespace() );
    }
 
    public static function isSupportedLanguageCode( string $code ): bool {
        $all = self::getLanguageNames( null );
        return isset( $all[ $code ] );
    }
 
    public static function getTextFromTextContent( ?Content $content ): string {
        if ( !$content ) {
            throw new UnexpectedValueException( 'Expected $content to be TextContent, got null instead.' );
        }
 
        if ( $content instanceof TextContent ) {
            return $content->getText();
        }
 
        throw new UnexpectedValueException( 'Expected $content to be TextContent, but got ' . get_class( $content ) );
    }
 
    public static function getTranslations( MessageHandle $handle ): array {
        $namespace = $handle->getTitle()->getNamespace();
        $base = $handle->getKey();
 
        $dbr = MediaWikiServices::getInstance()
            ->getDBLoadBalancer()
            ->getConnection( DB_REPLICA );
 
        $titles = $dbr->newSelectQueryBuilder()
            ->select( 'page_title' )
            ->from( 'page' )
            ->where( [
                'page_namespace' => $namespace,
                'page_title ' . $dbr->buildLike( "$base/", $dbr->anyString() ),
            ] )
            ->caller( __METHOD__ )
            ->orderBy( 'page_title' )
            ->fetchFieldValues();
 
        if ( $titles === [] ) {
            return [];
        }
 
        $pageInfo = self::getContents( $titles, $namespace );
 
        return $pageInfo;
    }
}