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

  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\Attribute\AsCommand;
  15. use Symfony\Component\Console\Command\Command;
  16. use Symfony\Component\Console\Completion\CompletionInput;
  17. use Symfony\Component\Console\Completion\CompletionSuggestions;
  18. use Symfony\Component\Console\Exception\InvalidArgumentException;
  19. use Symfony\Component\Console\Input\InputArgument;
  20. use Symfony\Component\Console\Input\InputInterface;
  21. use Symfony\Component\Console\Input\InputOption;
  22. use Symfony\Component\Console\Output\ConsoleOutputInterface;
  23. use Symfony\Component\Console\Output\OutputInterface;
  24. use Symfony\Component\Console\Style\SymfonyStyle;
  25. use Symfony\Component\HttpKernel\KernelInterface;
  26. use Symfony\Component\Translation\Catalogue\MergeOperation;
  27. use Symfony\Component\Translation\Catalogue\TargetOperation;
  28. use Symfony\Component\Translation\Extractor\ExtractorInterface;
  29. use Symfony\Component\Translation\MessageCatalogue;
  30. use Symfony\Component\Translation\MessageCatalogueInterface;
  31. use Symfony\Component\Translation\Reader\TranslationReaderInterface;
  32. use Symfony\Component\Translation\Writer\TranslationWriterInterface;
  34. /**
  35.  * A command that parses templates to extract translation messages and adds them
  36.  * into the translation files.
  37.  *
  38.  * @author Michel Salib <michelsalib@hotmail.com>
  39.  *
  40.  * @final
  41.  */
  42. #[AsCommand(name: 'translation:extract', description: 'Extract missing translations keys from code to translation files.')]
  43. class TranslationUpdateCommand extends Command
  44. {
  45.     private const ASC = 'asc';
  46.     private const DESC = 'desc';
  47.     private const SORT_ORDERS = [self::ASC, self::DESC];
  48.     private const FORMATS = [
  49.         'xlf12' => ['xlf', '1.2'],
  50.         'xlf20' => ['xlf', '2.0'],
  51.     ];
  53.     private TranslationWriterInterface $writer;
  54.     private TranslationReaderInterface $reader;
  55.     private ExtractorInterface $extractor;
  56.     private string $defaultLocale;
  57.     private ?string $defaultTransPath;
  58.     private ?string $defaultViewsPath;
  59.     private array $transPaths;
  60.     private array $codePaths;
  61.     private array $enabledLocales;
  63.     public function __construct(TranslationWriterInterface $writer, TranslationReaderInterface $reader, ExtractorInterface $extractor, string $defaultLocale, string $defaultTransPath = null, string $defaultViewsPath = null, array $transPaths = [], array $codePaths = [], array $enabledLocales = [])
  64.     {
  65.         parent::__construct();
  67.         $this->writer = $writer;
  68.         $this->reader = $reader;
  69.         $this->extractor = $extractor;
  70.         $this->defaultLocale = $defaultLocale;
  71.         $this->defaultTransPath = $defaultTransPath;
  72.         $this->defaultViewsPath = $defaultViewsPath;
  73.         $this->transPaths = $transPaths;
  74.         $this->codePaths = $codePaths;
  75.         $this->enabledLocales = $enabledLocales;
  76.     }
  78.     protected function configure()
  79.     {
  80.         $this
  81.             ->setDefinition([
  82.                 new InputArgument('locale', InputArgument::REQUIRED, 'The locale'),
  83.                 new InputArgument('bundle', InputArgument::OPTIONAL, 'The bundle name or directory where to load the messages'),
  84.                 new InputOption('prefix', null, InputOption::VALUE_OPTIONAL, 'Override the default prefix', '__'),
  85.                 new InputOption('format', null, InputOption::VALUE_OPTIONAL, 'Override the default output format', 'xlf12'),
  86.                 new InputOption('dump-messages', null, InputOption::VALUE_NONE, 'Should the messages be dumped in the console'),
  87.                 new InputOption('force', null, InputOption::VALUE_NONE, 'Should the extract be done'),
  88.                 new InputOption('clean', null, InputOption::VALUE_NONE, 'Should clean not found messages'),
  89.                 new InputOption('domain', null, InputOption::VALUE_OPTIONAL, 'Specify the domain to extract'),
  90.                 new InputOption('sort', null, InputOption::VALUE_OPTIONAL, 'Return list of messages sorted alphabetically (only works with --dump-messages)', 'asc'),
  91.                 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'),
  92.             ])
  93.             ->setHelp(<<<'EOF'
  94. The <info>%command.name%</info> command extracts translation strings from templates
  95. of a given bundle or the default translations directory. It can display them or merge
  96. the new ones into the translation files.
  98. When new translation strings are found it can automatically add a prefix to the translation
  99. message.
  101. Example running against a Bundle (AcmeBundle)
  103.   <info>php %command.full_name% --dump-messages en AcmeBundle</info>
  104.   <info>php %command.full_name% --force --prefix="new_" fr AcmeBundle</info>
  106. Example running against default messages directory
  108.   <info>php %command.full_name% --dump-messages en</info>
  109.   <info>php %command.full_name% --force --prefix="new_" fr</info>
  111. You can sort the output with the <comment>--sort</> flag:
  113.     <info>php %command.full_name% --dump-messages --sort=asc en AcmeBundle</info>
  114.     <info>php %command.full_name% --dump-messages --sort=desc fr</info>
  116. You can dump a tree-like structure using the yaml format with <comment>--as-tree</> flag:
  118.     <info>php %command.full_name% --force --format=yaml --as-tree=3 en AcmeBundle</info>
  120. EOF
  121.             )
  122.         ;
  123.     }
  125.     protected function execute(InputInterface $input, OutputInterface $output): int
  126.     {
  127.         $io = new SymfonyStyle($input, $output);
  128.         $errorIo = $output instanceof ConsoleOutputInterface ? new SymfonyStyle($input, $output->getErrorOutput()) : $io;
  130.         if ('translation:update' === $input->getFirstArgument()) {
  131.             $errorIo->caution('Command "translation:update" is deprecated since version 5.4 and will be removed in Symfony 6.0. Use "translation:extract" instead.');
  132.         }
  134.         $io = new SymfonyStyle($input, $output);
  135.         $errorIo = $io->getErrorStyle();
  137.         // check presence of force or dump-message
  138.         if (true !== $input->getOption('force') && true !== $input->getOption('dump-messages')) {
  139.             $errorIo->error('You must choose one of --force or --dump-messages');
  141.             return 1;
  142.         }
  144.         $format = $input->getOption('format');
  145.         $xliffVersion = '1.2';
  147.         if (\in_array($format, array_keys(self::FORMATS), true)) {
  148.             [$format, $xliffVersion] = self::FORMATS[$format];
  149.         }
  151.         // check format
  152.         $supportedFormats = $this->writer->getFormats();
  153.         if (!\in_array($format, $supportedFormats, true)) {
  154.             $errorIo->error(['Wrong output format', 'Supported formats are: '.implode(', ', $supportedFormats).', xlf12 and xlf20.']);
  156.             return 1;
  157.         }
  159.         /** @var KernelInterface $kernel */
  160.         $kernel = $this->getApplication()->getKernel();
  162.         // Define Root Paths
  163.         $transPaths = $this->getRootTransPaths();
  164.         $codePaths = $this->getRootCodePaths($kernel);
  166.         $currentName = 'default directory';
  168.         // Override with provided Bundle info
  169.         if (null !== $input->getArgument('bundle')) {
  170.             try {
  171.                 $foundBundle = $kernel->getBundle($input->getArgument('bundle'));
  172.                 $bundleDir = $foundBundle->getPath();
  173.                 $transPaths = [is_dir($bundleDir.'/Resources/translations') ? $bundleDir.'/Resources/translations' : $bundleDir.'/translations'];
  174.                 $codePaths = [is_dir($bundleDir.'/Resources/views') ? $bundleDir.'/Resources/views' : $bundleDir.'/templates'];
  175.                 if ($this->defaultTransPath) {
  176.                     $transPaths[] = $this->defaultTransPath;
  177.                 }
  178.                 if ($this->defaultViewsPath) {
  179.                     $codePaths[] = $this->defaultViewsPath;
  180.                 }
  181.                 $currentName = $foundBundle->getName();
  182.             } catch (\InvalidArgumentException) {
  183.                 // such a bundle does not exist, so treat the argument as path
  184.                 $path = $input->getArgument('bundle');
  186.                 $transPaths = [$path.'/translations'];
  187.                 $codePaths = [$path.'/templates'];
  189.                 if (!is_dir($transPaths[0])) {
  190.                     throw new InvalidArgumentException(sprintf('"%s" is neither an enabled bundle nor a directory.', $transPaths[0]));
  191.                 }
  192.             }
  193.         }
  195.         $io->title('Translation Messages Extractor and Dumper');
  196.         $io->comment(sprintf('Generating "<info>%s</info>" translation files for "<info>%s</info>"', $input->getArgument('locale'), $currentName));
  198.         $io->comment('Parsing templates...');
  199.         $extractedCatalogue = $this->extractMessages($input->getArgument('locale'), $codePaths, $input->getOption('prefix'));
  201.         $io->comment('Loading translation files...');
  202.         $currentCatalogue = $this->loadCurrentMessages($input->getArgument('locale'), $transPaths);
  204.         if (null !== $domain = $input->getOption('domain')) {
  205.             $currentCatalogue = $this->filterCatalogue($currentCatalogue, $domain);
  206.             $extractedCatalogue = $this->filterCatalogue($extractedCatalogue, $domain);
  207.         }
  209.         // process catalogues
  210.         $operation = $input->getOption('clean')
  211.             ? new TargetOperation($currentCatalogue, $extractedCatalogue)
  212.             : new MergeOperation($currentCatalogue, $extractedCatalogue);
  214.         // Exit if no messages found.
  215.         if (!\count($operation->getDomains())) {
  216.             $errorIo->warning('No translation messages were found.');
  218.             return 0;
  219.         }
  221.         $resultMessage = 'Translation files were successfully updated';
  223.         $operation->moveMessagesToIntlDomainsIfPossible('new');
  225.         // show compiled list of messages
  226.         if (true === $input->getOption('dump-messages')) {
  227.             $extractedMessagesCount = 0;
  228.             $io->newLine();
  229.             foreach ($operation->getDomains() as $domain) {
  230.                 $newKeys = array_keys($operation->getNewMessages($domain));
  231.                 $allKeys = array_keys($operation->getMessages($domain));
  233.                 $list = array_merge(
  234.                     array_diff($allKeys, $newKeys),
  235.                     array_map(function ($id) {
  236.                         return sprintf('<fg=green>%s</>', $id);
  237.                     }, $newKeys),
  238.                     array_map(function ($id) {
  239.                         return sprintf('<fg=red>%s</>', $id);
  240.                     }, array_keys($operation->getObsoleteMessages($domain)))
  241.                 );
  243.                 $domainMessagesCount = \count($list);
  245.                 if ($sort = $input->getOption('sort')) {
  246.                     $sort = strtolower($sort);
  247.                     if (!\in_array($sort, self::SORT_ORDERS, true)) {
  248.                         $errorIo->error(['Wrong sort order', 'Supported formats are: '.implode(', ', self::SORT_ORDERS).'.']);
  250.                         return 1;
  251.                     }
  253.                     if (self::DESC === $sort) {
  254.                         rsort($list);
  255.                     } else {
  256.                         sort($list);
  257.                     }
  258.                 }
  260.                 $io->section(sprintf('Messages extracted for domain "<info>%s</info>" (%d message%s)', $domain, $domainMessagesCount, $domainMessagesCount > 1 ? 's' : ''));
  261.                 $io->listing($list);
  263.                 $extractedMessagesCount += $domainMessagesCount;
  264.             }
  266.             if ('xlf' === $format) {
  267.                 $io->comment(sprintf('Xliff output version is <info>%s</info>', $xliffVersion));
  268.             }
  270.             $resultMessage = sprintf('%d message%s successfully extracted', $extractedMessagesCount, $extractedMessagesCount > 1 ? 's were' : ' was');
  271.         }
  273.         // save the files
  274.         if (true === $input->getOption('force')) {
  275.             $io->comment('Writing files...');
  277.             $bundleTransPath = false;
  278.             foreach ($transPaths as $path) {
  279.                 if (is_dir($path)) {
  280.                     $bundleTransPath = $path;
  281.                 }
  282.             }
  284.             if (!$bundleTransPath) {
  285.                 $bundleTransPath = end($transPaths);
  286.             }
  288.             $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]);
  290.             if (true === $input->getOption('dump-messages')) {
  291.                 $resultMessage .= ' and translation files were updated';
  292.             }
  293.         }
  295.         $io->success($resultMessage.'.');
  297.         return 0;
  298.     }
  300.     public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
  301.     {
  302.         if ($input->mustSuggestArgumentValuesFor('locale')) {
  303.             $suggestions->suggestValues($this->enabledLocales);
  305.             return;
  306.         }
  308.         /** @var KernelInterface $kernel */
  309.         $kernel = $this->getApplication()->getKernel();
  310.         if ($input->mustSuggestArgumentValuesFor('bundle')) {
  311.             $bundles = [];
  313.             foreach ($kernel->getBundles() as $bundle) {
  314.                 $bundles[] = $bundle->getName();
  315.                 if ($bundle->getContainerExtension()) {
  316.                     $bundles[] = $bundle->getContainerExtension()->getAlias();
  317.                 }
  318.             }
  320.             $suggestions->suggestValues($bundles);
  322.             return;
  323.         }
  325.         if ($input->mustSuggestOptionValuesFor('format')) {
  326.             $suggestions->suggestValues(array_merge(
  327.                 $this->writer->getFormats(),
  328.                 array_keys(self::FORMATS)
  329.             ));
  331.             return;
  332.         }
  334.         if ($input->mustSuggestOptionValuesFor('domain') && $locale = $input->getArgument('locale')) {
  335.             $extractedCatalogue = $this->extractMessages($locale, $this->getRootCodePaths($kernel), $input->getOption('prefix'));
  337.             $currentCatalogue = $this->loadCurrentMessages($locale, $this->getRootTransPaths());
  339.             // process catalogues
  340.             $operation = $input->getOption('clean')
  341.                 ? new TargetOperation($currentCatalogue, $extractedCatalogue)
  342.                 : new MergeOperation($currentCatalogue, $extractedCatalogue);
  344.             $suggestions->suggestValues($operation->getDomains());
  346.             return;
  347.         }
  349.         if ($input->mustSuggestOptionValuesFor('sort')) {
  350.             $suggestions->suggestValues(self::SORT_ORDERS);
  351.         }
  352.     }
  354.     private function filterCatalogue(MessageCatalogue $catalogue, string $domain): MessageCatalogue
  355.     {
  356.         $filteredCatalogue = new MessageCatalogue($catalogue->getLocale());
  358.         // extract intl-icu messages only
  359.         $intlDomain = $domain.MessageCatalogueInterface::INTL_DOMAIN_SUFFIX;
  360.         if ($intlMessages = $catalogue->all($intlDomain)) {
  361.             $filteredCatalogue->add($intlMessages, $intlDomain);
  362.         }
  364.         // extract all messages and subtract intl-icu messages
  365.         if ($messages = array_diff($catalogue->all($domain), $intlMessages)) {
  366.             $filteredCatalogue->add($messages, $domain);
  367.         }
  368.         foreach ($catalogue->getResources() as $resource) {
  369.             $filteredCatalogue->addResource($resource);
  370.         }
  372.         if ($metadata = $catalogue->getMetadata('', $intlDomain)) {
  373.             foreach ($metadata as $k => $v) {
  374.                 $filteredCatalogue->setMetadata($k, $v, $intlDomain);
  375.             }
  376.         }
  378.         if ($metadata = $catalogue->getMetadata('', $domain)) {
  379.             foreach ($metadata as $k => $v) {
  380.                 $filteredCatalogue->setMetadata($k, $v, $domain);
  381.             }
  382.         }
  384.         return $filteredCatalogue;
  385.     }
  387.     private function extractMessages(string $locale, array $transPaths, string $prefix): MessageCatalogue
  388.     {
  389.         $extractedCatalogue = new MessageCatalogue($locale);
  390.         $this->extractor->setPrefix($prefix);
  391.         $transPaths = $this->filterDuplicateTransPaths($transPaths);
  392.         foreach ($transPaths as $path) {
  393.             if (is_dir($path) || is_file($path)) {
  394.                 $this->extractor->extract($path, $extractedCatalogue);
  395.             }
  396.         }
  398.         return $extractedCatalogue;
  399.     }
  401.     private function filterDuplicateTransPaths(array $transPaths): array
  402.     {
  403.         $transPaths = array_filter(array_map('realpath', $transPaths));
  405.         sort($transPaths);
  407.         $filteredPaths = [];
  409.         foreach ($transPaths as $path) {
  410.             foreach ($filteredPaths as $filteredPath) {
  411.                 if (str_starts_with($path, $filteredPath.\DIRECTORY_SEPARATOR)) {
  412.                     continue 2;
  413.                 }
  414.             }
  416.             $filteredPaths[] = $path;
  417.         }
  419.         return $filteredPaths;
  420.     }
  422.     private function loadCurrentMessages(string $locale, array $transPaths): MessageCatalogue
  423.     {
  424.         $currentCatalogue = new MessageCatalogue($locale);
  425.         foreach ($transPaths as $path) {
  426.             if (is_dir($path)) {
  427.                 $this->reader->read($path, $currentCatalogue);
  428.             }
  429.         }
  431.         return $currentCatalogue;
  432.     }
  434.     private function getRootTransPaths(): array
  435.     {
  436.         $transPaths = $this->transPaths;
  437.         if ($this->defaultTransPath) {
  438.             $transPaths[] = $this->defaultTransPath;
  439.         }
  441.         return $transPaths;
  442.     }
  444.     private function getRootCodePaths(KernelInterface $kernel): array
  445.     {
  446.         $codePaths = $this->codePaths;
  447.         $codePaths[] = $kernel->getProjectDir().'/src';
  448.         if ($this->defaultViewsPath) {
  449.             $codePaths[] = $this->defaultViewsPath;
  450.         }
  452.         return $codePaths;
  453.     }
  454. }