git-commit translation continued

[gitman-de.git] / git-commit-de.txt

git-commit(1)
=============

NAME
----
git-commit - Trage Änderungen im Projektarchiv (repository) ein

SYNOPSIS
--------
[verse]
'git commit' [-a | --interactive] [-s] [-v] [-u<mode>] [--amend]
           [(-c | -C) <commit>] [-F <file> | -m <msg>]
           [--allow-empty] [--no-verify] [-e] [--author=<author>]
           [--cleanup=<mode>] [--] [[-i | -o ]<file>...]

DESCRIPTION
-----------
Speichere den aktuellen Inhalt des Index gemeinsam mit einer die Änderungen
des Benutzers beschreibenden Log Nachricht als neue Eintragung (commit) im 
Projektarchiv.

Der neue Inhalt kann auf verschiedene Arten angegeben werden:

1. Durch Verwendung von 'git-add', um Änderungen, vor Aufruf des 
   'git commit' Befehls, schrittweise zum Index hinzuzufügen (Anmerkung: 
   auch lediglich modifizierte Dateien müssen "hinzugefügt" werden);

2. Durch Verwendung von 'git-rm' um Dateien, vor Aufruf des 'git commit'
   Befehls, aus dem Arbeitsbereich, und dem Index zu entfernen, 

3. Durch die Angabe von Dateien als Argumente des 'git commit' Befehls, 
   wodurch die Eintragung (commit) aller im Index vorgemerkten Änderungen 
   ignoriert wird, und statt dessen der aktuelle Inhalt der aufgezählten
   Dateien im Projektarchiv (repository) eingetragen wird.

4. Durch Verwendung des -a Schalters des 'git commit' Befehls, um zuvor
   automatisch die Änderungen aller bekannten Dateien (also aller Dateien 
   die im Index bereits bekannt sind) hinzuzufügen ('git add'), und um
   automatisch alle Dateien die aus dem Arbeitsbereich gelöscht wurden zu
   entfernen ('git rm').

5. Durch Verwendung des --interactive Schalters des 'git commit' Befehls,
   um zuvor für jede Datei einzeln zu entscheiden ob diese Teil der 
   Eintragung (commit) sein soll. Dies wird derzeit durch 
   'git-add --interactive' bewerkstelligt.

Der 'git-status' Befehl kann, durch Angabe der selben Parameter die man 
für 'git commit' benutzen würde, dazu verwendet werden, um einen Überblick
darüber zu erhalten, welche Dateien bei jeder der obigen Optionen in der
nächsten Eintragung (commit) beinhaltet sein würden.

Wurde eine Eintragung (commit) durchgeführt und unmittelbar danach
ein Fehler erkannt, so kann diese mit 'git-reset' rückgängig gemacht werden.


OPTIONS
-------
-a::
--all::
        Führe die Bereitstellung (staging) und Eintragung (commit) aller
        modifizierten und gelöschten Dateien durch.
        Es werden ausschließlich Dateien behandelt die in git bekannt 
        sind, alle für git neuen Dateien werden somit nicht eingetragen.


-C <commit>::
--reuse-message=<commit>::
        Nimm eine existierende Eintragung (commit) und verwende die 
        Eintragungsbemerkung (commit message) und die Autoreninformation
        (inklusive Zeitstempel) für die aktuelle Eintragung.

-c <commit>::
--reedit-message=<commit>::
        Ähnlich wie '-C' allerdings wird mit '-c' der Editor
        aufgerufen, wodurch der Benutzer die Eintragungsbemerkung
        vor der Eintragung überarbeiten kann.

-F <file>::
--file=<file>::
        Nimm die Eintragungsbemerkung (commit message) der spezifizierten
        Datei. Mit '-' wird die Bemerkung von der Standard Eingabe gelesen.

--author=<author>::
        Überschreibe den Namen des in der Eintragung verwendeten Authors.
        Benutze das `A U Thor <author@example.com>` Format.

-m <msg>::
--message=<msg>::
        Verwende die angegebene <msg> als Eintragungsbemerkung
        (commit message).

-t <file>::
--template=<file>::
        Verwende den Inhalt der angegebenen Datei als initiale
        Version der Eintragungsbemerkung. Der Editor wird aufgerufen
        um weitere Änderungen vornehmen zu können. Wird eine Bemerkung
        mittels der Optionen '-m' oder '-F' angegeben, so hat die
        '-t' Option keine Auswirkung. Diese Angabe überschreibt die
        'commit.template' Konfigurationsvariable.

-s::
--signoff::
        Füge eine Unterschriftenzeile am Ende der Eintragungsbemerkung
        (commit message) hinzu.

-n::
--no-verify::
        Diese Option schaltet die pre-commit und commit-msg 
        Einsprungspunkte (hooks) aus. Siehe auch linkgit:githooks[5].

--allow-empty::
        Normalerweise ist das Aufzeichnen einer Eintragung welche exakt
        den gleichen Inhalt wie sein Vorgänger hat ein Fehler, und 
        'git commit' verhindert eine derartige Eintragung. Mit dieser 
        Option kann diese Sicherheitsvorkehrung ausgeschalten werden, 
        was hauptsächlich für fremde SCM Schnittstellen-Skripte
        verwendet wird.

