Merge pull request #53 from BrainMaestro/add-global-hook-support

Add global hook support

Author: BrainMaestro

Dockerfile

@@ -5,7 +5,7 @@ WORKDIR /app
 COPY ./composer.json ./composer.lock /app/
 
 # Remove any scripts that have cghooks since it is not yet present in the container
-RUN sed -iE '/\.\/cghooks .*/d' composer.json
+RUN sed -i -E '/\.\/cghooks .*/d' composer.json
 
 RUN composer install
 

Makefile

@@ -1,7 +1,7 @@
-.PHONY: test
+.PHONY: build exec
 
-test:
+build:
 	docker build --rm -t cghooks .
 
 exec:
-	docker run --rm -it cghooks sh
+	docker run --rm -it cghooks bash

README.md

@@ -5,33 +5,51 @@
 [![Packagist][badge-packagist]][link-packagist]
 [![Download][badge-downloads]][link-packagist]
 
-> Manage git hooks easily in your composer configuration. This package makes it easy to implement a consistent project-wide usage of git hooks. Specifying hooks in the composer file makes them available for every member of the project team. This provides a consistent environment and behavior for everyone which is great.
+> Manage git hooks easily in your composer configuration. This command line tool makes it easy to implement a consistent project-wide usage of git hooks. Specifying hooks in the composer file makes them available for every member of the project team. This provides a consistent environment and behavior for everyone which is great. It is also possible to use to manage git hooks globally for every repository on your computer. That way you have a reliable set of hooks crafted by yourself for every project you choose to work on.
 
 ## Install
 
 Add a `hooks` section to the `extra` section of your `composer.json` and add the hooks there. The previous way of adding hooks to the `scripts` section of your `composer.json` is still supported, but this way is cleaner if you have many scripts.
 
-```json
+```javascript
 {
     "extra": {
         "hooks": {
-            "pre-commit": "phpunit",
-            "post-commit": "echo committed",
-            "pre-push": ["phpunit", "echo pushing!"],
+            "pre-commit": [
+                "echo committing as $(git config user.name)",
+                "php-cs-fixer fix ." // fix style
+            ],
+            // verify commit message. ex: ABC-123: Fix everything
+            "commit-msg": "grep -q '[A-Z]+-[0-9]+.*' $1",
+            "pre-push": [
+                "php-cs-fixer fix --dry-run ." // check style
+                "phpunit"
+            ],
+            "post-merge": "composer update"
             "...": "..."
         }
     }
 }
 ```
 
-Then install the library with
+Then install with
 
 ```sh
 composer require --dev brainmaestro/composer-git-hooks
 ```
 
 This installs the `cghooks` binary to your `vendor/bin` folder. If this folder is not in your path, you will need to preface every command with `vendor/bin/`.
 
+### Global support
+
+You can also install it globally. This feels much more natural when `cghooks` is used with the newly added support for managing global git hooks.
+
+```sh
+composer global require --dev brainmaestro/composer-git-hooks
+```
+
+All commands have global support (besides testing the hooks. Still requires being in the directory with the `composer.json` file).
+
 ### Optional Configuration
 
 #### Shortcut
@@ -63,7 +81,7 @@ Add the following events to your `composer.json` file. The `cghooks` commands wi
 
 ## Usage
 
-All the following commands have to be run in the same folder as your `composer.json` file.
+All the following commands have to be run either in the same folder as your `composer.json` file or by specifying the `--git-dir` option to point to a folder with a `composer.json` file.
 
 ### Adding Hooks
 
@@ -78,10 +96,14 @@ to add all the valid git hooks that have been specified in the composer config.
 
 The `lock` file contains a list of all added hooks.
 
+If the `--global` flag is used, the hooks will be added globally, and the global git config will also be modified. If no directory is provided, there is a fallback to the current `core.hooksPath` in the global config. If that value is not set, it defaults to `$COMPOSER_HOME` (this specific fallback only happens for the `add` command). It will fail with an error if there is still no path after the fallbacks.
+
 ### Updating Hooks
 
 The update command which is run with `cghooks update` basically ignores the lock file and tries to add hooks from the composer lock. This is similar to what the `--force` option for the `add` command did. This command is useful if the hooks in the `composer.json` file have changed since the first time the hooks were added.
 
+This works similarly when used with `--global` except that there is no fallback to `$COMPOSER_HOME` if no directory is provided.
+
 ### Removing Hooks
 
 Hooks can be easily removed with `cghooks remove`. This will remove all the hooks that were specified in the composer config.
@@ -94,6 +116,8 @@ Hooks can also be removed by passing them as arguments. The command `cghooks rem
 
 **CAREFUL**: If the lock file was tampered with or the force option was used, hooks that already existed before using this package, but were specified in the composer scripts config will be removed as well. That is, if you had a previous `pre-commit` hook, but your current composer config also has a `pre-commit` hook, this option will cause the command to remove your initial hook.
 
+This also does not have a fallback to `$COMPOSER_HOME` if no directory is provided when used with `--global`.
+
 ### Listing hooks
 
 Hooks can be listed with the `cghooks list-hooks` command. This basically checks composer config and list the hooks that actually have files.
