Utilities.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\Utilities;
 
use ConfigException;
use Content;
use LanguageCode;
use MediaWiki\Extension\Translate\PageTranslation\Hooks as PageTranslationHooks;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePage;
use MediaWiki\Extension\Translate\Services;
use MediaWiki\Languages\LanguageNameUtils;
use MediaWiki\MediaWikiServices;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\SlotRecord;
use MessageGroup;
use MessageHandle;
use RequestContext;
use TextContent;
use Title;
use UnexpectedValueException;
use Wikimedia\Rdbms\IDatabase;
use Xml;
use XmlSelect;
 
class Utilities {
    public static function title( string $message, string $code, int $ns = NS_MEDIAWIKI ): string {
        // 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( string $text ): array {
        $pos = strrpos( $text, '/' );
        $code = substr( $text, $pos + 1 );
        $key = substr( $text, 0, $pos );
 
        return [ $key, $code ];
    }
 
    public static function getMessageContent( string $key, string $language, int $namespace = NS_MEDIAWIKI ): ?string {
        $title = self::title( $key, $language, $namespace );
        $data = self::getContents( [ $title ], $namespace );
 
        return $data[$title][0] ?? null;
    }
 
    public static function getContents( $titles, int $namespace ): array {
        $mwServices = MediaWikiServices::getInstance();
        $dbr = $mwServices->getDBLoadBalancer()->getConnection( DB_REPLICA );
        $revStore = $mwServices->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, bool $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;
    }
 
    /* Some other helpers for output */
 
    public static function getLanguageName( string $code, ?string $language = 'en' ): string {
        $languages = self::getLanguageNames( $language );
        return $languages[$code] ?? $code;
    }
 
    // TODO remove languageSelector() after Sunsetting of TranslateSvg extension
 
    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, ?string $labelOption = null ) {
        $languages = self::getLanguageNames( $language );
        ksort( $languages );
 
        $selector = new XmlSelect();
        if ( $labelOption !== null ) {
            $selector->addOption( $labelOption, '-' );
        }
 
        foreach ( $languages as $code => $name ) {
            $selector->addOption( "$code - $name", $code );
        }
 
        return $selector;
    }
 
    public static function getLanguageNames( ?string $code ): array {
        $mwServices = MediaWikiServices::getInstance();
        $languageNames = $mwServices->getLanguageNameUtils()->getLanguageNames( $code );
 
        $deprecatedCodes = LanguageCode::getDeprecatedCodeMapping();
        foreach ( array_keys( $deprecatedCodes ) as $deprecatedCode ) {
            unset( $languageNames[ $deprecatedCode ] );
        }
        Services::getInstance()->getHookRunner()->onTranslateSupportedLanguages( $languageNames, $code );
 
        return $languageNames;
    }
 
    public static function messageKeyToGroup( int $namespace, string $key ): ?string {
        $groups = self::messageKeyToGroups( $namespace, $key );
 
        return count( $groups ) ? $groups[0] : null;
    }
 
    public static function messageKeyToGroups( int $namespace, string $key ): array {
        $mi = Services::getInstance()->getMessageIndex()->retrieve();
        $normkey = self::normaliseKey( $namespace, $key );
 
        if ( isset( $mi[$normkey] ) ) {
            return (array)$mi[$normkey];
        } else {
            return [];
        }
    }
 
    public static function normaliseKey( int $namespace, string $key ): string {
        $key = lcfirst( $key );
 
        return strtr( "$namespace:$key", ' ', '_' );
    }
 
    public static function fieldset( string $legend, string $contents, array $attributes = [] ): string {
        return Xml::openElement( 'fieldset', $attributes ) .
            Xml::tags( 'legend', null, $legend ) . $contents .
            Xml::closeElement( 'fieldset' );
    }
 
    public static function convertWhiteSpaceToHTML( string $message ): string {
        $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 cacheFile( string $filename ): string {
        global $wgTranslateCacheDirectory, $wgCacheDirectory;
 
        if ( $wgTranslateCacheDirectory !== false ) {
            $dir = $wgTranslateCacheDirectory;
        } elseif ( $wgCacheDirectory !== false ) {
            $dir = $wgCacheDirectory;
        } else {
            throw new ConfigException( "\$wgCacheDirectory must be configured" );
        }
 
        return "$dir/$filename";
    }
 
    public static function getPlaceholder(): string {
        static $i = 0;
 
        return "\x7fUNIQ" . dechex( mt_rand( 0, 0x7fffffff ) ) .
            dechex( mt_rand( 0, 0x7fffffff ) ) . '-' . $i++;
    }
 
    public static function getIcon( MessageGroup $g, int $size ): ?array {
        $icon = $g->getIcon();
        if ( !$icon || 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(): IDatabase {
        $lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
        $index = self::shouldReadFromPrimary() ? DB_PRIMARY : DB_REPLICA;
 
        return $lb->getConnection( $index );
    }
 
    public static function shouldReadFromPrimary(): bool {
        $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 ): string {
        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 ): string {
        return serialize( $value );
    }
 
    public static function deserialize( string $str, array $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( LanguageNameUtils::AUTONYMS );
        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 [];
        }
 
        return self::getContents( $titles, $namespace );
    }
 
    public static function isTranslationPage( MessageHandle $handle ): bool {
        // FIXME: A lot of this code is similar to TranslatablePage::isTranslationPage.
        // See if they can be merged
        // The major difference is that this method does not run a database query to check if
        // the page is marked.
        $key = $handle->getKey();
        $languageCode = $handle->getCode();
        if ( $key === '' || $languageCode === '' ) {
            return false;
        }
 
        $baseTitle = Title::makeTitle( $handle->getTitle()->getNamespace(), $key );
        if ( !TranslatablePage::isSourcePage( $baseTitle ) ) {
            return false;
        }
 
        static $codes = null;
        if ( $codes === null ) {
            $codes = self::getLanguageNames( LanguageNameUtils::AUTONYMS );
        }
 
        return !$handle->isDoc() && isset( $codes[ $languageCode ] );
    }
}
 
class_alias( Utilities::class, 'TranslateUtils' );