TranslationCatalog.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Language\ComponentTranslation\Catalog;
 
use ErrorException;
use Gettext\Generator\MoGenerator;
use Gettext\Generator\PoGenerator;
use Gettext\Loader\MoLoader;
use Gettext\Loader\StrictPoLoader;
use Gettext\Translation;
use Gettext\Translations;
use ILIAS\Language\ComponentTranslation\PluralForms;
use InvalidArgumentException;
use RuntimeException;
use Throwable;
 
final class TranslationCatalog
{
    private const string UTF8_BOM = "\xEF\xBB\xBF";
 
    private Translations $translations;
 
    public function __construct()
    {
        $this->translations = Translations::create();
    }
 
    public function __clone()
    {
        $this->translations = clone $this->translations;
    }
 
    public static function fromPoFile(string $file): self
    {
        $content = is_file($file) && is_readable($file) ? @file_get_contents($file) : false;
        if ($content === false) {
            throw new RuntimeException(sprintf('Could not read PO file "%s".', $file));
        }
 
        try {
            return self::fromPoString($content);
        } catch (RuntimeException $e) {
            throw new RuntimeException(sprintf('Invalid PO file "%s": %s', $file, $e->getMessage()), 0, $e);
        }
    }
 
    public static function fromPoString(string $content): self
    {
        if (str_starts_with($content, self::UTF8_BOM)) {
            $content = substr($content, strlen(self::UTF8_BOM));
        }
        // values are used as UTF-8 as they are, never converted
        if (!mb_check_encoding($content, 'UTF-8')) {
            throw new RuntimeException('The content is not valid UTF-8.');
        }
 
        $translations = self::withLibraryErrorsAsExceptions(
            static function () use ($content): Translations {
                $loader = new StrictPoLoader();
                $loader->displayErrorLine = true;
                return $loader->loadString($content);
            }
        );
        foreach ($translations->getHeaders()->toArray() as $name => $value) {
            // setHeader() refuses a line break, so such a file could be read but never written back: it counts as broken
            if (strpbrk($value, "\r\n") !== false) {
                throw new RuntimeException(sprintf('The value of header "%s" contains a line break.', $name));
            }
        }
        $content_type = $translations->getHeaders()->get('Content-Type');
        if (
            $content_type !== null
            && preg_match('/charset\s*=\s*"?([^\s;"]+)/i', $content_type, $matches) === 1
            && !in_array(strtolower($matches[1]), ['utf-8', 'utf8'], true)
        ) {
            throw new RuntimeException(sprintf('Unsupported charset "%s" - only UTF-8 is supported.', $matches[1]));
        }
        foreach ($translations->getTranslations() as $translation) {
            if ($translation->isDisabled()) {
                $translations->remove($translation);
            }
        }
 
        $catalog = new self();
        $catalog->translations = $translations;
 
        return $catalog;
    }
 
    public static function fromMoString(string $content): self
    {
        $translations = self::withLibraryErrorsAsExceptions(
            static fn(): Translations => (new MoLoader())->loadString($content)
        );
        foreach ($translations->getTranslations() as $translation) {
            if ($translation->getTranslation() === "0\0") {
                $translation->translate('0');
            }
        }
 
        $catalog = new self();
        $catalog->translations = $translations;
 
        return $catalog;
    }
 
    public function getHeaders(): array
    {
        return $this->translations->getHeaders()->toArray();
    }
 
    public function getHeader(string $name): ?string
    {
        return $this->translations->getHeaders()->get($name);
    }
 
    public function setHeader(string $name, string $value): void
    {
        if (strpbrk($value, "\r\n") !== false) {
            throw new InvalidArgumentException(sprintf('The value of header "%s" must not contain a line break.', $name));
        }
        $this->translations->getHeaders()->set($name, $value);
    }
 
    public function find(?string $context, string $id): ?TranslationEntry
    {
        $translation = $this->translations->find($context, $id);
 
        return $translation === null ? null : TranslationEntry::fromGettext($translation);
    }
 
    public function add(TranslationEntry $entry): void
    {
        $this->translations->add($entry->toGettext());
    }
 