@@ -102,9 +126,12 @@ Hooks can be listed with the `cghooks list-hooks` command. This basically checks
 
 The following options are common to all commands.
 
-| Option    | Description           | Command                                        |
-| --------- | --------------------- | ---------------------------------------------- |
-| `git-dir` | Path to git directory | `cghooks ${command} --git-dir='/path/to/.git'` |
+| Option    | Description                         | Command                                        |
+| --------- | ----------------------------------- | ---------------------------------------------- |
+| `git-dir` | Path to git directory               | `cghooks ${command} --git-dir='/path/to/.git'` |
+| `global`  | Runs the specified command globally | `cghooks ${command} --global`                  |
+
+Each command also has a flag `-v` to control verbosity for more detailed logs. Currently, only one level is supported.
 
 ### Testing Hooks
 

cghooks

@@ -22,15 +22,14 @@ use BrainMaestro\GitHooks\Commands\ListCommand;
 use BrainMaestro\GitHooks\Commands\HookCommand;
 use Symfony\Component\Console\Application;
 
-$application = new Application('Composer Git Hooks', '2.4.5');
+$application = new Application('Composer Git Hooks', '2.5.0');
 
-$hooks = Hook::getValidHooks($dir);
-$application->add(new AddCommand($hooks));
-$application->add(new UpdateCommand($hooks));
-$application->add(new RemoveCommand($hooks));
-$application->add(new ListCommand($hooks));
+$application->add(new AddCommand());
+$application->add(new UpdateCommand());
+$application->add(new RemoveCommand());
+$application->add(new ListCommand());
 
-foreach ($hooks as $hook => $script) {
+foreach (Hook::getValidHooks($dir) as $hook => $script) {
     $application->add(new HookCommand($hook, $script));
 }
 

composer.json

@@ -49,7 +49,16 @@
     "extra": {
         "hooks": {
             "pre-commit": "composer check-style",
-            "pre-push": "composer test"
+            "pre-push": [
+                "composer test",
+                "appver=$(grep -o -P '\\d.\\d.\\d' cghooks)",
+                "tag=$(git tag --sort=-v:refname | head -n 1 | tr -d v)",
+                "if [ \"$tag\" != \"$appver\" ]; then",
+                "echo \"The most recent tag v$tag does not match the application version $appver\n\"",
+                "sed -i -E \"s/$appver/$tag/\" cghooks",
+                "exit 1",
+                "fi"
+            ]
         }
     }
 }

src/Commands/AddCommand.php

@@ -10,12 +10,13 @@
 
 class AddCommand extends Command
 {
-    private $force;
-    private $windows;
-    private $noLock;
-    private $ignoreLock;
     private $addedHooks = [];
 
+    protected $force;
+    protected $noLock;
+    protected $windows;
+    protected $ignoreLock;
+
     protected function configure()
     {
         $this
@@ -27,6 +28,7 @@ protected function configure()
             ->addOption('ignore-lock', 'i', InputOption::VALUE_NONE, 'Add the lock file to .gitignore')
             ->addOption('git-dir', 'g', InputOption::VALUE_REQUIRED, 'Path to git directory', '.git')
             ->addOption('force-win', null, InputOption::VALUE_NONE, 'Force windows bash compatibility')
+            ->addOption('global', null, InputOption::VALUE_NONE, 'Add global git hooks')
         ;
     }
 
@@ -40,7 +42,12 @@ protected function init($input)
 
     protected function command()
     {
-        create_hooks_dir($this->gitDir);
+        if (empty($this->dir)) {
+            $this->error('You did not specify a git directory to use');
+            return;
+        }
+
+        create_hooks_dir($this->dir);
 
         foreach ($this->hooks as $hook => $contents) {
             $this->addHook($hook, $contents);
@@ -53,11 +60,20 @@ protected function command()
 
         $this->addLockFile();
         $this->ignoreLockFile();
+        $this->setGlobalGitHooksPath();
+    }
+
+    protected function global_dir_fallback()
+    {
+        if (!empty($this->dir = trim(getenv('COMPOSER_HOME')))) {
+            $this->dir = realpath($this->dir);
+            $this->debug("No global git hook path was provided. Falling back to COMPOSER_HOME [{$this->dir}]");
+        }
     }
 
     private function addHook($hook, $contents)
     {
-        $filename = "{$this->gitDir}/hooks/{$hook}";
+        $filename = "{$this->dir}/hooks/{$hook}";
         $exists = file_exists($filename);
 
         // On windows, the shebang needs to point to bash
@@ -66,28 +82,28 @@ private function addHook($hook, $contents)
         $contents = is_array($contents) ? implode(PHP_EOL, $contents) : $contents;
 
         if (! $this->force && $exists) {
-            $this->comment("{$hook} already exists");
+            $this->debug("[{$hook}] already exists");
             return;
         }
 
-        file_put_contents($filename, $shebang . $contents);
+        file_put_contents($filename, $shebang . $contents . PHP_EOL);
         chmod($filename, 0755);
 
-        $operation = $exists ? 'Overwrote' : 'Added';
-        $this->log("{$operation} <info>{$hook}</info> hook");
+        $operation = $exists ? 'Updated' : 'Added';
+        $this->info("{$operation} [{$hook}] hook");
 
         $this->addedHooks[] = $hook;
     }
 
     private function addLockFile()
     {
         if ($this->noLock) {
-            $this->comment('Skipped creating a '. Hook::LOCK_FILE . ' file');
+            $this->debug("Skipped creating a [{$this->lockFile}] file");
             return;
         }
 
         file_put_contents(Hook::LOCK_FILE, json_encode($this->addedHooks));
-        $this->comment('Created ' . Hook::LOCK_FILE . ' file');
+        $this->debug("Created [{$this->lockFile}] file");
     }
 
     private function ignoreLockFile()
@@ -97,16 +113,48 @@ private function ignoreLockFile()
         }
 
         if (! $this->ignoreLock) {
-            $this->comment('Skipped adding '. Hook::LOCK_FILE . ' to .gitignore');
+            $this->debug("Skipped adding [{$this->lockFile}] to .gitignore");
             return;
         }
 
         $contents = file_get_contents('.gitignore');
-        $return = strpos($contents, Hook::LOCK_FILE);
+        $return = strpos($contents, $this->lockFile);
 
         if ($return === false) {
-            file_put_contents('.gitignore', Hook::LOCK_FILE . PHP_EOL, FILE_APPEND);
-            $this->comment('Added ' . Hook::LOCK_FILE . ' to .gitignore');
+            file_put_contents('.gitignore', $this->lockFile . PHP_EOL, FILE_APPEND);
+            $this->debug("Added [{$this->lockFile}] to .gitignore");
         }
     }
