PHP InputDefinition::addArgument方法代码示例

 /**
  * @see Symfony\Component\Console\Command.Command::configure()
  */
 protected function configure()
 {
     $definition = new InputDefinition();
     $definition->addArgument(new InputArgument('namespace', InputArgument::REQUIRED, 'The namespace to process'));
     $definition->addArgument(new InputArgument('path', InputArgument::REQUIRED, 'The path the namespace can be found in'));
     $definition->addOption(new InputOption('output', 'o', InputOption::VALUE_REQUIRED, 'The path to output the ReST files', 'build'));
     $definition->addOption(new InputOption('title', 't', InputOption::VALUE_REQUIRED, 'An alternate title for the top level namespace', null));
     $definition->addOption(new InputOption('exclude', 'x', InputOption::VALUE_REQUIRED, 'Semicolon separated namespaces to ignore', null));
     $definition->addOption(new InputOption('filters', 'f', InputOption::VALUE_REQUIRED, 'Semicolon separated filename filters to apply', null));
     $this->setName('process')->setDescription('Processes a directory of PHPDoc documented code into ReST')->setHelp('The process command works recursively on a directory of PHP code.')->setDefinition($definition);
 }

 private function buildInputDefinition()
 {
     $inputDefinition = new InputDefinition();
     $inputDefinition->addArgument(new InputArgument('uno', InputArgument::REQUIRED));
     $inputDefinition->addOption(new InputOption('due', null, InputOption::VALUE_NONE));
     return $inputDefinition;
 }

 /**
  * Get an InputDefinition formed by the arguments provided
  *
  * Effectively provides a passthrough for any input arguments provided
  *
  * @param  array  $args Arguments
  * @return InputDefinition
  */
 protected function getInputDefinition(array $args)
 {
     $definition = new InputDefinition();
     foreach ($args as $field => $value) {
         $definition->addArgument(new InputArgument($field));
     }
     return $definition;
 }

 public function testConfigureSystemCommand()
 {
     $name = 'test_base_command';
     $description = 'test for base command creation';
     $keywords = 'base commands creation test';
     $arguments = array('username' => array('description' => 'linux username'));
     $options = 'options';
     $expectedArguments = new InputDefinition();
     $expectedArguments->addArgument(new InputArgument('username', InputArgument::REQUIRED, $arguments['username']['description']));
     $systemCommand = new SystemCommand($name, $description, $keywords, $arguments, $options);
     $this->assertEquals($expectedArguments, $systemCommand->getDefinition());
 }

 /**
  * @inheritdoc
  */
 public static function run($request, $response, $args)
 {
     global $argv;
     $container = static::getApp()->getContainer();
     $pathResolver = $container['pathResolver'];
     $filesystem = new Filesystem();
     $creator = new MigrationCreator($filesystem);
     $definition = new InputDefinition();
     $definition->addArgument(new InputArgument('name', InputArgument::REQUIRED));
     $definition->addOption(new InputOption('table', 't', InputOption::VALUE_OPTIONAL));
     $input = new ArgvInput(array_slice($argv, 1), $definition);
     $output = new ConsoleOutput();
     $path = $pathResolver->getAlias('@db/migrations');
     $name = $input->getArgument('name');
     $table = $input->getOption('table');
     $file = pathinfo($creator->create($name, $path, $table), PATHINFO_FILENAME);
     \dump($file);
 }

 /**
  * @test
  */
 public function configCommandAlias()
 {
     $config = new Config();
     $input = new ArgvInput();
     $actual = $config->checkConfigCommandAlias($input);
     $this->assertInstanceOf('Symfony\\Component\\Console\\Input\\InputInterface', $actual);
     $saved = $_SERVER['argv'];
     $config->setConfig(array('commands' => array('aliases' => array(array('list-help' => 'list --help')))));
     $definition = new InputDefinition();
     $definition->addArgument(new InputArgument('command'));
     $argv = array('/path/to/command', 'list-help');
     $_SERVER['argv'] = $argv;
     $input = new ArgvInput($argv, $definition);
     $this->assertSame('list-help', (string) $input);
     $actual = $config->checkConfigCommandAlias($input);
     $this->assertSame('list-help', $actual->getFirstArgument());
     $this->assertSame('list-help --help', (string) $actual);
     $_SERVER['argv'] = $saved;
     $command = new Command('list');
     $config->registerConfigCommandAlias($command);
     $this->assertSame(array('list-help'), $command->getAliases());
 }

 /**
  * @param InputInterface $input
  * @param $appDefinition
  * @return ArrayInput
  */
 public function filterByOriginalDefinition(InputInterface $input, $appDefinition)
 {
     $newDefinition = new InputDefinition();
     $newInput = new ArrayInput(array(), $newDefinition);
     foreach ($input->getArguments() as $name => $value) {
         if (!$appDefinition->hasArgument($name)) {
             $newDefinition->addArgument($this->getDefinition()->getArgument($name));
             if (!empty($value)) {
                 $newInput->setArgument($name, $value);
             }
         }
     }
     foreach ($input->getOptions() as $name => $value) {
         if (!$appDefinition->hasOption($name)) {
             $newDefinition->addOption($this->getDefinition()->getOption($name));
             if (!empty($value)) {
                 $newInput->setOption($name, $value);
             }
         }
     }
     return $newInput;
 }

 /**
  * Set command options/arguments
  * 
  * @return array
  */
 public function setCommandConfig()
 {
     $name = $this->config_name;
     // Конфиг. имя команды (пр. "my_greet")
     $definition = new Input\InputDefinition();
     //---------------------------
     $config = $this->app['config']['commands'][$name];
     // Set command description
     if ($config['configure']['description']) {
         $this->setDescription($config['configure']['description']);
     }
     // Set arguments
     if ($config['arguments']) {
         $arguments = $config['arguments'];
         foreach ($arguments as $argument) {
             $mode = $this->_getArgumentMode($argument['mode']);
             $newArgument = new InputArgument($argument['name'], $mode, $argument['description'], $argument['default']);
             $definition->addArgument($newArgument);
         }
     }
     // Set options
     if (isset($config['options'])) {
         $options = $config['options'];
         foreach ($options as $option) {
             $mode = $this->_getOptionMode($option['mode']);
             $newOption = new InputOption($option['name'], $option['shortcut'], $mode, $option['description'], $option['default']);
             $definition->addOption($newOption);
         }
     }
     $this->setDefinition($definition);
 }

 /**
  * Builds the Input Definition based upon Api Method Parameters.
  *
  * @param \ReflectionMethod $method
  * @param string            $token
  *
  * @return InputDefinition
  */
 private function buildDefinition(\ReflectionMethod $method, DocBlock $docBlock, $token = null)
 {
     $definition = new InputDefinition();
     foreach ($docBlock->getTags() as $tag) {
         if ($tag instanceof DocBlock\Tags\Param) {
             $tagsDescription[$tag->getVariableName()] = $tag->getDescription()->render();
         }
     }
     foreach ($method->getParameters() as $parameter) {
         if ($parameter->isDefaultValueAvailable()) {
             //option
             $definition->addOption(new InputOption($parameter->getName(), null, InputOption::VALUE_REQUIRED, $tagsDescription[$parameter->getName()], $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null));
         } else {
             //argument
             $definition->addArgument(new InputArgument($parameter->getName(), InputArgument::REQUIRED, $tagsDescription[$parameter->getName()], null));
         }
     }
     $definition->addOption(new InputOption('token', null, InputOption::VALUE_REQUIRED, 'Auth token to use', $token));
     $definition->addOption(new InputOption('debug', null, InputOption::VALUE_NONE, 'Display raw response'));
     return $definition;
 }

 public function testGetArgumentCount()
 {
     $this->initializeArguments();
     $definition = new InputDefinition();
     $definition->addArgument($this->foo2);
     $this->assertEquals(1, $definition->getArgumentCount(), '->getArgumentCount() returns the number of arguments');
     $definition->addArgument($this->foo);
     $this->assertEquals(2, $definition->getArgumentCount(), '->getArgumentCount() returns the number of arguments');
 }

 protected function bindSignature()
 {
     $signatureParts = new SignatureParts($this->signature);
     $signature = $signatureParts->getSignatureWithoutCommandName();
     list($name, $arguments, $options) = Parser::parse($signature);
     $this->name = $name;
     $inputDefinition = new InputDefinition();
     foreach ($arguments as $argument) {
         $inputDefinition->addArgument($argument);
     }
     foreach ($options as $option) {
         $inputDefinition->addOption($option);
     }
     $inputWithoutHandlerName = explode(' ', $this->request->text, 2)[1] ?? '';
     $this->input = new StringInput($inputWithoutHandlerName);
     $this->inputDefinition = $inputDefinition;
     try {
         $this->input->bind($inputDefinition);
     } catch (RuntimeException $exception) {
         return false;
     }
     return true;
 }

