UnicodePlural.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\Utilities;
 
use RuntimeException;
 
class UnicodePlural {
    public const KEYWORDS = [ 'zero', 'one', 'two', 'few', 'many', 'other' ];
    private const PRE = '{{PLURAL|';
    private const POST = '}}';
 
    public static function getPluralKeywords( string $code ): ?array {
        $filePath = __DIR__ . '/../../data/plural-cldr.json';
        $ruleData = json_decode( file_get_contents( $filePath ), true );
 
        $ruleSet = $ruleData[ 'supplemental' ][ 'plurals-type-cardinal' ][ $code ] ?? null;
        if ( $ruleSet === null ) {
            return null;
        }
 
        $keywords = [];
        foreach ( array_keys( $ruleSet ) as $name ) {
            $keywords[] = str_replace( 'pluralRule-count-', '', $name );
        }
 
        return $keywords;
    }
 
    public static function hasPlural( string $text ): bool {
        return str_contains( $text, self::PRE );
    }
 
    public static function flattenMap( array $forms ): string {
        $list = [];
        foreach ( $forms as $keyword => $value ) {
            $list[] = [ $keyword, $value ];
        }
 
        return self::flattenList( $list );
    }
 
    public static function flattenList( array $formList ): string {
        $formatted = [];
        foreach ( $formList as [ $keyword, $value ] ) {
            $formatted[] = self::formatForm( $keyword, $value );
        }
 
        return self::PRE . implode( '|', $formatted ) . self::POST;
    }
 
    private static function formatForm( string $keyword, string $value ): string {
        $prefix = $keyword === 'other' ? '' : "$keyword=";
        return $prefix . $value;
    }
 
    public static function unflatten( string $text, array $expectedKeywords ): array {
        [ $template, $instanceMap ] = self::parsePluralForms( $text );
        return self::expandTemplate( $template, $instanceMap, $expectedKeywords );
    }
 
    public static function parsePluralForms( string $text ): array {
        $m = [];
        $pre = preg_quote( self::PRE, '/' );
        $post = preg_quote( self::POST, '/' );
 
        $ok = preg_match_all( "/$pre(.*)$post/Us", $text, $m );
        if ( $ok === false ) {
            throw new RuntimeException( "Plural regular expression failed for text: $text" );
        }
 
        $template = $text;
        $instanceMap = [];
 
        foreach ( $m[0] as $instanceIndex => $instanceText ) {
            $ph = Utilities::getPlaceholder();
 
            // Using preg_replace instead of str_replace because of the limit parameter
            $pattern = '/' . preg_quote( $instanceText, '/' ) . '/';
            $template = preg_replace( $pattern, $ph, $template, 1 );
 
            $instanceForms = [];
            foreach ( explode( '|', $m[ 1 ][ $instanceIndex ] ) as $form ) {
                $m2 = [];
                $ok = preg_match( '~\s*([a-z]+)\s*=(.+)~s', $form, $m2 );
                $keyword = $ok ? $m2[ 1 ] : 'other';
                $value = $ok ? trim( $m2[ 2 ] ) : $form;
                $instanceForms[] = [ $keyword, $value ];
            }
 
            $instanceMap[$ph] = $instanceForms;
        }
 
        return [ $template, $instanceMap ];
    }
 
    public static function expandTemplate( string $template, array $instanceMap, array $expectedKeywords ): array {
        $formArray = [];
 
        // Convert from list of forms to map of forms for easier processing
        foreach ( $instanceMap as $ph => $list ) {
            $instanceMap[ $ph ] = self::convertFormListToFormMap( $list, $expectedKeywords );
        }
 
        foreach ( $expectedKeywords as $keyword ) {
            // Start with the whole string
            $form = $template;
 
            // Loop over each plural markup instance and replace it with the plural form belonging
            // to the current index
            foreach ( $instanceMap as $ph => $instanceFormMap ) {
                // For missing forms, fall back to empty text.
                $replacement = $instanceFormMap[ $keyword ] ?? '';
                $form = str_replace( $ph, $replacement, $form );
            }
 
            $formArray[ $keyword ] = $form;
        }
 
        return $formArray;
    }
 
    public static function convertFormListToFormMap( array $formList, array $expectedKeywords ): array {
        $formMap = [];
        foreach ( $formList as [ $keyword, $value ] ) {
            $formMap[ $keyword ] = $value;
        }
 
        $sortedFormMap = [];
        foreach ( $expectedKeywords as $keyword ) {
            $sortedFormMap[ $keyword ] = $formMap[ $keyword ] ?? null;
        }
 
        return $sortedFormMap;
    }
}