+
+    private function setGlobalGitHooksPath()
+    {
+        if (! $this->global) {
+            return;
+        }
+
+        $previousGlobalHookDir = global_hook_dir();
+        $globalHookDir = trim(realpath("{$this->dir}/hooks"));
+
+        if ($globalHookDir === $previousGlobalHookDir) {
+            return;
+        }
+
+        $this->info(
+            'About to modify global git hook path. '
+            . ($previousGlobalHookDir !== ''
+                ? "Previous value was [{$previousGlobalHookDir}]"
+                : 'There was no previous value')
+        );
+
+        $exitCode = 0;
+        passthru("git config --global core.hooksPath {$globalHookDir}", $exitCode);
+
+        if ($exitCode !== 0) {
+            $this->error("Could not set global git hook path.\n" .
+            " Try running this manually 'git config --global core.hooksPath {$globalHookDir}'");
+            return;
+        }
+
+        $this->info("Global git hook path set to [{$globalHookDir}]");
+    }
 }

src/Commands/Command.php

@@ -2,6 +2,7 @@
 
 namespace BrainMaestro\GitHooks\Commands;
 
+use BrainMaestro\GitHooks\Hook;
 use Symfony\Component\Console\Command\Command as SymfonyCommand;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
@@ -11,14 +12,11 @@ abstract class Command extends SymfonyCommand
 {
     private $output;
 
+    protected $dir;
     protected $hooks;
     protected $gitDir;
-
-    public function __construct($hooks)
-    {
-        $this->hooks = $hooks;
-        parent::__construct();
-    }
+    protected $global;
+    protected $lockFile;
 
     abstract protected function init($input);
     abstract protected function command();
@@ -27,22 +25,50 @@ final protected function execute(InputInterface $input, OutputInterface $output)
     {
         $this->output = $output;
         $this->gitDir = $input->getOption('git-dir');
+        $this->global = $input->getOption('global');
+        $this->lockFile = Hook::LOCK_FILE;
+        $this->dir = trim(
+            $this->global && $this->gitDir === '.git'
+                ? dirname(global_hook_dir())
+                : $this->gitDir
+        );
+
+        if ($this->global) {
+            if (empty($this->dir)) {
+                $this->global_dir_fallback();
+            }
+
+            $this->lockFile = $this->dir . '/' . Hook::LOCK_FILE;
+        }
+
+        $this->hooks = Hook::getValidHooks($this->global ? $this->dir : getcwd());
+
         $this->init($input);
         $this->command();
     }
 
-    protected function log($log)
+    protected function global_dir_fallback()
+    {
+    }
+
+    protected function info($info)
     {
-        $this->output->writeln($log);
+        $info = str_replace('[', '<info>', $info);
+        $info = str_replace(']', '</info>', $info);
+
+        $this->output->writeln($info);
     }
 
-    protected function comment($comment)
+    protected function debug($debug)
     {
-        $this->output->writeln("<comment>{$comment}</comment>");
+        $debug = str_replace('[', '<comment>', $debug);
+        $debug = str_replace(']', '</comment>', $debug);
+
+        $this->output->writeln($debug, OutputInterface::VERBOSITY_VERBOSE);
     }
 
     protected function error($error)
     {
-        $this->output->writeln("<error>{$error}</error>");
+        $this->output->writeln("<fg=red>{$error}</>");
     }
 }