LanguageFactory.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Languages;
 
use InvalidArgumentException;
use Language;
use LanguageCode;
use LanguageConverter;
use LocalisationCache;
use LogicException;
use MapCacheLRU;
use MediaWiki\Config\Config;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\MainConfigNames;
use MediaWiki\Title\NamespaceInfo;
use Wikimedia\Bcp47Code\Bcp47Code;
 
class LanguageFactory {
    private $options;
 
    private $namespaceInfo;
 
    private $localisationCache;
 
    private $langNameUtils;
 
    private $langFallback;
 
    private $langConverterFactory;
 
    private $hookContainer;
 
    private $langObjCache;
 
    private $config;
 
    private $parentLangCache = [];
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::DummyLanguageCodes,
    ];
 
    private const LANG_CACHE_SIZE = 10;
 
    public function __construct(
        ServiceOptions $options,
        NamespaceInfo $namespaceInfo,
        LocalisationCache $localisationCache,
        LanguageNameUtils $langNameUtils,
        LanguageFallback $langFallback,
        LanguageConverterFactory $langConverterFactory,
        HookContainer $hookContainer,
        Config $config
    ) {
        // We have both ServiceOptions and a Config object because
        // the Language class hasn't (yet) been updated to use ServiceOptions
        // and for now gets a full Config
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
 
        $this->options = $options;
        $this->namespaceInfo = $namespaceInfo;
        $this->localisationCache = $localisationCache;
        $this->langNameUtils = $langNameUtils;
        $this->langFallback = $langFallback;
        $this->langConverterFactory = $langConverterFactory;
        $this->hookContainer = $hookContainer;
        $this->langObjCache = new MapCacheLRU( self::LANG_CACHE_SIZE );
        $this->config = $config;
    }
 
    public function getLanguage( $code ): Language {
        if ( $code instanceof Language ) {
            return $code;
        }
        if ( $code instanceof Bcp47Code ) {
            // Any compatibility remapping of valid BCP-47 codes would be done
            // inside ::bcp47ToInternal, not here.
            $code = LanguageCode::bcp47ToInternal( $code );
        } else {
            // Perform various deprecated and compatibility mappings of
            // internal codes.
            $code = $this->options->get( MainConfigNames::DummyLanguageCodes )[$code] ?? $code;
        }
        return $this->getRawLanguage( $code );
    }
 
    public function getRawLanguage( $code ): Language {
        return $this->langObjCache->getWithSetCallback(
            $code,
            function () use ( $code ) {
                return $this->newFromCode( $code );
            }
        );
    }
 
    private function newFromCode( $code, $fallback = false ): Language {
        if ( !$this->langNameUtils->isValidCode( $code ) ) {
            throw new InvalidArgumentException( "Invalid language code \"$code\"" );
        }
 
        $constructorArgs = [
            $code,
            $this->namespaceInfo,
            $this->localisationCache,
            $this->langNameUtils,
            $this->langFallback,
            $this->langConverterFactory,
            $this->hookContainer,
            $this->config
        ];
 
        if ( !$this->langNameUtils->isValidBuiltInCode( $code ) ) {
            // It's not possible to customise this code with class files, so
            // just return a Language object. This is to support uselang= hacks.
            return new Language( ...$constructorArgs );
        }
 
        // Check if there is a language class for the code
        $class = $this->classFromCode( $code, $fallback );
        // LanguageCode does not inherit Language
        if ( class_exists( $class ) && is_a( $class, 'Language', true ) ) {
            return new $class( ...$constructorArgs );
        }
 
        // Keep trying the fallback list until we find an existing class
        $fallbacks = $this->langFallback->getAll( $code );
        foreach ( $fallbacks as $fallbackCode ) {
            $class = $this->classFromCode( $fallbackCode );
            if ( class_exists( $class ) ) {
                // TODO allow additional dependencies to be injected for subclasses somehow
                return new $class( ...$constructorArgs );
            }
        }
 
        throw new LogicException( "Invalid fallback sequence for language '$code'" );
    }
 
    private function classFromCode( $code, $fallback = true ) {
        if ( $fallback && $code == 'en' ) {
            return 'Language';
        } else {
            return 'Language' . str_replace( '-', '_', ucfirst( $code ) );
        }
    }
 
    public function getParentLanguage( $code ) {
        if ( $code instanceof Language ) {
            $code = $code->getCode();
        } elseif ( $code instanceof Bcp47Code ) {
            $code = LanguageCode::bcp47ToInternal( $code );
        }
        // $code is now a mediawiki internal code string.
        // We deliberately use array_key_exists() instead of isset() because we cache null.
        if ( !array_key_exists( $code, $this->parentLangCache ) ) {
            if ( !$this->langNameUtils->isValidBuiltInCode( $code ) ) {
                $this->parentLangCache[$code] = null;
                return null;
            }
            foreach ( LanguageConverter::$languagesWithVariants as $mainCode ) {
                $lang = $this->getLanguage( $mainCode );
                $converter = $this->langConverterFactory->getLanguageConverter( $lang );
                if ( $converter->hasVariant( $code ) ) {
                    $this->parentLangCache[$code] = $lang;
                    return $lang;
                }
            }
            $this->parentLangCache[$code] = null;
        }
 
        return $this->parentLangCache[$code];
    }
}