Merge branch 'jc/doc-commit-only'
authorJunio C Hamano <gitster@pobox.com>
Tue, 18 Nov 2014 18:19:38 +0000 (10:19 -0800)
committerJunio C Hamano <gitster@pobox.com>
Tue, 18 Nov 2014 18:19:42 +0000 (10:19 -0800)
* jc/doc-commit-only:
Documentation/git-commit: clarify that --only/--include records the working tree contents

1  2 
Documentation/git-commit.txt
index 0bbc8f55f9bb558033abb877bf0bc6cd10335edd,a157c6883aecd14008292385fd8c809885cd261e..1e74b75d383838b3828f3fee20750c399d77cba0
@@@ -12,8 -12,8 +12,8 @@@ SYNOPSI
           [--dry-run] [(-c | -C | --fixup | --squash) <commit>]
           [-F <file> | -m <msg>] [--reset-author] [--allow-empty]
           [--allow-empty-message] [--no-verify] [-e] [--author=<author>]
 -         [--date=<date>] [--cleanup=<mode>] [--status | --no-status]
 -         [-i | -o] [--] [<file>...]
 +         [--date=<date>] [--cleanup=<mode>] [--[no-]status]
 +         [-i | -o] [-S[<key-id>]] [--] [<file>...]
  
  DESCRIPTION
  -----------
