Translator.php

Go to the documentation of this file.

<?php
namespace Elgg\I18n;

class Translator {
    
    private $CONFIG;

    public function __construct() {
        global $CONFIG;
        $this->CONFIG = $CONFIG;
        $this->defaultPath = dirname(dirname(dirname(dirname(__DIR__)))) . "/languages/";
    }
    
    function translate($message_key, $args = array(), $language = "") {
        
    
        static $CURRENT_LANGUAGE;
    
        // old param order is deprecated
        if (!is_array($args)) {
            elgg_deprecated_notice(
                'As of Elgg 1.8, the 2nd arg to elgg_echo() is an array of string replacements and the 3rd arg is the language.',
                1.8
            );
    
            $language = $args;
            $args = array();
        }
    
        if (!isset($this->CONFIG->translations)) {
            // this means we probably had an exception before translations were initialized
            $this->registerTranslations($this->defaultPath);
        }
    
        if (!$CURRENT_LANGUAGE) {
            $CURRENT_LANGUAGE = $this->getLanguage();
        }
        if (!$language) {
            $language = $CURRENT_LANGUAGE;
        }

        if (!isset($this->CONFIG->translations[$language])) {
            // 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.)
            _elgg_load_translations_for_language($language);
        }

        if (isset($this->CONFIG->translations[$language][$message_key])) {
            $string = $this->CONFIG->translations[$language][$message_key];
        } else if (isset($this->CONFIG->translations["en"][$message_key])) {
            $string = $this->CONFIG->translations["en"][$message_key];
            _elgg_services()->logger->notice(sprintf('Missing %s translation for "%s" language key', $language, $message_key));
        } else {
            $string = $message_key;
            _elgg_services()->logger->notice(sprintf('Missing English translation for "%s" language key', $message_key));
        }
    
        // only pass through if we have arguments to allow backward compatibility
        // with manual sprintf() calls.
        if ($args) {
            $string = vsprintf($string, $args);
        }
    
        return $string;
    }
    
    function addTranslation($country_code, $language_array) {
        
        if (!isset($this->CONFIG->translations)) {
            $this->CONFIG->translations = array();
        }
    
        $country_code = strtolower($country_code);
        $country_code = trim($country_code);
        if (is_array($language_array) && $country_code != "") {
            if (sizeof($language_array) > 0) { 
                if (!isset($this->CONFIG->translations[$country_code])) {
                    $this->CONFIG->translations[$country_code] = $language_array;
                } else {
                    $this->CONFIG->translations[$country_code] = $language_array + $this->CONFIG->translations[$country_code];
                }
            }
            return true;
        }
        return false;
    }
    
    function getCurrentLanguage() {
        $language = $this->getLanguage();
    
        if (!$language) {
            $language = 'en';
        }
    
        return $language;
    }
    
    function getLanguage() {
        $user = _elgg_services()->session->getLoggedInUser();
        $language = false;
    
        if (($user) && ($user->language)) {
            $language = $user->language;
        }
    
        if ((!$language) && (isset($this->CONFIG->language)) && ($this->CONFIG->language)) {
            $language = $this->CONFIG->language;
        }
    
        if ($language) {
            return $language;
        }
    
        return false;
    }
    
    function loadTranslations() {
        
    
        if ($this->CONFIG->system_cache_enabled) {
            $loaded = true;
            $languages = array_unique(array('en', $this->getCurrentLanguage()));
            foreach ($languages as $language) {
                $data = elgg_load_system_cache("$language.lang");
                if ($data) {
                    $this->addTranslation($language, unserialize($data));
                } else {
                    $loaded = false;
                }
            }
    
            if ($loaded) {
                $this->CONFIG->i18n_loaded_from_cache = true;
                // this is here to force 
                $this->CONFIG->language_paths[$this->defaultPath] = true;
                return;
            }
        }
    
        // load core translations from languages directory
        $this->registerTranslations($this->defaultPath);
    }
    
    
    
