/** * @return array */ public function providerMake() { $inputDefinition = new InputDefinition(); $inputDefinition->addOption(new InputOption('option_optional_default', null, InputOption::VALUE_OPTIONAL, '', 'default')); $inputDefinition->addOption(new InputOption('option_array_default_array', null, InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY)); $inputDefinition->addOption(new InputOption('option_none', null, InputOption::VALUE_NONE)); $inputDefinition->addOption(new InputOption('out', null, InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY)); return ['option_optional_default_default' => [$inputDefinition, new ArrayInput(['--option_optional_default' => 'default'], $inputDefinition)], 'option_optional_default_value' => [$inputDefinition, new ArrayInput(['--option_optional_default' => 'value'], $inputDefinition), '--option_optional_default \'value\''], 'option_array_default_array_default' => [$inputDefinition, new ArrayInput(['--option_array_default_array' => []], $inputDefinition)], 'option_array_default_array_value' => [$inputDefinition, new ArrayInput(['--option_array_default_array' => ['value1', 'value2']], $inputDefinition), '--option_array_default_array \'value1\' --option_array_default_array \'value2\''], 'option_none_default' => [$inputDefinition, new ArrayInput([], $inputDefinition)], 'option_none_default_value' => [$inputDefinition, new ArrayInput(['--option_none' => 'any'], $inputDefinition), '--option_none'], 'out_folder_skip' => [$inputDefinition, new ArrayInput(['--out' => ['folder', 'std']], $inputDefinition), '', ['out']], 'out_folder' => [$inputDefinition, new ArrayInput(['--out' => ['folder', 'std']], $inputDefinition), '--out \'folder/59adaf3f0820898ecf0da97ceab30eab\' --out \'std\'']]; }
/** * @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; }
public function setUp() { parent::setUp(); $this->template = $this->prophesize(TemplateInterface::class); $inputDef = new InputDefinition(); $inputDef->addOption(new InputOption('test-option', null, InputOption::VALUE_OPTIONAL)); $this->input = new ArrayInput(['--test-option' => null], $inputDef); $this->output = new BufferedOutput(); $this->application = $this->getApplication(); $styleHelper = $this->application->getHelperSet()->get('gush_style'); $styleHelper->setInput($this->input); $styleHelper->setOutput($this->output); $this->helper = new TemplateHelper($styleHelper, $this->application); $this->helper->setInput($this->input); }
/** * @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); }
/** * @param string|\Symfony\Component\Form\FormTypeInterface $formType * @param array &$resources * * @return InputDefinition */ public function createForFormType($formType, array &$resources = []) { $resources[] = new FileResource(__FILE__); $form = $this->formFactory->create($formType); $actualFormType = $form->getConfig()->getType()->getInnerType(); $reflection = new \ReflectionObject($actualFormType); $resources[] = new FileResource($reflection->getFileName()); $inputDefinition = new InputDefinition(); foreach ($form->all() as $name => $field) { if (!$this->isFormFieldSupported($field)) { continue; } $type = InputOption::VALUE_REQUIRED; $default = $field->getConfig()->getOption('data', null); $description = FormUtil::label($field); $inputDefinition->addOption(new InputOption($name, null, $type, $description, $default)); } return $inputDefinition; }
/** * @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; }
/** * Add options to a Symfony Console input definition. * * @param InputDefinition $definition */ public function configureInputDefinition(InputDefinition $definition) { foreach ($this->fields as $field) { $definition->addOption($field->getAsOption()); } }
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; }
/** * Add options to a command's input definition. * * @param InputDefinition $definition */ public static function configureInput(InputDefinition $definition) { $description = 'The date format (as a PHP date format string)'; $option = new InputOption('date-fmt', null, InputOption::VALUE_REQUIRED, $description, self::DEFAULT_DATE_FORMAT); $definition->addOption($option); }
/** * Adds an option. * * @param string $name The option name * @param string $shortcut The shortcut (can be null) * @param int $mode The option mode: One of the InputOption::VALUE_* constants * @param string $description A description text * @param mixed $default The default value (must be null for InputOption::VALUE_REQUIRED or InputOption::VALUE_NONE) * * @return Command The current instance */ public function addOption($name, $shortcut = null, $mode = null, $description = '', $default = null) { $this->definition->addOption(new InputOption($name, $shortcut, $mode, $description, $default)); return $this; }
/** * Add the --format option to a command's input definition. * * @param InputDefinition $definition */ public static function addFormatOption(InputDefinition $definition) { $description = 'The output format ("table", "csv", or "tsv")'; $option = new InputOption('format', null, InputOption::VALUE_REQUIRED, $description, 'table'); $definition->addOption($option); }
/** * @param InputDefinition $inputDefinition */ private function setInputDefinition(InputDefinition $inputDefinition) { $inputDefinition->addOption(new InputOption('log-level', 'l', InputOption::VALUE_REQUIRED, 'Override the Monolog logging level for this execution of the command. Valid values: ' . implode(', ', array_keys(Logger::getLevels())))); $inputDefinition->addOption(new InputOption('log-filename', null, InputOption::VALUE_REQUIRED, 'Specify a different file (relative to the kernel log directory) to send file logs to')); $inputDefinition->addOption(new InputOption('locking', null, InputOption::VALUE_REQUIRED, 'Whether or not this execution needs to acquire a ' . ' lock that ensures that the command is only being run once concurrently. Valid values: on, off')); }
/** * {@inheritdoc} */ protected function configure() { $definition = new InputDefinition(); foreach ($this->argnames as $argname) { if (isset($this->callbackParams[$argname])) { $param = $this->callbackParams[$argname]; if (!$param->getClass()) { $mode = 0; if ($param->isOptional()) { $mode |= InputArgument::OPTIONAL; } else { $mode |= InputArgument::REQUIRED; } if ($param->isArray()) { $mode |= InputArgument::IS_ARRAY; } $description = ''; $default = null; if ($param->isDefaultValueAvailable()) { $default = $param->getDefaultValue(); } $definition->addArgument(new InputArgument($argname, $mode, $description, $default)); } } } foreach ($this->optnames as $optname) { if (isset($this->callbackParams[$optname])) { if (!$param->getClass()) { $shortcut = null; $mode = 0; $description = ''; $default = $param->getDefaultValue(); if (is_bool($default)) { $mode |= InputOption::VALUE_NONE; } else { $mode |= InputOption::VALUE_REQUIRED; if ($param->isArray()) { $mode |= InputOption::VALUE_IS_ARRAY; } } $definition->addOption(new InputOption($optname, $shortcut, $mode, $description, $default)); } } } $this->setDefinition($definition); }
/** * Register global options * * @param InputDefinition $definition An InputDefinition instance */ protected function register_global_options(InputDefinition $definition) { try { $definition->addOption(new InputOption('safe-mode', null, InputOption::VALUE_NONE, $this->language->lang('CLI_DESCRIPTION_OPTION_SAFE_MODE'))); $definition->addOption(new InputOption('env', 'e', InputOption::VALUE_REQUIRED, $this->language->lang('CLI_DESCRIPTION_OPTION_ENV'))); } catch (\LogicException $e) { // Do nothing } }
public function testAddOption() { $this->initializeOptions(); $definition = new InputDefinition(); $definition->addOption($this->foo); $this->assertEquals(array('foo' => $this->foo), $definition->getOptions(), '->addOption() adds a InputOption object'); $definition->addOption($this->bar); $this->assertEquals(array('foo' => $this->foo, 'bar' => $this->bar), $definition->getOptions(), '->addOption() adds a InputOption object'); try { $definition->addOption($this->foo2); $this->fail('->addOption() throws a Exception if the another option is already registered with the same name'); } catch (\Exception $e) { $this->assertInstanceOf('\\Exception', $e, '->addOption() throws a Exception if the another option is already registered with the same name'); $this->assertEquals('An option named "foo" already exist.', $e->getMessage()); } try { $definition->addOption($this->foo1); $this->fail('->addOption() throws a Exception if the another option is already registered with the same shortcut'); } catch (\Exception $e) { $this->assertInstanceOf('\\Exception', $e, '->addOption() throws a Exception if the another option is already registered with the same shortcut'); $this->assertEquals('An option with shortcut "f" already exist.', $e->getMessage()); } }
/** * 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; }
/** * @expectedException \LogicException * @expectedExceptionMessage An option with shortcut "f" already exists. */ public function testAddDuplicateShortcutOption() { $this->initializeOptions(); $definition = new InputDefinition(); $definition->addOption($this->foo); $definition->addOption($this->foo1); }
/** * 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; }
/** * 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); }
/** * Get the environment from the --environment option * or from the CRAFT_ENVIRONMENT env variable * @return string|null */ protected function getEnvironmentOption() { $definition = new InputDefinition(); $definition->addOption(new InputOption('environment', null, InputOption::VALUE_REQUIRED)); $input = new Console\GlobalArgvInput(null, $definition); return $input->getOption('environment') ?: getenv('CRAFT_ENVIRONMENT'); }