MessageGroupConfigurationParser.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\MessageGroupConfiguration;
 
use AggregateMessageGroup;
use Exception;
use MediaWiki\Extension\Translate\FileFormatSupport\FileFormatFactory;
use MediaWiki\Extension\Translate\MessageProcessing\StringMatcher;
use MediaWiki\Extension\Translate\Services;
use MediaWiki\Extension\Translate\Utilities\Yaml;
use RomaricDrigon\MetaYaml\MetaYaml;
 
class MessageGroupConfigurationParser {
    private ?array $baseSchema = null;
    private FileFormatFactory $fileFormatFactory;
 
    public function __construct() {
        // Don't perform validations if library not available
        if ( class_exists( MetaYaml::class ) ) {
            $this->baseSchema = $this->getBaseSchema();
        }
 
        $this->fileFormatFactory = Services::getInstance()->getFileFormatFactory();
    }
 
    public function getHopefullyValidConfigurations( string $data, ?callable $callback = null ): array {
        if ( !is_callable( $callback ) ) {
            $callback = static function ( $unused1, $unused2, $unused3 ) {
                /*noop*/
            };
        }
 
        $documents = self::getDocumentsFromYaml( $data );
        $configurations = self::parseDocuments( $documents );
        $groups = [];
 
        if ( is_array( $this->baseSchema ) ) {
            foreach ( $configurations as $index => $config ) {
                try {
                    $this->validate( $config );
                    $groups[$config['BASIC']['id']] = $config;
                } catch ( Exception $e ) {
                    $callback( $index, $config, $e->getMessage() );
                }
            }
        } else {
            foreach ( $configurations as $index => $config ) {
                if ( isset( $config['BASIC']['id'] ) ) {
                    $groups[$config['BASIC']['id']] = $config;
                } else {
                    $callback( $index, $config, 'id is missing' );
                }
            }
        }
 
        return $groups;
    }
 
    public function getDocumentsFromYaml( string $data ): array {
        return preg_split( "/^---$/m", $data, -1, PREG_SPLIT_NO_EMPTY );
    }
 
    public function parseDocuments( array $documents ): array {
        $groups = [];
        $template = [];
 
        foreach ( $documents as $document ) {
            $document = Yaml::loadString( $document );
 
            if ( isset( $document['TEMPLATE'] ) ) {
                $template = $document['TEMPLATE'];
            } else {
                $groups[] = $document;
            }
        }
 
        if ( $template ) {
            foreach ( $groups as $i => $group ) {
                $groups[$i] = self::mergeTemplate( $template, $group );
                // Little hack to allow aggregate groups to be defined in same file with other groups.
                if ( $groups[$i]['BASIC']['class'] === AggregateMessageGroup::class ) {
                    unset( $groups[$i]['FILES'] );
                }
            }
        }
 
        return $groups;
    }
 
    public function getBaseSchema(): array {
        return Yaml::load( __DIR__ . '/../../data/group-yaml-schema.yaml' );
    }
 
    public function validate( array $config ): void {
        $schema = $this->baseSchema;
 
        foreach ( $config as $key => $section ) {
            $extra = [];
            if ( $key === 'FILES' ) {
                $extra = $this->getFilesSchemaExtra( $section );
            } elseif ( $key === 'MANGLER' ) {
                $class = $section[ 'class' ] ?? null;
                // FIXME: UGLY HACK: StringMatcher is now under a namespace so use the fully prefixed
                // class to check if it has the getExtraSchema method
                if ( $class === 'StringMatcher' ) {
                    $extra = StringMatcher::getExtraSchema();
                }
            } else {
                $extra = $this->callGetExtraSchema( $section[ 'class' ] ?? null );
            }
 
            $schema = array_replace_recursive( $schema, $extra );
        }
 
        $schema = new MetaYaml( $schema );
        $schema->validate( $config );
    }
 
    public static function mergeTemplate( array $base, array $specific ): array {
        foreach ( $specific as $key => $value ) {
            if ( is_array( $value ) && isset( $base[$key] ) && is_array( $base[$key] ) ) {
                $base[$key] = self::mergeTemplate( $base[$key], $value );
            } else {
                $base[$key] = $value;
            }
        }
 
        return $base;
    }
 
    private function getFilesSchemaExtra( array $section ): array {
        $class = $section['class'] ?? null;
        $format = $section['format'] ?? null;
        $className = null;
 
        if ( $format ) {
            $className = $this->fileFormatFactory->getClassname( $format );
        } elseif ( $class ) {
            $className = $class;
        }
 
        return $this->callGetExtraSchema( $className );
    }
 
    private function callGetExtraSchema( ?string $className ): array {
        if ( $className && is_callable( [ $className, 'getExtraSchema' ] ) ) {
            return call_user_func( [ $className, 'getExtraSchema' ] );
        }
 
        return [];
    }
}