/**
* @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');
}