    public function addInIdOrder(TranslationEntry $entry): void
    {
        $translation = $entry->toGettext();
        if ($this->translations->has($translation)) {
            $this->translations->add($translation);
            return;
        }
        $following = [];
        foreach ($this->translations->getTranslations() as $existing) {
            if ($following !== [] || strcmp($existing->getOriginal(), $translation->getOriginal()) > 0) {
                $following[] = $existing;
                $this->translations->remove($existing);
            }
        }
        $this->translations->add($translation);
        foreach ($following as $existing) {
            $this->translations->add($existing);
        }
    }
 
    public function getEntries(): array
    {
        return array_values(array_map(
            static fn(Translation $translation): TranslationEntry => TranslationEntry::fromGettext($translation),
            $this->translations->getTranslations()
        ));
    }
 
    public function toPoString(): string
    {
        $translations = $this->prepareForGenerator(false);
        $headers = $translations->getHeaders();
        foreach ($headers->toArray() as $name => $value) {
            $headers->set($name, substr(PoGenerator::encode($value), 1, -1));
        }
 
        return (new PoGenerator())->generateString($translations);
    }
 
    public function toMoString(): string
    {
        return (new MoGenerator())->includeHeaders(true)->generateString($this->prepareForGenerator(true));
    }
 
    private function prepareForGenerator(bool $for_mo): Translations
    {
        $translations = clone $this->translations;
        foreach ($translations as $translation) {
            if (
                in_array($translation->getContext(), ['', '0'], true)
                || in_array($translation->getPlural(), ['', '0'], true)
            ) {
                throw new RuntimeException(sprintf(
                    'The message "%s" has a context or plural id gettext/gettext cannot write.',
                    $translation->getOriginal()
                ));
            }
            if ($for_mo && $translation->getPlural() !== null) {
                self::prepareMoPluralForms($translations, $translation);
            }
            if ($translation->getTranslation() !== '0') {
                continue;
            }
            if ($for_mo && $translation->getPlural() !== null) {
                // In a plural message the NUL would separate an additional, empty plural form
                throw new RuntimeException(sprintf(
                    'The plural message "%s" has the singular translation "0", which gettext/gettext cannot compile.',
                    $translation->getOriginal()
                ));
            }
            $translation->translate("0\0");
        }
 
        return $translations;
    }
 
    private static function prepareMoPluralForms(Translations $translations, Translation $translation): void
    {
        $headers = $translations->getHeaders();
        $plural_forms = PluralForms::fromHeaderOrGermanic($headers->get('Plural-Forms'));
        $library_plural_form = $headers->getPluralForm();
        if (
            $headers->get('Plural-Forms') !== null
            && (!is_array($library_plural_form) || (int) $library_plural_form[0] !== $plural_forms->getCount())
        ) {
            $headers->set('Plural-Forms', $plural_forms->getHeader());
        }
        $surplus = $plural_forms->getCount() - 1;
        $translation->translatePlural(...array_pad(
            array_slice(array_values($translation->getPluralTranslations()), 0, $surplus),
            $surplus,
            ''
        ));
        if (($translation->getTranslation() ?? '') === '' && implode('', $translation->getPluralTranslations()) !== '') {
            throw new RuntimeException(sprintf(
                'The plural message "%s" has an empty msgstr[0] but other forms, which gettext/gettext cannot compile.',
                $translation->getOriginal()
            ));
        }
    }
 
    private static function withLibraryErrorsAsExceptions(callable $load): Translations
    {
        $previous_handler = null;
        $previous_handler = set_error_handler(
            static function (int $severity, string $message, string $file, int $line) use (&$previous_handler): bool {
                if (($severity & (E_DEPRECATED | E_USER_DEPRECATED)) === 0) {
                    throw new ErrorException($message, 0, $severity, $file, $line);
                }
 
                return $previous_handler !== null && $previous_handler($severity, $message, $file, $line) !== false;
            }
        );
        try {
            return $load();
        } catch (Throwable $t) {
            throw new RuntimeException($t->getMessage(), 0, $t);
        } finally {
            restore_error_handler();
        }
    }
}