ApiQueryLanguageinfo.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Api;
 
use MediaWiki\Language\LanguageCode;
use MediaWiki\Language\LanguageConverterFactory;
use MediaWiki\Language\LanguageFactory;
use MediaWiki\Language\LanguageFallback;
use MediaWiki\Language\LanguageFallbackMode;
use MediaWiki\Language\LanguageNameUtils;
use MediaWiki\Message\Message;
use Wikimedia\Message\ListType;
use Wikimedia\ParamValidator\ParamValidator;
use Wikimedia\Timestamp\ConvertibleTimestamp;
 
class ApiQueryLanguageinfo extends ApiQueryBase {
 
    private const MAX_EXECUTE_SECONDS = 3;
 
    public function __construct(
        ApiQuery $queryModule,
        string $moduleName,
        private readonly LanguageFactory $languageFactory,
        private readonly LanguageNameUtils $languageNameUtils,
        private readonly LanguageFallback $languageFallback,
        private readonly LanguageConverterFactory $languageConverterFactory,
    ) {
        parent::__construct( $queryModule, $moduleName, 'li' );
    }
 
    public function execute() {
        // ConvertibleTimestamp::time() used so we can fake the current time in tests
        $endTime = ConvertibleTimestamp::time() + self::MAX_EXECUTE_SECONDS;
 
        $props = array_fill_keys( $this->getParameter( 'prop' ), true );
        $includeCode = isset( $props['code'] );
        $includeBcp47 = isset( $props['bcp47'] );
        $includeDir = isset( $props['dir'] );
        $includeAutonym = isset( $props['autonym'] );
        $includeName = isset( $props['name'] );
        $includeVariantnames = isset( $props['variantnames'] );
        $includeFallbacks = isset( $props['fallbacks'] );
        $includeVariants = isset( $props['variants'] );
        $includeDigitTransforms = isset( $props['digittransforms'] );
        $includeDigitGroupingPattern = isset( $props['digitgroupingpattern'] );
        $includeMinimumGroupingDigits = isset( $props['minimumgroupingdigits'] );
        $includeNamespaceNames = isset( $props['namespacenames'] );
        $includeNamespaceAliases = isset( $props['namespacealiases'] );
 
        $targetLanguageCode = $this->getLanguage()->getCode();
        $include = LanguageNameUtils::ALL;
 
        $availableLanguageCodes = array_keys( $this->languageNameUtils->getLanguageNames(
            // MediaWiki and extensions may return different sets of language codes
            // when asked for language names in different languages;
            // asking for English language names is most likely to give us the full set,
            // even though we may not need those at all
            'en',
            $include
        ) );
        $selectedLanguageCodes = $this->getParameter( 'code' );
        if ( $selectedLanguageCodes === [ '*' ] ) {
            $languageCodes = $availableLanguageCodes;
        } else {
            $languageCodes = array_values( array_intersect(
                $availableLanguageCodes,
                $selectedLanguageCodes
            ) );
            $unrecognizedCodes = array_values( array_diff(
                $selectedLanguageCodes,
                $availableLanguageCodes
            ) );
            if ( $unrecognizedCodes !== [] ) {
                $this->addWarning( [
                    'apiwarn-unrecognizedvalues',
                    $this->encodeParamName( 'code' ),
                    Message::listParam( $unrecognizedCodes, ListType::COMMA ),
                    count( $unrecognizedCodes ),
                ] );
            }
        }
        // order of $languageCodes is guaranteed by LanguageNameUtils::getLanguageNames()
        // and preserved by array_values() + array_intersect()
 
        $continue = $this->getParameter( 'continue' ) ?? reset( $languageCodes );
 
        $result = $this->getResult();
        $rootPath = [
            $this->getQuery()->getModuleName(),
            $this->getModuleName(),
        ];
        $result->addArrayType( $rootPath, 'assoc' );
 
        foreach ( $languageCodes as $languageCode ) {
            if ( $languageCode < $continue ) {
                continue;
            }
 
            $now = ConvertibleTimestamp::time();
            if ( $now >= $endTime ) {
                $this->setContinueEnumParameter( 'continue', $languageCode );
                break;
            }
 
            $info = [];
            ApiResult::setArrayType( $info, 'assoc' );
 
            if ( $includeCode ) {
                $info['code'] = $languageCode;
            }
 
            if ( $includeBcp47 ) {
                $bcp47 = LanguageCode::bcp47( $languageCode );
                $info['bcp47'] = $bcp47;
            }
 
            if ( $includeDir ) {
                $dir = $this->languageFactory->getLanguage( $languageCode )->getDir();
                $info['dir'] = $dir;
            }
 
            if ( $includeAutonym ) {
                $autonym = $this->languageNameUtils->getLanguageName(
                    $languageCode,
                    LanguageNameUtils::AUTONYMS,
                    $include
                );
                $info['autonym'] = $autonym;
            }
 
            if ( $includeName ) {
                $name = $this->languageNameUtils->getLanguageName(
                    $languageCode,
                    $targetLanguageCode,
                    $include
                );
                $info['name'] = $name;
            }
 
            if ( $includeFallbacks ) {
                $fallbacks = $this->languageFallback->getAll(
                    $languageCode,
                    // allow users to distinguish between implicit and explicit 'en' fallbacks
                    LanguageFallbackMode::STRICT
                );
                ApiResult::setIndexedTagName( $fallbacks, 'fb' );
                $info['fallbacks'] = $fallbacks;
            }
 
            if ( $includeVariants || $includeVariantnames ) {
                $language = $this->languageFactory->getLanguage( $languageCode );
                $converter = $this->languageConverterFactory->getLanguageConverter( $language );
                $variants = $converter->getVariants();
 
                if ( $includeVariants ) {
                    $info['variants'] = $variants;
                    ApiResult::setIndexedTagName( $info['variants'], 'var' );
                }
                if ( $includeVariantnames ) {
                    $info['variantnames'] = [];
                    foreach ( $variants as $variantCode ) {
                        $info['variantnames'][$variantCode] = $language->getVariantname( $variantCode );
                    }
                }
            }
 
            if ( $includeDigitTransforms ) {
                $language = $this->languageFactory->getLanguage( $languageCode );
                $digittransforms = $language->digitTransformTable();
                if ( !$digittransforms ) {
                    $digittransforms = [];
                }
                ApiResult::setIndexedTagName( $digittransforms, 'dig' );
                $info['digittransforms'] = $digittransforms;
            }
 
            if ( $includeDigitGroupingPattern ) {
                $language = $this->languageFactory->getLanguage( $languageCode );
                $info['digitgroupingpattern'] = $language->digitGroupingPattern() ?? '#,##0.###';
            }
 
            if ( $includeMinimumGroupingDigits ) {
                $language = $this->languageFactory->getLanguage( $languageCode );
                $info['minimumgroupingdigits'] = $language->minimumGroupingDigits();
            }
 
            if ( $includeNamespaceNames ) {
                $language = $this->languageFactory->getLanguage( $languageCode );
                $info['namespacenames'] = $language->getNamespaces();
            }
 
            if ( $includeNamespaceAliases ) {
                $language = $this->languageFactory->getLanguage( $languageCode );
                $info['namespacealiases'] = $language->getNamespaceAliases();
            }
 
            $fit = $result->addValue( $rootPath, $languageCode, $info );
            if ( !$fit ) {
                $this->setContinueEnumParameter( 'continue', $languageCode );
                break;
            }
        }
    }
 