@@@ -32,7 -32,7 +32,7 @@@ The content to be added can be specifie
  3. by listing files as arguments to the 'commit' command, in which
     case the commit will ignore changes staged in the index, and instead
     record the current content of the listed files (which must already
 -   be known to git);
 +   be known to Git);
  
  4. by using the -a switch with the 'commit' command to automatically
     "add" changes from all known files (i.e. all files that are already
@@@ -42,7 -42,7 +42,7 @@@
  
  5. by using the --interactive or --patch switches with the 'commit' command
     to decide one by one which files or hunks should be part of the commit,
 -   before finalizing the operation. See the ``Interactive Mode`` section of
 +   before finalizing the operation. See the ``Interactive Mode'' section of
     linkgit:git-add[1] to learn how to operate these modes.
  
  The `--dry-run` option can be used to obtain a
@@@ -59,7 -59,7 +59,7 @@@ OPTION
  --all::
        Tell the command to automatically stage files that have
        been modified and deleted, but new files you have not
 -      told git about are not affected.
 +      told Git about are not affected.
  
  -p::
  --patch::
        When doing a dry-run, give the output in the short-format. See
        linkgit:git-status[1] for details. Implies `--dry-run`.
  
 +--branch::
 +      Show the branch and tracking info even in short-format.
 +
  --porcelain::
        When doing a dry-run, give the output in a porcelain-ready
        format. See linkgit:git-status[1] for details. Implies
        `--dry-run`.
  
 +--long::
 +      When doing a dry-run, give the output in a the long-format.
 +      Implies `--dry-run`.
 +
  -z::
 +--null::
        When showing `short` or `porcelain` status output, terminate
        entries in the status output with NUL, instead of LF. If no
        format is given, implies the `--porcelain` output format.
  -m <msg>::
  --message=<msg>::
        Use the given <msg> as the commit message.
 +      If multiple `-m` options are given, their values are
 +      concatenated as separate paragraphs.
  
  -t <file>::
  --template=<file>::
 -      Use the contents of the given file as the initial version
 -      of the commit message. The editor is invoked and you can
 -      make subsequent changes. If a message is specified using
 -      the `-m` or `-F` options, this option has no effect. This
 -      overrides the `commit.template` configuration variable.
 +      When editing the commit message, start the editor with the
 +      contents in the given file.  The `commit.template` configuration
 +      variable is often used to give this option implicitly to the
 +      command.  This mechanism can be used by projects that want to
 +      guide participants with some hints on what to write in the message
 +      in what order.  If the user exits the editor without editing the
 +      message, the commit is aborted.  This has no effect when a message
 +      is given by other means, e.g. with the `-m` or `-F` options.
  
  -s::
  --signoff::
         linkgit:git-commit-tree[1].
  
  --cleanup=<mode>::
 -      This option sets how the commit message is cleaned up.
 -      The  '<mode>' can be one of 'verbatim', 'whitespace', 'strip',
 -      and 'default'. The 'default' mode will strip leading and
 -      trailing empty lines and #commentary from the commit message
 -      only if the message is to be edited. Otherwise only whitespace
 -      removed. The 'verbatim' mode does not change message at all,
 -      'whitespace' removes just leading/trailing whitespace lines
 -      and 'strip' removes both whitespace and commentary.
 +      This option determines how the supplied commit message should be
 +      cleaned up before committing.  The '<mode>' can be `strip`,
 +      `whitespace`, `verbatim`, `scissors` or `default`.
 ++
 +--
 +strip::
 +      Strip leading and trailing empty lines, trailing whitespace, and
 +      #commentary and collapse consecutive empty lines.
 +whitespace::
 +      Same as `strip` except #commentary is not removed.
 +verbatim::
 +      Do not change the message at all.
 +scissors::
 +      Same as `whitespace`, except that everything from (and
 +      including) the line
 +      "`# ------------------------ >8 ------------------------`"
 +      is truncated if the message is to be edited. "`#`" can be
 +      customized with core.commentChar.
 +default::
 +      Same as `strip` if the message is to be edited.
 +      Otherwise `whitespace`.
 +--
 ++
 +The default can be changed by the 'commit.cleanup' configuration
 +variable (see linkgit:git-config[1]).
  
  -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
 +      `-m`, and from commit object with `-C` are usually used as
 +      the commit log message unmodified. This option lets you
        further edit the message taken from these sources.
  
 +--no-edit::
 +      Use the selected commit message without launching an editor.
 +      For example, `git commit --amend --no-edit` amends a commit
 +      without changing its commit message.
 +
  --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.
 +      Replace the tip of the current branch by creating a new
 +      commit. The recorded tree is prepared as usual (including
 +      the effect of the `-i` and `-o` options and explicit
 +      pathspec), and the message from the original commit is used
 +      as the starting point, instead of an empty message, when no
 +      other message is specified from the command line via options
 +      such as `-m`, `-F`, `-c`, etc.  The new commit has the same
 +      parents and author as the current one (the `--reset-author`
 +      option can countermand this).
  +
  --
  It is a rough equivalent for:
@@@ -238,9 -202,6 +238,9 @@@ You should understand the implications 
  amend a commit that has already been published.  (See the "RECOVERING
  FROM UPSTREAM REBASE" section in linkgit:git-rebase[1].)
  
 +--no-post-rewrite::
 +      Bypass the post-rewrite hook.
 +
  -i::
  --include::
        Before making a commit out of staged contents so far,
  
  -o::
  --only::
-       Make a commit only from the paths specified on the
+       Make a commit by taking the updated working tree contents
+       of the paths specified on the
        command line, disregarding any contents that have been
-       staged so far. This is the default mode of operation of
+       staged for other paths. This is the default mode of operation of
        'git commit' if any paths are given on the command line,
        in which case this option can be omitted.
        If this option is specified together with '--amend', then
@@@ -304,14 -266,6 +305,14 @@@ configuration variable documented in li
        commit message template when using an editor to prepare the
        default commit message.
  
 +-S[<keyid>]::
 +--gpg-sign[=<keyid>]::
 +      GPG-sign commit.
 +
 +--no-gpg-sign::
 +      Countermand `commit.gpgsign` configuration variable that is
 +      set to force each and every commit to be signed.
 +
  \--::
        Do not interpret any more arguments as options.
  
@@@ -331,7 -285,7 +332,7 @@@ When recording your own work, the conte
  your working tree are temporarily stored to a staging area
  called the "index" with 'git add'.  A file can be
  reverted back, only in the index but not in the working tree,
 -to that of the last commit with `git reset HEAD \-- <file>`,
 +to that of the last commit with `git reset HEAD -- <file>`,
  which effectively reverts 'git add' and prevents the changes to
  this file from participating in the next commit.  After building
  the state to be committed incrementally with these commands,
@@@ -425,10 -379,8 +426,10 @@@ DISCUSSIO
  Though not required, it's a good idea to begin the commit message
  with a single short (less than 50 character) line summarizing the
  change, followed by a blank line and then a more thorough description.
 -Tools that turn commits into email, for example, use the first line
 -on the Subject: line and the rest of the commit in the body.
 +The text up to the first blank line in a commit message is treated
 +as the commit title, and that title is used throughout Git.
 +For example, linkgit:git-format-patch[1] turns a commit into email, and it uses
 +the title on the Subject line and the rest of the commit in the body.
  
  include::i18n.txt[]
  
@@@ -445,15 -397,6 +446,15 @@@ This command can run `commit-msg`, `pre
  and `post-commit` hooks.  See linkgit:githooks[5] for more
  information.
  
 +FILES
 +-----
 +
 +`$GIT_DIR/COMMIT_EDITMSG`::
 +      This file contains the commit message of a commit in progress.
 +      If `git commit` exits due to an error before creating a commit,
 +      any commit message that has been provided by the user (e.g., in
 +      an editor session) will be available in this file, but will be
 +      overwritten by the next invocation of `git commit`.
  
  SEE ALSO
  --------