Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/framework-bundle/Command/TranslationUpdateCommand.php line 64

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Bundle\FrameworkBundle\Command;
  14. use Symfony\Component\Console\Command\Command;
  15. use Symfony\Component\Console\Completion\CompletionInput;
  16. use Symfony\Component\Console\Completion\CompletionSuggestions;
  17. use Symfony\Component\Console\Exception\InvalidArgumentException;
  18. use Symfony\Component\Console\Input\InputArgument;
  19. use Symfony\Component\Console\Input\InputInterface;
  20. use Symfony\Component\Console\Input\InputOption;
  21. use Symfony\Component\Console\Output\ConsoleOutputInterface;
  22. use Symfony\Component\Console\Output\OutputInterface;
  23. use Symfony\Component\Console\Style\SymfonyStyle;
  24. use Symfony\Component\HttpKernel\KernelInterface;
  25. use Symfony\Component\Translation\Catalogue\MergeOperation;
  26. use Symfony\Component\Translation\Catalogue\TargetOperation;
  27. use Symfony\Component\Translation\Extractor\ExtractorInterface;
  28. use Symfony\Component\Translation\MessageCatalogue;
  29. use Symfony\Component\Translation\MessageCatalogueInterface;
  30. use Symfony\Component\Translation\Reader\TranslationReaderInterface;
  31. use Symfony\Component\Translation\Writer\TranslationWriterInterface;
  33. /**
  34.  * A command that parses templates to extract translation messages and adds them
  35.  * into the translation files.
  36.  *
  37.  * @author Michel Salib <michelsalib@hotmail.com>
  38.  *
  39.  * @final
  40.  */
  41. class TranslationUpdateCommand extends Command
  42. {
  43.     private const ASC = 'asc';
  44.     private const DESC = 'desc';
  45.     private const SORT_ORDERS = [self::ASC, self::DESC];
  46.     private const FORMATS = [
  47.         'xlf12' => ['xlf', '1.2'],
  48.         'xlf20' => ['xlf', '2.0'],
  49.     ];
  51.     protected static $defaultName = 'translation:extract|translation:update';
  52.     protected static $defaultDescription = 'Extract missing translations keys from code to translation files.';
  54.     private $writer;
  55.     private $reader;
  56.     private $extractor;
  57.     private $defaultLocale;
  58.     private $defaultTransPath;
  59.     private $defaultViewsPath;
  60.     private $transPaths;
  61.     private $codePaths;
  62.     private $enabledLocales;
  64.     public function __construct(TranslationWriterInterface $writer, TranslationReaderInterface $reader, ExtractorInterface $extractor, string $defaultLocale, string $defaultTransPath = null, string $defaultViewsPath = null, array $transPaths = [], array $codePaths = [], array $enabledLocales = [])
  65.     {
  66.         parent::__construct();
  68.         $this->writer = $writer;
  69.         $this->reader = $reader;
  70.         $this->extractor = $extractor;
  71.         $this->defaultLocale = $defaultLocale;
  72.         $this->defaultTransPath = $defaultTransPath;
  73.         $this->defaultViewsPath = $defaultViewsPath;
  74.         $this->transPaths = $transPaths;
  75.         $this->codePaths = $codePaths;
  76.         $this->enabledLocales = $enabledLocales;
  77.     }
  79.     /**
  80.      * {@inheritdoc}
  81.      */
  82.     protected function configure()
  83.     {
  84.         $this
  85.             ->setDefinition([
  86.                 new InputArgument('locale', InputArgument::REQUIRED, 'The locale'),
  87.                 new InputArgument('bundle', InputArgument::OPTIONAL, 'The bundle name or directory where to load the messages'),
  88.                 new InputOption('prefix', null, InputOption::VALUE_OPTIONAL, 'Override the default prefix', '__'),
  89.                 new InputOption('output-format', null, InputOption::VALUE_OPTIONAL, 'Override the default output format (deprecated)'),
  90.                 new InputOption('format', null, InputOption::VALUE_OPTIONAL, 'Override the default output format', 'xlf12'),
  91.                 new InputOption('dump-messages', null, InputOption::VALUE_NONE, 'Should the messages be dumped in the console'),
  92.                 new InputOption('force', null, InputOption::VALUE_NONE, 'Should the extract be done'),
  93.                 new InputOption('clean', null, InputOption::VALUE_NONE, 'Should clean not found messages'),
  94.                 new InputOption('domain', null, InputOption::VALUE_OPTIONAL, 'Specify the domain to extract'),
  95.                 new InputOption('xliff-version', null, InputOption::VALUE_OPTIONAL, 'Override the default xliff version (deprecated)'),
  96.                 new InputOption('sort', null, InputOption::VALUE_OPTIONAL, 'Return list of messages sorted alphabetically (only works with --dump-messages)', 'asc'),
  97.                 new InputOption('as-tree', null, InputOption::VALUE_OPTIONAL, 'Dump the messages as a tree-like structure: The given value defines the level where to switch to inline YAML'),
  98.             ])
  99.             ->setDescription(self::$defaultDescription)
  100.             ->setHelp(<<<'EOF'
  101. The <info>%command.name%</info> command extracts translation strings from templates
  102. of a given bundle or the default translations directory. It can display them or merge
  103. the new ones into the translation files.
  105. When new translation strings are found it can automatically add a prefix to the translation
  106. message.
  108. Example running against a Bundle (AcmeBundle)
  110.   <info>php %command.full_name% --dump-messages en AcmeBundle</info>
  111.   <info>php %command.full_name% --force --prefix="new_" fr AcmeBundle</info>
  113. Example running against default messages directory
  115.   <info>php %command.full_name% --dump-messages en</info>
  116.   <info>php %command.full_name% --force --prefix="new_" fr</info>
  118. You can sort the output with the <comment>--sort</> flag:
  120.     <info>php %command.full_name% --dump-messages --sort=asc en AcmeBundle</info>
  121.     <info>php %command.full_name% --dump-messages --sort=desc fr</info>
  123. You can dump a tree-like structure using the yaml format with <comment>--as-tree</> flag:
  125.     <info>php %command.full_name% --force --format=yaml --as-tree=3 en AcmeBundle</info>
  127. EOF
  128.             )
  129.         ;
  130.     }
  132.     /**
  133.      * {@inheritdoc}
  134.      */
  135.     protected function execute(InputInterface $input, OutputInterface $output): int
  136.     {
  137.         $io = new SymfonyStyle($input, $output);
  138.         $errorIo = $output instanceof ConsoleOutputInterface ? new SymfonyStyle($input, $output->getErrorOutput()) : $io;
  140.         if ('translation:update' === $input->getFirstArgument()) {
  141.             $errorIo->caution('Command "translation:update" is deprecated since version 5.4 and will be removed in Symfony 6.0. Use "translation:extract" instead.');
  142.         }
  144.         $io = new SymfonyStyle($input, $output);
  145.         $errorIo = $io->getErrorStyle();
  147.         // check presence of force or dump-message
  148.         if (true !== $input->getOption('force') && true !== $input->getOption('dump-messages')) {
  149.             $errorIo->error('You must choose one of --force or --dump-messages');
  151.             return 1;
  152.         }
  154.         $format = $input->getOption('output-format') ?: $input->getOption('format');
  155.         $xliffVersion = $input->getOption('xliff-version') ?? '1.2';
  157.         if ($input->getOption('xliff-version')) {
  158.             $errorIo->warning(sprintf('The "--xliff-version" option is deprecated since version 5.3, use "--format=xlf%d" instead.', 10 * $xliffVersion));
  159.         }
  161.         if ($input->getOption('output-format')) {
  162.             $errorIo->warning(sprintf('The "--output-format" option is deprecated since version 5.3, use "--format=xlf%d" instead.', 10 * $xliffVersion));
  163.         }
  165.         if (\in_array($format, array_keys(self::FORMATS), true)) {
  166.             [$format, $xliffVersion] = self::FORMATS[$format];
  167.         }
  169.         // check format
  170.         $supportedFormats = $this->writer->getFormats();
  171.         if (!\in_array($format, $supportedFormats, true)) {
  172.             $errorIo->error(['Wrong output format', 'Supported formats are: '.implode(', ', $supportedFormats).', xlf12 and xlf20.']);
  174.             return 1;
  175.         }
  177.         /** @var KernelInterface $kernel */
  178.         $kernel = $this->getApplication()->getKernel();
  180.         // Define Root Paths
  181.         $transPaths = $this->getRootTransPaths();
  182.         $codePaths = $this->getRootCodePaths($kernel);
  184.         $currentName = 'default directory';
  186.         // Override with provided Bundle info
  187.         if (null !== $input->getArgument('bundle')) {
  188.             try {
  189.                 $foundBundle = $kernel->getBundle($input->getArgument('bundle'));
  190.                 $bundleDir = $foundBundle->getPath();
  191.                 $transPaths = [is_dir($bundleDir.'/Resources/translations') ? $bundleDir.'/Resources/translations' : $bundleDir.'/translations'];
  192.                 $codePaths = [is_dir($bundleDir.'/Resources/views') ? $bundleDir.'/Resources/views' : $bundleDir.'/templates'];
  193.                 if ($this->defaultTransPath) {
  194.                     $transPaths[] = $this->defaultTransPath;
  195.                 }
  196.                 if ($this->defaultViewsPath) {
  197.                     $codePaths[] = $this->defaultViewsPath;
  198.                 }
  199.                 $currentName = $foundBundle->getName();
  200.             } catch (\InvalidArgumentException $e) {
  201.                 // such a bundle does not exist, so treat the argument as path
  202.                 $path = $input->getArgument('bundle');
  204.                 $transPaths = [$path.'/translations'];
  205.                 $codePaths = [$path.'/templates'];
  207.                 if (!is_dir($transPaths[0])) {
  208.                     throw new InvalidArgumentException(sprintf('"%s" is neither an enabled bundle nor a directory.', $transPaths[0]));
  209.                 }
  210.             }
  211.         }
  213.         $io->title('Translation Messages Extractor and Dumper');
  214.         $io->comment(sprintf('Generating "<info>%s</info>" translation files for "<info>%s</info>"', $input->getArgument('locale'), $currentName));
  216.         $io->comment('Parsing templates...');
  217.         $extractedCatalogue = $this->extractMessages($input->getArgument('locale'), $codePaths, $input->getOption('prefix'));
  219.         $io->comment('Loading translation files...');
  220.         $currentCatalogue = $this->loadCurrentMessages($input->getArgument('locale'), $transPaths);
  222.         if (null !== $domain = $input->getOption('domain')) {
  223.             $currentCatalogue = $this->filterCatalogue($currentCatalogue, $domain);
  224.             $extractedCatalogue = $this->filterCatalogue($extractedCatalogue, $domain);
  225.         }
  227.         // process catalogues
  228.         $operation = $input->getOption('clean')
  229.             ? new TargetOperation($currentCatalogue, $extractedCatalogue)
  230.             : new MergeOperation($currentCatalogue, $extractedCatalogue);
  232.         // Exit if no messages found.
  233.         if (!\count($operation->getDomains())) {
  234.             $errorIo->warning('No translation messages were found.');
  236.             return 0;
  237.         }
  239.         $resultMessage = 'Translation files were successfully updated';
  241.         $operation->moveMessagesToIntlDomainsIfPossible('new');
  243.         // show compiled list of messages
  244.         if (true === $input->getOption('dump-messages')) {
  245.             $extractedMessagesCount = 0;
  246.             $io->newLine();
  247.             foreach ($operation->getDomains() as $domain) {
  248.                 $newKeys = array_keys($operation->getNewMessages($domain));
  249.                 $allKeys = array_keys($operation->getMessages($domain));
  251.                 $list = array_merge(
  252.                     array_diff($allKeys, $newKeys),
  253.                     array_map(function ($id) {
  254.                         return sprintf('<fg=green>%s</>', $id);
  255.                     }, $newKeys),
  256.                     array_map(function ($id) {
  257.                         return sprintf('<fg=red>%s</>', $id);
  258.                     }, array_keys($operation->getObsoleteMessages($domain)))
  259.                 );
  261.                 $domainMessagesCount = \count($list);
  263.                 if ($sort = $input->getOption('sort')) {
  264.                     $sort = strtolower($sort);
  265.                     if (!\in_array($sort, self::SORT_ORDERS, true)) {
  266.                         $errorIo->error(['Wrong sort order', 'Supported formats are: '.implode(', ', self::SORT_ORDERS).'.']);
  268.                         return 1;
  269.                     }
  271.                     if (self::DESC === $sort) {
  272.                         rsort($list);
  273.                     } else {
  274.                         sort($list);
  275.                     }
  276.                 }
  278.                 $io->section(sprintf('Messages extracted for domain "<info>%s</info>" (%d message%s)', $domain, $domainMessagesCount, $domainMessagesCount > 1 ? 's' : ''));
  279.                 $io->listing($list);
  281.                 $extractedMessagesCount += $domainMessagesCount;
  282.             }
  284.             if ('xlf' === $format) {
  285.                 $io->comment(sprintf('Xliff output version is <info>%s</info>', $xliffVersion));
  286.             }
  288.             $resultMessage = sprintf('%d message%s successfully extracted', $extractedMessagesCount, $extractedMessagesCount > 1 ? 's were' : ' was');
  289.         }
  291.         // save the files
  292.         if (true === $input->getOption('force')) {
  293.             $io->comment('Writing files...');
  295.             $bundleTransPath = false;
  296.             foreach ($transPaths as $path) {
  297.                 if (is_dir($path)) {
  298.                     $bundleTransPath = $path;
  299.                 }
  300.             }
  302.             if (!$bundleTransPath) {
  303.                 $bundleTransPath = end($transPaths);
  304.             }
  306.             $this->writer->write($operation->getResult(), $format, ['path' => $bundleTransPath, 'default_locale' => $this->defaultLocale, 'xliff_version' => $xliffVersion, 'as_tree' => $input->getOption('as-tree'), 'inline' => $input->getOption('as-tree') ?? 0]);
  308.             if (true === $input->getOption('dump-messages')) {
  309.                 $resultMessage .= ' and translation files were updated';
  310.             }
  311.         }
  313.         $io->success($resultMessage.'.');
  315.         return 0;
  316.     }
  318.     public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
  319.     {
  320.         if ($input->mustSuggestArgumentValuesFor('locale')) {
  321.             $suggestions->suggestValues($this->enabledLocales);
  323.             return;
  324.         }
  326.         /** @var KernelInterface $kernel */
  327.         $kernel = $this->getApplication()->getKernel();
  328.         if ($input->mustSuggestArgumentValuesFor('bundle')) {
  329.             $bundles = [];
  331.             foreach ($kernel->getBundles() as $bundle) {
  332.                 $bundles[] = $bundle->getName();
  333.                 if ($bundle->getContainerExtension()) {
  334.                     $bundles[] = $bundle->getContainerExtension()->getAlias();
  335.                 }
  336.             }
  338.             $suggestions->suggestValues($bundles);
  340.             return;
  341.         }
  343.         if ($input->mustSuggestOptionValuesFor('format')) {
  344.             $suggestions->suggestValues(array_merge(
  345.                 $this->writer->getFormats(),
  346.                 array_keys(self::FORMATS)
  347.             ));
  349.             return;
  350.         }
  352.         if ($input->mustSuggestOptionValuesFor('domain') && $locale = $input->getArgument('locale')) {
  353.             $extractedCatalogue = $this->extractMessages($locale, $this->getRootCodePaths($kernel), $input->getOption('prefix'));
  355.             $currentCatalogue = $this->loadCurrentMessages($locale, $this->getRootTransPaths());
  357.             // process catalogues
  358.             $operation = $input->getOption('clean')
  359.                 ? new TargetOperation($currentCatalogue, $extractedCatalogue)
  360.                 : new MergeOperation($currentCatalogue, $extractedCatalogue);
  362.             $suggestions->suggestValues($operation->getDomains());
  364.             return;
  365.         }
  367.         if ($input->mustSuggestOptionValuesFor('sort')) {
  368.             $suggestions->suggestValues(self::SORT_ORDERS);
  369.         }
  370.     }
  372.     private function filterCatalogue(MessageCatalogue $catalogue, string $domain): MessageCatalogue
  373.     {
  374.         $filteredCatalogue = new MessageCatalogue($catalogue->getLocale());
  376.         // extract intl-icu messages only
  377.         $intlDomain = $domain.MessageCatalogueInterface::INTL_DOMAIN_SUFFIX;
  378.         if ($intlMessages = $catalogue->all($intlDomain)) {
  379.             $filteredCatalogue->add($intlMessages, $intlDomain);
  380.         }
  382.         // extract all messages and subtract intl-icu messages
  383.         if ($messages = array_diff($catalogue->all($domain), $intlMessages)) {
  384.             $filteredCatalogue->add($messages, $domain);
  385.         }
  386.         foreach ($catalogue->getResources() as $resource) {
  387.             $filteredCatalogue->addResource($resource);
  388.         }
  390.         if ($metadata = $catalogue->getMetadata('', $intlDomain)) {
  391.             foreach ($metadata as $k => $v) {
  392.                 $filteredCatalogue->setMetadata($k, $v, $intlDomain);
  393.             }
  394.         }
  396.         if ($metadata = $catalogue->getMetadata('', $domain)) {
  397.             foreach ($metadata as $k => $v) {
  398.                 $filteredCatalogue->setMetadata($k, $v, $domain);
  399.             }
  400.         }
  402.         return $filteredCatalogue;
  403.     }
  405.     private function extractMessages(string $locale, array $transPaths, string $prefix): MessageCatalogue
  406.     {
  407.         $extractedCatalogue = new MessageCatalogue($locale);
  408.         $this->extractor->setPrefix($prefix);
  409.         $transPaths = $this->filterDuplicateTransPaths($transPaths);
  410.         foreach ($transPaths as $path) {
  411.             if (is_dir($path) || is_file($path)) {
  412.                 $this->extractor->extract($path, $extractedCatalogue);
  413.             }
  414.         }
  416.         return $extractedCatalogue;
  417.     }
  419.     private function filterDuplicateTransPaths(array $transPaths): array
  420.     {
  421.         $transPaths = array_filter(array_map('realpath', $transPaths));
  423.         sort($transPaths);
  425.         $filteredPaths = [];
  427.         foreach ($transPaths as $path) {
  428.             foreach ($filteredPaths as $filteredPath) {
  429.                 if (str_starts_with($path, $filteredPath.\DIRECTORY_SEPARATOR)) {
  430.                     continue 2;
  431.                 }
  432.             }
  434.             $filteredPaths[] = $path;
  435.         }
  437.         return $filteredPaths;
  438.     }
  440.     private function loadCurrentMessages(string $locale, array $transPaths): MessageCatalogue
  441.     {
  442.         $currentCatalogue = new MessageCatalogue($locale);
  443.         foreach ($transPaths as $path) {
  444.             if (is_dir($path)) {
  445.                 $this->reader->read($path, $currentCatalogue);
  446.             }
  447.         }
  449.         return $currentCatalogue;
  450.     }
  452.     private function getRootTransPaths(): array
  453.     {
  454.         $transPaths = $this->transPaths;
  455.         if ($this->defaultTransPath) {
  456.             $transPaths[] = $this->defaultTransPath;
  457.         }
  459.         return $transPaths;
  460.     }
  462.     private function getRootCodePaths(KernelInterface $kernel): array
  463.     {
  464.         $codePaths = $this->codePaths;
  465.         $codePaths[] = $kernel->getProjectDir().'/src';
  466.         if ($this->defaultViewsPath) {
  467.             $codePaths[] = $this->defaultViewsPath;
  468.         }
  470.         return $codePaths;
  471.     }
  472. }