MessageGroupOld.php

Go to the documentation of this file.

<?php
use MediaWiki\Extension\Translate\MessageLoading\MessageCollection;
use MediaWiki\Extension\Translate\MessageLoading\MessageDefinitions;
use MediaWiki\Extension\Translate\MessageProcessing\StringMatcher;
use MediaWiki\Extension\Translate\TranslatorInterface\Aid\TranslationAid;
 
abstract class MessageGroupOld implements MessageGroup {
    protected $label = 'none';
 
    public function getLabel( IContextSource $context = null ) {
        return $this->label;
    }
 
    public function setLabel( $value ) {
        $this->label = $value;
    }
 
    protected $id = 'none';
 
    public function getId() {
        return $this->id;
    }
 
    public function setId( $value ) {
        $this->id = $value;
    }
 
    protected $namespace = NS_MEDIAWIKI;
 
    public function getNamespace() {
        return $this->namespace;
    }
 
    public function setNamespace( $ns ) {
        $this->namespace = $ns;
    }
 
    protected $description = null;
 
    public function getDescription( IContextSource $context = null ) {
        return $this->description;
    }
 
    public function setDescription( $value ) {
        $this->description = $value;
    }
 
    public function getIcon() {
        return null;
    }
 
    protected $meta = false;
 
    public function isMeta() {
        return $this->meta;
    }
 
    public function getSourceLanguage() {
        return 'en';
    }
 
    protected $mangler = null;
 
    public function getMangler() {
        if ( !isset( $this->mangler ) ) {
            $this->mangler = new StringMatcher();
        }
 
        return $this->mangler;
    }
 
    public function load( $code ) {
        return [];
    }
 
    public function getDefinitions() {
        $defs = $this->load( $this->getSourceLanguage() );
        if ( !is_array( $defs ) ) {
            throw new MWException( 'Unable to load definitions for ' . $this->getLabel() );
        }
 
        return $defs;
    }
 
    public function getUniqueDefinitions() {
        return $this->meta ? [] : $this->getDefinitions();
    }
 
    public function getKeys() {
        return array_keys( $this->getDefinitions() );
    }
 
    public function getMessage( $key, $code ) {
        if ( !isset( $this->messages[$code] ) ) {
            $this->messages[$code] = self::normaliseKeys( $this->load( $code ) );
        }
        $key = strtolower( str_replace( ' ', '_', $key ) );
 
        return $this->messages[$code][$key] ?? null;
    }
 
    public static function normaliseKeys( $array ) {
        if ( !is_array( $array ) ) {
            return null;
        }
 
        $new = [];
        foreach ( $array as $key => $v ) {
            $key = strtolower( str_replace( ' ', '_', $key ) );
            $new[$key] = $v;
        }
 
        return $new;
    }
 
    protected $messages = [];
 
    public function getMessageFile( $code ) {
        return false;
    }
 
    public function getPath() {
        return false;
    }
 
    public function getMessageFileWithPath( $code ) {
        $path = $this->getPath();
        $file = $this->getMessageFile( $code );
 
        if ( !$path || !$file ) {
            return false;
        }
 
        return "$path/$file";
    }
 
    public function getSourceFilePath( $code ) {
        return $this->getMessageFileWithPath( $code );
    }
 
    public function initCollection( $code, $unique = false ) {
        if ( !$unique ) {
            $definitions = $this->getDefinitions();
        } else {
            $definitions = $this->getUniqueDefinitions();
        }
 
        $defs = new MessageDefinitions( $definitions, $this->getNamespace() );
        $collection = MessageCollection::newFromDefinitions( $defs, $code );
 
        foreach ( $this->getTags() as $type => $tags ) {
            $collection->setTags( $type, $tags );
        }
 
        return $collection;
    }
 
    public function exists() {
        return true;
    }
 
    public function getValidator() {
        return null;
    }
 
    public function getTags( $type = null ) {
        return [];
    }
 
    protected function isSourceLanguage( $code ) {
        return $code === $this->getSourceLanguage();
    }
 
    public function getMessageGroupStates() {
        global $wgTranslateWorkflowStates;
        $conf = $wgTranslateWorkflowStates ?: [];
 
        Hooks::run( 'Translate:modifyMessageGroupStates', [ $this->getId(), &$conf ] );
 
        return new MessageGroupStates( $conf );
    }
 
    public function getTranslatableLanguages() {
        return null;
    }
 
    protected static function addContext( Message $message, IContextSource $context = null ) {
        if ( $context ) {
            $message->inLanguage( $context->getLanguage() );
        } else {
            $message->inLanguage( 'en' );
        }
 
        return $message;
    }
 
    public function getTranslationAids() {
        return TranslationAid::getTypes();
    }
 
    public function getSupportConfig(): ?array {
        return null;
    }
}