MessageGroupOld.php

Go to the documentation of this file.

<?php
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 $optional = array();

    public function getOptional() {
        return $this->optional;
    }

    public function setOptional( $value ) {
        $this->optional = $value;
    }

    protected $ignored = array();

    public function getIgnored() {
        return $this->ignored;
    }

    public function setIgnored( $value ) {
        $this->ignored = $value;
    }

    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 setMeta( $value ) {
        $this->meta = $value;
    }

    public function getSourceLanguage() {
        return 'en';
    }

    protected $mangler = null;

    public function getMangler() {
        if ( !isset( $this->mangler ) ) {
            $this->mangler = StringMatcher::emptyMatcher();
        }

        return $this->mangler;
    }

    public function setMangler( $value ) {
        $this->mangler = $value;
    }

    public function getReader( $code ) {
        return null;
    }

    public function getWriter() {
        return new SimpleFormatWriter( $this );
    }

    public function load( $code ) {
        $reader = $this->getReader( $code );
        if ( $reader ) {
            $messages = $reader->parseMessages( $this->mangler );

            return $messages ? $messages : array();
        }

        return array();
    }

    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 ? array() : $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 isset( $this->messages[$code][$key] ) ? $this->messages[$code][$key] : null;
    }

    public static function normaliseKeys( $array ) {
        if ( !is_array( $array ) ) {
            return null;
        }

        $new = array();
        foreach ( $array as $key => $v ) {
            $key = strtolower( str_replace( ' ', '_', $key ) );
            $new[$key] = $v;
        }

        return $new;
    }

    private $messages = array();

    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 __construct() {
    }

    public function exists() {
        return true;
    }

    public function getChecker() {
        return null;
    }

    public function getTags( $type = null ) {
        $tags = array(
            'optional' => $this->optional,
            'ignored' => $this->ignored,
        );

        if ( !$type ) {
            return $tags;
        }

        return isset( $tags[$type] ) ? $tags[$type] : array();
    }

    protected function isSourceLanguage( $code ) {
        return $code === $this->getSourceLanguage();
    }

    // Unsupported stuff, just to satisfy the new interface
    public function setConfiguration( $conf ) {
    }

    public function getConfiguration() {
    }

    public function getFFS() {
        return null;
    }

    public function getWorkflowConfiguration() {
        global $wgTranslateWorkflowStates;
        if ( !$wgTranslateWorkflowStates ) {
            // Not configured
            $conf = array();
        } else {
            $conf = $wgTranslateWorkflowStates;
        }

        return $conf;
    }

    public function getMessageGroupStates() {
        $conf = $this->getWorkflowConfiguration();

        return new MessageGroupStates( $conf );
    }

    public function getTranslatableLanguages() {
        return null;
    }

    protected static function addContext( Message $message, IContextSource $context = null ) {
        if ( $context ) {
            $message->inLanguage( $context->getLanguage() );
        }

        return $message;
    }

    public function getTranslationAids() {
        return TranslationAid::getTypes();
    }
}