Translator.php

Go to the documentation of this file.

<?php

namespace Elgg\I18n;

use Elgg\Config;
use Elgg\Includer;

class Translator {

    private $config;
    
    private $localeService;

    private $translations = [];

    private $defaultPath = null;

    private $current_language = null;

    private $language_paths = [];

    private $was_reloaded = false;

    public function __construct(Config $config, LocaleService $localService) {
        $this->config = $config;
        $this->localeService = $localService;
        
        $this->defaultPath = dirname(dirname(dirname(dirname(__DIR__)))) . "/languages/";
        
        $this->registerLanguagePath($this->defaultPath);
    }

    public function getLoadedTranslations() {
        return $this->translations;
    }

    public function translate($message_key, array $args = [], $language = "") {
        if (!is_string($message_key) || strlen($message_key) < 1) {
            _elgg_services()->logger->warning(
                '$message_key needs to be a string in ' . __METHOD__ . '(), ' . gettype($message_key) . ' provided'
            );
            return '';
        }

        if (!$language) {
            // no language provided, get current language
            // based on detection, user setting or site
            $language = $this->getCurrentLanguage();
        }

        $this->ensureTranslationsLoaded($language);

        // build language array for different trys
        // avoid dupes without overhead of array_unique
        $langs = [
            $language => true,
        ];

        // load site language
        $site_language = $this->config->language;
        if (!empty($site_language)) {
            $this->ensureTranslationsLoaded($site_language);

            $langs[$site_language] = true;
        }

        // ultimate language fallback
        $langs['en'] = true;

        // try to translate
        $logger = _elgg_services()->logger;
        $string = $message_key;
        foreach (array_keys($langs) as $try_lang) {
            if (isset($this->translations[$try_lang][$message_key])) {
                $string = $this->translations[$try_lang][$message_key];

                // only pass through if we have arguments to allow backward compatibility
                // with manual sprintf() calls.
                if (!empty($args)) {
                    $string = vsprintf($string, $args);
                }

                break;
            } else {
                $message = sprintf(
                    'Missing %s translation for "%s" language key',
                    ($try_lang === 'en') ? 'English' : $try_lang,
                    $message_key
                );
                
                if ($try_lang === 'en') {
                    $logger->notice($message);
                } else {
                    $logger->info($message);
                }
            }
        }

        return $string;
    }

    public function addTranslation($country_code, $language_array, $ensure_translations_loaded = true) {
        $country_code = strtolower($country_code);
        $country_code = trim($country_code);

        if (!is_array($language_array) || empty($language_array) || $country_code === "") {
            return false;
        }

        if (!isset($this->translations[$country_code])) {
            $this->translations[$country_code] = [];
            
            if ($ensure_translations_loaded) {
                // make sure all existing paths are included first before adding language arrays
                $this->loadTranslations($country_code);
            }
        }

        // Note that we are using union operator instead of array_merge() due to performance implications
        $this->translations[$country_code] = $language_array + $this->translations[$country_code];

        return true;
    }

    public function getCurrentLanguage() {
        if (!isset($this->current_language)) {
            $this->current_language = $this->detectLanguage();
        }

        if (!$this->current_language) {
            $this->current_language = 'en';
        }

        return $this->current_language;
    }

    public function setCurrentLanguage($language = null) {
        $this->current_language = $language;
    }

    public function detectLanguage() {
        // detect from URL
        $url_lang = _elgg_services()->request->getParam('hl');
        if (!empty($url_lang)) {
            return $url_lang;
        }

        // check logged in user
        $user = _elgg_services()->session->getLoggedInUser();
        if (!empty($user) && !empty($user->language)) {
            return $user->language;
        }

        // get site setting
        $site_language = $this->config->language;
        if (!empty($site_language)) {
            return $site_language;
        }

        return false;
    }

    public function bootTranslations() {
        $languages = array_unique(['en', $this->getCurrentLanguage()]);
        
        foreach ($languages as $language) {
            $this->loadTranslations($language);
        }
    }

    public function loadTranslations($language) {
        if (!is_string($language)) {
            return;
        }
        
        $data = elgg_load_system_cache("{$language}.lang");
        if (is_array($data)) {
            $this->addTranslation($language, $data, false);
            return;
        }
        
        foreach ($this->getLanguagePaths() as $path) {
            $this->registerTranslations($path, false, $language);
        }
            
        $translations = elgg_extract($language, $this->translations, []);
        elgg_save_system_cache("{$language}.lang", $translations);
    }

