vendor/symfony/form/Command/DebugCommand.php line 45

  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\Component\Form\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\OutputInterface;
  23. use Symfony\Component\Console\Style\SymfonyStyle;
  24. use Symfony\Component\Form\Console\Helper\DescriptorHelper;
  25. use Symfony\Component\Form\Extension\Core\CoreExtension;
  26. use Symfony\Component\Form\FormRegistryInterface;
  27. use Symfony\Component\Form\FormTypeInterface;
  28. use Symfony\Component\HttpKernel\Debug\FileLinkFormatter;
  30. /**
  31.  * A console command for retrieving information about form types.
  32.  *
  33.  * @author Yonel Ceruto <yonelceruto@gmail.com>
  34.  */
  35. #[AsCommand(name: 'debug:form', description: 'Display form type information')]
  36. class DebugCommand extends Command
  37. {
  38.     private FormRegistryInterface $formRegistry;
  39.     private array $namespaces;
  40.     private array $types;
  41.     private array $extensions;
  42.     private array $guessers;
  43.     private ?FileLinkFormatter $fileLinkFormatter;
  45.     public function __construct(FormRegistryInterface $formRegistry, array $namespaces = ['Symfony\Component\Form\Extension\Core\Type'], array $types = [], array $extensions = [], array $guessers = [], FileLinkFormatter $fileLinkFormatter = null)
  46.     {
  47.         parent::__construct();
  49.         $this->formRegistry = $formRegistry;
  50.         $this->namespaces = $namespaces;
  51.         $this->types = $types;
  52.         $this->extensions = $extensions;
  53.         $this->guessers = $guessers;
  54.         $this->fileLinkFormatter = $fileLinkFormatter;
  55.     }
  57.     protected function configure()
  58.     {
  59.         $this
  60.             ->setDefinition([
  61.                 new InputArgument('class', InputArgument::OPTIONAL, 'The form type class'),
  62.                 new InputArgument('option', InputArgument::OPTIONAL, 'The form type option'),
  63.                 new InputOption('show-deprecated', null, InputOption::VALUE_NONE, 'Display deprecated options in form types'),
  64.                 new InputOption('format', null, InputOption::VALUE_REQUIRED, 'The output format (txt or json)', 'txt'),
  65.             ])
  66.             ->setHelp(<<<'EOF'
  67. The <info>%command.name%</info> command displays information about form types.
  69.   <info>php %command.full_name%</info>
  71. The command lists all built-in types, services types, type extensions and
  72. guessers currently available.
  74.   <info>php %command.full_name% Symfony\Component\Form\Extension\Core\Type\ChoiceType</info>
  75.   <info>php %command.full_name% ChoiceType</info>
  77. The command lists all defined options that contains the given form type,
  78. as well as their parents and type extensions.
  80.   <info>php %command.full_name% ChoiceType choice_value</info>
  82. Use the <info>--show-deprecated</info> option to display form types with
  83. deprecated options or the deprecated options of the given form type:
  85.   <info>php %command.full_name% --show-deprecated</info>
  86.   <info>php %command.full_name% ChoiceType --show-deprecated</info>
  88. The command displays the definition of the given option name.
  90.   <info>php %command.full_name% --format=json</info>
  92. The command lists everything in a machine readable json format.
  93. EOF
  94.             )
  95.         ;
  96.     }
  98.     protected function execute(InputInterface $input, OutputInterface $output): int
  99.     {
  100.         $io = new SymfonyStyle($input, $output);
  102.         if (null === $class = $input->getArgument('class')) {
  103.             $object = null;
  104.             $options['core_types'] = $this->getCoreTypes();
  105.             $options['service_types'] = array_values(array_diff($this->types, $options['core_types']));
  106.             if ($input->getOption('show-deprecated')) {
  107.                 $options['core_types'] = $this->filterTypesByDeprecated($options['core_types']);
  108.                 $options['service_types'] = $this->filterTypesByDeprecated($options['service_types']);
  109.             }
  110.             $options['extensions'] = $this->extensions;
  111.             $options['guessers'] = $this->guessers;
  112.             foreach ($options as $k => $list) {
  113.                 sort($options[$k]);
  114.             }
  115.         } else {
  116.             if (!class_exists($class) || !is_subclass_of($class, FormTypeInterface::class)) {
  117.                 $class = $this->getFqcnTypeClass($input, $io, $class);
  118.             }
  119.             $resolvedType = $this->formRegistry->getType($class);
  121.             if ($option = $input->getArgument('option')) {
  122.                 $object = $resolvedType->getOptionsResolver();
  124.                 if (!$object->isDefined($option)) {
  125.                     $message = sprintf('Option "%s" is not defined in "%s".', $option, \get_class($resolvedType->getInnerType()));
  127.                     if ($alternatives = $this->findAlternatives($option, $object->getDefinedOptions())) {
  128.                         if (1 === \count($alternatives)) {
  129.                             $message .= "\n\nDid you mean this?\n    ";
  130.                         } else {
  131.                             $message .= "\n\nDid you mean one of these?\n    ";
  132.                         }
  133.                         $message .= implode("\n    ", $alternatives);
  134.                     }
  136.                     throw new InvalidArgumentException($message);
  137.                 }
  139.                 $options['type'] = $resolvedType->getInnerType();
  140.                 $options['option'] = $option;
  141.             } else {
  142.                 $object = $resolvedType;
  143.             }
  144.         }
  146.         $helper = new DescriptorHelper($this->fileLinkFormatter);
  147.         $options['format'] = $input->getOption('format');
  148.         $options['show_deprecated'] = $input->getOption('show-deprecated');
  149.         $helper->describe($io, $object, $options);
  151.         return 0;
  152.     }
  154.     private function getFqcnTypeClass(InputInterface $input, SymfonyStyle $io, string $shortClassName): string
  155.     {
  156.         $classes = $this->getFqcnTypeClasses($shortClassName);
  158.         if (0 === $count = \count($classes)) {
  159.             $message = sprintf("Could not find type \"%s\" into the following namespaces:\n    %s", $shortClassName, implode("\n    ", $this->namespaces));
  161.             $allTypes = array_merge($this->getCoreTypes(), $this->types);
  162.             if ($alternatives = $this->findAlternatives($shortClassName, $allTypes)) {
  163.                 if (1 === \count($alternatives)) {
  164.                     $message .= "\n\nDid you mean this?\n    ";
  165.                 } else {
  166.                     $message .= "\n\nDid you mean one of these?\n    ";
  167.                 }
  168.                 $message .= implode("\n    ", $alternatives);
  169.             }
  171.             throw new InvalidArgumentException($message);
  172.         }
  173.         if (1 === $count) {
  174.             return $classes[0];
  175.         }
  176.         if (!$input->isInteractive()) {
  177.             throw new InvalidArgumentException(sprintf("The type \"%s\" is ambiguous.\n\nDid you mean one of these?\n    %s.", $shortClassName, implode("\n    ", $classes)));
  178.         }
  180.         return $io->choice(sprintf("The type \"%s\" is ambiguous.\n\nSelect one of the following form types to display its information:", $shortClassName), $classes, $classes[0]);
  181.     }
  183.     private function getFqcnTypeClasses(string $shortClassName): array
  184.     {
  185.         $classes = [];
  186.         sort($this->namespaces);
  187.         foreach ($this->namespaces as $namespace) {
  188.             if (class_exists($fqcn = $namespace.'\\'.$shortClassName)) {
  189.                 $classes[] = $fqcn;
  190.             } elseif (class_exists($fqcn = $namespace.'\\'.ucfirst($shortClassName))) {
  191.                 $classes[] = $fqcn;
  192.             } elseif (class_exists($fqcn = $namespace.'\\'.ucfirst($shortClassName).'Type')) {
  193.                 $classes[] = $fqcn;
  194.             } elseif (str_ends_with($shortClassName, 'type') && class_exists($fqcn = $namespace.'\\'.ucfirst(substr($shortClassName, 0, -4).'Type'))) {
  195.                 $classes[] = $fqcn;
  196.             }
  197.         }
  199.         return $classes;
  200.     }
  202.     private function getCoreTypes(): array
  203.     {
  204.         $coreExtension = new CoreExtension();
  205.         $loadTypesRefMethod = (new \ReflectionObject($coreExtension))->getMethod('loadTypes');
  206.         $coreTypes = $loadTypesRefMethod->invoke($coreExtension);
  207.         $coreTypes = array_map(function (FormTypeInterface $type) { return $type::class; }, $coreTypes);
  208.         sort($coreTypes);
  210.         return $coreTypes;
  211.     }
  213.     private function filterTypesByDeprecated(array $types): array
  214.     {
  215.         $typesWithDeprecatedOptions = [];
  216.         foreach ($types as $class) {
  217.             $optionsResolver = $this->formRegistry->getType($class)->getOptionsResolver();
  218.             foreach ($optionsResolver->getDefinedOptions() as $option) {
  219.                 if ($optionsResolver->isDeprecated($option)) {
  220.                     $typesWithDeprecatedOptions[] = $class;
  221.                     break;
  222.                 }
  223.             }
  224.         }
  226.         return $typesWithDeprecatedOptions;
  227.     }
  229.     private function findAlternatives(string $name, array $collection): array
  230.     {
  231.         $alternatives = [];
  232.         foreach ($collection as $item) {
  233.             $lev = levenshtein($name, $item);
  234.             if ($lev <= \strlen($name) / 3 || str_contains($item, $name)) {
  235.                 $alternatives[$item] = isset($alternatives[$item]) ? $alternatives[$item] - $lev : $lev;
  236.             }
  237.         }
  239.         $threshold = 1e3;
  240.         $alternatives = array_filter($alternatives, function ($lev) use ($threshold) { return $lev < 2 * $threshold; });
  241.         ksort($alternatives, \SORT_NATURAL | \SORT_FLAG_CASE);
  243.         return array_keys($alternatives);
  244.     }
  246.     public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
  247.     {
  248.         if ($input->mustSuggestArgumentValuesFor('class')) {
  249.             $suggestions->suggestValues(array_merge($this->getCoreTypes(), $this->types));
  251.             return;
  252.         }
  254.         if ($input->mustSuggestArgumentValuesFor('option') && null !== $class = $input->getArgument('class')) {
  255.             $this->completeOptions($class, $suggestions);
  257.             return;
  258.         }
  260.         if ($input->mustSuggestOptionValuesFor('format')) {
  261.             $helper = new DescriptorHelper();
  262.             $suggestions->suggestValues($helper->getFormats());
  263.         }
  264.     }
  266.     private function completeOptions(string $class, CompletionSuggestions $suggestions): void
  267.     {
  268.         if (!class_exists($class) || !is_subclass_of($class, FormTypeInterface::class)) {
  269.             $classes = $this->getFqcnTypeClasses($class);
  271.             if (1 === \count($classes)) {
  272.                 $class = $classes[0];
  273.             }
  274.         }
  276.         if (!$this->formRegistry->hasType($class)) {
  277.             return;
  278.         }
  280.         $resolvedType = $this->formRegistry->getType($class);
  281.         $suggestions->suggestValues($resolvedType->getOptionsResolver()->getDefinedOptions());
  282.     }
  283. }