GettextPlural.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\Utilities;
 
use MediaWiki\Extension\Translate\FileFormatSupport\GettextPluralException;
 
class GettextPlural {
    private const PRE = '{{PLURAL:GETTEXT|';
    private const POST = '}}';
 
    public static function getPluralRule( string $code, ?string $ruleFile = null ): string {
        global $wgTranslateDocumentationLanguageCode;
 
        if ( $code === $wgTranslateDocumentationLanguageCode ) {
            return 'nplurals=1; plural=0;';
        }
 
        $rulefile = $ruleFile ?? __DIR__ . '/../../data/plural-gettext.txt';
        $rules = file_get_contents( $rulefile );
        foreach ( explode( "\n", $rules ) as $line ) {
            if ( trim( $line ) === '' ) {
                continue;
            }
            if ( str_starts_with( trim( $line ), '#' ) ) {
                continue;
            }
            [ $rulecode, $rule ] = explode( "\t", $line );
            if ( $rulecode === $code ) {
                return $rule;
            }
        }
 
        return '';
    }
 
    public static function getPluralCount( string $rule ): int {
        $m = [];
        $ok = preg_match( '/nplurals=([0-9]+).*;/', $rule, $m );
        if ( !$ok ) {
            throw new GettextPluralException( "Rule $rule is malformed" );
        }
        return (int)$m[ 1 ];
    }
 
    public static function hasPlural( string $text ): bool {
        return str_contains( $text, self::PRE );
    }
 
    public static function flatten( array $forms ): string {
        return self::PRE . implode( '|', $forms ) . self::POST;
    }
 
    public static function unflatten( string $text, int $expectedPluralCount ): array {
        [ $template, $instanceMap ] = self::parsePluralForms( $text );
        return self::expandTemplate( $template, $instanceMap, $expectedPluralCount );
    }
 
    private static function armour( string $text ): array {
        // |/| is commonly used in KDE to support inflections. It needs to be escaped
        // to avoid it messing up the plural markup.
        $replacements = [
            '|/|' => Utilities::getPlaceholder(),
        ];
        // {0} is a common variable format
        preg_match_all( '/\{\d+\}/', $text, $matches );
        foreach ( $matches[0] as $m ) {
            $replacements[$m] = Utilities::getPlaceholder();
        }
 
        $text = strtr( $text, $replacements );
        $map = array_flip( $replacements );
 
        return [ $text, $map ];
    }
 
    private static function unarmour( string $text, array $map ): string {
        return strtr( $text, $map );
    }
 
    public static function parsePluralForms( string $text ): array {
        $m = [];
        $pre = preg_quote( self::PRE, '/' );
        $post = preg_quote( self::POST, '/' );
 
        [ $armouredText, $armourMap ] = self::armour( $text );
 
        $ok = preg_match_all( "/$pre(.*)$post/Us", $armouredText, $m );
        if ( $ok === false ) {
            throw new GettextPluralException( "Plural regular expression failed for text: $text" );
        }
 
        $template = $armouredText;
        $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 = explode( '|', $m[ 1 ][ $instanceIndex ] );
            foreach ( $instanceForms as $i => $v ) {
                $instanceForms[ $i ] = self::unarmour( $v, $armourMap );
            }
 
            $instanceMap[$ph] = $instanceForms;
        }
 
        $template = self::unarmour( $template, $armourMap );
        return [ $template, $instanceMap ];
    }
 
    public static function expandTemplate( string $template, array $instanceMap, int $expectedPluralCount ): array {
        $formArray = [];
        for ( $formIndex = 0; $formIndex < $expectedPluralCount; $formIndex++ ) {
            // 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 => $instanceForms ) {
                // For missing forms, fall back to empty text.
                // Extra forms are excluded because $formIndex < $expectedPluralCount
                $replacement = $instanceForms[ $formIndex ] ?? '';
                $form = str_replace( $ph, $replacement, $form );
            }
 
            $formArray[ $formIndex ] = $form;
        }
 
        return $formArray;
    }
}