vendor/symfony/console/Command/Command.php line 70

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\Console\Command;
  11. use Symfony\Component\Console\Application;
  12. use Symfony\Component\Console\Attribute\AsCommand;
  13. use Symfony\Component\Console\Completion\CompletionInput;
  14. use Symfony\Component\Console\Completion\CompletionSuggestions;
  15. use Symfony\Component\Console\Completion\Suggestion;
  16. use Symfony\Component\Console\Exception\ExceptionInterface;
  17. use Symfony\Component\Console\Exception\InvalidArgumentException;
  18. use Symfony\Component\Console\Exception\LogicException;
  19. use Symfony\Component\Console\Helper\HelperSet;
  20. use Symfony\Component\Console\Input\InputArgument;
  21. use Symfony\Component\Console\Input\InputDefinition;
  22. use Symfony\Component\Console\Input\InputInterface;
  23. use Symfony\Component\Console\Input\InputOption;
  24. use Symfony\Component\Console\Output\OutputInterface;
  25. /**
  26.  * Base class for all commands.
  27.  *
  28.  * @author Fabien Potencier <fabien@symfony.com>
  29.  */
  30. class Command
  31. {
  32.     // see https://tldp.org/LDP/abs/html/exitcodes.html
  33.     public const SUCCESS 0;
  34.     public const FAILURE 1;
  35.     public const INVALID 2;
  36.     /**
  37.      * @var string|null The default command name
  38.      *
  39.      * @deprecated since Symfony 6.1, use the AsCommand attribute instead
  40.      */
  41.     protected static $defaultName;
  42.     /**
  43.      * @var string|null The default command description
  44.      *
  45.      * @deprecated since Symfony 6.1, use the AsCommand attribute instead
  46.      */
  47.     protected static $defaultDescription;
  48.     private ?Application $application null;
  49.     private ?string $name null;
  50.     private ?string $processTitle null;
  51.     private array $aliases = [];
  52.     private InputDefinition $definition;
  53.     private bool $hidden false;
  54.     private string $help '';
  55.     private string $description '';
  56.     private ?InputDefinition $fullDefinition null;
  57.     private bool $ignoreValidationErrors false;
  58.     private ?\Closure $code null;
  59.     private array $synopsis = [];
  60.     private array $usages = [];
  61.     private ?HelperSet $helperSet null;
  62.     public static function getDefaultName(): ?string
  63.     {
  64.         $class = static::class;
  65.         if ($attribute = (new \ReflectionClass($class))->getAttributes(AsCommand::class)) {
  66.             return $attribute[0]->newInstance()->name;
  67.         }
  68.         $r = new \ReflectionProperty($class'defaultName');
  69.         if ($class !== $r->class || null === static::$defaultName) {
  70.             return null;
  71.         }
  72.         trigger_deprecation('symfony/console''6.1''Relying on the static property "$defaultName" for setting a command name is deprecated. Add the "%s" attribute to the "%s" class instead.'AsCommand::class, static::class);
  73.         return static::$defaultName;
  74.     }
  75.     public static function getDefaultDescription(): ?string
  76.     {
  77.         $class = static::class;
  78.         if ($attribute = (new \ReflectionClass($class))->getAttributes(AsCommand::class)) {
  79.             return $attribute[0]->newInstance()->description;
  80.         }
  81.         $r = new \ReflectionProperty($class'defaultDescription');
  82.         if ($class !== $r->class || null === static::$defaultDescription) {
  83.             return null;
  84.         }
  85.         trigger_deprecation('symfony/console''6.1''Relying on the static property "$defaultDescription" for setting a command description is deprecated. Add the "%s" attribute to the "%s" class instead.'AsCommand::class, static::class);
  86.         return static::$defaultDescription;
  87.     }
  88.     /**
  89.      * @param string|null $name The name of the command; passing null means it must be set in configure()
  90.      *
  91.      * @throws LogicException When the command name is empty
  92.      */
  93.     public function __construct(string $name null)
  94.     {
  95.         $this->definition = new InputDefinition();
  96.         if (null === $name && null !== $name = static::getDefaultName()) {
  97.             $aliases explode('|'$name);
  98.             if ('' === $name array_shift($aliases)) {
  99.                 $this->setHidden(true);
  100.                 $name array_shift($aliases);
  101.             }
  102.             $this->setAliases($aliases);
  103.         }
  104.         if (null !== $name) {
  105.             $this->setName($name);
  106.         }
  107.         if ('' === $this->description) {
  108.             $this->setDescription(static::getDefaultDescription() ?? '');
  109.         }
  110.         $this->configure();
  111.     }
  112.     /**
  113.      * Ignores validation errors.
  114.      *
  115.      * This is mainly useful for the help command.
  116.      */
  117.     public function ignoreValidationErrors()
  118.     {
  119.         $this->ignoreValidationErrors true;
  120.     }
  121.     public function setApplication(Application $application null)
  122.     {
  123.         $this->application $application;
  124.         if ($application) {
  125.             $this->setHelperSet($application->getHelperSet());
  126.         } else {
  127.             $this->helperSet null;
  128.         }
  129.         $this->fullDefinition null;
  130.     }
  131.     public function setHelperSet(HelperSet $helperSet)
  132.     {
  133.         $this->helperSet $helperSet;
  134.     }
  135.     /**
  136.      * Gets the helper set.
  137.      */
  138.     public function getHelperSet(): ?HelperSet
  139.     {
  140.         return $this->helperSet;
  141.     }
  142.     /**
  143.      * Gets the application instance for this command.
  144.      */
  145.     public function getApplication(): ?Application
  146.     {
  147.         return $this->application;
  148.     }
  149.     /**
  150.      * Checks whether the command is enabled or not in the current environment.
  151.      *
  152.      * Override this to check for x or y and return false if the command cannot
  153.      * run properly under the current conditions.
  154.      *
  155.      * @return bool
  156.      */
  157.     public function isEnabled()
  158.     {
  159.         return true;
  160.     }
  161.     /**
  162.      * Configures the current command.
  163.      */
  164.     protected function configure()
  165.     {
  166.     }
  167.     /**
  168.      * Executes the current command.
  169.      *
  170.      * This method is not abstract because you can use this class
  171.      * as a concrete class. In this case, instead of defining the
  172.      * execute() method, you set the code to execute by passing
  173.      * a Closure to the setCode() method.
  174.      *
  175.      * @return int 0 if everything went fine, or an exit code
  176.      *
  177.      * @throws LogicException When this abstract method is not implemented
  178.      *
  179.      * @see setCode()
  180.      */
  181.     protected function execute(InputInterface $inputOutputInterface $output)
  182.     {
  183.         throw new LogicException('You must override the execute() method in the concrete command class.');
  184.     }
  185.     /**
  186.      * Interacts with the user.
  187.      *
  188.      * This method is executed before the InputDefinition is validated.
  189.      * This means that this is the only place where the command can
  190.      * interactively ask for values of missing required arguments.
  191.      */
  192.     protected function interact(InputInterface $inputOutputInterface $output)
  193.     {
  194.     }
  195.     /**
  196.      * Initializes the command after the input has been bound and before the input
  197.      * is validated.
  198.      *
  199.      * This is mainly useful when a lot of commands extends one main command
  200.      * where some things need to be initialized based on the input arguments and options.
  201.      *
  202.      * @see InputInterface::bind()
  203.      * @see InputInterface::validate()
  204.      */
  205.     protected function initialize(InputInterface $inputOutputInterface $output)
  206.     {
  207.     }
  208.     /**
  209.      * Runs the command.
  210.      *
  211.      * The code to execute is either defined directly with the
  212.      * setCode() method or by overriding the execute() method
  213.      * in a sub-class.
  214.      *
  215.      * @return int The command exit code
  216.      *
  217.      * @throws \Exception When binding input fails. Bypass this by calling {@link ignoreValidationErrors()}.
  218.      *
  219.      * @see setCode()
  220.      * @see execute()
  221.      */
  222.     public function run(InputInterface $inputOutputInterface $output): int
  223.     {
  224.         // add the application arguments and options
  225.         $this->mergeApplicationDefinition();
  226.         // bind the input against the command specific arguments/options
  227.         try {
  228.             $input->bind($this->getDefinition());
  229.         } catch (ExceptionInterface $e) {
  230.             if (!$this->ignoreValidationErrors) {
  231.                 throw $e;
  232.             }
  233.         }
  234.         $this->initialize($input$output);
  235.         if (null !== $this->processTitle) {
  236.             if (\function_exists('cli_set_process_title')) {
  237.                 if (!@cli_set_process_title($this->processTitle)) {
  238.                     if ('Darwin' === \PHP_OS) {
  239.                         $output->writeln('<comment>Running "cli_set_process_title" as an unprivileged user is not supported on MacOS.</comment>'OutputInterface::VERBOSITY_VERY_VERBOSE);
  240.                     } else {
  241.                         cli_set_process_title($this->processTitle);
  242.                     }
  243.                 }
  244.             } elseif (\function_exists('setproctitle')) {
  245.                 setproctitle($this->processTitle);
  246.             } elseif (OutputInterface::VERBOSITY_VERY_VERBOSE === $output->getVerbosity()) {
  247.                 $output->writeln('<comment>Install the proctitle PECL to be able to change the process title.</comment>');
  248.             }
  249.         }
  250.         if ($input->isInteractive()) {
  251.             $this->interact($input$output);
  252.         }
  253.         // The command name argument is often omitted when a command is executed directly with its run() method.
  254.         // It would fail the validation if we didn't make sure the command argument is present,
  255.         // since it's required by the application.
  256.         if ($input->hasArgument('command') && null === $input->getArgument('command')) {
  257.             $input->setArgument('command'$this->getName());
  258.         }
  259.         $input->validate();
  260.         if ($this->code) {
  261.             $statusCode = ($this->code)($input$output);
  262.         } else {
  263.             $statusCode $this->execute($input$output);
  264.             if (!\is_int($statusCode)) {
  265.                 throw new \TypeError(sprintf('Return value of "%s::execute()" must be of the type int, "%s" returned.', static::class, get_debug_type($statusCode)));
  266.             }
  267.         }
  268.         return is_numeric($statusCode) ? (int) $statusCode 0;
  269.     }
  270.     /**
  271.      * Adds suggestions to $suggestions for the current completion input (e.g. option or argument).
  272.      */
  273.     public function complete(CompletionInput $inputCompletionSuggestions $suggestions): void
  274.     {
  275.         $definition $this->getDefinition();
  276.         if (CompletionInput::TYPE_OPTION_VALUE === $input->getCompletionType() && $definition->hasOption($input->getCompletionName())) {
  277.             $definition->getOption($input->getCompletionName())->complete($input$suggestions);
  278.         } elseif (CompletionInput::TYPE_ARGUMENT_VALUE === $input->getCompletionType() && $definition->hasArgument($input->getCompletionName())) {
  279.             $definition->getArgument($input->getCompletionName())->complete($input$suggestions);
  280.         }
  281.     }
  282.     /**
  283.      * Sets the code to execute when running this command.
  284.      *
  285.      * If this method is used, it overrides the code defined
  286.      * in the execute() method.
  287.      *
  288.      * @param callable $code A callable(InputInterface $input, OutputInterface $output)
  289.      *
  290.      * @return $this
  291.      *
  292.      * @throws InvalidArgumentException
  293.      *
  294.      * @see execute()
  295.      */
  296.     public function setCode(callable $code): static
  297.     {
  298.         if ($code instanceof \Closure) {
  299.             $r = new \ReflectionFunction($code);
  300.             if (null === $r->getClosureThis()) {
  301.                 set_error_handler(static function () {});
  302.                 try {
  303.                     if ($c \Closure::bind($code$this)) {
  304.                         $code $c;
  305.                     }
  306.                 } finally {
  307.                     restore_error_handler();
  308.                 }
  309.             }
  310.         } else {
  311.             $code $code(...);
  312.         }
  313.         $this->code $code;
  314.         return $this;
  315.     }
  316.     /**
  317.      * Merges the application definition with the command definition.
  318.      *
  319.      * This method is not part of public API and should not be used directly.
  320.      *
  321.      * @param bool $mergeArgs Whether to merge or not the Application definition arguments to Command definition arguments
  322.      *
  323.      * @internal
  324.      */
  325.     public function mergeApplicationDefinition(bool $mergeArgs true)
  326.     {
  327.         if (null === $this->application) {
  328.             return;
  329.         }
  330.         $this->fullDefinition = new InputDefinition();
  331.         $this->fullDefinition->setOptions($this->definition->getOptions());
  332.         $this->fullDefinition->addOptions($this->application->getDefinition()->getOptions());
  333.         if ($mergeArgs) {
  334.             $this->fullDefinition->setArguments($this->application->getDefinition()->getArguments());
  335.             $this->fullDefinition->addArguments($this->definition->getArguments());
  336.         } else {
  337.             $this->fullDefinition->setArguments($this->definition->getArguments());
  338.         }
  339.     }
  340.     /**
  341.      * Sets an array of argument and option instances.
  342.      *
  343.      * @return $this
  344.      */
  345.     public function setDefinition(array|InputDefinition $definition): static
  346.     {
  347.         if ($definition instanceof InputDefinition) {
  348.             $this->definition $definition;
  349.         } else {
  350.             $this->definition->setDefinition($definition);
  351.         }
  352.         $this->fullDefinition null;
  353.         return $this;
  354.     }
  355.     /**
  356.      * Gets the InputDefinition attached to this Command.
  357.      */
  358.     public function getDefinition(): InputDefinition
  359.     {
  360.         return $this->fullDefinition ?? $this->getNativeDefinition();
  361.     }
  362.     /**
  363.      * Gets the InputDefinition to be used to create representations of this Command.
  364.      *
  365.      * Can be overridden to provide the original command representation when it would otherwise
  366.      * be changed by merging with the application InputDefinition.
  367.      *
  368.      * This method is not part of public API and should not be used directly.
  369.      */
  370.     public function getNativeDefinition(): InputDefinition
  371.     {
  372.         return $this->definition ?? throw new LogicException(sprintf('Command class "%s" is not correctly initialized. You probably forgot to call the parent constructor.', static::class));
  373.     }
  374.     /**
  375.      * Adds an argument.
  376.      *
  377.      * @param $mode    The argument mode: InputArgument::REQUIRED or InputArgument::OPTIONAL
  378.      * @param $default The default value (for InputArgument::OPTIONAL mode only)
  379.      * @param array|\Closure(CompletionInput,CompletionSuggestions):list<string|Suggestion> $suggestedValues The values used for input completion
  380.      *
  381.      * @throws InvalidArgumentException When argument mode is not valid
  382.      *
  383.      * @return $this
  384.      */
  385.     public function addArgument(string $nameint $mode nullstring $description ''mixed $default null/*array|\Closure $suggestedValues = null*/): static
  386.     {
  387.         $suggestedValues <= \func_num_args() ? func_get_arg(4) : [];
  388.         if (!\is_array($suggestedValues) && !$suggestedValues instanceof \Closure) {
  389.             throw new \TypeError(sprintf('Argument 5 passed to "%s()" must be array or \Closure, "%s" given.'__METHOD__get_debug_type($suggestedValues)));
  390.         }
  391.         $this->definition->addArgument(new InputArgument($name$mode$description$default$suggestedValues));
  392.         $this->fullDefinition?->addArgument(new InputArgument($name$mode$description$default$suggestedValues));
  393.         return $this;
  394.     }
  395.     /**
  396.      * Adds an option.
  397.      *
  398.      * @param $shortcut The shortcuts, can be null, a string of shortcuts delimited by | or an array of shortcuts
  399.      * @param $mode     The option mode: One of the InputOption::VALUE_* constants
  400.      * @param $default  The default value (must be null for InputOption::VALUE_NONE)
  401.      * @param array|\Closure(CompletionInput,CompletionSuggestions):list<string|Suggestion> $suggestedValues The values used for input completion
  402.      *
  403.      * @throws InvalidArgumentException If option mode is invalid or incompatible
  404.      *
  405.      * @return $this
  406.      */
  407.     public function addOption(string $namestring|array $shortcut nullint $mode nullstring $description ''mixed $default null/*array|\Closure $suggestedValues = []*/): static
  408.     {
  409.         $suggestedValues <= \func_num_args() ? func_get_arg(5) : [];
  410.         if (!\is_array($suggestedValues) && !$suggestedValues instanceof \Closure) {
  411.             throw new \TypeError(sprintf('Argument 5 passed to "%s()" must be array or \Closure, "%s" given.'__METHOD__get_debug_type($suggestedValues)));
  412.         }
  413.         $this->definition->addOption(new InputOption($name$shortcut$mode$description$default$suggestedValues));
  414.         $this->fullDefinition?->addOption(new InputOption($name$shortcut$mode$description$default$suggestedValues));
  415.         return $this;
  416.     }
  417.     /**
  418.      * Sets the name of the command.
  419.      *
  420.      * This method can set both the namespace and the name if
  421.      * you separate them by a colon (:)
  422.      *
  423.      *     $command->setName('foo:bar');
  424.      *
  425.      * @return $this
  426.      *
  427.      * @throws InvalidArgumentException When the name is invalid
  428.      */
  429.     public function setName(string $name): static
  430.     {
  431.         $this->validateName($name);
  432.         $this->name $name;
  433.         return $this;
  434.     }
  435.     /**
  436.      * Sets the process title of the command.
  437.      *
  438.      * This feature should be used only when creating a long process command,
  439.      * like a daemon.
  440.      *
  441.      * @return $this
  442.      */
  443.     public function setProcessTitle(string $title): static
  444.     {
  445.         $this->processTitle $title;
  446.         return $this;
  447.     }
  448.     /**
  449.      * Returns the command name.
  450.      */
  451.     public function getName(): ?string
  452.     {
  453.         return $this->name;
  454.     }
  455.     /**
  456.      * @param bool $hidden Whether or not the command should be hidden from the list of commands
  457.      *
  458.      * @return $this
  459.      */
  460.     public function setHidden(bool $hidden true): static
  461.     {
  462.         $this->hidden $hidden;
  463.         return $this;
  464.     }
  465.     /**
  466.      * @return bool whether the command should be publicly shown or not
  467.      */
  468.     public function isHidden(): bool
  469.     {
  470.         return $this->hidden;
  471.     }
  472.     /**
  473.      * Sets the description for the command.
  474.      *
  475.      * @return $this
  476.      */
  477.     public function setDescription(string $description): static
  478.     {
  479.         $this->description $description;
  480.         return $this;
  481.     }
  482.     /**
  483.      * Returns the description for the command.
  484.      */
  485.     public function getDescription(): string
  486.     {
  487.         return $this->description;
  488.     }
  489.     /**
  490.      * Sets the help for the command.
  491.      *
  492.      * @return $this
  493.      */
  494.     public function setHelp(string $help): static
  495.     {
  496.         $this->help $help;
  497.         return $this;
  498.     }
  499.     /**
  500.      * Returns the help for the command.
  501.      */
  502.     public function getHelp(): string
  503.     {
  504.         return $this->help;
  505.     }
  506.     /**
  507.      * Returns the processed help for the command replacing the %command.name% and
  508.      * %command.full_name% patterns with the real values dynamically.
  509.      */
  510.     public function getProcessedHelp(): string
  511.     {
  512.         $name $this->name;
  513.         $isSingleCommand $this->application?->isSingleCommand();
  514.         $placeholders = [
  515.             '%command.name%',
  516.             '%command.full_name%',
  517.         ];
  518.         $replacements = [
  519.             $name,
  520.             $isSingleCommand $_SERVER['PHP_SELF'] : $_SERVER['PHP_SELF'].' '.$name,
  521.         ];
  522.         return str_replace($placeholders$replacements$this->getHelp() ?: $this->getDescription());
  523.     }
  524.     /**
  525.      * Sets the aliases for the command.
  526.      *
  527.      * @param string[] $aliases An array of aliases for the command
  528.      *
  529.      * @return $this
  530.      *
  531.      * @throws InvalidArgumentException When an alias is invalid
  532.      */
  533.     public function setAliases(iterable $aliases): static
  534.     {
  535.         $list = [];
  536.         foreach ($aliases as $alias) {
  537.             $this->validateName($alias);
  538.             $list[] = $alias;
  539.         }
  540.         $this->aliases \is_array($aliases) ? $aliases $list;
  541.         return $this;
  542.     }
  543.     /**
  544.      * Returns the aliases for the command.
  545.      */
  546.     public function getAliases(): array
  547.     {
  548.         return $this->aliases;
  549.     }
  550.     /**
  551.      * Returns the synopsis for the command.
  552.      *
  553.      * @param bool $short Whether to show the short version of the synopsis (with options folded) or not
  554.      */
  555.     public function getSynopsis(bool $short false): string
  556.     {
  557.         $key $short 'short' 'long';
  558.         if (!isset($this->synopsis[$key])) {
  559.             $this->synopsis[$key] = trim(sprintf('%s %s'$this->name$this->definition->getSynopsis($short)));
  560.         }
  561.         return $this->synopsis[$key];
  562.     }
  563.     /**
  564.      * Add a command usage example, it'll be prefixed with the command name.
  565.      *
  566.      * @return $this
  567.      */
  568.     public function addUsage(string $usage): static
  569.     {
  570.         if (!str_starts_with($usage$this->name)) {
  571.             $usage sprintf('%s %s'$this->name$usage);
  572.         }
  573.         $this->usages[] = $usage;
  574.         return $this;
  575.     }
  576.     /**
  577.      * Returns alternative usages of the command.
  578.      */
  579.     public function getUsages(): array
  580.     {
  581.         return $this->usages;
  582.     }
  583.     /**
  584.      * Gets a helper instance by name.
  585.      *
  586.      * @throws LogicException           if no HelperSet is defined
  587.      * @throws InvalidArgumentException if the helper is not defined
  588.      */
  589.     public function getHelper(string $name): mixed
  590.     {
  591.         if (null === $this->helperSet) {
  592.             throw new LogicException(sprintf('Cannot retrieve helper "%s" because there is no HelperSet defined. Did you forget to add your command to the application or to set the application on the command using the setApplication() method? You can also set the HelperSet directly using the setHelperSet() method.'$name));
  593.         }
  594.         return $this->helperSet->get($name);
  595.     }
  596.     /**
  597.      * Validates a command name.
  598.      *
  599.      * It must be non-empty and parts can optionally be separated by ":".
  600.      *
  601.      * @throws InvalidArgumentException When the name is invalid
  602.      */
  603.     private function validateName(string $name)
  604.     {
  605.         if (!preg_match('/^[^\:]++(\:[^\:]++)*$/'$name)) {
  606.             throw new InvalidArgumentException(sprintf('Command name "%s" is invalid.'$name));
  607.         }
  608.     }
  609. }