symfony-autocomplete

#!/usr/bin/env php
<?php

use Symfony\Component\Console\Application as BaseApplication;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Process\Process;

if (file_exists($autoload = __DIR__.'/../../autoload.php')) {
    require_once $autoload;
} else {
    require_once __DIR__.'/vendor/autoload.php';
}

class Application extends BaseApplication
{
    private $command;

    public function __construct(Command $command)
    {
        $this->command = $command;

        parent::__construct();
    }

    protected function getCommandName(InputInterface $input)
    {
        return $this->command->getName();
    }

    protected function getDefaultCommands()
    {
        $defaultCommands = parent::getDefaultCommands();
        $defaultCommands[] = $this->command;

        return $defaultCommands;
    }

    public function getDefinition()
    {
        $inputDefinition = parent::getDefinition();
        $inputDefinition->setArguments();

        return $inputDefinition;
    }
}

function zsh_describe($value, $description = null)
{
    $value = '"'.str_replace(':', '\\:', $value);
    if (!empty($description)) {
        $value .= ':'.escapeshellcmd($description);
    }

    return $value.'"';
}

$command = new Command('dump');
$command
    ->setDefinition(array(
        new InputArgument('script', InputArgument::OPTIONAL, "The script to generate completion for."),
        new InputOption('script-options', null, InputOption::VALUE_REQUIRED, "Options to be passed to the script."),
        new InputOption('aliases', null, InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY, "Extra aliases to be used."),
        new InputOption('disable-default-tools', null, InputOption::VALUE_NONE),
        new InputOption('shell', null, InputOption::VALUE_REQUIRED, 'Shell type ("bash" or "zsh")', basename($_SERVER['SHELL'])),
    ))
    ->setDescription('Dumps bash autocompletion for any executable based on a Symfony Console Application.')
    ->setCode(function (InputInterface $input, OutputInterface $output) {
        $shell = $input->getOption('shell');
        $script = $input->getArgument('script');

        if (!in_array($shell, array('bash', 'zsh'))) {
            throw new InvalidArgumentException(sprintf(
                'Completion is only available for Bash and Zsh, "%s" given.',
                $shell
            ));
        }

        /* =====================================
         * DEFAULT SCRIPT
         * ===========================================
         */
        if (!$script) {
            if ($input->getOption('disable-default-tools')) {
                $tools = array();
            } else {
                $tools = array(
                    'console',
                    'composer',
                    'php-cs-fixer',
                    'phpspec',
                    'behat',
                );
            }

            if ($extraTools = $input->getOption('aliases')) {
                $extraTools = array_filter(preg_split('/\s+/', implode(' ', $extraTools)));
                $tools = array_unique(array_merge($tools, $extraTools));
            }

            if ('zsh' == $shell) {
                $tools = array_map(function ($v) {
                    return 'compdef _symfony ' . $v;
                }, $tools);
            } else {
                $tools = array_map(function ($v) {
                    return 'complete -o default -F _symfony ' . $v;
                }, $tools);
            }

            $template = file_get_contents(__DIR__.'/templates/default.'.$shell.'.tpl');
            $output->write(str_replace(
                array('%%TOOLS%%'),
                array(implode("\n", $tools)),
                $template
            ));

            return;
        }

        /* =====================================
         * STATIC SCRIPT
         * ===========================================
         */
        $scriptOptions = $input->getOption('script-options');

        // find all commands
        $process = new Process($script.' '.$scriptOptions.' list --raw | awk \'{if (NF>1) print $1 " " substr($0, index($0,$2)); else print $1}\'');
        $process->run();
        if (!$process->isSuccessful()) {
            throw new RuntimeException($process->getErrorOutput());
        }

        $rawCommands = explode("\n", $process->getOutput());
        array_pop($rawCommands);

        $commands = array();
        $commandsDescriptions = array();
        $commandsOptionsDescriptions = array();
        foreach ($rawCommands as $rawCommand) {
            $rawCommand = explode(' ', $rawCommand, 2);
            $commands[] = $rawCommand[0];
            $commandsDescriptions[$rawCommand[0]] = !empty($rawCommand[1]) ? $rawCommand[1] : null;
            $commandsOptionsDescriptions[$rawCommand[0]] = array();
        }

        // find all options
        $commandsOptions = array();
        $globalOptions = array();
        $optionsDescriptions = array();
        foreach ($commands as $command) {
            // get command help as xml
            $process = new Process($script.' '.$scriptOptions.' help --format=xml '.$command);
            $process->run();
            if (!$process->isSuccessful()) {
                throw new RuntimeException($process->getErrorOutput());
            }
            $xmlHelp = $process->getOutput();

            // extract options from xml help
            $commandOptions = array();
            $xml = simplexml_load_string($xmlHelp);
            foreach ($xml->xpath('/command/options/option') as $commandOption) {
                $name = (string) $commandOption['name'];
                $commandOptions[] = $name;
                $optionsDescriptions[$name] = $commandsOptionsDescriptions[$command][$name] = (string) $commandOption->description;
            }

            $commandsOptions[$command] = $commandOptions;
            if ('list' !== $command) {
                if (empty($globalOptions)) {
                    $globalOptions = $commandOptions;
                }

                $globalOptions = array_intersect($globalOptions, $commandOptions);
            }
        }

        if ('zsh' == $shell) {
            $switchCaseStatementTemplate = 'opts+=(%%COMMAND_OPTIONS%%)';
        } else {
            $switchCaseStatementTemplate = 'opts="${opts} %%COMMAND_OPTIONS%%"';
        }

        // generate the switch content
        $switchCaseTemplate = <<<SWITCHCASE
    %%COMMAND%%)
            $switchCaseStatementTemplate
            ;;
SWITCHCASE;

        $switchContent = '';
        foreach ($commandsOptions as $command => $options) {
            if (empty($options)) {
                continue;
            }

            $options = array_diff($options, $globalOptions);
            if ('zsh' === $shell) {
                $options = array_map(function ($option) use ($command, $commandsOptionsDescriptions) {
                    return zsh_describe($option, $commandsOptionsDescriptions[$command][$option]);
                }, $options);
            }

            $switchContent .= str_replace(
                array('%%COMMAND%%', '%%COMMAND_OPTIONS%%'),
                array($command, join(' ', $options)),
                $switchCaseTemplate
            )."\n        ";
        }
        $switchContent = rtrim($switchContent, ' ');

        // dump
        $template = file_get_contents(__DIR__.'/templates/cached.'.$shell.'.tpl');
        $script = explode('/', $script);
        $script = array_pop($script);
        $tools = array($script);

        if ($extraTools = $input->getOption('aliases')) {
            $extraTools = array_filter(preg_split('/\s+/', implode(' ', $extraTools)));
            $tools = array_unique(array_merge($tools, $extraTools));
        }

        if ('zsh' == $shell) {
            $commands = array_map(function ($command) use ($commandsDescriptions) {
                return zsh_describe($command, $commandsDescriptions[$command]);
            }, $commands);

            $globalOptions = array_map(function ($option) use ($optionsDescriptions) {
                return zsh_describe($option, $optionsDescriptions[$option]);
            }, $globalOptions);

            $tools = array_map(function ($v) use ($script) {
                return "compdef _$script $v";
            }, $tools);
        } else {
            $tools = array_map(function ($v) use ($script) {
                return "complete -o default -F _$script $v";
            }, $tools);
        }

        $output->write(str_replace(
            array('%%SCRIPT%%', '%%COMMANDS%%', '%%SHARED_OPTIONS%%', '%%SWITCH_CONTENT%%', '%%TOOLS%%'),
            array($script, join(' ', $commands), join(' ', $globalOptions), $switchContent, implode("\n", $tools)),
            $template
        ));
    })
;

$console = new Application($command);
$console->run();