AggregateMessageGroup.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Extension\Translate\MessageGroups;
 
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroups;
use MediaWiki\Extension\Translate\MessageLoading\MessageCollection;
use MediaWiki\Extension\Translate\MessageLoading\MessageDefinitions;
use MediaWiki\Extension\Translate\MessageLoading\MessageHandle;
use MediaWiki\Extension\Translate\MessageProcessing\StringMatcher;
use MediaWiki\Extension\Translate\Services;
use MediaWiki\Title\Title;
 
class AggregateMessageGroup extends MessageGroupBase {
    public const UNDETERMINED_LANGUAGE_CODE = 'und';
    private $groups;
 
    public function exists() {
        // Group exists if there are any subgroups.
        return (bool)$this->conf['GROUPS'];
    }
 
    public function load( $code ) {
        $messages = [];
 
        foreach ( $this->getGroups() as $group ) {
            $messages += $group->load( $code );
        }
 
        return $messages;
    }
 
    public function getMangler() {
        if ( $this->mangler === null ) {
            $this->mangler = new StringMatcher();
        }
 
        return $this->mangler;
    }
 
    public function getGroups(): array {
        if ( $this->groups === null ) {
            $groups = [];
            $ids = (array)$this->conf['GROUPS'];
            $ids = MessageGroups::expandWildcards( $ids );
 
            foreach ( $ids as $id ) {
                // Do not try to include self and go to infinite loop.
                if ( $id === $this->getId() ) {
                    continue;
                }
 
                $group = MessageGroups::getGroup( $id );
                if ( $group === null ) {
                    error_log( "Invalid group id in {$this->getId()}: $id" );
                    continue;
                }
 
                if ( MessageGroups::getPriority( $group ) === 'discouraged' ) {
                    continue;
                }
 
                $groups[$id] = $group;
            }
 
            $this->groups = $groups;
        }
 
        return $this->groups;
    }
 
    protected function loadMessagesFromCache( array $groups ): array {
        $messages = [];
        foreach ( $groups as $group ) {
            if ( $group instanceof self ) {
                $messages += $this->loadMessagesFromCache( $group->getGroups() );
                continue;
            }
 
            if ( $group instanceof FileBasedMessageGroup ) {
                $cache = $group->getMessageGroupCache( $group->getSourceLanguage() );
                if ( $cache->exists() ) {
                    foreach ( $cache->getKeys() as $key ) {
                        $messages[$key] = $cache->get( $key );
                    }
                }
                continue;
            }
 
            $messages += $group->getDefinitions();
        }
 
        return $messages;
    }
 
    public function initCollection( $code ) {
        $messages = $this->loadMessagesFromCache( $this->getGroups() );
        $namespace = $this->getNamespace();
        $definitions = new MessageDefinitions( $messages, $namespace );
        $collection = MessageCollection::newFromDefinitions( $definitions, $code );
 
        $this->setTags( $collection );
 
        return $collection;
    }
 
    public function getMessage( $key, $code ) {
        /* Just hand over the message content retrieval to the primary message
         * group directly. This used to iterate over the subgroups looking for
         * the primary group, but that might actually be under some other
         * aggregate message group.
         * @todo Implement getMessageContent to avoid hardcoding the namespace
         * here.
         */
        $title = Title::makeTitle( $this->getNamespace(), $key );
        $handle = new MessageHandle( $title );
        $groupId = Services::getInstance()->getMessageIndex()->getPrimaryGroupId( $handle );
        if ( $groupId === null ) {
            error_log( "Could not determine groupId for MessageHandle of key $key" );
            return null;
        }
        if ( $groupId === $this->getId() ) {
            // Message key owned by aggregate group.
            // Should not ever happen, but it does.
            error_log( "AggregateMessageGroup $groupId cannot be primary owner of key $key" );
 
            return null;
        }
 
        $group = MessageGroups::getGroup( $groupId );
        if ( $group ) {
            return $group->getMessage( $key, $code );
        } else {
            return null;
        }
    }
 
    public function getTags( $type = null ) {
        $tags = [];
 
        foreach ( $this->getGroups() as $group ) {
            $tags = array_merge_recursive( $tags, $group->getTags( $type ) );
        }
 
        return $tags;
    }
 
    public function getKeys() {
        $keys = [];
        foreach ( $this->getGroups() as $group ) {
            // Array merge is *really* slow (tested in PHP 7.1), so avoiding it. A loop
            // followed by array_unique (which we need anyway) is magnitudes faster.
            foreach ( $group->getKeys() as $key ) {
                $keys[] = $key;
            }
        }
 
        return array_values( array_unique( $keys ) );
    }
 
    public function getSourceLanguage(): string {
        // Return undetermined language code (und) if no language is defined for the web configured
        // aggregate group
        return $this->conf['BASIC']['sourcelanguage'] ?? self::UNDETERMINED_LANGUAGE_CODE;
    }
}
 
class_alias( AggregateMessageGroup::class, 'AggregateMessageGroup' );