Expand documentation describing --signoff
[git/git.git] / Documentation / git-commit.txt
1 git-commit(1)
2 =============
3
4 NAME
5 ----
6 git-commit - Record changes to the repository
7
8 SYNOPSIS
9 --------
10 [verse]
11 'git commit' [-a | --interactive | --patch] [-s] [-v] [-u<mode>] [--amend]
12 [--dry-run] [(-c | -C | --fixup | --squash) <commit>]
13 [-F <file> | -m <msg>] [--reset-author] [--allow-empty]
14 [--allow-empty-message] [--no-verify] [-e] [--author=<author>]
15 [--date=<date>] [--cleanup=<mode>] [--[no-]status]
16 [-i | -o] [-S[<keyid>]] [--] [<file>...]
17
18 DESCRIPTION
19 -----------
20 Stores the current contents of the index in a new commit along
21 with a log message from the user describing the changes.
22
23 The content to be added can be specified in several ways:
24
25 1. by using 'git add' to incrementally "add" changes to the
26 index before using the 'commit' command (Note: even modified
27 files must be "added");
28
29 2. by using 'git rm' to remove files from the working tree
30 and the index, again before using the 'commit' command;
31
32 3. by listing files as arguments to the 'commit' command, in which
33 case the commit will ignore changes staged in the index, and instead
34 record the current content of the listed files (which must already
35 be known to Git);
36
37 4. by using the -a switch with the 'commit' command to automatically
38 "add" changes from all known files (i.e. all files that are already
39 listed in the index) and to automatically "rm" files in the index
40 that have been removed from the working tree, and then perform the
41 actual commit;
42
43 5. by using the --interactive or --patch switches with the 'commit' command
44 to decide one by one which files or hunks should be part of the commit,
45 before finalizing the operation. See the ``Interactive Mode'' section of
46 linkgit:git-add[1] to learn how to operate these modes.
47
48 The `--dry-run` option can be used to obtain a
49 summary of what is included by any of the above for the next
50 commit by giving the same set of parameters (options and paths).
51
52 If you make a commit and then find a mistake immediately after
53 that, you can recover from it with 'git reset'.
54
55
56 OPTIONS
57 -------
58 -a::
59 --all::
60 Tell the command to automatically stage files that have
61 been modified and deleted, but new files you have not
62 told Git about are not affected.
63
64 -p::
65 --patch::
66 Use the interactive patch selection interface to chose
67 which changes to commit. See linkgit:git-add[1] for
68 details.
69
70 -C <commit>::
71 --reuse-message=<commit>::
72 Take an existing commit object, and reuse the log message
73 and the authorship information (including the timestamp)
74 when creating the commit.
75
76 -c <commit>::
77 --reedit-message=<commit>::
78 Like '-C', but with '-c' the editor is invoked, so that
79 the user can further edit the commit message.
80
81 --fixup=<commit>::
82 Construct a commit message for use with `rebase --autosquash`.
83 The commit message will be the subject line from the specified
84 commit with a prefix of "fixup! ". See linkgit:git-rebase[1]
85 for details.
86
87 --squash=<commit>::
88 Construct a commit message for use with `rebase --autosquash`.
89 The commit message subject line is taken from the specified
90 commit with a prefix of "squash! ". Can be used with additional
91 commit message options (`-m`/`-c`/`-C`/`-F`). See
92 linkgit:git-rebase[1] for details.
93
94 --reset-author::
95 When used with -C/-c/--amend options, or when committing after a
96 a conflicting cherry-pick, declare that the authorship of the
97 resulting commit now belongs to the committer. This also renews
98 the author timestamp.
99
100 --short::
101 When doing a dry-run, give the output in the short-format. See
102 linkgit:git-status[1] for details. Implies `--dry-run`.
103
104 --branch::
105 Show the branch and tracking info even in short-format.
106
107 --porcelain::
108 When doing a dry-run, give the output in a porcelain-ready
109 format. See linkgit:git-status[1] for details. Implies
110 `--dry-run`.
111
112 --long::
113 When doing a dry-run, give the output in a the long-format.
114 Implies `--dry-run`.
115
116 -z::
117 --null::
118 When showing `short` or `porcelain` status output, terminate
119 entries in the status output with NUL, instead of LF. If no
120 format is given, implies the `--porcelain` output format.
121
122 -F <file>::
123 --file=<file>::
124 Take the commit message from the given file. Use '-' to
125 read the message from the standard input.
126
127 --author=<author>::
128 Override the commit author. Specify an explicit author using the
129 standard `A U Thor <author@example.com>` format. Otherwise <author>
130 is assumed to be a pattern and is used to search for an existing
131 commit by that author (i.e. rev-list --all -i --author=<author>);
132 the commit author is then copied from the first such commit found.
133
134 --date=<date>::
135 Override the author date used in the commit.
136
137 -m <msg>::
138 --message=<msg>::
139 Use the given <msg> as the commit message.
140 If multiple `-m` options are given, their values are
141 concatenated as separate paragraphs.
142
143 -t <file>::
144 --template=<file>::
145 When editing the commit message, start the editor with the
146 contents in the given file. The `commit.template` configuration
147 variable is often used to give this option implicitly to the
148 command. This mechanism can be used by projects that want to
149 guide participants with some hints on what to write in the message
150 in what order. If the user exits the editor without editing the
151 message, the commit is aborted. This has no effect when a message
152 is given by other means, e.g. with the `-m` or `-F` options.
153
154 -s::
155 --signoff::
156 Add Signed-off-by line by the committer at the end of the commit
157 log message. The meaning of a signoff depends on the project,
158 but it typically certifies that committer has
159 the rights to submit this work under the same license and
160 agrees to a Developer Certificate of Origin
161 (see http://developercertificate.org/ for more information).
162
163 -n::
164 --no-verify::
165 This option bypasses the pre-commit and commit-msg hooks.
166 See also linkgit:githooks[5].
167
168 --allow-empty::
169 Usually recording a commit that has the exact same tree as its
170 sole parent commit is a mistake, and the command prevents you
171 from making such a commit. This option bypasses the safety, and
172 is primarily for use by foreign SCM interface scripts.
173
174 --allow-empty-message::
175 Like --allow-empty this command is primarily for use by foreign
176 SCM interface scripts. It allows you to create a commit with an
177 empty commit message without using plumbing commands like
178 linkgit:git-commit-tree[1].
179
180 --cleanup=<mode>::
181 This option determines how the supplied commit message should be
182 cleaned up before committing. The '<mode>' can be `strip`,
183 `whitespace`, `verbatim`, `scissors` or `default`.
184 +
185 --
186 strip::
187 Strip leading and trailing empty lines, trailing whitespace,
188 commentary and collapse consecutive empty lines.
189 whitespace::
190 Same as `strip` except #commentary is not removed.
191 verbatim::
192 Do not change the message at all.
193 scissors::
194 Same as `whitespace`, except that everything from (and
195 including) the line
196 "`# ------------------------ >8 ------------------------`"
197 is truncated if the message is to be edited. "`#`" can be
198 customized with core.commentChar.
199 default::
200 Same as `strip` if the message is to be edited.
201 Otherwise `whitespace`.
202 --
203 +
204 The default can be changed by the 'commit.cleanup' configuration
205 variable (see linkgit:git-config[1]).
206
207 -e::
208 --edit::
209 The message taken from file with `-F`, command line with
210 `-m`, and from commit object with `-C` are usually used as
211 the commit log message unmodified. This option lets you
212 further edit the message taken from these sources.
213
214 --no-edit::
215 Use the selected commit message without launching an editor.
216 For example, `git commit --amend --no-edit` amends a commit
217 without changing its commit message.
218
219 --amend::
220 Replace the tip of the current branch by creating a new
221 commit. The recorded tree is prepared as usual (including
222 the effect of the `-i` and `-o` options and explicit
223 pathspec), and the message from the original commit is used
224 as the starting point, instead of an empty message, when no
225 other message is specified from the command line via options
226 such as `-m`, `-F`, `-c`, etc. The new commit has the same
227 parents and author as the current one (the `--reset-author`
228 option can countermand this).
229 +
230 --
231 It is a rough equivalent for:
232 ------
233 $ git reset --soft HEAD^
234 $ ... do something else to come up with the right tree ...
235 $ git commit -c ORIG_HEAD
236
237 ------
238 but can be used to amend a merge commit.
239 --
240 +
241 You should understand the implications of rewriting history if you
242 amend a commit that has already been published. (See the "RECOVERING
243 FROM UPSTREAM REBASE" section in linkgit:git-rebase[1].)
244
245 --no-post-rewrite::
246 Bypass the post-rewrite hook.
247
248 -i::
249 --include::
250 Before making a commit out of staged contents so far,
251 stage the contents of paths given on the command line
252 as well. This is usually not what you want unless you
253 are concluding a conflicted merge.
254
255 -o::
256 --only::
257 Make a commit by taking the updated working tree contents
258 of the paths specified on the
259 command line, disregarding any contents that have been
260 staged for other paths. This is the default mode of operation of
261 'git commit' if any paths are given on the command line,
262 in which case this option can be omitted.
263 If this option is specified together with '--amend', then
264 no paths need to be specified, which can be used to amend
265 the last commit without committing changes that have
266 already been staged.
267
268 -u[<mode>]::
269 --untracked-files[=<mode>]::
270 Show untracked files.
271 +
272 The mode parameter is optional (defaults to 'all'), and is used to
273 specify the handling of untracked files; when -u is not used, the
274 default is 'normal', i.e. show untracked files and directories.
275 +
276 The possible options are:
277 +
278 - 'no' - Show no untracked files
279 - 'normal' - Shows untracked files and directories
280 - 'all' - Also shows individual files in untracked directories.
281 +
282 The default can be changed using the status.showUntrackedFiles
283 configuration variable documented in linkgit:git-config[1].
284
285 -v::
286 --verbose::
287 Show unified diff between the HEAD commit and what
288 would be committed at the bottom of the commit message
289 template to help the user describe the commit by reminding
290 what changes the commit has.
291 Note that this diff output doesn't have its
292 lines prefixed with '#'. This diff will not be a part
293 of the commit message.
294 +
295 If specified twice, show in addition the unified diff between
296 what would be committed and the worktree files, i.e. the unstaged
297 changes to tracked files.
298
299 -q::
300 --quiet::
301 Suppress commit summary message.
302
303 --dry-run::
304 Do not create a commit, but show a list of paths that are
305 to be committed, paths with local changes that will be left
306 uncommitted and paths that are untracked.
307
308 --status::
309 Include the output of linkgit:git-status[1] in the commit
310 message template when using an editor to prepare the commit
311 message. Defaults to on, but can be used to override
312 configuration variable commit.status.
313
314 --no-status::
315 Do not include the output of linkgit:git-status[1] in the
316 commit message template when using an editor to prepare the
317 default commit message.
318
319 -S[<keyid>]::
320 --gpg-sign[=<keyid>]::
321 GPG-sign commits. The `keyid` argument is optional and
322 defaults to the committer identity; if specified, it must be
323 stuck to the option without a space.
324
325 --no-gpg-sign::
326 Countermand `commit.gpgSign` configuration variable that is
327 set to force each and every commit to be signed.
328
329 \--::
330 Do not interpret any more arguments as options.
331
332 <file>...::
333 When files are given on the command line, the command
334 commits the contents of the named files, without
335 recording the changes already staged. The contents of
336 these files are also staged for the next commit on top
337 of what have been staged before.
338
339 :git-commit: 1
340 include::date-formats.txt[]
341
342 EXAMPLES
343 --------
344 When recording your own work, the contents of modified files in
345 your working tree are temporarily stored to a staging area
346 called the "index" with 'git add'. A file can be
347 reverted back, only in the index but not in the working tree,
348 to that of the last commit with `git reset HEAD -- <file>`,
349 which effectively reverts 'git add' and prevents the changes to
350 this file from participating in the next commit. After building
351 the state to be committed incrementally with these commands,
352 `git commit` (without any pathname parameter) is used to record what
353 has been staged so far. This is the most basic form of the
354 command. An example:
355
356 ------------
357 $ edit hello.c
358 $ git rm goodbye.c
359 $ git add hello.c
360 $ git commit
361 ------------
362
363 Instead of staging files after each individual change, you can
364 tell `git commit` to notice the changes to the files whose
365 contents are tracked in
366 your working tree and do corresponding `git add` and `git rm`
367 for you. That is, this example does the same as the earlier
368 example if there is no other change in your working tree:
369
370 ------------
371 $ edit hello.c
372 $ rm goodbye.c
373 $ git commit -a
374 ------------
375
376 The command `git commit -a` first looks at your working tree,
377 notices that you have modified hello.c and removed goodbye.c,
378 and performs necessary `git add` and `git rm` for you.
379
380 After staging changes to many files, you can alter the order the
381 changes are recorded in, by giving pathnames to `git commit`.
382 When pathnames are given, the command makes a commit that
383 only records the changes made to the named paths:
384
385 ------------
386 $ edit hello.c hello.h
387 $ git add hello.c hello.h
388 $ edit Makefile
389 $ git commit Makefile
390 ------------
391
392 This makes a commit that records the modification to `Makefile`.
393 The changes staged for `hello.c` and `hello.h` are not included
394 in the resulting commit. However, their changes are not lost --
395 they are still staged and merely held back. After the above
396 sequence, if you do:
397
398 ------------
399 $ git commit
400 ------------
401
402 this second commit would record the changes to `hello.c` and
403 `hello.h` as expected.
404
405 After a merge (initiated by 'git merge' or 'git pull') stops
406 because of conflicts, cleanly merged
407 paths are already staged to be committed for you, and paths that
408 conflicted are left in unmerged state. You would have to first
409 check which paths are conflicting with 'git status'
410 and after fixing them manually in your working tree, you would
411 stage the result as usual with 'git add':
412
413 ------------
414 $ git status | grep unmerged
415 unmerged: hello.c
416 $ edit hello.c
417 $ git add hello.c
418 ------------
419
420 After resolving conflicts and staging the result, `git ls-files -u`
421 would stop mentioning the conflicted path. When you are done,
422 run `git commit` to finally record the merge:
423
424 ------------
425 $ git commit
426 ------------
427
428 As with the case to record your own changes, you can use `-a`
429 option to save typing. One difference is that during a merge
430 resolution, you cannot use `git commit` with pathnames to
431 alter the order the changes are committed, because the merge
432 should be recorded as a single commit. In fact, the command
433 refuses to run when given pathnames (but see `-i` option).
434
435
436 DISCUSSION
437 ----------
438
439 Though not required, it's a good idea to begin the commit message
440 with a single short (less than 50 character) line summarizing the
441 change, followed by a blank line and then a more thorough description.
442 The text up to the first blank line in a commit message is treated
443 as the commit title, and that title is used throughout Git.
444 For example, linkgit:git-format-patch[1] turns a commit into email, and it uses
445 the title on the Subject line and the rest of the commit in the body.
446
447 include::i18n.txt[]
448
449 ENVIRONMENT AND CONFIGURATION VARIABLES
450 ---------------------------------------
451 The editor used to edit the commit log message will be chosen from the
452 GIT_EDITOR environment variable, the core.editor configuration variable, the
453 VISUAL environment variable, or the EDITOR environment variable (in that
454 order). See linkgit:git-var[1] for details.
455
456 HOOKS
457 -----
458 This command can run `commit-msg`, `prepare-commit-msg`, `pre-commit`,
459 and `post-commit` hooks. See linkgit:githooks[5] for more
460 information.
461
462 FILES
463 -----
464
465 `$GIT_DIR/COMMIT_EDITMSG`::
466 This file contains the commit message of a commit in progress.
467 If `git commit` exits due to an error before creating a commit,
468 any commit message that has been provided by the user (e.g., in
469 an editor session) will be available in this file, but will be
470 overwritten by the next invocation of `git commit`.
471
472 SEE ALSO
473 --------
474 linkgit:git-add[1],
475 linkgit:git-rm[1],
476 linkgit:git-mv[1],
477 linkgit:git-merge[1],
478 linkgit:git-commit-tree[1]
479
480 GIT
481 ---
482 Part of the linkgit:git[1] suite