LanguageVariantConverter.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Parser\Parsoid;
 
use MediaWiki\Languages\LanguageConverterFactory;
use MediaWiki\Languages\LanguageFactory;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Parser\Parsoid\Config\PageConfigFactory;
use MediaWiki\Rest\HttpException;
use MediaWiki\Revision\RevisionAccessException;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleFactory;
use ParserOutput;
use Wikimedia\Bcp47Code\Bcp47Code;
use Wikimedia\Bcp47Code\Bcp47CodeValue;
use Wikimedia\Parsoid\Config\PageConfig;
use Wikimedia\Parsoid\Config\SiteConfig;
use Wikimedia\Parsoid\Core\PageBundle;
use Wikimedia\Parsoid\Parsoid;
 
class LanguageVariantConverter {
    private $pageConfigFactory;
 
    private $pageConfig;
 
    private $pageIdentity;
 
    private $pageTitle;
 
    private $parsoid;
 
    private $parsoidSettings;
 
    private $siteConfig;
 
    private $titleFactory;
 
    private $languageConverterFactory;
 
    private $languageFactory;
 
    private $pageLanguageOverride;
 
    private $isFallbackLanguageConverterEnabled = true;
 
    public function __construct(
        PageIdentity $pageIdentity,
        PageConfigFactory $pageConfigFactory,
        Parsoid $parsoid,
        array $parsoidSettings,
        SiteConfig $siteConfig,
        TitleFactory $titleFactory,
        LanguageConverterFactory $languageConverterFactory,
        LanguageFactory $languageFactory
    ) {
        $this->pageConfigFactory = $pageConfigFactory;
        $this->pageIdentity = $pageIdentity;
        $this->parsoid = $parsoid;
        $this->parsoidSettings = $parsoidSettings;
        $this->siteConfig = $siteConfig;
        $this->titleFactory = $titleFactory;
        // @phan-suppress-next-line PhanPossiblyNullTypeMismatchProperty
        $this->pageTitle = $this->titleFactory->castFromPageIdentity( $this->pageIdentity );
        $this->languageConverterFactory = $languageConverterFactory;
        $this->languageFactory = $languageFactory;
        $this->pageLanguageOverride = null;
    }
 
    public function setPageConfig( PageConfig $pageConfig ) {
        $this->pageConfig = $pageConfig;
    }
 
    public function setPageLanguageOverride( Bcp47Code $language ) {
        $this->pageLanguageOverride = $language;
    }
 
    public function convertPageBundleVariant(
        PageBundle $pageBundle,
        Bcp47Code $targetVariant,
        ?Bcp47Code $sourceVariant = null
    ): PageBundle {
        [ $pageLanguage, $sourceVariant ] =
            $this->getBaseAndSourceLanguage( $pageBundle, $sourceVariant );
 
        if ( !$this->siteConfig->langConverterEnabledBcp47( $pageLanguage ) ) {
            // If the language doesn't support variants, just return the content unmodified.
            return $pageBundle;
        }
 
        $pageConfig = $this->getPageConfig( $pageLanguage, $sourceVariant );
 
        if ( !$this->parsoid->implementsLanguageConversionBcp47( $pageConfig, $targetVariant ) ) {
            if ( !$this->isFallbackLanguageConverterEnabled ) {
                // Fallback variant conversion is not enabled, return the page bundle as is.
                return $pageBundle;
            }
 
            // LanguageConverter::hasVariant and LanguageConverter::convertTo
            // could take a string|Bcp47Code in the future, which would
            // allow us to avoid the $targetVariantCode conversion here.
            $baseLanguage = $this->languageFactory->getParentLanguage( $targetVariant );
            $languageConverter = $this->languageConverterFactory->getLanguageConverter( $baseLanguage );
            $targetVariantCode = $this->languageFactory->getLanguage( $targetVariant )->getCode();
            if ( $languageConverter->hasVariant( $targetVariantCode ) ) {
                $convertedHtml = $languageConverter->convertTo( $pageBundle->html, $targetVariantCode );
            } else {
                // No conversion possible - pass through original HTML.
                $convertedHtml = $pageBundle->html;
            }
 
            // Add a note so that we can identify what was used to perform the variant conversion
            $msg = "<!-- Variant conversion performed using the core LanguageConverter -->";
            $convertedHtml = $msg . $convertedHtml;
 
            // HACK: Pass the HTML to Parsoid for variant conversion in order to add metadata that is
            // missing when we use the core LanguageConverter directly.
 
            // Replace the original page bundle, so Parsoid gets the converted HTML as input.
            $pageBundle = new PageBundle(
                $convertedHtml,
                [],
                [],
                $pageBundle->version,
                [ 'content-language' => $targetVariant->toBcp47Code() ]
            );
        }
 
        $modifiedPageBundle = $this->parsoid->pb2pb(
            $pageConfig, 'variant', $pageBundle,
            [
                'variant' => [
                    'source' => $sourceVariant,
                    'target' => $targetVariant,
                ]
            ]
        );
 
        return $modifiedPageBundle;
    }
 
