TranslatorManager.php

Go to the documentation of this file.

<?php
 
namespace Ubiquity\translation;
 
use Ubiquity\exceptions\CacheException;
use Ubiquity\log\Logger;
use Ubiquity\translation\loader\ArrayLoader;
use Ubiquity\utils\base\UFileSystem;
use Ubiquity\utils\http\URequest;
 
class TranslatorManager {
    protected static $locale;
    protected static $loader;
    protected static $catalogues;
    protected static $fallbackLocale;
 
    protected static function transCallable($callback, $id, array $parameters = array (), $domain = null, $locale = null) {
        if (null === $domain) {
            $domain = 'messages';
        }
        $id = ( string ) $id;
        $catalogue = self::getCatalogue ( $locale );
        if ($catalogue === false) {
            if (isset ( self::$fallbackLocale ) && $locale !== self::$fallbackLocale) {
                self::setLocale ( self::$fallbackLocale );
                Logger::warn ( 'Translation', 'Locale ' . $locale . ' not found, set active locale to ' . self::$locale );
                return self::trans ( $id, $parameters, $domain, self::$locale );
            } else {
                Logger::error ( 'Translation', 'Locale not found, no valid fallbackLocale specified' );
                return $id;
            }
        }
        $transId = self::getTransId ( $id, $domain );
        if (isset ( $catalogue [$transId] )) {
            return $callback ( $catalogue [$transId], $parameters );
        } elseif (self::$fallbackLocale !== null && $locale !== self::$fallbackLocale) {
            Logger::warn ( 'Translation', 'Translation not found for ' . $id . '. Switch to fallbackLocale ' . self::$fallbackLocale );
            return self::trans ( $id, $parameters, $domain, self::$fallbackLocale );
        } else {
            Logger::warn ( 'Translation', 'Translation not found for ' . $id . '. in locales.' );
            return $id;
        }
    }
 
    protected static function doChoice($message, array $choice, array $parameters = [ ]) {
        $message = ( string ) $message;
 
        $number = ( float ) current ( $choice );
        $parameters = $parameters + $choice;
        $parts = [ ];
        if (preg_match ( '/^\|++$/', $message )) {
            $parts = explode ( '|', $message );
        } elseif (preg_match_all ( '/(?:\|\||[^\|])++/', $message, $matches )) {
            $parts = $matches [0];
        }
        $intervalRegexp = <<<'EOF'
        /^(?P<interval>
            ({\s*
                (\-?\d+(\.\d+)?[\s*,\s*\-?\d+(\.\d+)?]*)
            \s*})
                |
            (?P<left_delimiter>[\[\]])
                \s*
                (?P<left>-Inf|\-?\d+(\.\d+)?)
                \s*,\s*
                (?P<right>\+?Inf|\-?\d+(\.\d+)?)
                \s*
            (?P<right_delimiter>[\[\]])
        )\s*(?P<message>.*?)$/xs
        EOF;
        foreach ( $parts as $part ) {
            $part = trim ( str_replace ( '||', '|', $part ) );
            if (preg_match ( $intervalRegexp, $part, $matches )) {
                if ($matches [2]) {
                    foreach ( explode ( ',', $matches [3] ) as $n ) {
                        if ($number == $n) {
                            return self::replaceParams ( $matches ['message'], $parameters );
                        }
                    }
                } else {
                    $leftNumber = '-Inf' === $matches ['left'] ? - INF : ( float ) $matches ['left'];
                    $rightNumber = \is_numeric ( $matches ['right'] ) ? ( float ) $matches ['right'] : INF;
                    if (('[' === $matches ['left_delimiter'] ? $number >= $leftNumber : $number > $leftNumber) && (']' === $matches ['right_delimiter'] ? $number <= $rightNumber : $number < $rightNumber)) {
                        return self::replaceParams ( $matches ['message'], $parameters );
                    }
                }
            } else {
                return self::replaceParams ( $message, $parameters );
            }
        }
    }
 
    protected static function replaceParams($trans, array $parameters = array ()) {
        foreach ( $parameters as $k => $v ) {
            $trans = str_replace ( '%' . $k . '%', $v, $trans );
        }
        return $trans;
    }
 
    protected static function getTransId($id, $domain) {
        return $domain . '.' . $id;
    }
 
