Merge branch 'ab/config-based-hooks-2'

More "config-based hooks".

* ab/config-based-hooks-2:
  run-command: remove old run_hook_{le,ve}() hook API
  receive-pack: convert push-to-checkout hook to hook.h
  read-cache: convert post-index-change to use hook.h
  commit: convert {pre-commit,prepare-commit-msg} hook to hook.h
  git-p4: use 'git hook' to run hooks
  send-email: use 'git hook run' for 'sendemail-validate'
  git hook run: add an --ignore-missing flag
  hooks: convert worktree 'post-checkout' hook to hook library
  hooks: convert non-worktree 'post-checkout' hook to hook library
  merge: convert post-merge to use hook.h
  am: convert applypatch-msg to use hook.h
  rebase: convert pre-rebase to use hook.h
  hook API: add a run_hooks_l() wrapper
  am: convert {pre,post}-applypatch to use hook.h
  gc: use hook library for pre-auto-gc hook
  hook API: add a run_hooks() wrapper
  hook: add 'run' subcommand

diff --cc Makefile
Simple merge

diff --cc builtin/am.c
Simple merge

diff --cc builtin/checkout.c
Simple merge

diff --cc builtin/clone.c
Simple merge

diff --cc builtin/gc.c
Simple merge

diff --cc builtin/merge.c
Simple merge

diff --cc builtin/rebase.c
Simple merge

diff --cc builtin/receive-pack.c
Simple merge

diff --cc builtin/worktree.c
Simple merge

diff --cc commit.c
Simple merge

diff --cc git-p4.py
index 47ad2d6409356ca49c4965fc1be0bdf4c46e56c7,3b54168eb4a59e6c325fb34877dd2a3fde73b99d..a9b1f9044108e4dce94b865f1f777039d8755613
--- 1/git-p4.py
--- 2/git-p4.py
+++ b/git-p4.py
@@@ -220,76 -208,19 +220,18 @@@ def decode_path(path)
  
  def run_git_hook(cmd, param=[]):
      """Execute a hook if the hook exists."""
-     if verbose:
-         sys.stderr.write("Looking for hook: %s\n" % cmd)
-         sys.stderr.flush()
- 
-     hooks_path = gitConfig("core.hooksPath")
-     if len(hooks_path) <= 0:
-         hooks_path = os.path.join(os.environ["GIT_DIR"], "hooks")
- 
-     if not isinstance(param, list):
-         param=[param]
- 
-     # resolve hook file name, OS depdenent
-     hook_file = os.path.join(hooks_path, cmd)
-     if platform.system() == 'Windows':
-         if not os.path.isfile(hook_file):
-             # look for the file with an extension
-             files = glob.glob(hook_file + ".*")
-             if not files:
-                 return True
-             files.sort()
-             hook_file = files.pop()
-             while hook_file.upper().endswith(".SAMPLE"):
-                 # The file is a sample hook. We don't want it
-                 if len(files) > 0:
-                     hook_file = files.pop()
-                 else:
-                     return True
- 
-     if not os.path.isfile(hook_file) or not os.access(hook_file, os.X_OK):
-         return True
- 
-     return run_hook_command(hook_file, param) == 0
- 
- def run_hook_command(cmd, param):
-     """Executes a git hook command
-        cmd = the command line file to be executed. This can be
-        a file that is run by OS association.
- 
-        param = a list of parameters to pass to the cmd command
- 
-        On windows, the extension is checked to see if it should
-        be run with the Git for Windows Bash shell.  If there
-        is no file extension, the file is deemed a bash shell
-        and will be handed off to sh.exe. Otherwise, Windows
-        will be called with the shell to handle the file assocation.
- 
-        For non Windows operating systems, the file is called
-        as an executable.
-     """
-     cli = [cmd] + param
-     use_shell = False
-     if platform.system() == 'Windows':
-         (root,ext) = os.path.splitext(cmd)
-         if ext == "":
-             exe_path = os.environ.get("EXEPATH")
-             if exe_path is None:
-                 exe_path = ""
-             else:
-                 exe_path = os.path.join(exe_path, "bin")
-             cli = [os.path.join(exe_path, "SH.EXE")] + cli
-         else:
-             use_shell = True
-     return subprocess.call(cli, shell=use_shell)
- 
+     args = ['git', 'hook', 'run', '--ignore-missing', cmd]
+     if param:
+         args.append("--")
+         for p in param:
+             args.append(p)
+     return subprocess.call(args) == 0
  
 -def write_pipe(c, stdin):
 +def write_pipe(c, stdin, *k, **kw):
      if verbose:
 -        sys.stderr.write('Writing pipe: %s\n' % str(c))
 +        sys.stderr.write('Writing pipe: {}\n'.format(' '.join(c)))
  
 -    expand = not isinstance(c, list)
 -    p = subprocess.Popen(c, stdin=subprocess.PIPE, shell=expand)
 +    p = subprocess.Popen(c, stdin=subprocess.PIPE, *k, **kw)
      pipe = p.stdin
      val = pipe.write(stdin)
      pipe.close()

diff --cc git.c
Simple merge

diff --cc read-cache.c
Simple merge

diff --cc run-command.c
Simple merge