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

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\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.         switch ($input->getOption('format')) {
  105.             case 'text':
  106.                 $name ? $this->displayPathsText($io, $name) : $this->displayGeneralText($io, $filter);
  107.                 break;
  108.             case 'json':
  109.                 $name ? $this->displayPathsJson($io, $name) : $this->displayGeneralJson($io, $filter);
  110.                 break;
  111.             default:
  112.                 throw new InvalidArgumentException(sprintf('The format "%s" is not supported.', $input->getOption('format')));
  113.         }
  115.         return 0;
  116.     }
  118.     public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
  119.     {
  120.         if ($input->mustSuggestArgumentValuesFor('name')) {
  121.             $suggestions->suggestValues(array_keys($this->getLoaderPaths()));
  122.         }
  124.         if ($input->mustSuggestOptionValuesFor('format')) {
  125.             $suggestions->suggestValues(['text', 'json']);
  126.         }
  127.     }
  129.     private function displayPathsText(SymfonyStyle $io, string $name)
  130.     {
  131.         $file = new \ArrayIterator($this->findTemplateFiles($name));
  132.         $paths = $this->getLoaderPaths($name);
  134.         $io->section('Matched File');
  135.         if ($file->valid()) {
  136.             if ($fileLink = $this->getFileLink($file->key())) {
  137.                 $io->block($file->current(), 'OK', sprintf('fg=black;bg=green;href=%s', $fileLink), ' ', true);
  138.             } else {
  139.                 $io->success($file->current());
  140.             }
  141.             $file->next();
  143.             if ($file->valid()) {
  144.                 $io->section('Overridden Files');
  145.                 do {
  146.                     if ($fileLink = $this->getFileLink($file->key())) {
  147.                         $io->text(sprintf('* <href=%s>%s</>', $fileLink, $file->current()));
  148.                     } else {
  149.                         $io->text(sprintf('* %s', $file->current()));
  150.                     }
  151.                     $file->next();
  152.                 } while ($file->valid());
  153.             }
  154.         } else {
  155.             $alternatives = [];
  157.             if ($paths) {
  158.                 $shortnames = [];
  159.                 $dirs = [];
  160.                 foreach (current($paths) as $path) {
  161.                     $dirs[] = $this->isAbsolutePath($path) ? $path : $this->projectDir.'/'.$path;
  162.                 }
  163.                 foreach (Finder::create()->files()->followLinks()->in($dirs) as $file) {
  164.                     $shortnames[] = str_replace('\\', '/', $file->getRelativePathname());
  165.                 }
  167.                 [$namespace, $shortname] = $this->parseTemplateName($name);
  168.                 $alternatives = $this->findAlternatives($shortname, $shortnames);
  169.                 if (FilesystemLoader::MAIN_NAMESPACE !== $namespace) {
  170.                     $alternatives = array_map(function ($shortname) use ($namespace) {
  171.                         return '@'.$namespace.'/'.$shortname;
  172.                     }, $alternatives);
  173.                 }
  174.             }
  176.             $this->error($io, sprintf('Template name "%s" not found', $name), $alternatives);
  177.         }
  179.         $io->section('Configured Paths');
  180.         if ($paths) {
  181.             $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  182.         } else {
  183.             $alternatives = [];
  184.             $namespace = $this->parseTemplateName($name)[0];
  186.             if (FilesystemLoader::MAIN_NAMESPACE === $namespace) {
  187.                 $message = 'No template paths configured for your application';
  188.             } else {
  189.                 $message = sprintf('No template paths configured for "@%s" namespace', $namespace);
  190.                 foreach ($this->getFilesystemLoaders() as $loader) {
  191.                     $namespaces = $loader->getNamespaces();
  192.                     foreach ($this->findAlternatives($namespace, $namespaces) as $namespace) {
  193.                         $alternatives[] = '@'.$namespace;
  194.                     }
  195.                 }
  196.             }
  198.             $this->error($io, $message, $alternatives);
  200.             if (!$alternatives && $paths = $this->getLoaderPaths()) {
  201.                 $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  202.             }
  203.         }
  204.     }
  206.     private function displayPathsJson(SymfonyStyle $io, string $name)
  207.     {
  208.         $files = $this->findTemplateFiles($name);
  209.         $paths = $this->getLoaderPaths($name);
  211.         if ($files) {
  212.             $data['matched_file'] = array_shift($files);
  213.             if ($files) {
  214.                 $data['overridden_files'] = $files;
  215.             }
  216.         } else {
  217.             $data['matched_file'] = sprintf('Template name "%s" not found', $name);
  218.         }
  219.         $data['loader_paths'] = $paths;
  221.         $io->writeln(json_encode($data));
  222.     }
  224.     private function displayGeneralText(SymfonyStyle $io, string $filter = null)
  225.     {
  226.         $decorated = $io->isDecorated();
  227.         $types = ['functions', 'filters', 'tests', 'globals'];
  228.         foreach ($types as $index => $type) {
  229.             $items = [];
  230.             foreach ($this->twig->{'get'.ucfirst($type)}() as $name => $entity) {
  231.                 if (!$filter || str_contains($name, $filter)) {
  232.                     $items[$name] = $name.$this->getPrettyMetadata($type, $entity, $decorated);
  233.                 }
  234.             }
  236.             if (!$items) {
  237.                 continue;
  238.             }
  240.             $io->section(ucfirst($type));
  242.             ksort($items);
  243.             $io->listing($items);
  244.         }
  246.         if (!$filter && $paths = $this->getLoaderPaths()) {
  247.             $io->section('Loader Paths');
  248.             $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  249.         }
  251.         if ($wrongBundles = $this->findWrongBundleOverrides()) {
  252.             foreach ($this->buildWarningMessages($wrongBundles) as $message) {
  253.                 $io->warning($message);
  254.             }
  255.         }
  256.     }
  258.     private function displayGeneralJson(SymfonyStyle $io, ?string $filter)
  259.     {
  260.         $decorated = $io->isDecorated();
  261.         $types = ['functions', 'filters', 'tests', 'globals'];
  262.         $data = [];
  263.         foreach ($types as $type) {
  264.             foreach ($this->twig->{'get'.ucfirst($type)}() as $name => $entity) {
  265.                 if (!$filter || str_contains($name, $filter)) {
  266.                     $data[$type][$name] = $this->getMetadata($type, $entity);
  267.                 }
  268.             }
  269.         }
  270.         if (isset($data['tests'])) {
  271.             $data['tests'] = array_keys($data['tests']);
  272.         }
  274.         if (!$filter && $paths = $this->getLoaderPaths($filter)) {
  275.             $data['loader_paths'] = $paths;
  276.         }
  278.         if ($wrongBundles = $this->findWrongBundleOverrides()) {
  279.             $data['warnings'] = $this->buildWarningMessages($wrongBundles);
  280.         }
  282.         $data = json_encode($data, \JSON_PRETTY_PRINT);
  283.         $io->writeln($decorated ? OutputFormatter::escape($data) : $data);
  284.     }
  286.     private function getLoaderPaths(string $name = null): array
  287.     {
  288.         $loaderPaths = [];
  289.         foreach ($this->getFilesystemLoaders() as $loader) {
  290.             $namespaces = $loader->getNamespaces();
  291.             if (null !== $name) {
  292.                 $namespace = $this->parseTemplateName($name)[0];
  293.                 $namespaces = array_intersect([$namespace], $namespaces);
  294.             }
  296.             foreach ($namespaces as $namespace) {
  297.                 $paths = array_map($this->getRelativePath(...), $loader->getPaths($namespace));
  299.                 if (FilesystemLoader::MAIN_NAMESPACE === $namespace) {
  300.                     $namespace = '(None)';
  301.                 } else {
  302.                     $namespace = '@'.$namespace;
  303.                 }
  305.                 $loaderPaths[$namespace] = array_merge($loaderPaths[$namespace] ?? [], $paths);
  306.             }
  307.         }
  309.         return $loaderPaths;
  310.     }
  312.     private function getMetadata(string $type, mixed $entity)
  313.     {
  314.         if ('globals' === $type) {
  315.             return $entity;
  316.         }
  317.         if ('tests' === $type) {
  318.             return null;
  319.         }
  320.         if ('functions' === $type || 'filters' === $type) {
  321.             $cb = $entity->getCallable();
  322.             if (null === $cb) {
  323.                 return null;
  324.             }
  325.             if (\is_array($cb)) {
  326.                 if (!method_exists($cb[0], $cb[1])) {
  327.                     return null;
  328.                 }
  329.                 $refl = new \ReflectionMethod($cb[0], $cb[1]);
  330.             } elseif (\is_object($cb) && method_exists($cb, '__invoke')) {
  331.                 $refl = new \ReflectionMethod($cb, '__invoke');
  332.             } elseif (\function_exists($cb)) {
  333.                 $refl = new \ReflectionFunction($cb);
  334.             } elseif (\is_string($cb) && preg_match('{^(.+)::(.+)$}', $cb, $m) && method_exists($m[1], $m[2])) {
  335.                 $refl = new \ReflectionMethod($m[1], $m[2]);
  336.             } else {
  337.                 throw new \UnexpectedValueException('Unsupported callback type.');
  338.             }
  340.             $args = $refl->getParameters();
  342.             // filter out context/environment args
  343.             if ($entity->needsEnvironment()) {
  344.                 array_shift($args);
  345.             }
  346.             if ($entity->needsContext()) {
  347.                 array_shift($args);
  348.             }
  350.             if ('filters' === $type) {
  351.                 // remove the value the filter is applied on
  352.                 array_shift($args);
  353.             }
  355.             // format args
  356.             $args = array_map(function (\ReflectionParameter $param) {
  357.                 if ($param->isDefaultValueAvailable()) {
  358.                     return $param->getName().' = '.json_encode($param->getDefaultValue());
  359.                 }
  361.                 return $param->getName();
  362.             }, $args);
  364.             return $args;
  365.         }
  367.         return null;
  368.     }
  370.     private function getPrettyMetadata(string $type, mixed $entity, bool $decorated): ?string
  371.     {
  372.         if ('tests' === $type) {
  373.             return '';
  374.         }
  376.         try {
  377.             $meta = $this->getMetadata($type, $entity);
  378.             if (null === $meta) {
  379.                 return '(unknown?)';
  380.             }
  381.         } catch (\UnexpectedValueException $e) {
  382.             return sprintf(' <error>%s</error>', $decorated ? OutputFormatter::escape($e->getMessage()) : $e->getMessage());
  383.         }
  385.         if ('globals' === $type) {
  386.             if (\is_object($meta)) {
  387.                 return ' = object('.\get_class($meta).')';
  388.             }
  390.             $description = substr(@json_encode($meta), 0, 50);
  392.             return sprintf(' = %s', $decorated ? OutputFormatter::escape($description) : $description);
  393.         }
  395.         if ('functions' === $type) {
  396.             return '('.implode(', ', $meta).')';
  397.         }
  399.         if ('filters' === $type) {
  400.             return $meta ? '('.implode(', ', $meta).')' : '';
  401.         }
  403.         return null;
  404.     }
  406.     private function findWrongBundleOverrides(): array
  407.     {
  408.         $alternatives = [];
  409.         $bundleNames = [];
  411.         if ($this->twigDefaultPath && $this->projectDir) {
  412.             $folders = glob($this->twigDefaultPath.'/bundles/*', \GLOB_ONLYDIR);
  413.             $relativePath = ltrim(substr($this->twigDefaultPath.'/bundles/', \strlen($this->projectDir)), \DIRECTORY_SEPARATOR);
  414.             $bundleNames = array_reduce($folders, function ($carry, $absolutePath) use ($relativePath) {
  415.                 if (str_starts_with($absolutePath, $this->projectDir)) {
  416.                     $name = basename($absolutePath);
  417.                     $path = ltrim($relativePath.$name, \DIRECTORY_SEPARATOR);
  418.                     $carry[$name] = $path;
  419.                 }
  421.                 return $carry;
  422.             }, $bundleNames);
  423.         }
  425.         if ($notFoundBundles = array_diff_key($bundleNames, $this->bundlesMetadata)) {
  426.             $alternatives = [];
  427.             foreach ($notFoundBundles as $notFoundBundle => $path) {
  428.                 $alternatives[$path] = $this->findAlternatives($notFoundBundle, array_keys($this->bundlesMetadata));
  429.             }
  430.         }
  432.         return $alternatives;
  433.     }
  435.     private function buildWarningMessages(array $wrongBundles): array
  436.     {
  437.         $messages = [];
  438.         foreach ($wrongBundles as $path => $alternatives) {
  439.             $message = sprintf('Path "%s" not matching any bundle found', $path);
  440.             if ($alternatives) {
  441.                 if (1 === \count($alternatives)) {
  442.                     $message .= sprintf(", did you mean \"%s\"?\n", $alternatives[0]);
  443.                 } else {
  444.                     $message .= ", did you mean one of these:\n";
  445.                     foreach ($alternatives as $bundle) {
  446.                         $message .= sprintf("  - %s\n", $bundle);
  447.                     }
  448.                 }
  449.             }
  450.             $messages[] = trim($message);
  451.         }
  453.         return $messages;
  454.     }
  456.     private function error(SymfonyStyle $io, string $message, array $alternatives = []): void
  457.     {
  458.         if ($alternatives) {
  459.             if (1 === \count($alternatives)) {
  460.                 $message .= "\n\nDid you mean this?\n    ";
  461.             } else {
  462.                 $message .= "\n\nDid you mean one of these?\n    ";
  463.             }
  464.             $message .= implode("\n    ", $alternatives);
  465.         }
  467.         $io->block($message, null, 'fg=white;bg=red', ' ', true);
  468.     }
  470.     private function findTemplateFiles(string $name): array
  471.     {
  472.         [$namespace, $shortname] = $this->parseTemplateName($name);
  474.         $files = [];
  475.         foreach ($this->getFilesystemLoaders() as $loader) {
  476.             foreach ($loader->getPaths($namespace) as $path) {
  477.                 if (!$this->isAbsolutePath($path)) {
  478.                     $path = $this->projectDir.'/'.$path;
  479.                 }
  480.                 $filename = $path.'/'.$shortname;
  482.                 if (is_file($filename)) {
  483.                     if (false !== $realpath = realpath($filename)) {
  484.                         $files[$realpath] = $this->getRelativePath($realpath);
  485.                     } else {
  486.                         $files[$filename] = $this->getRelativePath($filename);
  487.                     }
  488.                 }
  489.             }
  490.         }
  492.         return $files;
  493.     }
  495.     private function parseTemplateName(string $name, string $default = FilesystemLoader::MAIN_NAMESPACE): array
  496.     {
  497.         if (isset($name[0]) && '@' === $name[0]) {
  498.             if (false === ($pos = strpos($name, '/')) || $pos === \strlen($name) - 1) {
  499.                 throw new InvalidArgumentException(sprintf('Malformed namespaced template name "%s" (expecting "@namespace/template_name").', $name));
  500.             }
  502.             $namespace = substr($name, 1, $pos - 1);
  503.             $shortname = substr($name, $pos + 1);
  505.             return [$namespace, $shortname];
  506.         }
  508.         return [$default, $name];
  509.     }
  511.     private function buildTableRows(array $loaderPaths): array
  512.     {
  513.         $rows = [];
  514.         $firstNamespace = true;
  515.         $prevHasSeparator = false;
  517.         foreach ($loaderPaths as $namespace => $paths) {
  518.             if (!$firstNamespace && !$prevHasSeparator && \count($paths) > 1) {
  519.                 $rows[] = ['', ''];
  520.             }
  521.             $firstNamespace = false;
  522.             foreach ($paths as $path) {
  523.                 $rows[] = [$namespace, $path.\DIRECTORY_SEPARATOR];
  524.                 $namespace = '';
  525.             }
  526.             if (\count($paths) > 1) {
  527.                 $rows[] = ['', ''];
  528.                 $prevHasSeparator = true;
  529.             } else {
  530.                 $prevHasSeparator = false;
  531.             }
  532.         }
  533.         if ($prevHasSeparator) {
  534.             array_pop($rows);
  535.         }
  537.         return $rows;
  538.     }
  540.     private function findAlternatives(string $name, array $collection): array
  541.     {
  542.         $alternatives = [];
  543.         foreach ($collection as $item) {
  544.             $lev = levenshtein($name, $item);
  545.             if ($lev <= \strlen($name) / 3 || str_contains($item, $name)) {
  546.                 $alternatives[$item] = isset($alternatives[$item]) ? $alternatives[$item] - $lev : $lev;
  547.             }
  548.         }
  550.         $threshold = 1e3;
  551.         $alternatives = array_filter($alternatives, function ($lev) use ($threshold) { return $lev < 2 * $threshold; });
  552.         ksort($alternatives, \SORT_NATURAL | \SORT_FLAG_CASE);
  554.         return array_keys($alternatives);
  555.     }
  557.     private function getRelativePath(string $path): string
  558.     {
  559.         if (null !== $this->projectDir && str_starts_with($path, $this->projectDir)) {
  560.             return ltrim(substr($path, \strlen($this->projectDir)), \DIRECTORY_SEPARATOR);
  561.         }
  563.         return $path;
  564.     }
  566.     private function isAbsolutePath(string $file): bool
  567.     {
  568.         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);
  569.     }
  571.     /**
  572.      * @return FilesystemLoader[]
  573.      */
  574.     private function getFilesystemLoaders(): array
  575.     {
  576.         if (isset($this->filesystemLoaders)) {
  577.             return $this->filesystemLoaders;
  578.         }
  579.         $this->filesystemLoaders = [];
  581.         $loader = $this->twig->getLoader();
  582.         if ($loader instanceof FilesystemLoader) {
  583.             $this->filesystemLoaders[] = $loader;
  584.         } elseif ($loader instanceof ChainLoader) {
  585.             foreach ($loader->getLoaders() as $l) {
  586.                 if ($l instanceof FilesystemLoader) {
  587.                     $this->filesystemLoaders[] = $l;
  588.                 }
  589.             }
  590.         }
  592.         return $this->filesystemLoaders;
  593.     }
  595.     private function getFileLink(string $absolutePath): string
  596.     {
  597.         if (null === $this->fileLinkFormatter) {
  598.             return '';
  599.         }
  601.         return (string) $this->fileLinkFormatter->format($absolutePath, 1);
  602.     }
  603. }