    function registerTranslations($path, $load_all = false) {
        $path = sanitise_filepath($path);
    
        // Make a note of this path just incase we need to register this language later
        if (!isset($this->CONFIG->language_paths)) {
            $this->CONFIG->language_paths = array();
        }
        $this->CONFIG->language_paths[$path] = true;
    
        // Get the current language based on site defaults and user preference
        $current_language = $this->getCurrentLanguage();
        _elgg_services()->logger->info("Translations loaded from: $path");

        // only load these files unless $load_all is true.
        $load_language_files = array(
            'en.php',
            "$current_language.php"
        );
    
        $load_language_files = array_unique($load_language_files);
    
        $handle = opendir($path);
        if (!$handle) {
            _elgg_services()->logger->error("Could not open language path: $path");
            return false;
        }
    
        $return = true;
        while (false !== ($language = readdir($handle))) {
            // ignore bad files
            if (substr($language, 0, 1) == '.' || substr($language, -4) !== '.php') {
                continue;
            }
    
            if (in_array($language, $load_language_files) || $load_all) {
                $result = include_once($path . $language);
                if ($result === false) {
                    $return = false;
                    continue;
                } elseif (is_array($result)) {
                    $this->addTranslation(basename($language, '.php'), $result);
                }
            }
        }
    
        return $return;
    }
    
    function reloadAllTranslations() {
        
    
        static $LANG_RELOAD_ALL_RUN;
        if ($LANG_RELOAD_ALL_RUN) {
            return;
        }
    
        if ($this->CONFIG->i18n_loaded_from_cache) {
            $cache = elgg_get_system_cache();
            $cache_dir = $cache->getVariable("cache_path");
            $filenames = elgg_get_file_list($cache_dir, array(), array(), array(".lang"));
            foreach ($filenames as $filename) {
                // Look for files matching for example 'en.lang', 'cmn.lang' or 'pt_br.lang'.
                // Note that this regex is just for the system cache. The original language
                // files are allowed to have uppercase letters (e.g. pt_BR.php).
                if (preg_match('/(([a-z]{2,3})(_[a-z]{2})?)\.lang$/', $filename, $matches)) {
                    $language = $matches[1];
                    $data = elgg_load_system_cache("$language.lang");
                    if ($data) {
                        $this->addTranslation($language, unserialize($data));
                    }
                }
            }
        } else {
            foreach ($this->CONFIG->language_paths as $path => $dummy) {
                $this->registerTranslations($path, true);
            }
        }
    
        $LANG_RELOAD_ALL_RUN = true;
    }
    
    function getInstalledTranslations() {
        
    
        // Ensure that all possible translations are loaded
        $this->reloadAllTranslations();
    
        $installed = array();
    
        foreach ($this->CONFIG->translations as $k => $v) {
            $installed[$k] = $this->translate($k, array(), $k);
            if (_elgg_services()->session->isAdminLoggedIn()) {
                $completeness = $this->getLanguageCompleteness($k);
                if (($completeness < 100) && ($k != 'en')) {
                    $installed[$k] .= " (" . $completeness . "% " . $this->translate('complete') . ")";
                }
            }
        }
    
        return $installed;
    }
    
    function getLanguageCompleteness($language) {
        
    
        // Ensure that all possible translations are loaded
        $this->reloadAllTranslations();
    
        $language = sanitise_string($language);
    
        $en = count($this->CONFIG->translations['en']);
    
        $missing = $this->getMissingLanguageKeys($language);
        if ($missing) {
            $missing = count($missing);
        } else {
            $missing = 0;
        }
    
        //$lang = count($this->CONFIG->translations[$language]);
        $lang = $en - $missing;
    
        return round(($lang / $en) * 100, 2);
    }
    
    function getMissingLanguageKeys($language) {
        
    
        // Ensure that all possible translations are loaded
        $this->reloadAllTranslations();
    
        $missing = array();
    
        foreach ($this->CONFIG->translations['en'] as $k => $v) {
            if ((!isset($this->CONFIG->translations[$language][$k]))
            || ($this->CONFIG->translations[$language][$k] == $this->CONFIG->translations['en'][$k])) {
                $missing[] = $k;
            }
        }
    
        if (count($missing)) {
            return $missing;
        }
    
        return false;
    }

}