    public function convertParserOutputVariant(
        ParserOutput $parserOutput,
        Bcp47Code $targetVariant,
        ?Bcp47Code $sourceVariant = null
    ): ParserOutput {
        $pageBundle = PageBundleParserOutputConverter::pageBundleFromParserOutput( $parserOutput );
        $modifiedPageBundle = $this->convertPageBundleVariant( $pageBundle, $targetVariant, $sourceVariant );
 
        return PageBundleParserOutputConverter::parserOutputFromPageBundle( $modifiedPageBundle, $parserOutput );
    }
 
    public function disableFallbackLanguageConverter(): void {
        $this->isFallbackLanguageConverterEnabled = false;
    }
 
    private function getPageConfig( Bcp47Code $pageLanguage, ?Bcp47Code $sourceVariant ): PageConfig {
        if ( $this->pageConfig ) {
            return $this->pageConfig;
        }
 
        try {
            $this->pageConfig = $this->pageConfigFactory->create(
                $this->pageIdentity,
                null,
                null,
                null,
                $pageLanguage,
                $this->parsoidSettings
            );
 
            if ( $sourceVariant ) {
                $this->pageConfig->setVariantBcp47( $sourceVariant );
            }
        } catch ( RevisionAccessException $exception ) {
            // TODO: Throw a different exception, this class should not know
            //       about HTTP status codes.
            throw new HttpException( 'The specified revision is deleted or suppressed.', 404 );
        }
 
        return $this->pageConfig;
    }
 
    private function getPageLanguage( PageBundle $pageBundle, ?Bcp47Code $default = null ): Bcp47Code {
        // If a language was set by calling setPageLanguageOverride(), always use it!
        if ( $this->pageLanguageOverride ) {
            return $this->pageLanguageOverride;
        }
 
        // If the page bundle contains a language code, use that.
        $pageBundleLanguage = $pageBundle->headers[ 'content-language' ] ?? null;
        if ( $pageBundleLanguage ) {
            // The HTTP header will contain a BCP-47 language code, not a
            // mediawiki-internal one.
            return new Bcp47CodeValue( $pageBundleLanguage );
        }
 
        // NOTE: Use explicit default *before* we try PageBundle, because PageConfig::getPageLanguage()
        //       falls back to Title::getPageLanguage(). If we did that first, $default would never be used.
        if ( $default ) {
            return $default;
        }
 
        // If we have a PageConfig, we can ask it for the page's language. Note that this will fall back to
        // Title::getPageLanguage(), so it has to be the last thing we try.
        if ( $this->pageConfig ) {
            return $this->pageConfig->getPageLanguageBcp47();
        }
 
        // Finally, just go by the code associated with the title. This may come from the database or
        // it may be determined based on the title itself.
        return $this->pageTitle->getPageLanguage();
    }
 
    private function getBaseAndSourceLanguage( PageBundle $pageBundle, ?Bcp47Code $sourceLanguage ): array {
        // Try to determine the language code associated with the content of the page.
        // The result may be a variant code.
        $baseLanguage = $this->getPageLanguage( $pageBundle, $sourceLanguage );
 
        // To find out if $baseLanguage is actually a variant, get the parent language and compare.
        $parentLang = $this->languageFactory->getParentLanguage( $baseLanguage );
 
        // If $parentLang is not the same language as $baseLanguage, this means that
        // $baseLanguage is a variant. In that case, set $sourceLanguage to that
        // variant (unless $sourceLanguage is already set), and set $baseLanguage
        // to the $parentLang
        if ( $parentLang && strcasecmp( $parentLang->toBcp47Code(), $baseLanguage->toBcp47Code() ) !== 0 ) {
            if ( !$sourceLanguage ) {
                $sourceLanguage = $baseLanguage;
            }
            $baseLanguage = $parentLang;
        }
 
        // If the source variant isn't actually a variant, trigger auto-detection
        // FIXME: This should probably use LanguageConverter::validateVariant()
        // as well, but we'd need a LanguageConverterFactory for that.
        if ( $sourceLanguage && strcasecmp( $sourceLanguage->toBcp47Code(), $baseLanguage->toBcp47Code() ) === 0 ) {
            $sourceLanguage = null;
        }
 
        return [ $baseLanguage, $sourceLanguage ];
    }
}