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/twig-bridge/Command/DebugCommand.php line 283

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\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\Formatter\OutputFormatter;
  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\OutputInterface;
  23. use Symfony\Component\Console\Style\SymfonyStyle;
  24. use Symfony\Component\Finder\Finder;
  25. use Symfony\Component\HttpKernel\Debug\FileLinkFormatter;
  26. use Twig\Environment;
  27. use Twig\Loader\ChainLoader;
  28. use Twig\Loader\FilesystemLoader;
  30. /**
  31.  * Lists twig functions, filters, globals and tests present in the current project.
  32.  *
  33.  * @author Jordi Boggiano <j.boggiano@seld.be>
  34.  */
  35. class DebugCommand extends Command
  36. {
  37.     protected static $defaultName = 'debug:twig';
  38.     protected static $defaultDescription = 'Show a list of twig functions, filters, globals and tests';
  40.     private $twig;
  41.     private $projectDir;
  42.     private $bundlesMetadata;
  43.     private $twigDefaultPath;
  44.     private $filesystemLoaders;
  45.     private $fileLinkFormatter;
  47.     public function __construct(Environment $twig, string $projectDir = null, array $bundlesMetadata = [], string $twigDefaultPath = null, FileLinkFormatter $fileLinkFormatter = null)
  48.     {
  49.         parent::__construct();
  51.         $this->twig = $twig;
  52.         $this->projectDir = $projectDir;
  53.         $this->bundlesMetadata = $bundlesMetadata;
  54.         $this->twigDefaultPath = $twigDefaultPath;
  55.         $this->fileLinkFormatter = $fileLinkFormatter;
  56.     }
  58.     protected function configure()
  59.     {
  60.         $this
  61.             ->setDefinition([
  62.                 new InputArgument('name', InputArgument::OPTIONAL, 'The template name'),
  63.                 new InputOption('filter', null, InputOption::VALUE_REQUIRED, 'Show details for all entries matching this filter'),
  64.                 new InputOption('format', null, InputOption::VALUE_REQUIRED, 'The output format (text or json)', 'text'),
  65.             ])
  66.             ->setDescription(self::$defaultDescription)
  67.             ->setHelp(<<<'EOF'
  68. The <info>%command.name%</info> command outputs a list of twig functions,
  69. filters, globals and tests.
  71.   <info>php %command.full_name%</info>
  73. The command lists all functions, filters, etc.
  75.   <info>php %command.full_name% @Twig/Exception/error.html.twig</info>
  77. The command lists all paths that match the given template name.
  79.   <info>php %command.full_name% --filter=date</info>
  81. The command lists everything that contains the word date.
  83.   <info>php %command.full_name% --format=json</info>
  85. The command lists everything in a machine readable json format.
  86. EOF
  87.             )
  88.         ;
  89.     }
  91.     protected function execute(InputInterface $input, OutputInterface $output)
  92.     {
  93.         $io = new SymfonyStyle($input, $output);
  94.         $name = $input->getArgument('name');
  95.         $filter = $input->getOption('filter');
  97.         if (null !== $name && [] === $this->getFilesystemLoaders()) {
  98.             throw new InvalidArgumentException(sprintf('Argument "name" not supported, it requires the Twig loader "%s".', FilesystemLoader::class));
  99.         }
  101.         switch ($input->getOption('format')) {
  102.             case 'text':
  103.                 $name ? $this->displayPathsText($io, $name) : $this->displayGeneralText($io, $filter);
  104.                 break;
  105.             case 'json':
  106.                 $name ? $this->displayPathsJson($io, $name) : $this->displayGeneralJson($io, $filter);
  107.                 break;
  108.             default:
  109.                 throw new InvalidArgumentException(sprintf('The format "%s" is not supported.', $input->getOption('format')));
  110.         }
  112.         return 0;
  113.     }
  115.     public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
  116.     {
  117.         if ($input->mustSuggestArgumentValuesFor('name')) {
  118.             $suggestions->suggestValues(array_keys($this->getLoaderPaths()));
  119.         }
  121.         if ($input->mustSuggestOptionValuesFor('format')) {
  122.             $suggestions->suggestValues(['text', 'json']);
  123.         }
  124.     }
  126.     private function displayPathsText(SymfonyStyle $io, string $name)
  127.     {
  128.         $file = new \ArrayIterator($this->findTemplateFiles($name));
  129.         $paths = $this->getLoaderPaths($name);
  131.         $io->section('Matched File');
  132.         if ($file->valid()) {
  133.             if ($fileLink = $this->getFileLink($file->key())) {
  134.                 $io->block($file->current(), 'OK', sprintf('fg=black;bg=green;href=%s', $fileLink), ' ', true);
  135.             } else {
  136.                 $io->success($file->current());
  137.             }
  138.             $file->next();
  140.             if ($file->valid()) {
  141.                 $io->section('Overridden Files');
  142.                 do {
  143.                     if ($fileLink = $this->getFileLink($file->key())) {
  144.                         $io->text(sprintf('* <href=%s>%s</>', $fileLink, $file->current()));
  145.                     } else {
  146.                         $io->text(sprintf('* %s', $file->current()));
  147.                     }
  148.                     $file->next();
  149.                 } while ($file->valid());
  150.             }
  151.         } else {
  152.             $alternatives = [];
  154.             if ($paths) {
  155.                 $shortnames = [];
  156.                 $dirs = [];
  157.                 foreach (current($paths) as $path) {
  158.                     $dirs[] = $this->isAbsolutePath($path) ? $path : $this->projectDir.'/'.$path;
  159.                 }
  160.                 foreach (Finder::create()->files()->followLinks()->in($dirs) as $file) {
  161.                     $shortnames[] = str_replace('\\', '/', $file->getRelativePathname());
  162.                 }
  164.                 [$namespace, $shortname] = $this->parseTemplateName($name);
  165.                 $alternatives = $this->findAlternatives($shortname, $shortnames);
  166.                 if (FilesystemLoader::MAIN_NAMESPACE !== $namespace) {
  167.                     $alternatives = array_map(function ($shortname) use ($namespace) {
  168.                         return '@'.$namespace.'/'.$shortname;
  169.                     }, $alternatives);
  170.                 }
  171.             }
  173.             $this->error($io, sprintf('Template name "%s" not found', $name), $alternatives);
  174.         }
  176.         $io->section('Configured Paths');
  177.         if ($paths) {
  178.             $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  179.         } else {
  180.             $alternatives = [];
  181.             $namespace = $this->parseTemplateName($name)[0];
  183.             if (FilesystemLoader::MAIN_NAMESPACE === $namespace) {
  184.                 $message = 'No template paths configured for your application';
  185.             } else {
  186.                 $message = sprintf('No template paths configured for "@%s" namespace', $namespace);
  187.                 foreach ($this->getFilesystemLoaders() as $loader) {
  188.                     $namespaces = $loader->getNamespaces();
  189.                     foreach ($this->findAlternatives($namespace, $namespaces) as $namespace) {
  190.                         $alternatives[] = '@'.$namespace;
  191.                     }
  192.                 }
  193.             }
  195.             $this->error($io, $message, $alternatives);
  197.             if (!$alternatives && $paths = $this->getLoaderPaths()) {
  198.                 $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  199.             }
  200.         }
  201.     }
  203.     private function displayPathsJson(SymfonyStyle $io, string $name)
  204.     {
  205.         $files = $this->findTemplateFiles($name);
  206.         $paths = $this->getLoaderPaths($name);
  208.         if ($files) {
  209.             $data['matched_file'] = array_shift($files);
  210.             if ($files) {
  211.                 $data['overridden_files'] = $files;
  212.             }
  213.         } else {
  214.             $data['matched_file'] = sprintf('Template name "%s" not found', $name);
  215.         }
  216.         $data['loader_paths'] = $paths;
  218.         $io->writeln(json_encode($data));
  219.     }
  221.     private function displayGeneralText(SymfonyStyle $io, string $filter = null)
  222.     {
  223.         $decorated = $io->isDecorated();
  224.         $types = ['functions', 'filters', 'tests', 'globals'];
  225.         foreach ($types as $index => $type) {
  226.             $items = [];
  227.             foreach ($this->twig->{'get'.ucfirst($type)}() as $name => $entity) {
  228.                 if (!$filter || str_contains($name, $filter)) {
  229.                     $items[$name] = $name.$this->getPrettyMetadata($type, $entity, $decorated);
  230.                 }
  231.             }
  233.             if (!$items) {
  234.                 continue;
  235.             }
  237.             $io->section(ucfirst($type));
  239.             ksort($items);
  240.             $io->listing($items);
  241.         }
  243.         if (!$filter && $paths = $this->getLoaderPaths()) {
  244.             $io->section('Loader Paths');
  245.             $io->table(['Namespace', 'Paths'], $this->buildTableRows($paths));
  246.         }
  248.         if ($wrongBundles = $this->findWrongBundleOverrides()) {
  249.             foreach ($this->buildWarningMessages($wrongBundles) as $message) {
  250.                 $io->warning($message);
  251.             }
  252.         }
  253.     }
  255.     private function displayGeneralJson(SymfonyStyle $io, ?string $filter)
  256.     {
  257.         $decorated = $io->isDecorated();
  258.         $types = ['functions', 'filters', 'tests', 'globals'];
  259.         $data = [];
  260.         foreach ($types as $type) {
  261.             foreach ($this->twig->{'get'.ucfirst($type)}() as $name => $entity) {
  262.                 if (!$filter || str_contains($name, $filter)) {
  263.                     $data[$type][$name] = $this->getMetadata($type, $entity);
  264.                 }
  265.             }
  266.         }
  267.         if (isset($data['tests'])) {
  268.             $data['tests'] = array_keys($data['tests']);
  269.         }
  271.         if (!$filter && $paths = $this->getLoaderPaths($filter)) {
  272.             $data['loader_paths'] = $paths;
  273.         }
  275.         if ($wrongBundles = $this->findWrongBundleOverrides()) {
  276.             $data['warnings'] = $this->buildWarningMessages($wrongBundles);
  277.         }
  279.         $data = json_encode($data, \JSON_PRETTY_PRINT);
  280.         $io->writeln($decorated ? OutputFormatter::escape($data) : $data);
  281.     }
  283.     private function getLoaderPaths(string $name = null): array
  284.     {
  285.         $loaderPaths = [];
  286.         foreach ($this->getFilesystemLoaders() as $loader) {
  287.             $namespaces = $loader->getNamespaces();
  288.             if (null !== $name) {
  289.                 $namespace = $this->parseTemplateName($name)[0];
  290.                 $namespaces = array_intersect([$namespace], $namespaces);
  291.             }
  293.             foreach ($namespaces as $namespace) {
  294.                 $paths = array_map([$this, 'getRelativePath'], $loader->getPaths($namespace));
  296.                 if (FilesystemLoader::MAIN_NAMESPACE === $namespace) {
  297.                     $namespace = '(None)';
  298.                 } else {
  299.                     $namespace = '@'.$namespace;
  300.                 }
  302.                 $loaderPaths[$namespace] = array_merge($loaderPaths[$namespace] ?? [], $paths);
  303.             }
  304.         }
  306.         return $loaderPaths;
  307.     }
  309.     private function getMetadata(string $type, $entity)
  310.     {
  311.         if ('globals' === $type) {
  312.             return $entity;
  313.         }
  314.         if ('tests' === $type) {
  315.             return null;
  316.         }
  317.         if ('functions' === $type || 'filters' === $type) {
  318.             $cb = $entity->getCallable();
  319.             if (null === $cb) {
  320.                 return null;
  321.             }
  322.             if (\is_array($cb)) {
  323.                 if (!method_exists($cb[0], $cb[1])) {
  324.                     return null;
  325.                 }
  326.                 $refl = new \ReflectionMethod($cb[0], $cb[1]);
  327.             } elseif (\is_object($cb) && method_exists($cb, '__invoke')) {
  328.                 $refl = new \ReflectionMethod($cb, '__invoke');
  329.             } elseif (\function_exists($cb)) {
  330.                 $refl = new \ReflectionFunction($cb);
  331.             } elseif (\is_string($cb) && preg_match('{^(.+)::(.+)$}', $cb, $m) && method_exists($m[1], $m[2])) {
  332.                 $refl = new \ReflectionMethod($m[1], $m[2]);
  333.             } else {
  334.                 throw new \UnexpectedValueException('Unsupported callback type.');
  335.             }
  337.             $args = $refl->getParameters();
  339.             // filter out context/environment args
  340.             if ($entity->needsEnvironment()) {
  341.                 array_shift($args);
  342.             }
  343.             if ($entity->needsContext()) {
  344.                 array_shift($args);
  345.             }
  347.             if ('filters' === $type) {
  348.                 // remove the value the filter is applied on
  349.                 array_shift($args);
  350.             }
  352.             // format args
  353.             $args = array_map(function (\ReflectionParameter $param) {
  354.                 if ($param->isDefaultValueAvailable()) {
  355.                     return $param->getName().' = '.json_encode($param->getDefaultValue());
  356.                 }
  358.                 return $param->getName();
  359.             }, $args);
  361.             return $args;
  362.         }
  364.         return null;
  365.     }
  367.     private function getPrettyMetadata(string $type, $entity, bool $decorated): ?string
  368.     {
  369.         if ('tests' === $type) {
  370.             return '';
  371.         }
  373.         try {
  374.             $meta = $this->getMetadata($type, $entity);
  375.             if (null === $meta) {
  376.                 return '(unknown?)';
  377.             }
  378.         } catch (\UnexpectedValueException $e) {
  379.             return sprintf(' <error>%s</error>', $decorated ? OutputFormatter::escape($e->getMessage()) : $e->getMessage());
  380.         }
  382.         if ('globals' === $type) {
  383.             if (\is_object($meta)) {
  384.                 return ' = object('.\get_class($meta).')';
  385.             }
  387.             $description = substr(@json_encode($meta), 0, 50);
  389.             return sprintf(' = %s', $decorated ? OutputFormatter::escape($description) : $description);
  390.         }
  392.         if ('functions' === $type) {
  393.             return '('.implode(', ', $meta).')';
  394.         }
  396.         if ('filters' === $type) {
  397.             return $meta ? '('.implode(', ', $meta).')' : '';
  398.         }
  400.         return null;
  401.     }
  403.     private function findWrongBundleOverrides(): array
  404.     {
  405.         $alternatives = [];
  406.         $bundleNames = [];
  408.         if ($this->twigDefaultPath && $this->projectDir) {
  409.             $folders = glob($this->twigDefaultPath.'/bundles/*', \GLOB_ONLYDIR);
  410.             $relativePath = ltrim(substr($this->twigDefaultPath.'/bundles/', \strlen($this->projectDir)), \DIRECTORY_SEPARATOR);
  411.             $bundleNames = array_reduce($folders, function ($carry, $absolutePath) use ($relativePath) {
  412.                 if (str_starts_with($absolutePath, $this->projectDir)) {
  413.                     $name = basename($absolutePath);
  414.                     $path = ltrim($relativePath.$name, \DIRECTORY_SEPARATOR);
  415.                     $carry[$name] = $path;
  416.                 }
  418.                 return $carry;
  419.             }, $bundleNames);
  420.         }
  422.         if ($notFoundBundles = array_diff_key($bundleNames, $this->bundlesMetadata)) {
  423.             $alternatives = [];
  424.             foreach ($notFoundBundles as $notFoundBundle => $path) {
  425.                 $alternatives[$path] = $this->findAlternatives($notFoundBundle, array_keys($this->bundlesMetadata));
  426.             }
  427.         }
  429.         return $alternatives;
  430.     }
  432.     private function buildWarningMessages(array $wrongBundles): array
  433.     {
  434.         $messages = [];
  435.         foreach ($wrongBundles as $path => $alternatives) {
  436.             $message = sprintf('Path "%s" not matching any bundle found', $path);
  437.             if ($alternatives) {
  438.                 if (1 === \count($alternatives)) {
  439.                     $message .= sprintf(", did you mean \"%s\"?\n", $alternatives[0]);
  440.                 } else {
  441.                     $message .= ", did you mean one of these:\n";
  442.                     foreach ($alternatives as $bundle) {
  443.                         $message .= sprintf("  - %s\n", $bundle);
  444.                     }
  445.                 }
  446.             }
  447.             $messages[] = trim($message);
  448.         }
  450.         return $messages;
  451.     }
  453.     private function error(SymfonyStyle $io, string $message, array $alternatives = []): void
  454.     {
  455.         if ($alternatives) {
  456.             if (1 === \count($alternatives)) {
  457.                 $message .= "\n\nDid you mean this?\n    ";
  458.             } else {
  459.                 $message .= "\n\nDid you mean one of these?\n    ";
  460.             }
  461.             $message .= implode("\n    ", $alternatives);
  462.         }
  464.         $io->block($message, null, 'fg=white;bg=red', ' ', true);
  465.     }
  467.     private function findTemplateFiles(string $name): array
  468.     {
  469.         [$namespace, $shortname] = $this->parseTemplateName($name);
  471.         $files = [];
  472.         foreach ($this->getFilesystemLoaders() as $loader) {
  473.             foreach ($loader->getPaths($namespace) as $path) {
  474.                 if (!$this->isAbsolutePath($path)) {
  475.                     $path = $this->projectDir.'/'.$path;
  476.                 }
  477.                 $filename = $path.'/'.$shortname;
  479.                 if (is_file($filename)) {
  480.                     if (false !== $realpath = realpath($filename)) {
  481.                         $files[$realpath] = $this->getRelativePath($realpath);
  482.                     } else {
  483.                         $files[$filename] = $this->getRelativePath($filename);
  484.                     }
  485.                 }
  486.             }
  487.         }
  489.         return $files;
  490.     }
  492.     private function parseTemplateName(string $name, string $default = FilesystemLoader::MAIN_NAMESPACE): array
  493.     {
  494.         if (isset($name[0]) && '@' === $name[0]) {
  495.             if (false === ($pos = strpos($name, '/')) || $pos === \strlen($name) - 1) {
  496.                 throw new InvalidArgumentException(sprintf('Malformed namespaced template name "%s" (expecting "@namespace/template_name").', $name));
  497.             }
  499.             $namespace = substr($name, 1, $pos - 1);
  500.             $shortname = substr($name, $pos + 1);
  502.             return [$namespace, $shortname];
  503.         }
  505.         return [$default, $name];
  506.     }
  508.     private function buildTableRows(array $loaderPaths): array
  509.     {
  510.         $rows = [];
  511.         $firstNamespace = true;
  512.         $prevHasSeparator = false;
  514.         foreach ($loaderPaths as $namespace => $paths) {
  515.             if (!$firstNamespace && !$prevHasSeparator && \count($paths) > 1) {
  516.                 $rows[] = ['', ''];
  517.             }
  518.             $firstNamespace = false;
  519.             foreach ($paths as $path) {
  520.                 $rows[] = [$namespace, $path.\DIRECTORY_SEPARATOR];
  521.                 $namespace = '';
  522.             }
  523.             if (\count($paths) > 1) {
  524.                 $rows[] = ['', ''];
  525.                 $prevHasSeparator = true;
  526.             } else {
  527.                 $prevHasSeparator = false;
  528.             }
  529.         }
  530.         if ($prevHasSeparator) {
  531.             array_pop($rows);
  532.         }
  534.         return $rows;
  535.     }
  537.     private function findAlternatives(string $name, array $collection): array
  538.     {
  539.         $alternatives = [];
  540.         foreach ($collection as $item) {
  541.             $lev = levenshtein($name, $item);
  542.             if ($lev <= \strlen($name) / 3 || str_contains($item, $name)) {
  543.                 $alternatives[$item] = isset($alternatives[$item]) ? $alternatives[$item] - $lev : $lev;
  544.             }
  545.         }
  547.         $threshold = 1e3;
  548.         $alternatives = array_filter($alternatives, function ($lev) use ($threshold) { return $lev < 2 * $threshold; });
  549.         ksort($alternatives, \SORT_NATURAL | \SORT_FLAG_CASE);
  551.         return array_keys($alternatives);
  552.     }
  554.     private function getRelativePath(string $path): string
  555.     {
  556.         if (null !== $this->projectDir && str_starts_with($path, $this->projectDir)) {
  557.             return ltrim(substr($path, \strlen($this->projectDir)), \DIRECTORY_SEPARATOR);
  558.         }
  560.         return $path;
  561.     }
  563.     private function isAbsolutePath(string $file): bool
  564.     {
  565.         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);
  566.     }
  568.     /**
  569.      * @return FilesystemLoader[]
  570.      */
  571.     private function getFilesystemLoaders(): array
  572.     {
  573.         if (null !== $this->filesystemLoaders) {
  574.             return $this->filesystemLoaders;
  575.         }
  576.         $this->filesystemLoaders = [];
  578.         $loader = $this->twig->getLoader();
  579.         if ($loader instanceof FilesystemLoader) {
  580.             $this->filesystemLoaders[] = $loader;
  581.         } elseif ($loader instanceof ChainLoader) {
  582.             foreach ($loader->getLoaders() as $l) {
  583.                 if ($l instanceof FilesystemLoader) {
  584.                     $this->filesystemLoaders[] = $l;
  585.                 }
  586.             }
  587.         }
  589.         return $this->filesystemLoaders;
  590.     }
  592.     private function getFileLink(string $absolutePath): string
  593.     {
  594.         if (null === $this->fileLinkFormatter) {
  595.             return '';
  596.         }
  598.         return (string) $this->fileLinkFormatter->format($absolutePath, 1);
  599.     }
  600. }