    public function registerTranslations($path, $load_all = false, $language = null) {
        $path = \Elgg\Project\Paths::sanitize($path);
        
        // don't need to register translations as the folder is missing
        if (!is_dir($path)) {
            _elgg_services()->logger->info("No translations could be loaded from: $path");
            return true;
        }

        // Make a note of this path just in case we need to register this language later
        $this->registerLanguagePath($path);

        _elgg_services()->logger->info("Translations loaded from: $path");

        if ($language) {
            $load_language_files = ["$language.php"];
            $load_all = false;
        } else {
            // Get the current language based on site defaults and user preference
            $current_language = $this->getCurrentLanguage();

            $load_language_files = [
                'en.php',
                "$current_language.php"
            ];

            $load_language_files = array_unique($load_language_files);
        }

        $return = true;
        if ($handle = opendir($path)) {
            while (false !== ($language_file = readdir($handle))) {
                // ignore bad files
                if (substr($language_file, 0, 1) == '.' || substr($language_file, -4) !== '.php') {
                    continue;
                }

                if (in_array($language_file, $load_language_files) || $load_all) {
                    $return = $return && $this->includeLanguageFile($path . $language_file);
                }
            }
            closedir($handle);
        } else {
            _elgg_services()->logger->error("Could not open language path: $path");
            $return = false;
        }

        return $return;
    }

    protected function includeLanguageFile($path) {
        $result = Includer::includeFile($path);
        
        if (is_array($result)) {
            $this->addTranslation(basename($path, '.php'), $result);
            return true;
        }

        return false;
    }

    public function reloadAllTranslations() {
        if ($this->was_reloaded) {
            return;
        }

        $languages = $this->getAvailableLanguages();
        
        foreach ($languages as $language) {
            $this->ensureTranslationsLoaded($language);
        }
        
        _elgg_services()->events->triggerAfter('reload', 'translations');

        $this->was_reloaded = true;
    }

    public function getInstalledTranslations($calculate_completeness = false) {
        if ($calculate_completeness) {
            // Ensure that all possible translations are loaded
            $this->reloadAllTranslations();
        }
        
        $result = [];

        $languages = $this->getAvailableLanguages();
        foreach ($languages as $language) {
            if ($this->languageKeyExists($language, $language)) {
                $value = $this->translate($language, [], $language);
            } else {
                $value = $this->translate($language);
            }
            
            if (($language !== 'en') && $calculate_completeness) {
                $completeness = $this->getLanguageCompleteness($language);
                $value .= " (" . $completeness . "% " . $this->translate('complete') . ")";
            }
            
            $result[$language] = $value;
        }
        
        natcasesort($result);
            
        return $result;
    }

    public function getLanguageCompleteness($language) {

        if ($language == 'en') {
            return (float) 100;
        }

        // Ensure that all possible translations are loaded
        $this->reloadAllTranslations();

        $en = count($this->translations['en']);

        $missing = $this->getMissingLanguageKeys($language);
        if ($missing) {
            $missing = count($missing);
        } else {
            $missing = 0;
        }

        $lang = $en - $missing;

        return round(($lang / $en) * 100, 2);
    }

    public function getMissingLanguageKeys($language) {

        // Ensure that all possible translations are loaded
        $this->reloadAllTranslations();

        $missing = [];

        foreach ($this->translations['en'] as $k => $v) {
            if ((!isset($this->translations[$language][$k]))
                || ($this->translations[$language][$k] == $this->translations['en'][$k])) {
                $missing[] = $k;
            }
        }

        if (count($missing)) {
            return $missing;
        }

        return false;
    }

    public function languageKeyExists($key, $language = 'en') {
        if (empty($key)) {
            return false;
        }

        $this->ensureTranslationsLoaded($language);

        if (!array_key_exists($language, $this->translations)) {
            return false;
        }

        return array_key_exists($key, $this->translations[$language]);
    }
    
    public function getAvailableLanguages() {
        $languages = [];
        
        $allowed_languages = $this->localeService->getLanguageCodes();
        
        foreach ($this->getLanguagePaths() as $path) {
            try {
                $iterator = new \DirectoryIterator($path);
            } catch (\Exception $e) {
                continue;
            }
            
            foreach ($iterator as $file) {
                if ($file->isDir()) {
                    continue;
                }
                
                if ($file->getExtension() !== 'php') {
                    continue;
                }
                
                $language = $file->getBasename('.php');
                if (empty($language) || !in_array($language, $allowed_languages)) {
                    continue;
                }
                
                $languages[$language] = true;
            }
        }
        
        $languages = array_keys($languages);
                
        return _elgg_services()->hooks->trigger('languages', 'translations', [], $languages);
    }
    
    public function registerLanguagePath($path) {
        $this->language_paths[$path] = true;
    }
    
    protected function getLanguagePaths() {
        return array_keys($this->language_paths);
    }

    private function ensureTranslationsLoaded($language) {
        if (isset($this->translations[$language])) {
            return;
        }
        
        // The language being requested is not the same as the language of the
        // logged in user, so we will have to load it separately. (Most likely
        // we're sending a notification and the recipient is using a different
        // language than the logged in user.)
        $this->loadTranslations($language);
    }

    public static function getAllLanguageCodes() {
        elgg_deprecated_notice(__METHOD__ . ' has been deprecated use elgg()->locale->getLanguageCodes()', '3.0');
        return elgg()->locale->getLanguageCodes();
    }

    public static function normalizeLanguageCode($code) {
        $code = strtolower($code);
        $code = preg_replace('~[^a-z0-9]~', '_', $code);
        return $code;
    }
}