src/Core/L10n/L10n.php

   1 <?php
   2
   3 namespace Friendica\Core\L10n;
   4
   5 use Friendica\Core\Config\Configuration;
   6 use Friendica\Core\Hook;
   7 use Friendica\Core\Session;
   8 use Friendica\Database\Database;
   9 use Friendica\Util\Strings;
  10 use Psr\Log\LoggerInterface;
  11
  12 /**
  13  * Provide Language, Translation, and Localization functions to the application
  14  * Localization can be referred to by the numeronym L10N (as in: "L", followed by ten more letters, and then "N").
  15  */
  16 class L10n
  17 {
  18         /**
  19          * A string indicating the current language used for translation:
  20          * - Two-letter ISO 639-1 code.
  21          * - Two-letter ISO 639-1 code + dash + Two-letter ISO 3166-1 alpha-2 country code.
  22          *
  23          * @var string
  24          */
  25         private $lang = '';
  26         /**
  27          * A language code saved for later after pushLang() has been called.
  28          *
  29          * @var string
  30          */
  31         private $langSave = '';
  32
  33         /**
  34          * An array of translation strings whose key is the neutral english message.
  35          *
  36          * @var array
  37          */
  38         private $strings = [];
  39         /**
  40          * An array of translation strings saved for later after pushLang() has been called.
  41          *
  42          * @var array
  43          */
  44         private $stringsSave = [];
  45
  46         /**
  47          * @var Database
  48          */
  49         private $dba;
  50
  51         /**
  52          * @var LoggerInterface
  53          */
  54         private $logger;
  55
  56         public function __construct(Configuration $config, Database $dba, LoggerInterface $logger, array $server, array $get)
  57         {
  58                 $this->dba    = $dba;
  59                 $this->logger = $logger;
  60
  61                 $this->loadTranslationTable(L10n::detectLanguage($server, $get, $config->get('system', 'language', 'en')));
  62         }
  63
  64         /**
  65          * Returns the current language code
  66          *
  67          * @return string Language code
  68          */
  69         public function getCurrentLang()
  70         {
  71                 return $this->lang;
  72         }
  73
  74         /**
  75          * Sets the language session variable
  76          */
  77         public function setSessionVariable()
  78         {
  79                 if (Session::get('authenticated') && !Session::get('language')) {
  80                         $_SESSION['language'] = $this->lang;
  81                         // we haven't loaded user data yet, but we need user language
  82                         if (Session::get('uid')) {
  83                                 $user = $this->dba->selectFirst('user', ['language'], ['uid' => $_SESSION['uid']]);
  84                                 if ($this->dba->isResult($user)) {
  85                                         $_SESSION['language'] = $user['language'];
  86                                 }
  87                         }
  88                 }
  89
  90                 if (isset($_GET['lang'])) {
  91                         Session::set('language', $_GET['lang']);
  92                 }
  93         }
  94
  95         public function setLangFromSession()
  96         {
  97                 if (Session::get('language') !== $this->lang) {
  98                         $this->loadTranslationTable(Session::get('language'));
  99                 }
 100         }
 101
 102         /**
 103          * This function should be called before formatting messages in a specific target language
 104          * different from the current user/system language.
 105          *
 106          * It saves the current translation strings in a separate variable and loads new translations strings.
 107          *
 108          * If called repeatedly, it won't save the translation strings again, just load the new ones.
 109          *
 110          * @param string $lang Language code
 111          *
 112          * @throws \Exception
 113          * @see   popLang()
 114          * @brief Stores the current language strings and load a different language.
 115          */
 116         public function pushLang($lang)
 117         {
 118                 if ($lang === $this->lang) {
 119                         return;
 120                 }
 121
 122                 if (empty($this->langSave)) {
 123                         $this->langSave    = $this->lang;
 124                         $this->stringsSave = $this->strings;
 125                 }
 126
 127                 $this->loadTranslationTable($lang);
 128         }
 129
 130         /**
 131          * Restores the original user/system language after having used pushLang()
 132          */
 133         public function popLang()
 134         {
 135                 if (!isset($this->langSave)) {
 136                         return;
 137                 }
 138
 139                 $this->strings = $this->stringsSave;
 140                 $this->lang    = $this->langSave;
 141
 142                 $this->stringsSave = null;
 143                 $this->langSave    = null;
 144         }
 145
 146         /**
 147          * Loads string translation table
 148          *
 149          * First addon strings are loaded, then globals
 150          *
 151          * Uses an App object shim since all the strings files refer to $a->strings
 152          *
 153          * @param string $lang language code to load
 154          *
 155          * @throws \Exception
 156          */
 157         private function loadTranslationTable($lang)
 158         {
 159                 $lang = Strings::sanitizeFilePathItem($lang);
 160
 161                 // Don't override the language setting with empty languages
 162                 if (empty($lang)) {
 163                         return;
 164                 }
 165
 166                 $a          = new \stdClass();
 167                 $a->strings = [];
 168
 169                 // load enabled addons strings
 170                 $addons = $this->dba->select('addon', ['name'], ['installed' => true]);
 171                 while ($p = $this->dba->fetch($addons)) {
 172                         $name = Strings::sanitizeFilePathItem($p['name']);
 173                         if (file_exists("addon/$name/lang/$lang/strings.php")) {
 174                                 include __DIR__ . "/../../../addon/$name/lang/$lang/strings.php";
 175                         }
 176                 }
 177
 178                 if (file_exists(__DIR__ . "/../../../view/lang/$lang/strings.php")) {
 179                         include __DIR__ . "/../../../view/lang/$lang/strings.php";
 180                 }
 181
 182                 $this->lang    = $lang;
 183                 $this->strings = $a->strings;
 184
 185                 unset($a);
 186         }
 187
 188         /**
 189          * @brief Returns the preferred language from the HTTP_ACCEPT_LANGUAGE header
 190          *
 191          * @param string $sysLang The default fallback language
 192          * @param array  $server  The $_SERVER array
 193          * @param array  $get     The $_GET array
 194          *
 195          * @return string The two-letter language code
 196          */
 197         public static function detectLanguage(array $server, array $get, string $sysLang = 'en')
 198         {
 199                 $lang_variable = $server['HTTP_ACCEPT_LANGUAGE'] ?? null;
 200
 201                 $acceptedLanguages = preg_split('/,\s*/', $lang_variable);
 202
 203                 if (empty($acceptedLanguages)) {
 204                         $acceptedLanguages = [];
 205                 }
 206
 207                 // Add get as absolute quality accepted language (except this language isn't valid)
 208                 if (!empty($get['lang'])) {
 209                         $acceptedLanguages[] = $get['lang'];
 210                 }
 211
 212                 // return the sys language in case there's nothing to do
 213                 if (empty($acceptedLanguages)) {
 214                         return $sysLang;
 215                 }
 216
 217                 // Set the syslang as default fallback
 218                 $current_lang = $sysLang;
 219                 // start with quality zero (every guessed language is more acceptable ..)
 220                 $current_q = 0;
 221
 222                 foreach ($acceptedLanguages as $acceptedLanguage) {
 223                         $res = preg_match(
 224                                 '/^([a-z]{1,8}(?:-[a-z]{1,8})*)(?:;\s*q=(0(?:\.[0-9]{1,3})?|1(?:\.0{1,3})?))?$/i',
 225                                 $acceptedLanguage,
 226                                 $matches
 227                         );
 228
 229                         // Invalid language? -> skip
 230                         if (!$res) {
 231                                 continue;
 232                         }
 233
 234                         // split language codes based on it's "-"
 235                         $lang_code = explode('-', $matches[1]);
 236
 237                         // determine the quality of the guess
 238                         if (isset($matches[2])) {
 239                                 $lang_quality = (float)$matches[2];
 240                         } else {
 241                                 // fallback so without a quality parameter, it's probably the best
 242                                 $lang_quality = 1;
 243                         }
 244
 245                         // loop through each part of the code-parts
 246                         while (count($lang_code)) {
 247                                 // try to mix them so we can get double-code parts too
 248                                 $match_lang = strtolower(join('-', $lang_code));
 249                                 if (file_exists(__DIR__ . "/../../../view/lang/$match_lang") &&
 250                                     is_dir(__DIR__ . "/../../../view/lang/$match_lang")) {
 251                                         if ($lang_quality > $current_q) {
 252                                                 $current_lang = $match_lang;
 253                                                 $current_q    = $lang_quality;
 254                                                 break;
 255                                         }
 256                                 }
 257
 258                                 // remove the most right code-part
 259                                 array_pop($lang_code);
 260                         }
 261                 }
 262
 263                 return $current_lang;
 264         }
 265
 266         /**
 267          * @brief Return the localized version of the provided string with optional string interpolation
 268          *
 269          * This function takes a english string as parameter, and if a localized version
 270          * exists for the current language, substitutes it before performing an eventual
 271          * string interpolation (sprintf) with additional optional arguments.
 272          *
 273          * Usages:
 274          * - L10n::t('This is an example')
 275          * - L10n::t('URL %s returned no result', $url)
 276          * - L10n::t('Current version: %s, new version: %s', $current_version, $new_version)
 277          *
 278          * @param string $s
 279          * @param array  $vars Variables to interpolate in the translation string
 280          *
 281          * @return string
 282          */
 283         public function t($s, ...$vars)
 284         {
 285                 if (empty($s)) {
 286                         return '';
 287                 }
 288
 289                 if (!empty($this->strings[$s])) {
 290                         $t = $this->strings[$s];
 291                         $s = is_array($t) ? $t[0] : $t;
 292                 }
 293
 294                 if (count($vars) > 0) {
 295                         $s = sprintf($s, ...$vars);
 296                 }
 297
 298                 return $s;
 299         }
 300
 301         /**
 302          * @brief Return the localized version of a singular/plural string with optional string interpolation
 303          *
 304          * This function takes two english strings as parameters, singular and plural, as
 305          * well as a count. If a localized version exists for the current language, they
 306          * are used instead. Discrimination between singular and plural is done using the
 307          * localized function if any or the default one. Finally, a string interpolation
 308          * is performed using the count as parameter.
 309          *
 310          * Usages:
 311          * - L10n::tt('Like', 'Likes', $count)
 312          * - L10n::tt("%s user deleted", "%s users deleted", count($users))
 313          *
 314          * @param string $singular
 315          * @param string $plural
 316          * @param int    $count
 317          *
 318          * @return string
 319          * @throws \Exception
 320          */
 321         public function tt(string $singular, string $plural, int $count)
 322         {
 323                 if (!empty($this->strings[$singular])) {
 324                         $t = $this->strings[$singular];
 325                         if (is_array($t)) {
 326                                 $plural_function = 'string_plural_select_' . str_replace('-', '_', $this->lang);
 327                                 if (function_exists($plural_function)) {
 328                                         $i = $plural_function($count);
 329                                 } else {
 330                                         $i = $this->stringPluralSelectDefault($count);
 331                                 }
 332
 333                                 // for some languages there is only a single array item
 334                                 if (!isset($t[$i])) {
 335                                         $s = $t[0];
 336                                 } else {
 337                                         $s = $t[$i];
 338                                 }
 339                         } else {
 340                                 $s = $t;
 341                         }
 342                 } elseif ($this->stringPluralSelectDefault($count)) {
 343                         $s = $plural;
 344                 } else {
 345                         $s = $singular;
 346                 }
 347
 348                 $s = @sprintf($s, $count);
 349
 350                 return $s;
 351         }
 352
 353         /**
 354          * Provide a fallback which will not collide with a function defined in any language file
 355          *
 356          * @param int $n
 357          *
 358          * @return bool
 359          */
 360         private function stringPluralSelectDefault($n)
 361         {
 362                 return $n != 1;
 363         }
 364
 365         /**
 366          * Return installed languages codes as associative array
 367          *
 368          * Scans the view/lang directory for the existence of "strings.php" files, and
 369          * returns an alphabetical list of their folder names (@-char language codes).
 370          * Adds the english language if it's missing from the list.
 371          *
 372          * Ex: array('de' => 'de', 'en' => 'en', 'fr' => 'fr', ...)
 373          *
 374          * @return array
 375          */
 376         public static function getAvailableLanguages()
 377         {
 378                 $langs              = [];
 379                 $strings_file_paths = glob('view/lang/*/strings.php');
 380
 381                 if (is_array($strings_file_paths) && count($strings_file_paths)) {
 382                         if (!in_array('view/lang/en/strings.php', $strings_file_paths)) {
 383                                 $strings_file_paths[] = 'view/lang/en/strings.php';
 384                         }
 385                         asort($strings_file_paths);
 386                         foreach ($strings_file_paths as $strings_file_path) {
 387                                 $path_array            = explode('/', $strings_file_path);
 388                                 $langs[$path_array[2]] = $path_array[2];
 389                         }
 390                 }
 391                 return $langs;
 392         }
 393
 394         /**
 395          * Translate days and months names.
 396          *
 397          * @param string $s String with day or month name.
 398          *
 399          * @return string Translated string.
 400          */
 401         public function getDay($s)
 402         {
 403                 $ret = str_replace(['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'],
 404                         [$this->t('Monday'), $this->t('Tuesday'), $this->t('Wednesday'), $this->t('Thursday'), $this->t('Friday'), $this->t('Saturday'), $this->t('Sunday')],
 405                         $s);
 406
 407                 $ret = str_replace(['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
 408                         [$this->t('January'), $this->t('February'), $this->t('March'), $this->t('April'), $this->t('May'), $this->t('June'), $this->t('July'), $this->t('August'), $this->t('September'), $this->t('October'), $this->t('November'), $this->t('December')],
 409                         $ret);
 410
 411                 return $ret;
 412         }
 413
 414         /**
 415          * Translate short days and months names.
 416          *
 417          * @param string $s String with short day or month name.
 418          *
 419          * @return string Translated string.
 420          */
 421         public function getDayShort($s)
 422         {
 423                 $ret = str_replace(['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'],
 424                         [$this->t('Mon'), $this->t('Tue'), $this->t('Wed'), $this->t('Thu'), $this->t('Fri'), $this->t('Sat'), $this->t('Sun')],
 425                         $s);
 426
 427                 $ret = str_replace(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
 428                         [$this->t('Jan'), $this->t('Feb'), $this->t('Mar'), $this->t('Apr'), $this->t('May'), $this->t('Jun'), $this->t('Jul'), $this->t('Aug'), $this->t('Sep'), $this->t('Oct'), $this->t('Nov'), $this->t('Dec')],
 429                         $ret);
 430
 431                 return $ret;
 432         }
 433
 434         /**
 435          * Load poke verbs
 436          *
 437          * @return array index is present tense verb
 438          *                 value is array containing past tense verb, translation of present, translation of past
 439          * @throws \Friendica\Network\HTTPException\InternalServerErrorException
 440          * @hook poke_verbs pokes array
 441          */
 442         public function getPokeVerbs()
 443         {
 444                 // index is present tense verb
 445                 // value is array containing past tense verb, translation of present, translation of past
 446                 $arr = [
 447                         'poke'   => ['poked', $this->t('poke'), $this->t('poked')],
 448                         'ping'   => ['pinged', $this->t('ping'), $this->t('pinged')],
 449                         'prod'   => ['prodded', $this->t('prod'), $this->t('prodded')],
 450                         'slap'   => ['slapped', $this->t('slap'), $this->t('slapped')],
 451                         'finger' => ['fingered', $this->t('finger'), $this->t('fingered')],
 452                         'rebuff' => ['rebuffed', $this->t('rebuff'), $this->t('rebuffed')],
 453                 ];
 454
 455                 Hook::callAll('poke_verbs', $arr);
 456
 457                 return $arr;
 458         }
 459 }