MessageBundleMessageGroup.php

<?php
 
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\MessageBundleTranslation;
 
use Hooks as MediaWikiHooks;
use IContextSource;
use LogicException;
use MediaWiki\Extension\Translate\MessageProcessing\StringMatcher;
use MediaWiki\Extension\Translate\Validation\ValidationRunner;
use MediaWiki\MediaWikiServices;
use MediaWiki\Revision\SlotRecord;
use MessageCollection;
use MessageDefinitions;
use MessageGroup;
use MessageGroupStates;
use Title;
use const NS_TRANSLATIONS;
 
class MessageBundleMessageGroup implements MessageGroup {
    private $name;
    private $groupId;
    private $pageId;
    private $revisionId;
    private $data;
    private $description;
 
    public function __construct(
        string $groupId,
        string $name,
        int $pageId,
        int $revisionId,
        ?string $description
    ) {
        $this->groupId = $groupId;
        $this->name = $name;
        $this->pageId = $pageId;
        $this->revisionId = $revisionId;
        $this->description = $description;
    }
 
    public static function getGroupId( string $name ): string {
        return "messagebundle-$name";
    }
 
    private function getData(): array {
        if ( !$this->data ) {
            $revisionStore = MediaWikiServices::getInstance()->getRevisionStore();
            $revision = $revisionStore->getRevisionById( $this->revisionId );
 
            if ( $revision === null ) {
                throw new LogicException( "Could not find revision id $this->revisionId" );
            }
 
            $content = $revision->getContent( SlotRecord::MAIN );
            if ( !$content instanceof MessageBundleContent ) {
                throw new LogicException(
                    "Content with revision id $this->revisionId has wrong content format"
                );
            }
 
            $data = json_decode( $content->getText(), true );
            if ( !$data ) {
                throw new LogicException(
                    "Content with revision id $this->revisionId is not valid JSON"
                );
            }
 
            $this->data = $data;
        }
 
        return $this->data;
    }
 
    private function prefixKeys( array $keys ): array {
        $result = [];
        foreach ( $keys as $key ) {
            $result[] = "$this->name/$key";
        }
        return $result;
    }
 
    public function getId(): string {
        return $this->groupId;
    }
 
    public function getLabel( IContextSource $context = null ): string {
        return $this->name;
    }
 
    public function getDescription( IContextSource $context = null ): string {
        $titleText = Title::newFromID( $this->pageId )->getPrefixedText();
        $linkTargetText = ":$titleText";
        if ( $context ) {
            $message = $context->msg( 'translate-messagebundle-group-description' );
        } else {
            $message = wfMessage( 'translate-messagebundle-group-description' )
                ->inContentLanguage();
        }
 
        $plainMessage = $message->params( $titleText, $linkTargetText )->plain();
 
        if ( $this->description === null ) {
            return $plainMessage;
        }
 
        return $plainMessage . ' ' . $this->description;
    }
 
    public function getIcon(): ?string {
        return null;
    }
 
    public function getNamespace(): int {
        return NS_TRANSLATIONS;
    }
 
    public function isMeta(): bool {
        return false;
    }
 
    public function exists(): bool {
        return true;
    }
 
    public function getValidator(): ?ValidationRunner {
        return null;
    }
 
    public function getMangler(): ?StringMatcher {
        return null;
    }
 
    public function initCollection( $code ): MessageCollection {
        $defs = new MessageDefinitions( $this->getDefinitions(), $this->getNamespace() );
        $collection = MessageCollection::newFromDefinitions( $defs, $code );
 
        foreach ( $this->getTags() as $type => $tags ) {
            $collection->setTags( $type, $tags );
        }
 
        return $collection;
    }
 
    public function load( $code ): array {
        return [];
    }
 
    public function getDefinitions(): array {
        $data = $this->getData();
        unset( $data['@metadata'] );
 
        return array_combine(
            $this->prefixKeys( array_keys( $data ) ),
            array_values( $data )
        );
    }
 
    public function getKeys(): array {
        return array_keys( $this->getDefinitions() );
    }
 
    public function getTags( $type = null ): array {
        return [];
    }
 
    public function getMessage( $key, $code ): ?string {
        if ( $code === $this->getSourceLanguage() ) {
            return $this->getData()[$key] ?? null;
        }
 
        return null;
    }
 
    public function getSourceLanguage(): string {
        return Title::newFromText( $this->name )->getPageLanguage()->getCode();
    }
 
    public function getMessageGroupStates(): MessageGroupStates {
        global $wgTranslateWorkflowStates;
        $conf = $wgTranslateWorkflowStates ?: [];
 
        MediaWikiHooks::run( 'Translate:modifyMessageGroupStates', [ $this->getId(), &$conf ] );
 
        return new MessageGroupStates( $conf );
    }
 
    public function getTranslatableLanguages(): ?array {
        return null;
    }
 
    public function getSupportConfig(): ?array {
        return null;
    }
}