core/lib/Thelia/Action/Translation.php line 257

  1. <?php
  3. /*
  4.  * This file is part of the Thelia package.
  5.  * http://www.thelia.net
  6.  *
  7.  * (c) OpenStudio <info@thelia.net>
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Thelia\Action;
  15. use Symfony\Component\DependencyInjection\ContainerInterface;
  16. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  17. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  18. use Symfony\Component\Filesystem\Filesystem;
  19. use Thelia\Core\Event\Cache\CacheEvent;
  20. use Thelia\Core\Event\TheliaEvents;
  21. use Thelia\Core\Event\Translation\TranslationEvent;
  22. use Thelia\Core\Translation\Translator;
  23. use Thelia\Log\Tlog;
  25. /**
  26.  * Class Translation.
  27.  *
  28.  * @author Manuel Raynaud <manu@raynaud.io>
  29.  */
  30. class Translation extends BaseAction implements EventSubscriberInterface
  31. {
  32.     /** @var ContainerInterface */
  33.     protected $container;
  35.     public function __construct(ContainerInterface $container)
  36.     {
  37.         $this->container = $container;
  38.     }
  40.     public function getTranslatableStrings(TranslationEvent $event): void
  41.     {
  42.         $strings = [];
  43.         $stringCount = $this->walkDir(
  44.             $event->getDirectory(),
  45.             $event->getMode(),
  46.             $event->getLocale(),
  47.             $event->getDomain(),
  48.             $strings
  49.         );
  51.         $event
  52.             ->setTranslatableStrings($strings)
  53.             ->setTranslatableStringCount($stringCount)
  54.         ;
  55.     }
  57.     /**
  58.      * Recursively examine files in a directory tree, and extract translatable strings.
  59.      *
  60.      * Returns an array of translatable strings, each item having with the following structure:
  61.      * 'files' an array of file names in which the string appears,
  62.      * 'text' the translatable text
  63.      * 'translation' => the text translation, or an empty string if none available.
  64.      * 'dollar'  => true if the translatable text contains a $
  65.      *
  66.      * @param string $directory     the path to the directory to examine
  67.      * @param string $walkMode      type of file scanning: WALK_MODE_PHP or WALK_MODE_TEMPLATE
  68.      * @param string $currentLocale the current locale
  69.      * @param string $domain        the translation domain (fontoffice, backoffice, module, etc...)
  70.      * @param array  $strings       the list of strings
  71.      *
  72.      * @throws \InvalidArgumentException if $walkMode contains an invalid value
  73.      *
  74.      * @return number the total number of translatable texts
  75.      */
  76.     protected function walkDir(string $directory, string $walkMode, string $currentLocale, string $domain, array &$strings)
  77.     {
  78.         $numTexts = 0;
  80.         if ($walkMode == TranslationEvent::WALK_MODE_PHP) {
  81.             $prefix = '\-\>[\s]*trans[\s]*\([\s]*';
  83.             $allowedExts = ['php'];
  84.         } elseif ($walkMode == TranslationEvent::WALK_MODE_TEMPLATE) {
  85.             $prefix = '\{intl(?:.*?)[\s]l=[\s]*';
  87.             $allowedExts = ['html', 'tpl', 'xml', 'txt'];
  88.         } else {
  89.             throw new \InvalidArgumentException(
  90.                 Translator::getInstance()->trans(
  91.                     'Invalid value for walkMode parameter: %value',
  92.                     ['%value' => $walkMode]
  93.                 )
  94.             );
  95.         }
  97.         try {
  98.             Tlog::getInstance()->debug("Walking in $directory, in mode $walkMode");
  100.             /** @var \DirectoryIterator $fileInfo */
  101.             foreach (new \DirectoryIterator($directory) as $fileInfo) {
  102.                 if ($fileInfo->isDot()) {
  103.                     continue;
  104.                 }
  106.                 if ($fileInfo->isDir()) {
  107.                     $numTexts += $this->walkDir(
  108.                         $fileInfo->getPathName(),
  109.                         $walkMode,
  110.                         $currentLocale,
  111.                         $domain,
  112.                         $strings
  113.                     );
  114.                 }
  116.                 if ($fileInfo->isFile()) {
  117.                     $ext = $fileInfo->getExtension();
  119.                     if (\in_array($ext, $allowedExts)) {
  120.                         if ($content = file_get_contents($fileInfo->getPathName())) {
  121.                             $short_path = $this->normalizePath($fileInfo->getPathName());
  123.                             Tlog::getInstance()->debug("Examining file $short_path\n");
  125.                             $matches = [];
  127.                             if (preg_match_all(
  128.                                 '/'.$prefix.'((?<![\\\\])[\'"])((?:.(?!(?<![\\\\])\1))*.?)*?\1/ms',
  129.                                 $content,
  130.                                 $matches
  131.                             )) {
  132.                                 Tlog::getInstance()->debug('Strings found: ', $matches[2]);
  134.                                 $idx = 0;
  136.                                 foreach ($matches[2] as $match) {
  137.                                     $hash = md5($match);
  139.                                     if (isset($strings[$hash])) {
  140.                                         if (!\in_array($short_path, $strings[$hash]['files'])) {
  141.                                             $strings[$hash]['files'][] = $short_path;
  142.                                         }
  143.                                     } else {
  144.                                         ++$numTexts;
  146.                                         // remove \' (or \"), that will prevent the translator to work properly, as
  147.                                         // "abc \def\" ghi" will be passed as abc "def" ghi to the translator.
  149.                                         $quote = $matches[1][$idx];
  151.                                         $match = str_replace("\\$quote", $quote, $match);
  153.                                         // Ignore empty strings
  154.                                         if (\strlen($match) == 0) {
  155.                                             continue;
  156.                                         }
  158.                                         $strings[$hash] = [
  159.                                             'files' => [$short_path],
  160.                                             'text' => $match,
  161.                                             'translation' => Translator::getInstance()->trans(
  162.                                                 $match,
  163.                                                 [],
  164.                                                 $domain,
  165.                                                 $currentLocale,
  166.                                                 false,
  167.                                                 false
  168.                                             ),
  169.                                             'custom_fallback' => Translator::getInstance()->trans(
  170.                                                 sprintf(
  171.                                                     Translator::GLOBAL_FALLBACK_KEY,
  172.                                                     $domain,
  173.                                                     $match
  174.                                                 ),
  175.                                                 [],
  176.                                                 Translator::GLOBAL_FALLBACK_DOMAIN,
  177.                                                 $currentLocale,
  178.                                                 false,
  179.                                                 false
  180.                                             ),
  181.                                             'global_fallback' => Translator::getInstance()->trans(
  182.                                                 $match,
  183.                                                 [],
  184.                                                 Translator::GLOBAL_FALLBACK_DOMAIN,
  185.                                                 $currentLocale,
  186.                                                 false,
  187.                                                 false
  188.                                             ),
  189.                                             'dollar' => strstr($match, '$') !== false,
  190.                                         ];
  191.                                     }
  193.                                     ++$idx;
  194.                                 }
  195.                             }
  196.                         }
  197.                     }
  198.                 }
  199.             }
  200.         } catch (\UnexpectedValueException $ex) {
  201.             // Directory does not exists => ignore it.
  202.         }
  204.         return $numTexts;
  205.     }
  207.     public function writeTranslationFile(TranslationEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  208.     {
  209.         $file = $event->getTranslationFilePath();
  211.         $fs = new Filesystem();
  213.         if (!$fs->exists($file) && true === $event->isCreateFileIfNotExists()) {
  214.             $dir = \dirname($file);
  216.             if (!$fs->exists($file)) {
  217.                 $fs->mkdir($dir);
  219.                 $this->cacheClear($dispatcher);
  220.             }
  221.         }
  223.         if ($fp = @fopen($file, 'w')) {
  224.             fwrite($fp, '<'."?php\n\n");
  225.             fwrite($fp, "return array(\n");
  227.             $texts = $event->getTranslatableStrings();
  228.             $translations = $event->getTranslatedStrings();
  230.             // Sort keys alphabetically while keeping index
  231.             asort($texts);
  233.             foreach ($texts as $key => $text) {
  234.                 // Write only defined (not empty) translations
  235.                 if (!empty($translations[$key])) {
  236.                     $text = str_replace("'", "\'", $text);
  238.                     $translation = str_replace("'", "\'", $translations[$key]);
  240.                     fwrite($fp, sprintf("    '%s' => '%s',\n", $text, $translation));
  241.                 }
  242.             }
  244.             fwrite($fp, ");\n");
  246.             @fclose($fp);
  247.         } else {
  248.             throw new \RuntimeException(
  249.                 Translator::getInstance()->trans(
  250.                     'Failed to open translation file %file. Please be sure that this file is writable by your Web server',
  251.                     ['%file' => $file]
  252.                 )
  253.             );
  254.         }
  255.     }
  257.     public function writeFallbackFile(TranslationEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  258.     {
  259.         $file = THELIA_LOCAL_DIR.'I18n'.DS.$event->getLocale().'.php';
  261.         $fs = new Filesystem();
  262.         $translations = [];
  264.         if (!$fs->exists($file)) {
  265.             if (true === $event->isCreateFileIfNotExists()) {
  266.                 $dir = \dirname($file);
  267.                 $fs->mkdir($dir);
  269.                 $this->cacheClear($dispatcher);
  270.             } else {
  271.                 throw new \RuntimeException(
  272.                     Translator::getInstance()->trans(
  273.                         'Failed to open translation file %file. Please be sure that this file is writable by your Web server',
  274.                         ['%file' => $file]
  275.                     )
  276.                 );
  277.             }
  278.         } else {
  279.             /*$loader = new PhpFileLoader();
  280.             $catalogue = $loade     r->load($file);
  281.             $translations = $catalogue->all();
  282.             */
  283.             $translations = require $file;
  285.             if (!\is_array($translations)) {
  286.                 $translations = [];
  287.             }
  288.         }
  290.         if ($fp = @fopen($file, 'w')) {
  291.             $texts = $event->getTranslatableStrings();
  292.             $customs = $event->getCustomFallbackStrings();
  293.             $globals = $event->getGlobalFallbackStrings();
  295.             // just reset current translations for this domain to remove strings that do not exist anymore
  296.             $translations[$event->getDomain()] = [];
  298.             foreach ($texts as $key => $text) {
  299.                 if (!empty($customs[$key])) {
  300.                     $translations[$event->getDomain()][$text] = $customs[$key];
  301.                 }
  303.                 if (!empty($globals[$key])) {
  304.                     $translations[$text] = $globals[$key];
  305.                 } else {
  306.                     unset($translations[$text]);
  307.                 }
  308.             }
  310.             fwrite($fp, '<'."?php\n\n");
  311.             fwrite($fp, "return [\n");
  313.             // Sort keys alphabetically while keeping index
  314.             ksort($translations);
  316.             foreach ($translations as $key => $text) {
  317.                 // Write only defined (not empty) translations
  318.                 if (!empty($translations[$key])) {
  319.                     if (\is_array($translations[$key])) {
  320.                         $key = str_replace("'", "\'", $key);
  321.                         fwrite($fp, sprintf("    '%s' => [\n", $key));
  322.                         ksort($translations[$key]);
  323.                         foreach ($translations[$key] as $subKey => $subText) {
  324.                             $subKey = str_replace("'", "\'", $subKey);
  325.                             $translation = str_replace("'", "\'", $subText);
  326.                             fwrite($fp, sprintf("        '%s' => '%s',\n", $subKey, $translation));
  327.                         }
  328.                         fwrite($fp, "    ],\n");
  329.                     } else {
  330.                         $key = str_replace("'", "\'", $key);
  331.                         $translation = str_replace("'", "\'", $text);
  332.                         fwrite($fp, sprintf("    '%s' => '%s',\n", $key, $translation));
  333.                     }
  334.                 }
  335.             }
  337.             fwrite($fp, "];\n");
  339.             @fclose($fp);
  340.         }
  341.     }
  343.     protected function normalizePath($path)
  344.     {
  345.         $path = str_replace(
  346.             str_replace('\\', '/', THELIA_ROOT),
  347.             '',
  348.             str_replace('\\', '/', realpath($path))
  349.         );
  351.         return ltrim($path, '/');
  352.     }
  354.     protected function cacheClear(EventDispatcherInterface $dispatcher): void
  355.     {
  356.         $cacheEvent = new CacheEvent(
  357.             $this->container->getParameter('kernel.cache_dir')
  358.         );
  360.         $dispatcher->dispatch($cacheEvent, TheliaEvents::CACHE_CLEAR);
  361.     }
  363.     /**
  364.      * {@inheritdoc}
  365.      */
  366.     public static function getSubscribedEvents()
  367.     {
  368.         return [
  369.             TheliaEvents::TRANSLATION_GET_STRINGS => ['getTranslatableStrings', 128],
  370.             TheliaEvents::TRANSLATION_WRITE_FILE => [
  371.                 ['writeTranslationFile', 128],
  372.                 ['writeFallbackFile', 128],
  373.             ],
  374.         ];
  375.     }
  376. }