Add support for ZSH

This commit refactors hook generation into its own class, and includes the
ZSH completion hook I wrote a few months ago for stecman/composer-bash-completion-plugin.

Author: stecman

README.md

@@ -1,6 +1,6 @@
 # BASH completion for Symfony Console applications
 
-This package provides automatic BASH completion for Symfony Console Component based applications. With zero configuration, this package allows completion of available command names and the options they provide. Custom completion behaviour can be added for option and argument values by name.
+This package provides automatic (tab) completion in BASH and ZSH for Symfony Console Component based applications. With zero configuration, this package allows completion of available command names and the options they provide. Custom completion behaviour can be added for option and argument values by name.
 
 Example of zero-config use with Composer:
 
@@ -12,20 +12,28 @@ If you don't need any custom completion behaviour, all you need to do is add the
 
 1. Install `stecman/symfony-console-completion` through composer
 2. Add an instance of `CompletionCommand` to your application's `Application::getDefaultCommands()` method:
-```php
-protected function getDefaultCommands()
-{
-   //...
-    $commands[] = new \Stecman\Component\Symfony\Console\BashCompletion\CompletionCommand();
-   //...
-}
-```
-
-3. Run `eval $([program] _completion --generate-hook)` in a terminal, replacing `[program]` with the command you use to run your application (eg. 'composer'). By default this registers completion for the absolute path to you application; you can specify a command name to complete for instead using the `-p` option.
+  ```php
+  protected function getDefaultCommands()
+  {
+     //...
+      $commands[] = new \Stecman\Component\Symfony\Console\BashCompletion\CompletionCommand();
+     //...
+  }
+  ```
+
+3. Run the following in a terminal, replacing `[program]` with the command you use to run your application (eg. 'composer'):
+
+  ```bash
+  [program] _completion --generate-hook | source /dev/stdin
+  ```
+  
+  By default this registers completion for the absolute path to you application. You can specify a command name to complete for instead using the `-p` option, which is useful if you're using an alias to run the program. Under BASH, an alternative command is `eval $([program] _completion --generate-hook)`, however the command above is recommended as it works for both BASH and ZSH.
 4. Add the command from step 3 to your bash profile if you want the completion to apply automatically for all new terminal sessions.
 
 Note: If `[program]` is an alias you will need to specify the aliased name with the `-p|--program` option, as completion may not work otherwise: `_completion --generate-hook -p [myalias]`.
 
+Second note: The type of shell (ZSH/BASH) is automatically detected using the `SHELL` environment variable at run time. In some circumstances, you may need to explicitly set the shell type using the `--shell` option.
+
 ### How it works
 
 The `--generate-hook` option of `CompletionCommand` generates a few lines of BASH that, when executed, register your application as a completion handler for your itself in the current shell session. When you request completion for your program (by pressing tab), the completion command on your application is run with no arguments: `[program] _completion`. This uses environment variables set by BASH to get the current command line contents and cursor position, then completes from your console command definitions.

src/CompletionCommand.php

@@ -41,6 +41,12 @@ protected function configure()
                 'p',
                 InputOption::VALUE_REQUIRED,
                 "Program name that should trigger completion\n<comment>(defaults to the absolute application path)</comment>."
+            )
+            ->addOption(
+                'shell',
+                's',
+                InputOption::VALUE_REQUIRED,
+                "Force the shell to generate a hook for <comment>(" . implode(', ', HookFactory::getShellTypes()) . ")</comment>\n"
             );
     }
 
@@ -50,7 +56,17 @@ protected function execute(InputInterface $input, OutputInterface $output)
         $handler = $this->handler;
 
         if ( $input->getOption('generate-hook') ) {
-            $output->write( $handler->generateBashCompletionHook($input->getOption('program')), true );
+            global $argv;
+            $program = $argv[0];
+
+            $factory = new HookFactory();
+            $hook = $factory->generateHook(
+                $input->getOption('shell') ?: $this->getShellType(),
+                $program,
+                $input->getOption('program')
+            );
+
+            $output->write($hook, true);
         } else {
             $handler->setContext(new EnvironmentCompletionContext());
             $output->write($this->runCompletion(), true);
@@ -62,4 +78,17 @@ protected function runCompletion()
         return $this->handler->runCompletion();
     }
 
+    /**
+     * Determine the shell type for use with HookFactory
+     * @return string
+     */
+    protected function getShellType()
+    {
+        if (!getenv('SHELL')) {
+            throw new \RuntimeException('Could not read SHELL environment variable. Please specify your shell type with the --shell option');
+        }
+
+        return basename(realpath(getenv('SHELL')));
+    }
+
 }

src/CompletionHandler.php

@@ -332,50 +332,6 @@ protected function filterResults($array)
         );
     }
 
