MigratedLanguageFilePaths.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Language\ComponentTranslation;
 
final class MigratedLanguageFilePaths
{
    private const string LANGUAGE_KEY_FORMAT = '/^[a-z]{2}\z/';
 
    private const string MODULE_FORMAT = '/^[A-Za-z0-9_-]+\z/';
 
    private const string SHIPPED_ARTIFACT_DIRECTORY = 'artifacts/language';
    private const string BUILD_POINTER_FILE = 'current.json';
    private const string SYSTEM_LOCALE_BUILD_POINTER_FILE = 'current-system.json';
    private const string BUILD_ID_FORMAT = '/^b-[0-9a-f]{16,64}\z/';
    private const string OVERLAY_REVISION_FORMAT = '/^r-[0-9a-f]{16,64}\z/';
    private const string SHIPPED_TEMPLATES = 'components/*/*/lang/*.pot';
 
    private static ?string $artifact_directory_for_tests = null;
 
    public static function resolveClientDataDir(?string $ilias_absolute_path = null): ?string
    {
        if (defined('CLIENT_DATA_DIR')) {
            return (string) CLIENT_DATA_DIR;
        }
 
        $ilias_absolute_path ??= dirname(__DIR__, 5);
        $ini_file = rtrim($ilias_absolute_path, '/') . '/ilias.ini.php';
        if (!is_file($ini_file) || !is_readable($ini_file)) {
            return null;
        }
        $ini = @parse_ini_file($ini_file, true);
        if (!is_array($ini)) {
            return null;
        }
 
        $data_dir = $ini['clients']['datadir'] ?? null;
        if (is_string($data_dir) && $data_dir !== '' && !str_starts_with($data_dir, '/')) {
            $data_dir = rtrim($ilias_absolute_path, '/') . '/' . $data_dir;
        }
 
        $client_id = defined('CLIENT_ID') ? (string) CLIENT_ID : ($ini['clients']['default'] ?? null);
 
        return self::fromDataDirAndClientId(
            is_string($data_dir) ? $data_dir : null,
            is_string($client_id) ? $client_id : null
        );
    }
 
    public static function fromDataDirAndClientId(?string $data_dir, ?string $client_id): ?string
    {
        if ($data_dir === null || $data_dir === '' || $client_id === null || $client_id === '') {
            return null;
        }
        if ($client_id === '.' || $client_id === '..' || strpbrk($client_id, "/\\\0") !== false) {
            return null;
        }
 
        $client_data_dir = rtrim($data_dir, '/') . '/' . $client_id;
 
        return is_dir($client_data_dir) ? $client_data_dir : null;
    }
 
    public static function shippedBasePath(
        string $ilias_absolute_path,
        LanguageFileDirectory $directory,
        string $lang_key
    ): string {
        self::assertValidLanguageKey($lang_key);
 
        return self::shippedDirectoryPath($ilias_absolute_path, $directory)
            . sprintf(self::shippedFileNamePattern($directory), $lang_key);
    }
 
    public static function findShippedPoFiles(string $ilias_absolute_path, LanguageFileDirectory $directory): array
    {
        $pattern = self::shippedFileNamePattern($directory);
        $base = self::shippedDirectoryPath($ilias_absolute_path, $directory);
        [$before, $after] = explode('%s', $pattern, 2);
        $name_format = '/\A' . preg_quote($before, '/') . '([a-z]{2})' . preg_quote($after, '/') . '\.po\z/';
 
        $files = [];
        foreach (glob($base . sprintf($pattern, '*') . '.po') ?: [] as $file) {
            if (is_file($file) && preg_match($name_format, basename($file), $matches) === 1) {
                $files[$matches[1]] = $file;
            }
        }
        ksort($files, SORT_STRING);
 
        return $files;
    }
 
    public static function shippedTemplatePath(string $ilias_absolute_path, LanguageFileDirectory $directory): string
    {
        return self::shippedDirectoryPath($ilias_absolute_path, $directory)
            . self::templateFileName(self::shippedFileNamePattern($directory), $directory->getPrefix());
    }
 
