?iť?
Your IP : 18.188.180.254
<?php
namespace Stecman\Component\Symfony\Console\BashCompletion;
use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionAwareInterface;
use Stecman\Component\Symfony\Console\BashCompletion\Completion\CompletionInterface;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
class CompletionHandler
{
/**
* Application to complete for
* @var \Symfony\Component\Console\Application
*/
protected $application;
/**
* @var Command
*/
protected $command;
/**
* @var CompletionContext
*/
protected $context;
/**
* Array of completion helpers.
* @var CompletionInterface[]
*/
protected $helpers = array();
public function __construct(Application $application, CompletionContext $context = null)
{
$this->application = $application;
$this->context = $context;
$this->addHandler(
new Completion(
'help',
'command_name',
Completion::TYPE_ARGUMENT,
array_keys($application->all())
)
);
$this->addHandler(
new Completion(
'list',
'namespace',
Completion::TYPE_ARGUMENT,
$application->getNamespaces()
)
);
}
public function setContext(CompletionContext $context)
{
$this->context = $context;
}
/**
* @return CompletionContext
*/
public function getContext()
{
return $this->context;
}
/**
* @param CompletionInterface[] $array
*/
public function addHandlers(array $array)
{
$this->helpers = array_merge($this->helpers, $array);
}
/**
* @param CompletionInterface $helper
*/
public function addHandler(CompletionInterface $helper)
{
$this->helpers[] = $helper;
}
/**
* Do the actual completion, returning an array of strings to provide to the parent shell's completion system
*
* @throws \RuntimeException
* @return string[]
*/
public function runCompletion()
{
if (!$this->context) {
throw new \RuntimeException('A CompletionContext must be set before requesting completion.');
}
$cmdName = $this->getInput()->getFirstArgument();
try {
$this->command = $this->application->find($cmdName);
} catch (\InvalidArgumentException $e) {
// Exception thrown, when multiple or none commands are found.
}
$process = array(
'completeForOptionValues',
'completeForOptionShortcuts',
'completeForOptionShortcutValues',
'completeForOptions',
'completeForCommandName',
'completeForCommandArguments'
);
foreach ($process as $methodName) {
$result = $this->{$methodName}();
if (false !== $result) {
// Return the result of the first completion mode that matches
return $this->filterResults((array) $result);
}
}
return array();
}
/**
* Get an InputInterface representation of the completion context
*
* @return ArrayInput
*/
public function getInput()
{
// Filter the command line content to suit ArrayInput
$words = $this->context->getWords();
array_shift($words);
$words = array_filter($words);
return new ArrayInput($words);
}
/**
* Attempt to complete the current word as a long-form option (--my-option)
*
* @return array|false
*/
protected function completeForOptions()
{
$word = $this->context->getCurrentWord();
if (substr($word, 0, 2) === '--') {
$options = array();
foreach ($this->getAllOptions() as $opt) {
$options[] = '--'.$opt->getName();
}
return $options;
}
return false;
}
/**
* Attempt to complete the current word as an option shortcut.
*
* If the shortcut exists it will be completed, but a list of possible shortcuts is never returned for completion.
*
* @return array|false
*/
protected function completeForOptionShortcuts()
{
$word = $this->context->getCurrentWord();
if (strpos($word, '-') === 0 && strlen($word) == 2) {
$definition = $this->command ? $this->command->getNativeDefinition() : $this->application->getDefinition();
if ($definition->hasShortcut(substr($word, 1))) {
return array($word);
}
}
return false;
}
/**
* Attempt to complete the current word as the value of an option shortcut
*
* @return array|false
*/
protected function completeForOptionShortcutValues()
{
$wordIndex = $this->context->getWordIndex();
if ($this->command && $wordIndex > 1) {
$left = $this->context->getWordAtIndex($wordIndex - 1);
// Complete short options
if ($left[0] == '-' && strlen($left) == 2) {
$shortcut = substr($left, 1);
$def = $this->command->getNativeDefinition();
if (!$def->hasShortcut($shortcut)) {
return false;
}
$opt = $def->getOptionForShortcut($shortcut);
if ($opt->isValueRequired() || $opt->isValueOptional()) {
return $this->completeOption($opt);
}
}
}
return false;
}
/**
* Attemp to complete the current word as the value of a long-form option
*
* @return array|false
*/
protected function completeForOptionValues()
{
$wordIndex = $this->context->getWordIndex();
if ($this->command && $wordIndex > 1) {
$left = $this->context->getWordAtIndex($wordIndex - 1);
if (strpos($left, '--') === 0) {
$name = substr($left, 2);
$def = $this->command->getNativeDefinition();
if (!$def->hasOption($name)) {
return false;
}
$opt = $def->getOption($name);
if ($opt->isValueRequired() || $opt->isValueOptional()) {
return $this->completeOption($opt);
}
}
}
return false;
}
/**
* Attempt to complete the current word as a command name
*
* @return array|false
*/
protected function completeForCommandName()
{
if (!$this->command || (count($this->context->getWords()) == 2 && $this->context->getWordIndex() == 1)) {
$commands = $this->application->all();
$names = array_keys($commands);
if ($key = array_search('_completion', $names)) {
unset($names[$key]);
}
return $names;
}
return false;
}
/**
* Attempt to complete the current word as a command argument value
*
* @see Symfony\Component\Console\Input\InputArgument
* @return array|false
*/
protected function completeForCommandArguments()
{
if (!$this->command || strpos($this->context->getCurrentWord(), '-') === 0) {
return false;
}
$definition = $this->command->getNativeDefinition();
$argWords = $this->mapArgumentsToWords($definition->getArguments());
$wordIndex = $this->context->getWordIndex();
if (isset($argWords[$wordIndex])) {
$name = $argWords[$wordIndex];
} elseif (!empty($argWords) && $definition->getArgument(end($argWords))->isArray()) {
$name = end($argWords);
} else {
return false;
}
if ($helper = $this->getCompletionHelper($name, Completion::TYPE_ARGUMENT)) {
return $helper->run();
}
if ($this->command instanceof CompletionAwareInterface) {
return $this->command->completeArgumentValues($name, $this->context);
}
return false;
}
/**
* Find a CompletionInterface that matches the current command, target name, and target type
*
* @param string $name
* @param string $type
* @return CompletionInterface|null
*/
protected function getCompletionHelper($name, $type)
{
foreach ($this->helpers as $helper) {
if ($helper->getType() != $type && $helper->getType() != CompletionInterface::ALL_TYPES) {
continue;
}
if ($helper->getCommandName() == CompletionInterface::ALL_COMMANDS || $helper->getCommandName() == $this->command->getName()) {
if ($helper->getTargetName() == $name) {
return $helper;
}
}
}
return null;
}
/**
* Complete the value for the given option if a value completion is availble
*
* @param InputOption $option
* @return array|false
*/
protected function completeOption(InputOption $option)
{
if ($helper = $this->getCompletionHelper($option->getName(), Completion::TYPE_OPTION)) {
return $helper->run();
}
if ($this->command instanceof CompletionAwareInterface) {
return $this->command->completeOptionValues($option->getName(), $this->context);
}
return false;
}
/**
* Step through the command line to determine which word positions represent which argument values
*
* The word indexes of argument values are found by eliminating words that are known to not be arguments (options,
* option values, and command names). Any word that doesn't match for elimination is assumed to be an argument value,
*
* @param InputArgument[] $argumentDefinitions
* @return array as [argument name => word index on command line]
*/
protected function mapArgumentsToWords($argumentDefinitions)
{
$argumentPositions = array();
$argumentNumber = 0;
$previousWord = null;
$argumentNames = array_keys($argumentDefinitions);
// Build a list of option values to filter out
$optionsWithArgs = $this->getOptionWordsWithValues();
foreach ($this->context->getWords() as $wordIndex => $word) {
// Skip program name, command name, options, and option values
if ($wordIndex < 2
|| ($word && '-' === $word[0])
|| in_array($previousWord, $optionsWithArgs)) {
$previousWord = $word;
continue;
} else {
$previousWord = $word;
}
// If argument n exists, pair that argument's name with the current word
if (isset($argumentNames[$argumentNumber])) {
$argumentPositions[$wordIndex] = $argumentNames[$argumentNumber];
}
$argumentNumber++;
}
return $argumentPositions;
}
/**
* Build a list of option words/flags that will have a value after them
* Options are returned in the format they appear as on the command line.
*
* @return string[] - eg. ['--myoption', '-m', ... ]
*/
protected function getOptionWordsWithValues()
{
$strings = array();
foreach ($this->getAllOptions() as $option) {
if ($option->isValueRequired()) {
$strings[] = '--' . $option->getName();
if ($option->getShortcut()) {
$strings[] = '-' . $option->getShortcut();
}
}
}
return $strings;
}
/**
* Filter out results that don't match the current word on the command line
*
* @param string[] $array
* @return string[]
*/
protected function filterResults(array $array)
{
$curWord = $this->context->getCurrentWord();
return array_filter($array, function($val) use ($curWord) {
return fnmatch($curWord.'*', $val);
});
}
/**
* Get the combined options of the application and entered command
*
* @return InputOption[]
*/
protected function getAllOptions()
{
if (!$this->command) {
return $this->application->getDefinition()->getOptions();
}
return array_merge(
$this->command->getNativeDefinition()->getOptions(),
$this->application->getDefinition()->getOptions()
);
}
}