Utilities.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\Utilities;
 
use MediaWiki\Config\ConfigException;
use MediaWiki\Content\Content;
use MediaWiki\Content\TextContent;
use MediaWiki\Context\RequestContext;
use MediaWiki\Extension\Translate\MessageLoading\MessageHandle;
use MediaWiki\Extension\Translate\PageTranslation\Hooks as PageTranslationHooks;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePage;
use MediaWiki\Extension\Translate\Services;
use MediaWiki\Html\Html;
use MediaWiki\Language\LanguageCode;
use MediaWiki\Language\LanguageNameUtils;
use MediaWiki\MediaWikiServices;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Title\Title;
use MessageGroup;
use UnexpectedValueException;
use Wikimedia\Rdbms\IReadableDatabase;
 
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;
    }
 
    private static function fetchLatestRevisionsByTitles( array $titles, int $namespace ): array {
        $mwServices = MediaWikiServices::getInstance();
        $dbr = $mwServices->getConnectionProvider()->getReplicaDatabase();
        $revStore = $mwServices->getRevisionStore();
 
        $rows = $revStore->newSelectQueryBuilder( $dbr )
            ->joinPage()
            ->joinComment()
            ->where( [ 'page_namespace' => $namespace, 'page_title' => $titles, 'page_latest=rev_id' ] )
            ->caller( __METHOD__ )
            ->fetchResultSet();
 
        $revisions = $revStore->newRevisionsFromBatch( $rows, [
            'slots' => true,
            'content' => true
        ] )->getValue();
 
        $result = [];
        foreach ( $rows as $row ) {
            $revision = $revisions[$row->rev_id] ?? null;
            if ( $revision !== null ) {
                $content = $revision->getContent( SlotRecord::MAIN );
                if ( $content instanceof TextContent ) {
                    $result[$row->page_title] = $revision;
                }
            }
        }
 
        $rows->free();
 
        return $result;
    }
 
    public static function getContents( $titles, int $namespace ): array {
        $titleContents = [];
        foreach ( self::fetchLatestRevisionsByTitles( (array)$titles, $namespace ) as $pageTitle => $revision ) {
            $user = $revision->getUser( RevisionRecord::FOR_PUBLIC );
            $titleContents[$pageTitle] = [
                self::getTextFromTextContent( $revision->getContent( SlotRecord::MAIN ) ),
                $user ? $user->getName() : '',
            ];
        }
 
        return $titleContents;
    }
 
    public static function getContentForTitle( Title $title, bool $addFuzzy = false ): ?string {
        $revision = MediaWikiServices::getInstance()->getRevisionStore()->getRevisionByTitle( $title );
        $wiki = self::getTextFromContentOrNull( $revision?->getContent( SlotRecord::MAIN ) );
        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;
    }
 
    public static function getLanguageNames( ?string $code ): array {
        $mwServices = MediaWikiServices::getInstance();
        $languageNames = array_diff_key(
            $mwServices->getLanguageNameUtils()->getLanguageNames( $code ),
            LanguageCode::getDeprecatedCodeMapping()
        );
        Services::getInstance()->getHookRunner()->onTranslateSupportedLanguages( $languageNames, $code );
 
        return $languageNames;
    }
 
    public static function fieldset( string $legend, string $contents, array $attributes = [] ): string {
        return Html::rawElement(
            'fieldset',
            $attributes,
            Html::rawElement( 'legend', [], $legend ) . $contents
        );
    }
 
    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(): IReadableDatabase {
        $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 $action_source = '',
        bool $includeLanguageParam = true
    ): string {
        if ( !$handle->isValid() ) {
            return $handle->getTitle()->getLocalURL( [ 'action' => 'edit' ] );
        }
 
        $title = MediaWikiServices::getInstance()
            ->getSpecialPageFactory()->getPage( 'Translate' )->getPageTitle();
        $urlParameters = [
            'showMessage' => $handle->getInternalKey(),
            'group' => $handle->getGroup()->getId(),
            'language' => $includeLanguageParam ? $handle->getCode() : null,
        ];
 
        if ( $action_source !== '' ) {
            $urlParameters[ 'action_source' ] = $action_source;
        }
 
        return $title->getFullURL( $urlParameters );
    }
 
    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;
        $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 getTextFromContentOrNull( ?Content $content ): ?string {
        return $content instanceof TextContent ? $content->getText() : null;
    }
 
    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 {
        $titleContents = [];
        foreach ( self::getTranslationRevisions( $handle ) as $pageTitle => $revision ) {
            $user = $revision->getUser( RevisionRecord::FOR_PUBLIC );
            $titleContents[$pageTitle] = [
                self::getTextFromTextContent( $revision->getContent( SlotRecord::MAIN ) ),
                $user ? $user->getName() : '',
            ];
        }
 
        return $titleContents;
    }
 
    public static function getTranslationRevisions( MessageHandle $handle ): array {
        $namespace = $handle->getTitle()->getNamespace();
        $base = $handle->getKey();
 
        $dbr = MediaWikiServices::getInstance()->getConnectionProvider()->getReplicaDatabase();
 
        $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 [];
        }
 
        // fetchLatestRevisionsByTitles may return results in a different order
        // (by rev_id or row insertion), so re-index in the original page_title order.
        $revisionsByTitle = self::fetchLatestRevisionsByTitles( $titles, $namespace );
        $ordered = [];
        foreach ( $titles as $title ) {
            if ( isset( $revisionsByTitle[$title] ) ) {
                $ordered[$title] = $revisionsByTitle[$title];
            }
        }
        return $ordered;
    }
 
    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;
        $codes ??= self::getLanguageNames( LanguageNameUtils::AUTONYMS );
 
        return !$handle->isDoc() && isset( $codes[ $languageCode ] );
    }
 
    public static function isValidRegex( string $pattern, ?string &$error = null ): bool {
        set_error_handler( static function ( $severity, $message ) use ( &$error ) {
            $error = $message;
            return true;
        } );
 
        try {
            // @phan-suppress-next-line PhanParamSuspiciousOrder
            $result = preg_match( $pattern, '' );
            return $result !== false;
        } finally {
            restore_error_handler();
        }
    }
}
 
class_alias( Utilities::class, 'TranslateUtils' );