--cleanup=<mode>::
        Diese Option bestimmt, wie Eintragungsbemerkungen (commit
        message) 'aufgeräumt' werden. Der '<mode>' kann sein: 
        'verbatim', 'whitespace', 'strip', oder 'default'. 
        Der 'default' Modus entfernt führende und am Ende befindliche
        Leerzeilen und #Bemerkungen wenn die Eintragungsbemerkung 
        editiert wurde. Ansonst werden nur Leerzeichen (whitespaces)
        entfernt. Der 'verbatim' Modusläßt die Eintragungsbemerkung
        gänzlich unverändert, 'whitespace' entfernt vorne und hinten
        die Leerzeichen und 'strip' entfernt sowohl Leerzeichen 
        wie auch Kommentare (Zeilen die mit '#' beginnen).

-e::
--edit::
        Die Eintragungsbemerkungen (commit message) einer Datei ('-F'),
        der Befehlszeile ('-m') oder einer Eintragung ('-C') werden
        normalerweise nicht weiter bearbeitet. Diese Option ermöglicht
        das weitere Editieren dieser Bemerkung bevor die Eintragung 
        (commit) durchgeführt wird.

--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::
        Before making a commit out of staged contents so far,
        stage the contents of paths given on the command line
        as well.  This is usually not what you want unless you
        are concluding a conflicted merge.

-o::
--only::
        Make a commit only from the paths specified on the
        command line, disregarding any contents that have been
        staged so far. 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
        no paths need be specified, which can be used to amend
        the last commit without committing changes that have
        already been staged.

-u[<mode>]::
--untracked-files[=<mode>]::
        Show untracked files (Default: 'all').
+
The mode parameter is optional, and is used to specify
the handling of untracked files. The possible options are:
+
--
        - 'no'     - Show no untracked files
        - 'normal' - Shows untracked files and directories
        - 'all'    - Also shows individual files in untracked directories.
--
+
See linkgit:git-config[1] for configuration variable
used to change the default for when the option is not
specified.

-v::
--verbose::
        Show unified diff between the HEAD commit and what
        would be committed at the bottom of the commit message
        template.  Note that this diff output doesn't have its
        lines prefixed with '#'.

-q::
--quiet::
        Suppress commit summary message.

\--::
        Do not interpret any more arguments as options.

<file>...::
        When files are given on the command line, the command
        commits the contents of the named files, without
        recording the changes already staged.  The contents of
        these files are also staged for the next commit on top
        of what have been staged before.


EXAMPLES
--------
When recording your own work, the contents of modified files in
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>`,
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,
`git commit` (without any pathname parameter) is used to record what
has been staged so far.  This is the most basic form of the
command.  An example:

------------
$ edit hello.c
$ git rm goodbye.c
$ git add hello.c
$ git commit
------------

Instead of staging files after each individual change, you can
tell `git commit` to notice the changes to the files whose
contents are tracked in
your working tree and do corresponding `git add` and `git rm`
for you.  That is, this example does the same as the earlier
example if there is no other change in your working tree:

------------
$ edit hello.c
$ rm goodbye.c
$ git commit -a
------------

The command `git commit -a` first looks at your working tree,
notices that you have modified hello.c and removed goodbye.c,
and performs necessary `git add` and `git rm` for you.

After staging changes to many files, you can alter the order the
changes are recorded in, by giving pathnames to `git commit`.
When pathnames are given, the command makes a commit that
only records the changes made to the named paths:

------------
$ edit hello.c hello.h
$ git add hello.c hello.h
$ edit Makefile
$ git commit Makefile
------------

This makes a commit that records the modification to `Makefile`.
The changes staged for `hello.c` and `hello.h` are not included
in the resulting commit.  However, their changes are not lost --
they are still staged and merely held back.  After the above
sequence, if you do:

------------
$ git commit
------------

this second commit would record the changes to `hello.c` and
`hello.h` as expected.

After a merge (initiated by 'git-merge' or 'git-pull') stops
because of conflicts, cleanly merged
paths are already staged to be committed for you, and paths that
conflicted are left in unmerged state.  You would have to first
check which paths are conflicting with 'git-status'
and after fixing them manually in your working tree, you would
stage the result as usual with 'git-add':

------------
$ git status | grep unmerged
unmerged: hello.c
$ edit hello.c
$ git add hello.c
------------

After resolving conflicts and staging the result, `git ls-files -u`
would stop mentioning the conflicted path.  When you are done,
run `git commit` to finally record the merge:

------------
$ git commit
------------

As with the case to record your own changes, you can use `-a`
option to save typing.  One difference is that during a merge
resolution, you cannot use `git commit` with pathnames to
alter the order the changes are committed, because the merge
should be recorded as a single commit.  In fact, the command
refuses to run when given pathnames (but see `-i` option).


DISCUSSION
----------

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.

include::i18n.txt[]

ENVIRONMENT AND CONFIGURATION VARIABLES
---------------------------------------
The editor used to edit the commit log message will be chosen from the
GIT_EDITOR environment variable, the core.editor configuration variable, the
VISUAL environment variable, or the EDITOR environment variable (in that
order).

HOOKS
-----
This command can run `commit-msg`, `prepare-commit-msg`, `pre-commit`,
and `post-commit` hooks.  See linkgit:githooks[5] for more
information.


SEE ALSO
--------
linkgit:git-add[1],
linkgit:git-rm[1],
linkgit:git-mv[1],
linkgit:git-merge[1],
linkgit:git-commit-tree[1]

Author
------
Written by Linus Torvalds <torvalds@osdl.org> and
Junio C Hamano <gitster@pobox.com>


GIT
---
Part of the linkgit:git[1] suite