PremadeMediawikiExtensionGroups.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\MessageGroupConfiguration;
 
use FileDependency;
use MediaWiki\Extension\Translate\FileFormatSupport\JsonFormat;
use MediaWiki\Extension\Translate\MessageProcessing\StringMatcher;
use MediaWiki\Extension\Translate\TranslatorInterface\Insertable\MediaWikiInsertablesSuggester;
use MediaWikiExtensionMessageGroup;
use MessageGroup;
use MessageGroupBase;
use RuntimeException;
use UnexpectedValueException;
 
class PremadeMediawikiExtensionGroups {
    protected string $idPrefix = 'ext-';
    protected ?int $namespace = null;
    protected string $path;
    protected string $definitionFile;
 
    public function __construct( string $def, string $path ) {
        $this->definitionFile = $def;
        $this->path = rtrim( $path, '/' );
    }
 
    protected function getDefaultNamespace(): int {
        return NS_MEDIAWIKI;
    }
 
    protected function getNamespace(): int {
        if ( $this->namespace === null ) {
            $this->namespace = $this->getDefaultNamespace();
        }
        return $this->namespace;
    }
 
    public function setGroupPrefix( string $value ): void {
        $this->idPrefix = $value;
    }
 
    public function setNamespace( int $value ): void {
        $this->namespace = $value;
    }
 
    public function register( array &$list, array &$deps ): void {
        $groups = $this->parseFile();
        $groups = $this->processGroups( $groups );
        foreach ( $groups as $id => $g ) {
            $list[$id] = $this->createMessageGroup( $id, $g );
        }
 
        $deps[] = new FileDependency( $this->definitionFile );
    }
 
    protected function createMessageGroup( string $id, array $info ): MessageGroup {
        $conf = [];
        $conf['BASIC']['class'] = MediaWikiExtensionMessageGroup::class;
        $conf['BASIC']['id'] = $id;
        $conf['BASIC']['namespace'] = $this->getNamespace();
        $conf['BASIC']['label'] = $info['name'];
 
        if ( isset( $info['desc'] ) ) {
            $conf['BASIC']['description'] = $info['desc'];
        } else {
            $conf['BASIC']['descriptionmsg'] = $info['descmsg'];
        }
 
        $conf['FILES']['class'] = JsonFormat::class;
        $conf['FILES']['sourcePattern'] = $this->path . '/' . $info['file'];
 
        // @todo Find a better way
        if ( isset( $info['aliasfile'] ) ) {
            $conf['FILES']['aliasFileSource'] = $this->path . '/' . $info['aliasfile'];
            $conf['FILES']['aliasFile'] = $info['aliasfile'];
        }
        if ( isset( $info['magicfile'] ) ) {
            $conf['FILES']['magicFileSource'] = $this->path . '/' . $info['magicfile'];
            $conf['FILES']['magicFile'] = $info['magicfile'];
        }
 
        if ( isset( $info['prefix'] ) ) {
            $conf['MANGLER']['class'] = StringMatcher::class;
            $conf['MANGLER']['prefix'] = $info['prefix'];
            $conf['MANGLER']['patterns'] = $info['mangle'];
 
            $mangler = new StringMatcher( $info['prefix'], $info['mangle'] );
            if ( isset( $info['ignored'] ) ) {
                $info['ignored'] = $mangler->mangleList( $info['ignored'] );
            }
            if ( isset( $info['optional'] ) ) {
                $info['optional'] = $mangler->mangleList( $info['optional'] );
            }
        }
 
        $conf['VALIDATORS'] = [
            [ 'id' => 'BraceBalance' ],
            [ 'id' => 'MediaWikiLink' ],
            [ 'id' => 'MediaWikiPageName' ],
            [ 'id' => 'MediaWikiParameter' ],
            [ 'id' => 'MediaWikiPlural' ],
        ];
 
        $conf['INSERTABLES'] = [
            [ 'class' => MediaWikiInsertablesSuggester::class ]
        ];
 
        if ( isset( $info['optional'] ) ) {
            $conf['TAGS']['optional'] = $info['optional'];
        }
        if ( isset( $info['ignored'] ) ) {
            $conf['TAGS']['ignored'] = $info['ignored'];
        }
 
        if ( isset( $info['languages'] ) ) {
            $conf['LANGUAGES'] = [
                'include' => [],
                'exclude' => [],
            ];
 
            foreach ( $info['languages'] as $tagSpec ) {
                if ( preg_match( '/^([+-])?(.+)$/', $tagSpec, $m ) ) {
                    [ , $sign, $tag ] = $m;
                    if ( $sign === '+' ) {
                        $conf['LANGUAGES']['include'][] = $tag;
                    } elseif ( $sign === '-' ) {
                        $conf['LANGUAGES']['exclude'][] = $tag;
                    } else {
                        $conf['LANGUAGES']['exclude'] = '*';
                        $conf['LANGUAGES']['include'][] = $tag;
                    }
                }
            }
        }
 
        return MessageGroupBase::factory( $conf );
    }
 