-    /**
-     * Return the BASH script necessary to use bash completion with this addHandler
-     * @param string $programName
-     * @return string
-     */
-    public function generateBashCompletionHook($programName = null)
-    {
-        global $argv;
-        $command = $argv[0];
-
-        if (!$programName) {
-            $programName = $command;
-            $funcName = sprintf('_%s_%s_complete',
-                basename($programName),
-                substr(md5($command), 0, 12)
-            );
-        } else {
-            $funcName = "_{$programName}complete";
-        }
-
-        return <<<"END"
-function $funcName {
-    export COMP_LINE COMP_POINT COMP_WORDBREAKS;
-    local RESULT STATUS;
-
-    RESULT=`$command _completion`;
-    STATUS=\$?;
-
-    if [ \$STATUS -ne 0 ]; then
-        echo \$RESULT;
-        return \$?;
-    fi;
-
-    local cur;
-    _get_comp_words_by_ref -n : cur;
-
-    COMPREPLY=(`compgen -W "\$RESULT" -- \$cur`);
-
-    __ltrim_colon_completions "\$cur";
-};
-complete -F $funcName $programName;
-END;
-    }
-
     protected function getAllOptions(){
         return array_merge(
             $this->command->getDefinition()->getOptions(),

src/HookFactory.php

@@ -0,0 +1,148 @@
+<?php
+
+
+namespace Stecman\Component\Symfony\Console\BashCompletion;
+
+
+final class HookFactory
+{
+    /**
+     * Hook scripts
+     *
+     * These are shell-specific scripts that pass required information from existing
+     * completion systems in a common form the completion component of this module.
+     *
+     * The following placeholders are replaced with their value at runtime:
+     *
+     *     %%function_name%%      - name of the generated shell function run for completion
+     *     %%program_name%%       - command name completion will be enabled for
+     *     %%program_path%%       - path to program the completion is for/generated by
+     *     %%completion_command%% - command to be run to compute completions
+     *
+     * NOTE: Comments are stripped out by HookFactory::stripComments as eval reads
+     *       input as a single line, causing it to break if comments are included.
+     *       While comments work using `... | source /dev/stdin`, existing installations
+     *       are likely using eval as it's been part of the instructions for a while.
+     *
+     * @var array
+     */
+    protected static $hooks = array(
+        // BASH Hook
+        'bash' => <<<'END'
+# BASH completion for %%program_path%%
+function %%function_name%% {
+    export COMP_LINE COMP_POINT COMP_WORDBREAKS;
+    local RESULT STATUS;
+
+    RESULT=`%%completion_command%%`;
+    STATUS=$?;
+
+    # Bail out if PHP didn't exit cleanly
+    if [ $STATUS -ne 0 ]; then
+        echo $RESULT;
+        return $?;
+    fi;
+
+    local cur;
+    _get_comp_words_by_ref -n : cur;
+
+    COMPREPLY=(`compgen -W "$RESULT" -- \$cur`);
+
+    __ltrim_colon_completions "$cur";
+};
+
+complete -F %%function_name%% %%program_name%%;
+END
+
+        // ZSH Hook
+        , 'zsh' => <<<'END'
+# ZSH completion for %%program_path%%
+function %%function_name%% {
+    # Emulate BASH's command line contents variable
+    local -x COMP_LINE="$words"
+
+    # Emulate BASH's cursor position variable, setting it to the end of the current word.
+    local -x COMP_POINT
+    (( COMP_POINT = ${#${(j. .)words[1,CURRENT]}} ))
+
+    local RESULT STATUS
+    local -x COMPOSER_CWD=`pwd`
+    RESULT=("${(@f)$( %%completion_command%% )}")
+    STATUS=$?;
+
+    # Bail out if PHP didn't exit cleanly
+    if [ $STATUS -ne 0 ]; then
+        echo $RESULT;
+        return $?;
+    fi;
+
+    compadd -- $RESULT
+};
+
+compdef %%function_name%% %%program_name%%;
+END
+    );
+
+    public static function getShellTypes()
+    {
+        return array_keys(self::$hooks);
+    }
+
+    /**
+     * Return a completion hook for the specified shell type
+     *
+     * @param string $type - a key from self::$hooks
+     * @param string $programPath
+     * @param string $programName
+     * @return string
+     */
+    public function generateHook($type, $programPath, $programName = null)
+    {
+        if (!isset(self::$hooks[$type])) {
+            throw new \RuntimeException(sprintf(
+                "Cannot generate hook for unknown shell type '%s'. Available hooks are: %s",
+                $type,
+                implode(', ', self::getShellTypes())
+            ));
+        }
+
+        // Use the program path if an alias/name is not given
+        $programName = $programName ?: $programPath;
+
+        return str_replace([
+                '%%function_name%%',
+                '%%program_name%%',
+                '%%program_path%%',
+                '%%completion_command%%',
+            ], [
+                $this->generateFunctionName($programPath, $programName),
+                $programName,
+                $programPath,
+                "$programPath _completion"
+            ],
+            $this->stripComments(self::$hooks[$type])
+        );
+    }
+
+    /**
+     * Generate a function name that is unlikely to conflict with other
+     * generated function names in the same shell
+     */
+    protected function generateFunctionName($programPath, $programName)
+    {
+        return sprintf('_%s_%s_complete',
+            basename($programName),
+            substr(md5($programPath), 0, 16)
+        );
+    }
+
+    /**
+     * BASH's eval doesn't work with comments, so these have to be stripped out
+     * @param string $script
+     * @return string
+     */
+    protected function stripComments($script)
+    {
+        return preg_replace('/(^\s*\#.*$)/m', '', $script);
+    }
+}