<?php

require __DIR__ . '/vendor/autoload.php';
use Elastica\Client;
use Elastica\Document;
use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\InputOption;
$inputDefinition = new InputDefinition();
$inputDefinition->addArgument(new InputArgument('host', InputArgument::REQUIRED));
$inputDefinition->addArgument(new InputArgument('tree', InputArgument::REQUIRED));
$options = [['port', null, InputOption::VALUE_REQUIRED, '', 9200], ['index', null, InputOption::VALUE_REQUIRED, '', 'test'], ['type', null, InputOption::VALUE_REQUIRED, '', 'test'], ['treeLevels', null, InputOption::VALUE_REQUIRED, '', null], ['precision', null, InputOption::VALUE_REQUIRED, '', null], ['tab', null, InputOption::VALUE_NONE], ['bulk-size', null, InputOption::VALUE_REQUIRED, '', 10]];
foreach ($options as $option) {
    $inputDefinition->addOption(new InputOption($option[0], $option[1], $option[2], $option[3], $option[4]));
}
$argvInput = new ArgvInput($argv, $inputDefinition);
$main = function () use($argvInput) {
    $host = $argvInput->getArgument('host');
    $port = $argvInput->getOption('port');
    $indexName = $argvInput->getOption('index');
    $typeName = $argvInput->getOption('type');
    $treeLevels = $argvInput->getOption('treeLevels');
    $precision = $argvInput->getOption('precision');
    $tree = $argvInput->getArgument('tree');
    $bulkSize = $argvInput->getOption('bulk-size');
    $tab = $argvInput->getOption('tab');
    if (!in_array($tree, ['quadtree', 'geohash'])) {
        throw new \Exception(sprintf('Supported tree types are quadtree and geohash, "%s" given.', $tree));
    }
    if (!isset($treeLevels) && !isset($precision)) {

 /**
  * Add the retrieved options and arguments to a definition
  *
  * @return InputDefinition
  */
 public function getDefinition()
 {
     if (!$this->initialized) {
         $this->initialize();
     }
     $definition = new InputDefinition();
     foreach ($this->definitions as $from => $info) {
         $config = $info['config'];
         $required = array_key_exists('required', $config) && $config['required'];
         if ($info['type'] === 'option') {
             $mode = array_key_exists('mode', $config) ? $config['mode'] : InputOption::VALUE_OPTIONAL;
             if ($required) {
                 $mode |= InputOption::VALUE_REQUIRED;
             }
             if (in_array('array', explode('|', $config['type']), true)) {
                 $mode |= InputOption::VALUE_IS_ARRAY;
             }
             if (preg_match('/(^|\\|)bool(ean)?($|\\|)/', $config['type'])) {
                 if (strpos($config['type'], '|')) {
                     $mode |= InputOption::VALUE_NONE;
                 } else {
                     $mode = InputOption::VALUE_NONE;
                 }
             }
             $definition->addOption(new InputOption($from, array_key_exists('shortcut', $config) ? $config['shortcut'] : null, $mode, $config['label'], array_key_exists('default', $config) ? $config['default'] : null));
         } else {
             $mode = array_key_exists('mode', $config) ? $config['mode'] : InputArgument::OPTIONAL;
             if ($required) {
                 $mode |= InputArgument::REQUIRED;
             }
             if (in_array('array', explode('|', $config['type']), true)) {
                 $mode |= InputArgument::IS_ARRAY;
             }
             $definition->addArgument(new InputArgument($from, $mode, $config['label'], array_key_exists('default', $config) ? $config['default'] : null));
         }
     }
     return $definition;
 }

 /**
  * builds the Input Definition based upon Api Method Parameters.
  *
  * @param \ReflectionMethod $method
  * @param string            $token
  *
  * @return InputDefinition
  */
 private function buildDefinition(\ReflectionMethod $method, $token = null)
 {
     $definition = new InputDefinition();
     foreach ($method->getParameters() as $parameter) {
         if ($parameter->isDefaultValueAvailable()) {
             //option
             $definition->addOption(new InputOption($parameter->getName(), null, InputOption::VALUE_REQUIRED, null, $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null));
         } else {
             //argument
             $definition->addArgument(new InputArgument($parameter->getName(), InputArgument::REQUIRED, null, null));
         }
     }
     $definition->addOption(new InputOption('token', null, InputOption::VALUE_REQUIRED, 'the auth token to use', $token));
     $definition->addOption(new InputOption('debug', null, InputOption::VALUE_NONE, 'display raw response'));
     return $definition;
 }

 /**
  * Adds an argument.
  *
  * @param string $name        The argument name
  * @param int    $mode        The argument mode: InputArgument::REQUIRED or InputArgument::OPTIONAL
  * @param string $description A description text
  * @param mixed  $default     The default value (for InputArgument::OPTIONAL mode only)
  *
  * @return Command The current instance
  */
 public function addArgument($name, $mode = null, $description = '', $default = null)
 {
     $this->definition->addArgument(new InputArgument($name, $mode, $description, $default));
     return $this;
 }