    public static function findShippedTemplates(string $ilias_absolute_path): array
    {
        $templates = [];
        foreach (glob(rtrim($ilias_absolute_path, '/') . '/' . self::SHIPPED_TEMPLATES) ?: [] as $file) {
            $module = basename($file, '.pot');
            if (self::isValidModule($module) && is_file($file)) {
                $templates[$module] ??= dirname($file);
            }
        }
 
        return $templates;
    }
 
    public static function isFoundWithoutGraph(string $ilias_absolute_path, LanguageFileDirectory $directory): bool
    {
        $template = self::shippedTemplatePath($ilias_absolute_path, $directory);
 
        return basename($template) === $directory->getPrefix() . '.pot'
            && fnmatch(rtrim($ilias_absolute_path, '/') . '/' . self::SHIPPED_TEMPLATES, $template, FNM_PATHNAME)
            && is_file($template);
    }
 
    public static function templateFileName(string $pattern, string $module): string
    {
        $name = trim(str_replace('%s', '', $pattern), '_-.');
 
        return ($name === '' ? $module : $name) . '.pot';
    }
 
    private static function shippedDirectoryPath(string $ilias_absolute_path, LanguageFileDirectory $directory): string
    {
        return rtrim($ilias_absolute_path, '/') . '/' . ltrim($directory->getPath(), '/');
    }
 
    public static function shippedFileNamePattern(LanguageFileDirectory $directory): string
    {
        $pattern = $directory instanceof NamesShippedLanguageFiles
            ? $directory->getShippedFileNamePattern()
            : $directory->getPrefix() . '_%s';
        self::assertValidShippedFileNamePattern($pattern);
 
        return $pattern;
    }
 
    public static function assertValidShippedFileNamePattern(string $pattern): void
    {
        if (
            substr_count($pattern, '%s') !== 1
            || str_contains($pattern, '..')
            || preg_match('/\A[A-Za-z0-9_.\-]*%s[A-Za-z0-9_.\-]*\z/', $pattern) !== 1
        ) {
            throw new \InvalidArgumentException(sprintf('"%s" is not a valid file name pattern for shipped language files.', $pattern));
        }
    }
 
    public static function shippedArtifactDirectory(string $ilias_absolute_path): string
    {
        return self::$artifact_directory_for_tests
            ?? rtrim($ilias_absolute_path, '/') . '/' . self::SHIPPED_ARTIFACT_DIRECTORY;
    }
 
    public static function useArtifactDirectoryForTests(?string $artifact_directory): void
    {
        self::$artifact_directory_for_tests = $artifact_directory;
    }
 
    public static function buildPointerFile(string $artifact_directory): string
    {
        return self::buildPointerFileOf($artifact_directory, NativeGettext::usesSystemLocale());
    }
 
    public static function buildPointerFileOf(string $artifact_directory, bool $system_locale): string
    {
        return rtrim($artifact_directory, '/') . '/'
            . ($system_locale ? self::SYSTEM_LOCALE_BUILD_POINTER_FILE : self::BUILD_POINTER_FILE);
    }
 
    public static function buildDirectory(string $artifact_directory, string $build_id): string
    {
        if (preg_match(self::BUILD_ID_FORMAT, $build_id) !== 1) {
            throw new \InvalidArgumentException(sprintf('"%s" is not a valid build id.', $build_id));
        }
 
        return rtrim($artifact_directory, '/') . '/' . $build_id;
    }
 
    public static function isBuildId(string $name): bool
    {
        return preg_match(self::BUILD_ID_FORMAT, $name) === 1;
    }
 
    public static function buildMoFile(string $build_directory, string $module, string $lang_key): string
    {
        return rtrim($build_directory, '/') . '/' . NativeGettext::CATALOG_DIRECTORY . '/' . self::shippedDomain($module, $lang_key) . '.mo';
    }
 