    protected function parseFile(): array {
        $defines = file_get_contents( $this->definitionFile );
        $linefeed = '(\r\n|\n)';
        $sections = array_map(
            'trim',
            preg_split( "/$linefeed{2,}/", $defines, -1, PREG_SPLIT_NO_EMPTY )
        );
        $groups = [];
 
        foreach ( $sections as $section ) {
            $lines = array_map( 'trim', preg_split( "/$linefeed/", $section ) );
            $newGroup = [];
 
            foreach ( $lines as $line ) {
                if ( $line === '' || $line[0] === '#' ) {
                    continue;
                }
 
                if ( !str_contains( $line, '=' ) ) {
                    if ( empty( $newGroup['name'] ) ) {
                        $newGroup['name'] = $line;
                    } else {
                        throw new RuntimeException( 'Trying to define name twice: ' . $line );
                    }
                } else {
                    [ $key, $value ] = array_map( 'trim', explode( '=', $line, 2 ) );
                    switch ( $key ) {
                        case 'aliasfile':
                        case 'desc':
                        case 'descmsg':
                        case 'file':
                        case 'id':
                        case 'magicfile':
                        case 'var':
                            $newGroup[$key] = $value;
                            break;
                        case 'optional':
                        case 'ignored':
                        case 'languages':
                            $values = array_map( 'trim', explode( ',', $value ) );
                            if ( !isset( $newGroup[$key] ) ) {
                                $newGroup[$key] = [];
                            }
                            $newGroup[$key] = array_merge( $newGroup[$key], $values );
                            break;
                        case 'prefix':
                            [ $prefix, $messages ] = array_map(
                                'trim',
                                explode( '|', $value, 2 )
                            );
                            if ( isset( $newGroup['prefix'] ) && $newGroup['prefix'] !== $prefix ) {
                                throw new RuntimeException(
                                    "Only one prefix supported: {$newGroup['prefix']} !== $prefix"
                                );
                            }
                            $newGroup['prefix'] = $prefix;
 
                            if ( !isset( $newGroup['mangle'] ) ) {
                                $newGroup['mangle'] = [];
                            }
 
                            $messages = array_map( 'trim', explode( ',', $messages ) );
                            $newGroup['mangle'] = array_merge( $newGroup['mangle'], $messages );
                            break;
                        default:
                            throw new UnexpectedValueException( 'Unknown key:' . $key );
                    }
                }
            }
 
            if ( count( $newGroup ) ) {
                if ( empty( $newGroup['name'] ) ) {
                    throw new RuntimeException( "Name missing\n" . print_r( $newGroup, true ) );
                }
                $groups[] = $newGroup;
            }
        }
 
        return $groups;
    }
 
    protected function processGroups( array $groups ): array {
        $fixedGroups = [];
        foreach ( $groups as $g ) {
            $name = $g['name'];
 
            $id = $g['id'] ?? $this->idPrefix . preg_replace( '/\s+/', '', strtolower( $name ) );
 
            if ( !isset( $g['file'] ) ) {
                $file = preg_replace( '/\s+/', '', "$name/i18n/%CODE%.json" );
            } else {
                $file = $g['file'];
            }
 
            $descMsg = $g['descmsg'] ?? str_replace( $this->idPrefix, '', $id ) . '-desc';
 
            $newGroup = [
                'name' => $name,
                'file' => $file,
                'descmsg' => $descMsg,
            ];
 
            $copyVars = [
                'aliasfile',
                'desc',
                'ignored',
                'languages',
                'magicfile',
                'mangle',
                'optional',
                'prefix',
                'var',
            ];
 
            foreach ( $copyVars as $var ) {
                if ( isset( $g[$var] ) ) {
                    $newGroup[$var] = $g[$var];
                }
            }
 
            // Mark some fixed form optional messages automatically
            if ( !isset( $newGroup['optional' ] ) ) {
                $newGroup['optional'] = [];
            }
 
            // Mark extension name and skin names optional.
            $newGroup['optional'][] = '*-extensionname';
            $newGroup['optional'][] = 'skinname-*';
 
            $fixedGroups[$id] = $newGroup;
        }
 
        return $fixedGroups;
    }
}
 
class_alias( PremadeMediawikiExtensionGroups::class, 'PremadeMediawikiExtensionGroups' );