TranslationUnit.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\PageTranslation;
 
use Html;
use Language;
use TMessage;
use const PREG_SET_ORDER;
 
class TranslationUnit {
    public const UNIT_MARKER_INVALID_CHARS = "_/\n<>";
    public const NEW_UNIT_ID = '-1';
    // Deprecated syntax. Example: <tvar|1>...</>
    public const TVAR_OLD_SYNTAX_REGEX = '~<tvar\|([^>]+)>(.*?)</>~us';
    // Current syntax. Example: <tvar name=1>...</tvar>
    public const TVAR_NEW_SYNTAX_REGEX = <<<'REGEXP'
~
<tvar \s+ name \s* = \s*
( ( ' (?<key1> [^']* ) ' ) | ( " (?<key2> [^"]* ) " ) | (?<key3> [^"'\s>]* ) )
\s* > (?<value>.*?) </tvar \s* >
~xusi
REGEXP;
 
    public $id;
    public $text;
    public $type;
    public $oldText = null;
    protected $inline = false;
    private $canWrap = true;
    private $version = 1;
    private static $properties = [ 'version', 'id', 'text', 'type', 'oldText', 'inline' ];
 
    public function __construct(
        string $text,
        string $id = self::NEW_UNIT_ID,
        string $type = 'new',
        string $oldText = null
    ) {
        $this->text = $text;
        $this->id = $id;
        $this->type = $type;
        $this->oldText = $oldText;
    }
 
    public function setIsInline( bool $value ): void {
        $this->inline = $value;
    }
 
    public function isInline(): bool {
        return $this->inline;
    }
 
    public function setCanWrap( bool $value ): void {
        $this->canWrap = $value;
    }
 
    public function canWrap(): bool {
        return $this->canWrap;
    }
 
    public function getText(): string {
        return $this->text;
    }
 
    public function getTextWithVariables(): string {
        $variableReplacements = [];
        foreach ( $this->getVariables() as $variable ) {
            $variableReplacements[$variable->getDefinition()] = $variable->getName();
        }
 
        return strtr( $this->text, $variableReplacements );
    }
 
    public function getTextForTrans(): string {
        $variableReplacements = [];
        foreach ( $this->getVariables() as $variable ) {
            $variableReplacements[$variable->getDefinition()] = $variable->getValue();
        }
 
        return strtr( $this->text, $variableReplacements );
    }
 
    public function getMarkedText(): string {
        $id = $this->id;
        $header = "<!--T:$id-->";
        $re = '~^(=+.*?=+\s*?$)~m';
        $rep = "\\1 $header";
        $count = 0;
 
        $text = preg_replace( $re, $rep, $this->text, 1, $count );
 
        if ( $count === 0 ) {
            if ( $this->inline ) {
                $text = $header . ' ' . $this->text;
            } else {
                $text = $header . "\n" . $this->text;
            }
        }
 
        return $text;
    }
 
    public function getOldText(): string {
        return $this->oldText ?? $this->text;
    }
 
    public function getVariables(): array {
        $vars = [];
 
        $matches = [];
        preg_match_all( self::TVAR_OLD_SYNTAX_REGEX, $this->text, $matches, PREG_SET_ORDER );
        foreach ( $matches as $m ) {
            $vars[] = new TranslationVariable( $m[0], '$' . $m[1], $m[2] );
        }
 
        $matches = [];
        preg_match_all( self::TVAR_NEW_SYNTAX_REGEX, $this->text, $matches, PREG_SET_ORDER );
        foreach ( $matches as $m ) {
            $vars[] = new TranslationVariable(
                $m[0],
                // Maximum of one of these is non-empty string
                '$' . ( $m['key1'] . $m['key2'] . $m['key3'] ),
                $m['value']
            );
        }
 
        return $vars;
    }
 
    public function serializeToArray(): array {
        $data = [];
        foreach ( self::$properties as $index => $property ) {
            // Because this is used for the JobQueue, use a list
            // instead of an array to save space.
            $data[$index] = $this->$property;
        }
 
        return $data;
    }
 
    public static function unserializeFromArray( array $data ): self {
        // Give dummy default text, will be overridden
        $unit = new self( '' );
        foreach ( self::$properties as $index => $property ) {
            $unit->$property = $data[$index];
        }
 
        return $unit;
    }
 
    public function getTextForRendering(
        ?TMessage $msg,
        Language $sourceLanguage,
        Language $targetLanguage,
        bool $wrapUntranslated
    ): string {
        $attributes = [];
 
        if ( $msg && $msg->translation() !== null ) {
            $content = $msg->translation();
            if ( $msg->hasTag( 'fuzzy' ) ) {
                // We do not ever want to show explicit fuzzy marks in the rendered pages
                $content = str_replace( TRANSLATE_FUZZY, '', $content );
                $attributes['class'] = 'mw-translate-fuzzy';
            }
            $translationLanguage = $targetLanguage->getCode();
        } else {
            $content = $this->getTextWithVariables();
            if ( $wrapUntranslated ) {
                $attributes['lang'] = $sourceLanguage->getHtmlCode();
                $attributes['dir'] = $sourceLanguage->getDir();
                $attributes['class'] = 'mw-content-' . $sourceLanguage->getDir();
            }
            $translationLanguage = $sourceLanguage->getCode();
        }
 
        if ( $this->canWrap() && $attributes ) {
            $tag = $this->isInline() ? 'span' : 'div';
            $content = $this->isInline() ? $content : "\n$content\n";
            $content = Html::rawElement( $tag, $attributes, $content );
        }
 
        $variableReplacements = [];
        foreach ( $this->getVariables() as $variable ) {
            $variableReplacements[$variable->getName()] = $variable->getValue();
        }
 
        $content = strtr( $content, $variableReplacements );
 
        // Allow wrapping this inside variables
        $content = preg_replace(
            '/{{\s*TRANSLATIONLANGUAGE\s*}}/',
            $translationLanguage,
            $content
        );
 
        return $content;
    }
 
    public function getIssues(): array {
        $issues = $usedNames = [];
        foreach ( $this->getVariables() as $variable ) {
            $name = $variable->getName();
            $pattern = '/^' . TranslatablePageInsertablesSuggester::NAME_PATTERN . '$/u';
            if ( !preg_match( $pattern, $name ) ) {
                // Key by name to avoid multiple issues of the same name
                $issues[$name] = new TranslationUnitIssue(
                    TranslationUnitIssue::WARNING,
                    'tpt-validation-not-insertable',
                    [ wfEscapeWikiText( $name ) ]
                );
            }
 
            $usedNames[ $name ][] = $variable->getValue();
        }
 
        foreach ( $usedNames as $name => $contents ) {
            $uniqueValueCount = count( array_unique( $contents ) );
            if ( $uniqueValueCount > 1 ) {
                $issues[] = new TranslationUnitIssue(
                    TranslationUnitIssue::ERROR,
                    'tpt-validation-name-reuse',
                    [ wfEscapeWikiText( $name ) ]
                );
            }
        }
 
        return array_values( $issues );
    }
}