    protected static function assertValidLocale($locale) {
        if (1 !== preg_match ( '/^[a-z0-9@_\\.\\-]*$/i', $locale )) {
            throw new \InvalidArgumentException ( sprintf ( 'Invalid "%s" locale.', $locale ) );
        }
    }
 
    public static function isValidLocale($locale) {
        return (1 === preg_match ( '/^[a-z0-9@_\\.\\-]*$/i', $locale ));
    }
 
    public static function start($locale = 'en_EN', $fallbackLocale = null, $rootDir = null) {
        self::$locale = $locale;
        self::$fallbackLocale = $fallbackLocale;
        self::setRootDir ( $rootDir );
    }
 
    public static function setLocale($locale) {
        self::assertValidLocale ( $locale );
        self::$locale = $locale;
    }
 
    public static function setRootDir($rootDir = null) {
        if (! isset ( $rootDir )) {
            $rootDir = \ROOT . \DS . 'translations';
        }
        self::$loader = new ArrayLoader ( $rootDir );
    }
 
    public static function getLocale() {
        return self::$locale;
    }
 
    public static function trans($id, array $parameters = array (), $domain = null, $locale = null) {
        return self::transCallable ( function ($trans, $parameters) {
            return self::replaceParams ( $trans, $parameters );
        }, $id, $parameters, $domain, $locale );
    }
 
    public static function transChoice($id, array $choice, array $parameters = array (), $domain = null, $locale = null) {
        return self::transCallable ( function ($message, $parameters) use ($choice) {
            return self::doChoice ( $message, $choice, $parameters );
        }, $id, $parameters, $domain, $locale );
    }
 
    public static function getCatalogue(&$locale = null) {
        if (null === $locale) {
            $locale = self::getLocale ();
        } else {
            self::assertValidLocale ( $locale );
        }
        if (! isset ( self::$catalogues [$locale] )) {
            self::loadCatalogue ( $locale );
        }
        return self::$catalogues [$locale] ?? false;
    }
 
    public static function loadCatalogue($locale = null) {
        self::$catalogues [$locale] = self::$loader->load ( $locale );
    }
 
    public static function getFallbackLocale() {
        return self::$fallbackLocale;
    }
 
    public static function setFallbackLocale($fallbackLocale) {
        self::$fallbackLocale = $fallbackLocale;
    }
 
    public static function clearCache() {
        self::$loader->clearCache ( '*' );
    }
 
    public static function clearLocaleCache($locale) {
        self::$loader->clearCache ( $locale );
    }
 
    public static function getLocales() {
        $locales = [ ];
        $dirs = \glob ( self::getRootDir () . \DS . '*', GLOB_ONLYDIR );
        foreach ( $dirs as $dir ) {
            $locales [] = \basename ( $dir );
        }
        return $locales;
    }
 
    public static function getDomains($locale) {
        $catalog = new MessagesCatalog ( $locale, self::$loader );
        return $catalog->getDomains ();
    }
 
    public static function getRootDir() {
        return self::$loader->getRootDir ();
    }
 
    public static function getLoader() {
        return self::$loader;
    }
 
    public static function getCatalogues() {
        return self::$catalogues;
    }
 
    public static function initialize($rootDir = null) {
        $locale = URequest::getDefaultLanguage ();
        self::createLocale ( self::fixLocale ( $locale ), $rootDir );
        return self::getLocales ();
    }
 
    public static function fixLocale($language) {
        return \str_replace ( [ '-','.' ], '_', $language );
    }
 
    public static function createLocale($locale, $rootDir = null) {
        self::setRootDir ( $rootDir );
        UFileSystem::safeMkdir ( self::getRootDir () . \DS . $locale );
    }
 
    public static function createDomain($locale, $domain, $defaultValues = null) {
        if (isset ( self::$loader )) {
            $domains = self::getDomains ( $locale );
            if (\array_search ( $domain, $domains ) === false) {
                $dom = new MessagesDomain ( $locale, self::$loader, $domain );
                if (\is_array ( $defaultValues )) {
                    $dom->setMessages ( $defaultValues );
                }
                $dom->store ();
                return $dom;
            }
            return false;
        }
        throw new CacheException ( 'TranslatorManager is not started!' );
    }
 
    public static function cacheExist($locale, $domain = '*') {
        return self::$loader->cacheExists ( $locale, $domain );
    }
}