summaryrefslogtreecommitdiff
path: root/Documentation/git-commit.txt
blob: 2af472a5691007296ffb3a3c0921ab27e23e3884 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
git-commit(1)
=============
 
NAME
----
git-commit - Record your changes
 
SYNOPSIS
--------
[verse]
'git-commit' [-a] [-s] [-v] [(-c | -C) <commit> | -F <file> | -m <msg>]
	   [--no-verify] [--amend] [-e] [--author <author>]
	   [--] [[-i | -o ]<file>...]
 
DESCRIPTION
-----------
Updates the index file for given paths, or all modified files if
'-a' is specified, and makes a commit object.  The command
VISUAL and EDITOR environment variables to edit the commit log
message.
 
Several environment variable are used during commits.  They are
documented in gitlink:git-commit-tree[1].
 
 
This command can run `commit-msg`, `pre-commit`, and
`post-commit` hooks.  See link:hooks.html[hooks] for more
information.
 
OPTIONS
-------
-a|--all::
	Update all paths in the index file.  This flag notices
	files that have been modified and deleted, but new files
	you have not told git about are not affected.
 
-c or -C <commit>::
	Take existing commit object, and reuse the log message
	and the authorship information (including the timestamp)
	when creating the commit.  With '-C', the editor is not
	invoked; with '-c' the user can further edit the commit
	message.
 
-F <file>::
	Take the commit message from the given file.  Use '-' to
	read the message from the standard input.
 
--author <author>::
	Override the author name used in the commit.  Use
	`A U Thor <author@example.com>` format.
 
-m <msg>::
	Use the given <msg> as the commit message.
 
-s|--signoff::
	Add Signed-off-by line at the end of the commit message.
 
-v|--verify::
	Look for suspicious lines the commit introduces, and
	abort committing if there is one.  The definition of
	'suspicious lines' is currently the lines that has
	trailing whitespaces, and the lines whose indentation
	has a SP character immediately followed by a TAB
	character.  This is the default.
 
-n|--no-verify::
	The opposite of `--verify`.
 
-e|--edit::
	The message taken from file with `-F`, command line with
	`-m`, and from file with `-C` are usually used as the
	commit log message unmodified.  This option lets you
	further edit the message taken from these sources.
 
--amend::
 
	Used to amend the tip of the current branch. Prepare the tree
	object you would want to replace the latest commit as usual
	(this includes the usual -i/-o and explicit paths), and the
	commit log editor is seeded with the commit message from the
	tip of the current branch. The commit you create replaces the
	current tip -- if it was a merge, it will have the parents of
	the current tip as parents -- so the current top commit is
	discarded.
+
It is a rough equivalent for:
+
------------
	$ git reset --soft HEAD^
	$ ... do something else to come up with the right tree ...
	$ git commit -c ORIG_HEAD
------------
+
but can be used to amend a merge commit.
 
-i|--include::
	Instead of committing only the files specified on the
	command line, update them in the index file and then
	commit the whole index.  This is the traditional
	behaviour.
 
-o|--only::
	Commit only the files specified on the command line.
	This format cannot be used during a merge, nor when the
	index and the latest commit does not match on the
	specified paths to avoid confusion.
 
--::
	Do not interpret any more arguments as options.
 
<file>...::
	Files to be committed.  The meaning of these is
	different between `--include` and `--only`.  Without
	either, it defaults `--only` semantics.
 
If you make a commit and then found a mistake immediately after
that, you can recover from it with gitlink:git-reset[1].
 
 
Discussion
----------
 
`git commit` without _any_ parameter commits the tree structure
recorded by the current index file.  This is a whole-tree commit
even the command is invoked from a subdirectory.
 
`git commit --include paths...` is equivalent to
 
	git update-index --remove paths...
	git commit
 
That is, update the specified paths to the index and then commit
the whole tree.
 
`git commit paths...` largely bypasses the index file and
commits only the changes made to the specified paths.  It has
however several safety valves to prevent confusion.
 
. It refuses to run during a merge (i.e. when
  `$GIT_DIR/MERGE_HEAD` exists), and reminds trained git users
  that the traditional semantics now needs -i flag.
 
. It refuses to run if named `paths...` are different in HEAD
  and the index (ditto about reminding).  Added paths are OK.
  This is because an earlier `git diff` (not `git diff HEAD`)
  would have shown the differences since the last `git
  update-index paths...` to the user, and an inexperienced user
  may mistakenly think that the changes between the index and
  the HEAD (i.e. earlier changes made before the last `git
  update-index paths...` was done) are not being committed.
 
. It reads HEAD commit into a temporary index file, updates the
  specified `paths...` and makes a commit.  At the same time,
  the real index file is also updated with the same `paths...`.
 
`git commit --all` updates the index file with _all_ changes to
the working tree, and makes a whole-tree commit, regardless of
which subdirectory the command is invoked in.
 
 
Author
------
Written by Linus Torvalds <torvalds@osdl.org> and
Junio C Hamano <junkio@cox.net>
 
 
GIT
---
Part of the gitlink:git[7] suite