freshlybakedca.ke
Git fork
1githooks(5)
2===========
3
4NAME
5----
6githooks - Hooks used by Git
7
8SYNOPSIS
9--------
10$GIT_DIR/hooks/* (or \`git config core.hooksPath`/*)
11
12
13DESCRIPTION
14-----------
15
16Hooks are programs you can place in a hooks directory to trigger
17actions at certain points in git's execution. Hooks that don't have
18the executable bit set are ignored.
19
20By default the hooks directory is `$GIT_DIR/hooks`, but that can be
21changed via the `core.hooksPath` configuration variable (see
22linkgit:git-config[1]).
23
24Before Git invokes a hook, it changes its working directory to either
25$GIT_DIR in a bare repository or the root of the working tree in a non-bare
26repository. An exception are hooks triggered during a push ('pre-receive',
27'update', 'post-receive', 'post-update', 'push-to-checkout') which are always
28executed in $GIT_DIR.
29
30Environment variables, such as `GIT_DIR`, `GIT_WORK_TREE`, etc., are exported
31so that Git commands run by the hook can correctly locate the repository. If
32your hook needs to invoke Git commands in a foreign repository or in a
33different working tree of the same repository, then it should clear these
34environment variables so they do not interfere with Git operations at the
35foreign location. For example:
36
37------------
38local_desc=$(git describe)
39foreign_desc=$(unset $(git rev-parse --local-env-vars); git -C ../foreign-repo describe)
40------------
41
42Hooks can get their arguments via the environment, command-line
43arguments, and stdin. See the documentation for each hook below for
44details.
45
46`git init` may copy hooks to the new repository, depending on its
47configuration. See the "TEMPLATE DIRECTORY" section in
48linkgit:git-init[1] for details. When the rest of this document refers
49to "default hooks" it's talking about the default template shipped
50with Git.
51
52The currently supported hooks are described below.
53
54HOOKS
55-----
56
57applypatch-msg
58~~~~~~~~~~~~~~
59
60This hook is invoked by linkgit:git-am[1]. It takes a single
61parameter, the name of the file that holds the proposed commit
62log message. Exiting with a non-zero status causes `git am` to abort
63before applying the patch.
64
65The hook is allowed to edit the message file in place, and can
66be used to normalize the message into some project standard
67format. It can also be used to refuse the commit after inspecting
68the message file.
69
70The default 'applypatch-msg' hook, when enabled, runs the
71'commit-msg' hook, if the latter is enabled.
72
73pre-applypatch
74~~~~~~~~~~~~~~
75
76This hook is invoked by linkgit:git-am[1]. It takes no parameter, and is
77invoked after the patch is applied, but before a commit is made.
78
79If it exits with non-zero status, then the working tree will not be
80committed after applying the patch.
81
82It can be used to inspect the current working tree and refuse to
83make a commit if it does not pass certain tests.
84
85The default 'pre-applypatch' hook, when enabled, runs the
86'pre-commit' hook, if the latter is enabled.
87
88post-applypatch
89~~~~~~~~~~~~~~~
90
91This hook is invoked by linkgit:git-am[1]. It takes no parameter,
92and is invoked after the patch is applied and a commit is made.
93
94This hook is meant primarily for notification, and cannot affect
95the outcome of `git am`.
96
97pre-commit
98~~~~~~~~~~
99
100This hook is invoked by linkgit:git-commit[1], and can be bypassed
101with the `--no-verify` option. It takes no parameters, and is
102invoked before obtaining the proposed commit log message and
103making a commit. Exiting with a non-zero status from this script
104causes the `git commit` command to abort before creating a commit.
105
106The default 'pre-commit' hook, when enabled, catches introduction
107of lines with trailing whitespaces and aborts the commit when
108such a line is found.
109
110All the `git commit` hooks are invoked with the environment
111variable `GIT_EDITOR=:` if the command will not bring up an editor
112to modify the commit message.
113
114The default 'pre-commit' hook, when enabled--and with the
115`hooks.allownonascii` config option unset or set to false--prevents
116the use of non-ASCII filenames.
117
118pre-merge-commit
119~~~~~~~~~~~~~~~~
120
121This hook is invoked by linkgit:git-merge[1], and can be bypassed
122with the `--no-verify` option. It takes no parameters, and is
123invoked after the merge has been carried out successfully and before
124obtaining the proposed commit log message to
125make a commit. Exiting with a non-zero status from this script
126causes the `git merge` command to abort before creating a commit.
127
128The default 'pre-merge-commit' hook, when enabled, runs the
129'pre-commit' hook, if the latter is enabled.
130
131This hook is invoked with the environment variable
132`GIT_EDITOR=:` if the command will not bring up an editor
133to modify the commit message.
134
135If the merge cannot be carried out automatically, the conflicts
136need to be resolved and the result committed separately (see
137linkgit:git-merge[1]). At that point, this hook will not be executed,
138but the 'pre-commit' hook will, if it is enabled.
139
140prepare-commit-msg
141~~~~~~~~~~~~~~~~~~
142
143This hook is invoked by linkgit:git-commit[1] right after preparing the
144default log message, and before the editor is started.
145
146It takes one to three parameters. The first is the name of the file
147that contains the commit log message. The second is the source of the commit
148message, and can be: `message` (if a `-m` or `-F` option was
149given); `template` (if a `-t` option was given or the
150configuration option `commit.template` is set); `merge` (if the
151commit is a merge or a `.git/MERGE_MSG` file exists); `squash`
152(if a `.git/SQUASH_MSG` file exists); or `commit`, followed by
153a commit object name (if a `-c`, `-C` or `--amend` option was given).
154
155If the exit status is non-zero, `git commit` will abort.
156
157The purpose of the hook is to edit the message file in place, and
158it is not suppressed by the `--no-verify` option. A non-zero exit
159means a failure of the hook and aborts the commit. It should not
160be used as a replacement for the pre-commit hook.
161
162The sample `prepare-commit-msg` hook that comes with Git removes the
163help message found in the commented portion of the commit template.
164
165commit-msg
166~~~~~~~~~~
167
168This hook is invoked by linkgit:git-commit[1] and linkgit:git-merge[1], and can be
169bypassed with the `--no-verify` option. It takes a single parameter,
170the name of the file that holds the proposed commit log message.
171Exiting with a non-zero status causes the command to abort.
172
173The hook is allowed to edit the message file in place, and can be used
174to normalize the message into some project standard format. It
175can also be used to refuse the commit after inspecting the message
176file.
177
178The default 'commit-msg' hook, when enabled, detects duplicate
179`Signed-off-by` trailers, and aborts the commit if one is found.
180
181post-commit
182~~~~~~~~~~~
183
184This hook is invoked by linkgit:git-commit[1]. It takes no parameters, and is
185invoked after a commit is made.
186
187This hook is meant primarily for notification, and cannot affect
188the outcome of `git commit`.
189
190pre-rebase
191~~~~~~~~~~
192
193This hook is called by linkgit:git-rebase[1] and can be used to prevent a
194branch from getting rebased. The hook may be called with one or
195two parameters. The first parameter is the upstream from which
196the series was forked. The second parameter is the branch being
197rebased, and is not set when rebasing the current branch.
198
199post-checkout
200~~~~~~~~~~~~~
201
202This hook is invoked when a linkgit:git-checkout[1] or
203linkgit:git-switch[1] is run after having updated the
204worktree. The hook is given three parameters: the ref of the previous HEAD,
205the ref of the new HEAD (which may or may not have changed), and a flag
206indicating whether the checkout was a branch checkout (changing branches,
207flag=1) or a file checkout (retrieving a file from the index, flag=0).
208This hook cannot affect the outcome of `git switch` or `git checkout`,
209other than that the hook's exit status becomes the exit status of
210these two commands.
211
212It is also run after linkgit:git-clone[1], unless the `--no-checkout` (`-n`) option is
213used. The first parameter given to the hook is the null-ref, the second the
214ref of the new HEAD and the flag is always 1. Likewise for `git worktree add`
215unless `--no-checkout` is used.
216
217This hook can be used to perform repository validity checks, auto-display
218differences from the previous HEAD if different, or set working dir metadata
219properties.
220
221post-merge
222~~~~~~~~~~
223
224This hook is invoked by linkgit:git-merge[1], which happens when a `git pull`
225is done on a local repository. The hook takes a single parameter, a status
226flag specifying whether or not the merge being done was a squash merge.
227This hook cannot affect the outcome of `git merge` and is not executed,
228if the merge failed due to conflicts.
229
230This hook can be used in conjunction with a corresponding pre-commit hook to
231save and restore any form of metadata associated with the working tree
232(e.g.: permissions/ownership, ACLS, etc). See contrib/hooks/setgitperms.perl
233for an example of how to do this.
234
235pre-push
236~~~~~~~~
237
238This hook is called by linkgit:git-push[1] and can be used to prevent
239a push from taking place. The hook is called with two parameters
240which provide the name and location of the destination remote, if a
241named remote is not being used both values will be the same.
242
243Information about what is to be pushed is provided on the hook's standard
244input with lines of the form:
245
246 <local-ref> SP <local-object-name> SP <remote-ref> SP <remote-object-name> LF
247
248For instance, if the command +git push origin master:foreign+ were run the
249hook would receive a line like the following:
250
251 refs/heads/master 67890 refs/heads/foreign 12345
252
253although the full object name would be supplied. If the foreign ref does not
254yet exist the `<remote-object-name>` will be the all-zeroes object name. If a
255ref is to be deleted, the `<local-ref>` will be supplied as `(delete)` and the
256`<local-object-name>` will be the all-zeroes object name. If the local commit
257was specified by something other than a name which could be expanded (such as
258`HEAD~`, or an object name) it will be supplied as it was originally given.
259
260If this hook exits with a non-zero status, `git push` will abort without
261pushing anything. Information about why the push is rejected may be sent
262to the user by writing to standard error.
263
264[[pre-receive]]
265pre-receive
266~~~~~~~~~~~
267
268This hook is invoked by linkgit:git-receive-pack[1] when it reacts to
269`git push` and updates reference(s) in its repository.
270Just before starting to update refs on the remote repository, the
271pre-receive hook is invoked. Its exit status determines the success
272or failure of the update.
273
274This hook executes once for the receive operation. It takes no
275arguments, but for each ref to be updated it receives on standard
276input a line of the format:
277
278 <old-oid> SP <new-oid> SP <ref-name> LF
279
280where `<old-oid>` is the old object name stored in the ref,
281`<new-oid>` is the new object name to be stored in the ref and
282`<ref-name>` is the full name of the ref.
283When creating a new ref, `<old-oid>` is the all-zeroes object name.
284
285If the hook exits with non-zero status, none of the refs will be
286updated. If the hook exits with zero, updating of individual refs can
287still be prevented by the <<update,'update'>> hook.
288
289Both standard output and standard error output are forwarded to
290`git send-pack` on the other end, so you can simply `echo` messages
291for the user.
292
293The number of push options given on the command line of
294`git push --push-option=...` can be read from the environment
295variable `GIT_PUSH_OPTION_COUNT`, and the options themselves are
296found in `GIT_PUSH_OPTION_0`, `GIT_PUSH_OPTION_1`,...
297If it is negotiated to not use the push options phase, the
298environment variables will not be set. If the client selects
299to use push options, but doesn't transmit any, the count variable
300will be set to zero, `GIT_PUSH_OPTION_COUNT=0`.
301
302See the section on "Quarantine Environment" in
303linkgit:git-receive-pack[1] for some caveats.
304
305[[update]]
306update
307~~~~~~
308
309This hook is invoked by linkgit:git-receive-pack[1] when it reacts to
310`git push` and updates reference(s) in its repository.
311Just before updating the ref on the remote repository, the update hook
312is invoked. Its exit status determines the success or failure of
313the ref update.
314
315The hook executes once for each ref to be updated, and takes
316three parameters:
317
318 - the name of the ref being updated,
319 - the old object name stored in the ref,
320 - and the new object name to be stored in the ref.
321
322A zero exit from the update hook allows the ref to be updated.
323Exiting with a non-zero status prevents `git receive-pack`
324from updating that ref.
325
326This hook can be used to prevent 'forced' update on certain refs by
327making sure that the object name is a commit object that is a
328descendant of the commit object named by the old object name.
329That is, to enforce a "fast-forward only" policy.
330
331It could also be used to log the old..new status. However, it
332does not know the entire set of branches, so it would end up
333firing one e-mail per ref when used naively, though. The
334<<post-receive,'post-receive'>> hook is more suited to that.
335
336In an environment that restricts the users' access only to git
337commands over the wire, this hook can be used to implement access
338control without relying on filesystem ownership and group
339membership. See linkgit:git-shell[1] for how you might use the login
340shell to restrict the user's access to only git commands.
341
342Both standard output and standard error output are forwarded to
343`git send-pack` on the other end, so you can simply `echo` messages
344for the user.
345
346The default 'update' hook, when enabled--and with
347`hooks.allowunannotated` config option unset or set to false--prevents
348unannotated tags from being pushed.
349
350[[proc-receive]]
351proc-receive
352~~~~~~~~~~~~
353
354This hook is invoked by linkgit:git-receive-pack[1]. If the server has
355set the multi-valued config variable `receive.procReceiveRefs`, and the
356commands sent to 'receive-pack' have matching reference names, these
357commands will be executed by this hook, instead of by the internal
358`execute_commands()` function. This hook is responsible for updating
359the relevant references and reporting the results back to 'receive-pack'.
360
361This hook executes once for the receive operation. It takes no
362arguments, but uses a pkt-line format protocol to communicate with
363'receive-pack' to read commands, push-options and send results. In the
364following example for the protocol, the letter 'S' stands for
365'receive-pack' and the letter 'H' stands for this hook.
366
367 # Version and features negotiation.
368 S: PKT-LINE(version=1\0push-options atomic...)
369 S: flush-pkt
370 H: PKT-LINE(version=1\0push-options...)
371 H: flush-pkt
372
373 # Send commands from server to the hook.
374 S: PKT-LINE(<old-oid> <new-oid> <ref>)
375 S: ... ...
376 S: flush-pkt
377 # Send push-options only if the 'push-options' feature is enabled.
378 S: PKT-LINE(push-option)
379 S: ... ...
380 S: flush-pkt
381
382 # Receive results from the hook.
383 # OK, run this command successfully.
384 H: PKT-LINE(ok <ref>)
385 # NO, I reject it.
386 H: PKT-LINE(ng <ref> <reason>)
387 # Fall through, let 'receive-pack' execute it.
388 H: PKT-LINE(ok <ref>)
389 H: PKT-LINE(option fall-through)
390 # OK, but has an alternate reference. The alternate reference name
391 # and other status can be given in option directives.
392 H: PKT-LINE(ok <ref>)
393 H: PKT-LINE(option refname <refname>)
394 H: PKT-LINE(option old-oid <old-oid>)
395 H: PKT-LINE(option new-oid <new-oid>)
396 H: PKT-LINE(option forced-update)
397 H: ... ...
398 H: flush-pkt
399
400Each command for the 'proc-receive' hook may point to a pseudo-reference
401and always has a zero-old as its old-oid, while the 'proc-receive' hook
402may update an alternate reference and the alternate reference may exist
403already with a non-zero old-oid. For this case, this hook will use
404"option" directives to report extended attributes for the reference given
405by the leading "ok" directive.
406
407The report of the commands of this hook should have the same order as
408the input. The exit status of the 'proc-receive' hook only determines
409the success or failure of the group of commands sent to it, unless
410atomic push is in use.
411
412[[post-receive]]
413post-receive
414~~~~~~~~~~~~
415
416This hook is invoked by linkgit:git-receive-pack[1] when it reacts to
417`git push` and updates reference(s) in its repository.
418The hook executes on the remote repository once after all the proposed
419ref updates are processed and if at least one ref is updated as the
420result.
421
422The hook takes no arguments. It receives one line on standard input for
423each ref that is successfully updated following the same format as the
424<<pre-receive,'pre-receive'>> hook.
425
426This hook does not affect the outcome of `git receive-pack`, as it
427is called after the real work is done.
428
429This supersedes the <<post-update,'post-update'>> hook in that it gets
430both old and new values of all the refs in addition to their
431names.
432
433Both standard output and standard error output are forwarded to
434`git send-pack` on the other end, so you can simply `echo` messages
435for the user.
436
437The default 'post-receive' hook is empty, but there is
438a sample script `post-receive-email` provided in the `contrib/hooks`
439directory in Git distribution, which implements sending commit
440emails.
441
442The number of push options given on the command line of
443`git push --push-option=...` can be read from the environment
444variable `GIT_PUSH_OPTION_COUNT`, and the options themselves are
445found in `GIT_PUSH_OPTION_0`, `GIT_PUSH_OPTION_1`,...
446If it is negotiated to not use the push options phase, the
447environment variables will not be set. If the client selects
448to use push options, but doesn't transmit any, the count variable
449will be set to zero, `GIT_PUSH_OPTION_COUNT=0`.
450
451See the "post-receive" section in linkgit:git-receive-pack[1] for
452additional details.
453
454[[post-update]]
455post-update
456~~~~~~~~~~~
457
458This hook is invoked by linkgit:git-receive-pack[1] when it reacts to
459`git push` and updates reference(s) in its repository.
460It executes on the remote repository once after all the refs have
461been updated.
462
463It takes a variable number of parameters, each of which is the
464name of ref that was actually updated.
465
466This hook is meant primarily for notification, and cannot affect
467the outcome of `git receive-pack`.
468
469The 'post-update' hook can tell what are the heads that were pushed,
470but it does not know what their original and updated values are,
471so it is a poor place to do log old..new. The
472<<post-receive,'post-receive'>> hook does get both original and
473updated values of the refs. You might consider it instead if you need
474them.
475
476When enabled, the default 'post-update' hook runs
477`git update-server-info` to keep the information used by dumb
478transports (e.g., HTTP) up to date. If you are publishing
479a Git repository that is accessible via HTTP, you should
480probably enable this hook.
481
482Both standard output and standard error output are forwarded to
483`git send-pack` on the other end, so you can simply `echo` messages
484for the user.
485
486reference-transaction
487~~~~~~~~~~~~~~~~~~~~~
488
489This hook is invoked by any Git command that performs reference
490updates. It executes whenever a reference transaction is prepared,
491committed or aborted and may thus get called multiple times. The hook
492also supports symbolic reference updates.
493
494The hook takes exactly one argument, which is the current state the
495given reference transaction is in:
496
497 - "prepared": All reference updates have been queued to the
498 transaction and references were locked on disk.
499
500 - "committed": The reference transaction was committed and all
501 references now have their respective new value.
502
503 - "aborted": The reference transaction was aborted, no changes
504 were performed and the locks have been released.
505
506For each reference update that was added to the transaction, the hook
507receives on standard input a line of the format:
508
509 <old-value> SP <new-value> SP <ref-name> LF
510
511where `<old-value>` is the old object name passed into the reference
512transaction, `<new-value>` is the new object name to be stored in the
513ref and `<ref-name>` is the full name of the ref. When force updating
514the reference regardless of its current value or when the reference is
515to be created anew, `<old-value>` is the all-zeroes object name. To
516distinguish these cases, you can inspect the current value of
517`<ref-name>` via `git rev-parse`.
518
519For symbolic reference updates the `<old_value>` and `<new-value>`
520fields could denote references instead of objects. A reference will be
521denoted with a 'ref:' prefix, like `ref:<ref-target>`.
522
523The exit status of the hook is ignored for any state except for the
524"prepared" state. In the "prepared" state, a non-zero exit status will
525cause the transaction to be aborted. The hook will not be called with
526"aborted" state in that case.
527
528push-to-checkout
529~~~~~~~~~~~~~~~~
530
531This hook is invoked by linkgit:git-receive-pack[1] when it reacts to
532`git push` and updates reference(s) in its repository, and when
533the push tries to update the branch that is currently checked out
534and the `receive.denyCurrentBranch` configuration variable is set to
535`updateInstead`. Such a push by default is refused if the working
536tree and the index of the remote repository has any difference from
537the currently checked out commit; when both the working tree and the
538index match the current commit, they are updated to match the newly
539pushed tip of the branch. This hook is to be used to override the
540default behaviour.
541
542The hook receives the commit with which the tip of the current
543branch is going to be updated. It can exit with a non-zero status
544to refuse the push (when it does so, it must not modify the index or
545the working tree). Or it can make any necessary changes to the
546working tree and to the index to bring them to the desired state
547when the tip of the current branch is updated to the new commit, and
548exit with a zero status.
549
550For example, the hook can simply run `git read-tree -u -m HEAD "$1"`
551in order to emulate `git fetch` that is run in the reverse direction
552with `git push`, as the two-tree form of `git read-tree -u -m` is
553essentially the same as `git switch` or `git checkout`
554that switches branches while
555keeping the local changes in the working tree that do not interfere
556with the difference between the branches.
557
558
559pre-auto-gc
560~~~~~~~~~~~
561
562This hook is invoked by `git gc --auto` (see linkgit:git-gc[1]). It
563takes no parameter, and exiting with non-zero status from this script
564causes the `git gc --auto` to abort.
565
566post-rewrite
567~~~~~~~~~~~~
568
569This hook is invoked by commands that rewrite commits
570(linkgit:git-commit[1] when called with `--amend` and
571linkgit:git-rebase[1]; however, full-history (re)writing tools like
572linkgit:git-fast-import[1] or
573https://github.com/newren/git-filter-repo[git-filter-repo] typically
574do not call it!). Its first argument denotes the command it was
575invoked by: currently one of `amend` or `rebase`. Further
576command-dependent arguments may be passed in the future.
577
578The hook receives a list of the rewritten commits on stdin, in the
579format
580
581 <old-object-name> SP <new-object-name> [ SP <extra-info> ] LF
582
583The 'extra-info' is again command-dependent. If it is empty, the
584preceding SP is also omitted. Currently, no commands pass any
585'extra-info'.
586
587The hook always runs after the automatic note copying (see
588"notes.rewrite.<command>" in linkgit:git-config[1]) has happened, and
589thus has access to these notes.
590
591The following command-specific comments apply:
592
593rebase::
594 For the 'squash' and 'fixup' operation, all commits that were
595 squashed are listed as being rewritten to the squashed commit.
596 This means that there will be several lines sharing the same
597 'new-object-name'.
598+
599The commits are guaranteed to be listed in the order that they were
600processed by rebase.
601
602sendemail-validate
603~~~~~~~~~~~~~~~~~~
604
605This hook is invoked by linkgit:git-send-email[1].
606
607It takes these command line arguments. They are,
6081. the name of the file which holds the contents of the email to be sent.
6092. The name of the file which holds the SMTP headers of the email.
610
611The SMTP headers are passed in the exact same way as they are passed to the
612user's Mail Transport Agent (MTA). In effect, the email given to the user's
613MTA, is the contents of $2 followed by the contents of $1.
614
615An example of a few common headers is shown below. Take notice of the
616capitalization and multi-line tab structure.
617
618 From: Example <from@example.com>
619 To: to@example.com
620 Cc: cc@example.com,
621 A <author@example.com>,
622 One <one@example.com>,
623 two@example.com
624 Subject: PATCH-STRING
625
626Exiting with a non-zero status causes `git send-email` to abort
627before sending any e-mails.
628
629The following environment variables are set when executing the hook.
630
631`GIT_SENDEMAIL_FILE_COUNTER`::
632 A 1-based counter incremented by one for every file holding an e-mail
633 to be sent (excluding any FIFOs). This counter does not follow the
634 patch series counter scheme. It will always start at 1 and will end at
635 GIT_SENDEMAIL_FILE_TOTAL.
636
637`GIT_SENDEMAIL_FILE_TOTAL`::
638 The total number of files that will be sent (excluding any FIFOs). This
639 counter does not follow the patch series counter scheme. It will always
640 be equal to the number of files being sent, whether there is a cover
641 letter or not.
642
643These variables may for instance be used to validate patch series.
644
645The sample `sendemail-validate` hook that comes with Git checks that all sent
646patches (excluding the cover letter) can be applied on top of the upstream
647repository default branch without conflicts. Some placeholders are left for
648additional validation steps to be performed after all patches of a given series
649have been applied.
650
651fsmonitor-watchman
652~~~~~~~~~~~~~~~~~~
653
654This hook is invoked when the configuration option `core.fsmonitor` is
655set to `.git/hooks/fsmonitor-watchman` or `.git/hooks/fsmonitor-watchmanv2`
656depending on the version of the hook to use.
657
658Version 1 takes two arguments, a version (1) and the time in elapsed
659nanoseconds since midnight, January 1, 1970.
660
661Version 2 takes two arguments, a version (2) and a token that is used
662for identifying changes since the token. For watchman this would be
663a clock id. This version must output to stdout the new token followed
664by a NUL before the list of files.
665
666The hook should output to stdout the list of all files in the working
667directory that may have changed since the requested time. The logic
668should be inclusive so that it does not miss any potential changes.
669The paths should be relative to the root of the working directory
670and be separated by a single NUL.
671
672It is OK to include files which have not actually changed. All changes
673including newly-created and deleted files should be included. When
674files are renamed, both the old and the new name should be included.
675
676Git will limit what files it checks for changes as well as which
677directories are checked for untracked files based on the path names
678given.
679
680An optimized way to tell git "all files have changed" is to return
681the filename `/`.
682
683The exit status determines whether git will use the data from the
684hook to limit its search. On error, it will fall back to verifying
685all files and folders.
686
687p4-changelist
688~~~~~~~~~~~~~
689
690This hook is invoked by `git-p4 submit`.
691
692The `p4-changelist` hook is executed after the changelist
693message has been edited by the user. It can be bypassed with the
694`--no-verify` option. It takes a single parameter, the name
695of the file that holds the proposed changelist text. Exiting
696with a non-zero status causes the command to abort.
697
698The hook is allowed to edit the changelist file and can be used
699to normalize the text into some project standard format. It can
700also be used to refuse the Submit after inspect the message file.
701
702Run `git-p4 submit --help` for details.
703
704p4-prepare-changelist
705~~~~~~~~~~~~~~~~~~~~~
706
707This hook is invoked by `git-p4 submit`.
708
709The `p4-prepare-changelist` hook is executed right after preparing
710the default changelist message and before the editor is started.
711It takes one parameter, the name of the file that contains the
712changelist text. Exiting with a non-zero status from the script
713will abort the process.
714
715The purpose of the hook is to edit the message file in place,
716and it is not suppressed by the `--no-verify` option. This hook
717is called even if `--prepare-p4-only` is set.
718
719Run `git-p4 submit --help` for details.
720
721p4-post-changelist
722~~~~~~~~~~~~~~~~~~
723
724This hook is invoked by `git-p4 submit`.
725
726The `p4-post-changelist` hook is invoked after the submit has
727successfully occurred in P4. It takes no parameters and is meant
728primarily for notification and cannot affect the outcome of the
729git p4 submit action.
730
731Run `git-p4 submit --help` for details.
732
733p4-pre-submit
734~~~~~~~~~~~~~
735
736This hook is invoked by `git-p4 submit`. It takes no parameters and nothing
737from standard input. Exiting with non-zero status from this script prevent
738`git-p4 submit` from launching. It can be bypassed with the `--no-verify`
739command line option. Run `git-p4 submit --help` for details.
740
741
742
743post-index-change
744~~~~~~~~~~~~~~~~~
745
746This hook is invoked when the index is written in read-cache.c
747do_write_locked_index.
748
749The first parameter passed to the hook is the indicator for the
750working directory being updated. "1" meaning working directory
751was updated or "0" when the working directory was not updated.
752
753The second parameter passed to the hook is the indicator for whether
754or not the index was updated and the skip-worktree bit could have
755changed. "1" meaning skip-worktree bits could have been updated
756and "0" meaning they were not.
757
758Only one parameter should be set to "1" when the hook runs. The hook
759running passing "1", "1" should not be possible.
760
761SEE ALSO
762--------
763linkgit:git-hook[1]
764
765GIT
766---
767Part of the linkgit:git[1] suite