vendor/symfony/twig-bridge/Command/DebugCommand.php line 219

  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\Bridge\Twig\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\Formatter\OutputFormatter;
  20. use Symfony\Component\Console\Input\InputArgument;
  21. use Symfony\Component\Console\Input\InputInterface;
  22. use Symfony\Component\Console\Input\InputOption;
  23. use Symfony\Component\Console\Output\OutputInterface;
  24. use Symfony\Component\Console\Style\SymfonyStyle;
  25. use Symfony\Component\Finder\Finder;
  26. use Symfony\Component\HttpKernel\Debug\FileLinkFormatter;
  27. use Twig\Environment;
  28. use Twig\Loader\ChainLoader;
  29. use Twig\Loader\FilesystemLoader;
  31. /**
  32.  * Lists twig functions, filters, globals and tests present in the current project.
  33.  *
  34.  * @author Jordi Boggiano <j.boggiano@seld.be>
  35.  */
  36. #[AsCommand(name: 'debug:twig', description: 'Show a list of twig functions, filters, globals and tests')]
  37. class DebugCommand extends Command
  38. {
  39.     private Environment $twig;
  40.     private ?string $projectDir;
  41.     private array $bundlesMetadata;
  42.     private ?string $twigDefaultPath;
  44.     /**
  45.      * @var FilesystemLoader[]
  46.      */
  47.     private array $filesystemLoaders;
  49.     private ?FileLinkFormatter $fileLinkFormatter;
  51.     public function __construct(Environment $twig, string $projectDir = null, array $bundlesMetadata = [], string $twigDefaultPath = null, FileLinkFormatter $fileLinkFormatter = null)
  52.     {
  53.         parent::__construct();
  55.         $this->twig = $twig;
  56.         $this->projectDir = $projectDir;
  57.         $this->bundlesMetadata = $bundlesMetadata;
  58.         $this->twigDefaultPath = $twigDefaultPath;
  59.         $this->fileLinkFormatter = $fileLinkFormatter;
  60.     }
  62.     protected function configure()
  63.     {
  64.         $this
  65.             ->setDefinition([
  66.                 new InputArgument('name', InputArgument::OPTIONAL, 'The template name'),
  67.                 new InputOption('filter', null, InputOption::VALUE_REQUIRED, 'Show details for all entries matching this filter'),
  68.                 new InputOption('format', null, InputOption::VALUE_REQUIRED, 'The output format (text or json)', 'text'),
  69.             ])
  70.             ->setHelp(<<<'EOF'
  71. The <info>%command.name%</info> command outputs a list of twig functions,
  72. filters, globals and tests.
  74.   <info>php %command.full_name%</info>
  76. The command lists all functions, filters, etc.
  78.   <info>php %command.full_name% @Twig/Exception/error.html.twig</info>
  80. The command lists all paths that match the given template name.
  82.   <info>php %command.full_name% --filter=date</info>
  84. The command lists everything that contains the word date.
  86.   <info>php %command.full_name% --format=json</info>
  88. The command lists everything in a machine readable json format.
  89. EOF
  90.             )
  91.         ;
  92.     }
  94.     protected function execute(InputInterface $input, OutputInterface $output): int
  95.     {
  96.         $io = new SymfonyStyle($input, $output);
  97.         $name = $input->getArgument('name');
  98.         $filter = $input->getOption('filter');
  100.         if (null !== $name && [] === $this->getFilesystemLoaders()) {
  101.             throw new InvalidArgumentException(sprintf('Argument "name" not supported, it requires the Twig loader "%s".', FilesystemLoader::class));
  102.         }
  104.         match ($input->getOption('format')) {
  105.             'text' => $name ? $this->displayPathsText($io, $name) : $this->displayGeneralText($io, $filter),
  106.             'json' => $name ? $this->displayPathsJson($io, $name) : $this->displayGeneralJson($io, $filter),
  107.             default => throw new InvalidArgumentException(sprintf('The format "%s" is not supported.', $input->getOption('format'))),
  108.         };
  110.         return 0;
  111.     }
  113.     public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
  114.     {
  115.         if ($input->mustSuggestArgumentValuesFor('name')) {
  116.             $suggestions->suggestValues(array_keys($this->getLoaderPaths()));
  117.         }
  119.         if ($input->mustSuggestOptionValuesFor('format')) {
  120.             $suggestions->suggestValues(['text', 'json']);
  121.         }
  122.     }
  124.     private function displayPathsText(SymfonyStyle $io, string $name)
  125.     {
  126.         $file = new \ArrayIterator($this->findTemplateFiles($name));
  127.         $paths = $this->getLoaderPaths($name);
  129.         $io->section('Matched File');
  130.         if ($file->valid()) {
  131.             if ($fileLink = $this->getFileLink($file->key())) {
  132.                 $io->block($file->current(), 'OK', sprintf('fg=black;bg=green;href=%s', $fileLink), ' ', true);
  133.             } else {
  134.                 $io->success($file->current());
  135.             }
  136.             $file->next();
  138.             if ($file->valid()) {
  139.                 $io->section('Overridden Files');
  140.                 do {
  141.                     if ($fileLink = $this->getFileLink($file->key())) {
  142.                         $io->text(sprintf('* <href=%s>%s</>', $fileLink, $file->current()));
  143.                     } else {
  144.                         $io->text(sprintf('* %s', $file->current()));
  145.                     }
  146.                     $file->next();
  147.                 } while ($file->valid());
  148.             }
  149.         } else {
  150.             $alternatives = [];
  152.             if ($paths) {
  153.                 $shortnames = [];
  154.                 $dirs = [];
  155.                 foreach (current($paths) as $path) {
  156.                     $dirs[] = $this->isAbsolutePath($path) ? $path : $this->projectDir.'/'.$path;
  157.                 }
  158.                 foreach (Finder::create()->files()->followLinks()->in($dirs) as $file) {
  159.                     $shortnames[] = str_replace('\\', '/', $file->getRelativePathname());
  160.                 }
  162.                 [$namespace, $shortname] = $this->parseTemplateName($name);
  163.                 $alternatives = $this->findAlternatives($shortname, $shortnames);
  164.                 if (FilesystemLoader::MAIN_NAMESPACE !== $namespace) {
  165.                     $alternatives = array_map(function ($shortname) use ($namespace) {
  166.                         return '@'.$namespace.'/'.$shortname;
  167.                     }, $alternatives);
  168.                 }
  169.             }
  171.             $this->error($io, sprintf('Template name "%s" not found', $name), $alternatives);
  172.         }
  174.         $io->section('Configured Paths');
  175.         if ($paths) {
  176.             $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  177.         } else {
  178.             $alternatives = [];
  179.             $namespace = $this->parseTemplateName($name)[0];
  181.             if (FilesystemLoader::MAIN_NAMESPACE === $namespace) {
  182.                 $message = 'No template paths configured for your application';
  183.             } else {
  184.                 $message = sprintf('No template paths configured for "@%s" namespace', $namespace);
  185.                 foreach ($this->getFilesystemLoaders() as $loader) {
  186.                     $namespaces = $loader->getNamespaces();
  187.                     foreach ($this->findAlternatives($namespace, $namespaces) as $namespace) {
  188.                         $alternatives[] = '@'.$namespace;
  189.                     }
  190.                 }
  191.             }
  193.             $this->error($io, $message, $alternatives);
  195.             if (!$alternatives && $paths = $this->getLoaderPaths()) {
  196.                 $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  197.             }
  198.         }
  199.     }
  201.     private function displayPathsJson(SymfonyStyle $io, string $name)
  202.     {
  203.         $files = $this->findTemplateFiles($name);
  204.         $paths = $this->getLoaderPaths($name);
  206.         if ($files) {
  207.             $data['matched_file'] = array_shift($files);
  208.             if ($files) {
  209.                 $data['overridden_files'] = $files;
  210.             }
  211.         } else {
  212.             $data['matched_file'] = sprintf('Template name "%s" not found', $name);
  213.         }
  214.         $data['loader_paths'] = $paths;
  216.         $io->writeln(json_encode($data));
  217.     }
  219.     private function displayGeneralText(SymfonyStyle $io, string $filter = null)
  220.     {
  221.         $decorated = $io->isDecorated();
  222.         $types = ['functions', 'filters', 'tests', 'globals'];
  223.         foreach ($types as $index => $type) {
  224.             $items = [];
  225.             foreach ($this->twig->{'get'.ucfirst($type)}() as $name => $entity) {
  226.                 if (!$filter || str_contains($name, $filter)) {
  227.                     $items[$name] = $name.$this->getPrettyMetadata($type, $entity, $decorated);
  228.                 }
  229.             }
  231.             if (!$items) {
  232.                 continue;
  233.             }
  235.             $io->section(ucfirst($type));
  237.             ksort($items);
  238.             $io->listing($items);
  239.         }
  241.         if (!$filter && $paths = $this->getLoaderPaths()) {
  242.             $io->section('Loader Paths');
  243.             $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  244.         }
  246.         if ($wrongBundles = $this->findWrongBundleOverrides()) {
  247.             foreach ($this->buildWarningMessages($wrongBundles) as $message) {
  248.                 $io->warning($message);
  249.             }
  250.         }
  251.     }
  253.     private function displayGeneralJson(SymfonyStyle $io, ?string $filter)
  254.     {
  255.         $decorated = $io->isDecorated();
  256.         $types = ['functions', 'filters', 'tests', 'globals'];
  257.         $data = [];
  258.         foreach ($types as $type) {
  259.             foreach ($this->twig->{'get'.ucfirst($type)}() as $name => $entity) {
  260.                 if (!$filter || str_contains($name, $filter)) {
  261.                     $data[$type][$name] = $this->getMetadata($type, $entity);
  262.                 }
  263.             }
  264.         }
  265.         if (isset($data['tests'])) {
  266.             $data['tests'] = array_keys($data['tests']);
  267.         }
  269.         if (!$filter && $paths = $this->getLoaderPaths($filter)) {
  270.             $data['loader_paths'] = $paths;
  271.         }
  273.         if ($wrongBundles = $this->findWrongBundleOverrides()) {
  274.             $data['warnings'] = $this->buildWarningMessages($wrongBundles);
  275.         }
  277.         $data = json_encode($data, \JSON_PRETTY_PRINT);
  278.         $io->writeln($decorated ? OutputFormatter::escape($data) : $data);
  279.     }
  281.     private function getLoaderPaths(string $name = null): array
  282.     {
  283.         $loaderPaths = [];
  284.         foreach ($this->getFilesystemLoaders() as $loader) {
  285.             $namespaces = $loader->getNamespaces();
  286.             if (null !== $name) {
  287.                 $namespace = $this->parseTemplateName($name)[0];
  288.                 $namespaces = array_intersect([$namespace], $namespaces);
  289.             }
  291.             foreach ($namespaces as $namespace) {
  292.                 $paths = array_map($this->getRelativePath(...), $loader->getPaths($namespace));
  294.                 if (FilesystemLoader::MAIN_NAMESPACE === $namespace) {
  295.                     $namespace = '(None)';
  296.                 } else {
  297.                     $namespace = '@'.$namespace;
  298.                 }
  300.                 $loaderPaths[$namespace] = array_merge($loaderPaths[$namespace] ?? [], $paths);
  301.             }
  302.         }
  304.         return $loaderPaths;
  305.     }
  307.     private function getMetadata(string $type, mixed $entity)
  308.     {
  309.         if ('globals' === $type) {
  310.             return $entity;
  311.         }
  312.         if ('tests' === $type) {
  313.             return null;
  314.         }
  315.         if ('functions' === $type || 'filters' === $type) {
  316.             $cb = $entity->getCallable();
  317.             if (null === $cb) {
  318.                 return null;
  319.             }
  320.             if (\is_array($cb)) {
  321.                 if (!method_exists($cb[0], $cb[1])) {
  322.                     return null;
  323.                 }
  324.                 $refl = new \ReflectionMethod($cb[0], $cb[1]);
  325.             } elseif (\is_object($cb) && method_exists($cb, '__invoke')) {
  326.                 $refl = new \ReflectionMethod($cb, '__invoke');
  327.             } elseif (\function_exists($cb)) {
  328.                 $refl = new \ReflectionFunction($cb);
  329.             } elseif (\is_string($cb) && preg_match('{^(.+)::(.+)$}', $cb, $m) && method_exists($m[1], $m[2])) {
  330.                 $refl = new \ReflectionMethod($m[1], $m[2]);
  331.             } else {
  332.                 throw new \UnexpectedValueException('Unsupported callback type.');
  333.             }
  335.             $args = $refl->getParameters();
  337.             // filter out context/environment args
  338.             if ($entity->needsEnvironment()) {
  339.                 array_shift($args);
  340.             }
  341.             if ($entity->needsContext()) {
  342.                 array_shift($args);
  343.             }
  345.             if ('filters' === $type) {
  346.                 // remove the value the filter is applied on
  347.                 array_shift($args);
  348.             }
  350.             // format args
  351.             $args = array_map(function (\ReflectionParameter $param) {
  352.                 if ($param->isDefaultValueAvailable()) {
  353.                     return $param->getName().' = '.json_encode($param->getDefaultValue());
  354.                 }
  356.                 return $param->getName();
  357.             }, $args);
  359.             return $args;
  360.         }
  362.         return null;
  363.     }
  365.     private function getPrettyMetadata(string $type, mixed $entity, bool $decorated): ?string
  366.     {
  367.         if ('tests' === $type) {
  368.             return '';
  369.         }
  371.         try {
  372.             $meta = $this->getMetadata($type, $entity);
  373.             if (null === $meta) {
  374.                 return '(unknown?)';
  375.             }
  376.         } catch (\UnexpectedValueException $e) {
  377.             return sprintf(' <error>%s</error>', $decorated ? OutputFormatter::escape($e->getMessage()) : $e->getMessage());
  378.         }
  380.         if ('globals' === $type) {
  381.             if (\is_object($meta)) {
  382.                 return ' = object('.$meta::class.')';
  383.             }
  385.             $description = substr(@json_encode($meta), 0, 50);
  387.             return sprintf(' = %s', $decorated ? OutputFormatter::escape($description) : $description);
  388.         }
  390.         if ('functions' === $type) {
  391.             return '('.implode(', ', $meta).')';
  392.         }
  394.         if ('filters' === $type) {
  395.             return $meta ? '('.implode(', ', $meta).')' : '';
  396.         }
  398.         return null;
  399.     }
  401.     private function findWrongBundleOverrides(): array
  402.     {
  403.         $alternatives = [];
  404.         $bundleNames = [];
  406.         if ($this->twigDefaultPath && $this->projectDir) {
  407.             $folders = glob($this->twigDefaultPath.'/bundles/*', \GLOB_ONLYDIR);
  408.             $relativePath = ltrim(substr($this->twigDefaultPath.'/bundles/', \strlen($this->projectDir)), \DIRECTORY_SEPARATOR);
  409.             $bundleNames = array_reduce($folders, function ($carry, $absolutePath) use ($relativePath) {
  410.                 if (str_starts_with($absolutePath, $this->projectDir)) {
  411.                     $name = basename($absolutePath);
  412.                     $path = ltrim($relativePath.$name, \DIRECTORY_SEPARATOR);
  413.                     $carry[$name] = $path;
  414.                 }
  416.                 return $carry;
  417.             }, $bundleNames);
  418.         }
  420.         if ($notFoundBundles = array_diff_key($bundleNames, $this->bundlesMetadata)) {
  421.             $alternatives = [];
  422.             foreach ($notFoundBundles as $notFoundBundle => $path) {
  423.                 $alternatives[$path] = $this->findAlternatives($notFoundBundle, array_keys($this->bundlesMetadata));
  424.             }
  425.         }
  427.         return $alternatives;
  428.     }
  430.     private function buildWarningMessages(array $wrongBundles): array
  431.     {
  432.         $messages = [];
  433.         foreach ($wrongBundles as $path => $alternatives) {
  434.             $message = sprintf('Path "%s" not matching any bundle found', $path);
  435.             if ($alternatives) {
  436.                 if (1 === \count($alternatives)) {
  437.                     $message .= sprintf(", did you mean \"%s\"?\n", $alternatives[0]);
  438.                 } else {
  439.                     $message .= ", did you mean one of these:\n";
  440.                     foreach ($alternatives as $bundle) {
  441.                         $message .= sprintf("  - %s\n", $bundle);
  442.                     }
  443.                 }
  444.             }
  445.             $messages[] = trim($message);
  446.         }
  448.         return $messages;
  449.     }
  451.     private function error(SymfonyStyle $io, string $message, array $alternatives = []): void
  452.     {
  453.         if ($alternatives) {
  454.             if (1 === \count($alternatives)) {
  455.                 $message .= "\n\nDid you mean this?\n    ";
  456.             } else {
  457.                 $message .= "\n\nDid you mean one of these?\n    ";
  458.             }
  459.             $message .= implode("\n    ", $alternatives);
  460.         }
  462.         $io->block($message, null, 'fg=white;bg=red', ' ', true);
  463.     }
  465.     private function findTemplateFiles(string $name): array
  466.     {
  467.         [$namespace, $shortname] = $this->parseTemplateName($name);
  469.         $files = [];
  470.         foreach ($this->getFilesystemLoaders() as $loader) {
  471.             foreach ($loader->getPaths($namespace) as $path) {
  472.                 if (!$this->isAbsolutePath($path)) {
  473.                     $path = $this->projectDir.'/'.$path;
  474.                 }
  475.                 $filename = $path.'/'.$shortname;
  477.                 if (is_file($filename)) {
  478.                     if (false !== $realpath = realpath($filename)) {
  479.                         $files[$realpath] = $this->getRelativePath($realpath);
  480.                     } else {
  481.                         $files[$filename] = $this->getRelativePath($filename);
  482.                     }
  483.                 }
  484.             }
  485.         }
  487.         return $files;
  488.     }
  490.     private function parseTemplateName(string $name, string $default = FilesystemLoader::MAIN_NAMESPACE): array
  491.     {
  492.         if (isset($name[0]) && '@' === $name[0]) {
  493.             if (false === ($pos = strpos($name, '/')) || $pos === \strlen($name) - 1) {
  494.                 throw new InvalidArgumentException(sprintf('Malformed namespaced template name "%s" (expecting "@namespace/template_name").', $name));
  495.             }
  497.             $namespace = substr($name, 1, $pos - 1);
  498.             $shortname = substr($name, $pos + 1);
  500.             return [$namespace, $shortname];
  501.         }
  503.         return [$default, $name];
  504.     }
  506.     private function buildTableRows(array $loaderPaths): array
  507.     {
  508.         $rows = [];
  509.         $firstNamespace = true;
  510.         $prevHasSeparator = false;
  512.         foreach ($loaderPaths as $namespace => $paths) {
  513.             if (!$firstNamespace && !$prevHasSeparator && \count($paths) > 1) {
  514.                 $rows[] = ['', ''];
  515.             }
  516.             $firstNamespace = false;
  517.             foreach ($paths as $path) {
  518.                 $rows[] = [$namespace, $path.\DIRECTORY_SEPARATOR];
  519.                 $namespace = '';
  520.             }
  521.             if (\count($paths) > 1) {
  522.                 $rows[] = ['', ''];
  523.                 $prevHasSeparator = true;
  524.             } else {
  525.                 $prevHasSeparator = false;
  526.             }
  527.         }
  528.         if ($prevHasSeparator) {
  529.             array_pop($rows);
  530.         }
  532.         return $rows;
  533.     }
  535.     private function findAlternatives(string $name, array $collection): array
  536.     {
  537.         $alternatives = [];
  538.         foreach ($collection as $item) {
  539.             $lev = levenshtein($name, $item);
  540.             if ($lev <= \strlen($name) / 3 || str_contains($item, $name)) {
  541.                 $alternatives[$item] = isset($alternatives[$item]) ? $alternatives[$item] - $lev : $lev;
  542.             }
  543.         }
  545.         $threshold = 1e3;
  546.         $alternatives = array_filter($alternatives, function ($lev) use ($threshold) { return $lev < 2 * $threshold; });
  547.         ksort($alternatives, \SORT_NATURAL | \SORT_FLAG_CASE);
  549.         return array_keys($alternatives);
  550.     }
  552.     private function getRelativePath(string $path): string
  553.     {
  554.         if (null !== $this->projectDir && str_starts_with($path, $this->projectDir)) {
  555.             return ltrim(substr($path, \strlen($this->projectDir)), \DIRECTORY_SEPARATOR);
  556.         }
  558.         return $path;
  559.     }
  561.     private function isAbsolutePath(string $file): bool
  562.     {
  563.         return strspn($file, '/\\', 0, 1) || (\strlen($file) > 3 && ctype_alpha($file[0]) && ':' === $file[1] && strspn($file, '/\\', 2, 1)) || null !== parse_url($file, \PHP_URL_SCHEME);
  564.     }
  566.     /**
  567.      * @return FilesystemLoader[]
  568.      */
  569.     private function getFilesystemLoaders(): array
  570.     {
  571.         if (isset($this->filesystemLoaders)) {
  572.             return $this->filesystemLoaders;
  573.         }
  574.         $this->filesystemLoaders = [];
  576.         $loader = $this->twig->getLoader();
  577.         if ($loader instanceof FilesystemLoader) {
  578.             $this->filesystemLoaders[] = $loader;
  579.         } elseif ($loader instanceof ChainLoader) {
  580.             foreach ($loader->getLoaders() as $l) {
  581.                 if ($l instanceof FilesystemLoader) {
  582.                     $this->filesystemLoaders[] = $l;
  583.                 }
  584.             }
  585.         }
  587.         return $this->filesystemLoaders;
  588.     }
  590.     private function getFileLink(string $absolutePath): string
  591.     {
  592.         if (null === $this->fileLinkFormatter) {
  593.             return '';
  594.         }
  596.         return (string) $this->fileLinkFormatter->format($absolutePath, 1);
  597.     }
  598. }