    public static function buildKeysFile(string $build_directory, string $module): string
    {
        self::assertValidModule($module);
 
        return rtrim($build_directory, '/') . '/keys/' . $module . '.php';
    }
 
    public static function buildLocaleDirectory(string $build_directory): string
    {
        return rtrim($build_directory, '/') . '/locale';
    }
 
    public static function shippedDomain(string $module, string $lang_key): string
    {
        self::assertValidModule($module);
        self::assertValidLanguageKey($lang_key);
 
        return $module . '.' . $lang_key;
    }
 
    public static function overlayDomain(string $module, string $lang_key): string
    {
        return self::shippedDomain($module, $lang_key) . '.overlay';
    }
 
    public static function overlayDirectory(string $client_data_dir, string $module, string $lang_key): string
    {
        self::assertValidModule($module);
        self::assertValidLanguageKey($lang_key);
 
        return rtrim($client_data_dir, '/') . '/lang/' . $module . '/' . $lang_key;
    }
 
    public static function overlayPoFile(string $client_data_dir, LanguageFileDirectory $directory, string $lang_key): string
    {
        return self::overlayDirectory($client_data_dir, $directory->getPrefix(), $lang_key)
            . '/' . sprintf(self::shippedFileNamePattern($directory), $lang_key) . '.po';
    }
 
    public static function overlayLockFile(string $overlay_directory): string
    {
        return rtrim($overlay_directory, '/') . '/lock';
    }
 
    public static function overlayCurrentFile(string $overlay_directory): string
    {
        return rtrim($overlay_directory, '/') . '/current';
    }
 
    public static function overlayRevisionDirectory(string $overlay_directory, string $revision): string
    {
        if (!self::isOverlayRevision($revision)) {
            throw new \InvalidArgumentException(sprintf('"%s" is not a valid overlay revision.', $revision));
        }
 
        return rtrim($overlay_directory, '/') . '/' . $revision;
    }
 
    public static function isOverlayRevision(string $name): bool
    {
        return preg_match(self::OVERLAY_REVISION_FORMAT, $name) === 1;
    }
 
    public static function overlayMoFile(string $revision_directory, string $module, string $lang_key): string
    {
        return rtrim($revision_directory, '/') . '/' . NativeGettext::CATALOG_DIRECTORY . '/' . self::overlayDomain($module, $lang_key) . '.mo';
    }
 
    public static function overlayKeysFile(string $revision_directory): string
    {
        return rtrim($revision_directory, '/') . '/keys.json';
    }
 
    public static function takenOverFile(string $client_data_dir, string $lang_key): string
    {
        self::assertValidLanguageKey($lang_key);
 
        return rtrim($client_data_dir, '/') . '/lang/taken-over.' . $lang_key . '.json';
    }
 
    public static function takenOverLockFile(string $client_data_dir, string $lang_key): string
    {
        self::assertValidLanguageKey($lang_key);
 
        return rtrim($client_data_dir, '/') . '/lang/.locks/taken-over.' . $lang_key . '.lock';
    }
 
    public static function templateLockFile(string $client_data_dir, LanguageFileDirectory $directory): string
    {
        $module = $directory->getPrefix();
        self::assertValidModule($module);
 
        return rtrim($client_data_dir, '/') . '/lang/' . $module . '/template.lock';
    }
 
    public static function isValidModule(string $module): bool
    {
        return preg_match(self::MODULE_FORMAT, $module) === 1;
    }
 
    public static function isValidLanguageKey(string $lang_key): bool
    {
        return preg_match(self::LANGUAGE_KEY_FORMAT, $lang_key) === 1;
    }
 
    private static function assertValidModule(string $module): void
    {
        if (!self::isValidModule($module)) {
            throw new \InvalidArgumentException(sprintf('"%s" is not a valid module name.', $module));
        }
    }
 
    private static function assertValidLanguageKey(string $lang_key): void
    {
        if (!self::isValidLanguageKey($lang_key)) {
            throw new \InvalidArgumentException(sprintf('"%s" is not a valid language key.', $lang_key));
        }
    }
}