    public function getCacheMode( $params ) {
        return 'public';
    }
 
    public function getAllowedParams() {
        return [
            'prop' => [
                ParamValidator::PARAM_DEFAULT => 'code',
                ParamValidator::PARAM_ISMULTI => true,
                ParamValidator::PARAM_TYPE => [
                    'code',
                    'bcp47',
                    'dir',
                    'autonym',
                    'name',
                    'variantnames',
                    'fallbacks',
                    'variants',
                    'digittransforms',
                    'digitgroupingpattern',
                    'minimumgroupingdigits',
                    'namespacenames',
                    'namespacealiases',
                ],
                self::PARAM_HELP_MSG_PER_VALUE => [],
            ],
            'code' => [
                ParamValidator::PARAM_DEFAULT => '*',
                ParamValidator::PARAM_ISMULTI => true,
            ],
            'continue' => [
                self::PARAM_HELP_MSG => 'api-help-param-continue',
            ],
        ];
    }
 
    protected function getExamplesMessages() {
        $pathUrl = 'action=' . $this->getQuery()->getModuleName() .
            '&meta=' . $this->getModuleName();
        $pathMsg = $this->getModulePath();
        $prefix = $this->getModulePrefix();
 
        return [
            "$pathUrl"
                => "apihelp-$pathMsg-example-simple",
            "$pathUrl&{$prefix}prop=autonym|name&uselang=de"
                => "apihelp-$pathMsg-example-autonym-name-de",
            "$pathUrl&{$prefix}prop=fallbacks|variants&{$prefix}code=oc"
                => "apihelp-$pathMsg-example-fallbacks-variants-oc",
            "$pathUrl&{$prefix}prop=bcp47|dir"
                => "apihelp-$pathMsg-example-bcp47-dir",
        ];
    }
 
}
 
class_alias( ApiQueryLanguageinfo::class, 'ApiQueryLanguageinfo' );