--- /dev/null
+GIT v1.5.6.2 Release Notes
+==========================
+
+Futureproof
+-----------
+
+ * "git-shell" accepts requests without a dash between "git" and
+ subcommand name (e.g. "git upload-pack") which the newer client will
+ start to make sometime in the future.
+
+Fixes since v1.5.6.1
+--------------------
+
+* Optimization for a large import via "git-svn" introduced in v1.5.6 had a
+ serious memory and temporary file leak, which made it unusable for
+ moderately large import.
+
+* "git-svn" mangled remote nickname used in the configuration file
+ unnecessarily.
+
+* "git diff --check" did not report the result via its exit status
+ reliably.
+
+* "git show" segfaulted when an annotated tag that points at another
+ annotated tag was given to it.
+
+--
+exec >/var/tmp/1
+echo O=$(git describe maint)
+O=v1.5.6.1-13-g4f3dcc2
+git shortlog --no-merges $O..maint
User visible changes
--------------------
-[[Note that none of these are not merged to 'master' as of this writing
-but they will be before 1.6.0 happens]]
-
With the default Makefile settings, most of the programs are now
installed outside your $PATH, except for "git", "gitk", "git-gui" and
some server side programs that need to be accessible for technical
Source changes needed for porting to MinGW environment are now all in the
main git.git codebase.
+By default, packfiles created with this version uses delta-base-offset
+encoding introduced in v1.4.4. Pack idx files are using version 2 that
+allows larger packs and added robustness thanks to its CRC checking,
+introduced in v1.5.2.
+
Updates since v1.5.6
--------------------
(usability, bells and whistles)
+* git-apply can handle a patch that touches the same path more than once
+ much better than before.
+
+* git-apply can be told not to trust the line counts recorded in the input
+ patch but recount, with the new --recount option.
+
* git-archive can be told to omit certain paths from its output using
export-ignore attributes.
+* git-clone can clone from a remote whose URL would be rewritten by
+ configuration stored in $HOME/.gitconfig now.
+
+* git-diff --check now checks leftover merge conflict markers.
+
+* When remote side used to have branch 'foo' and git-fetch finds that now
+ it has branch 'foo/bar', it refuses to lose the existing remote tracking
+ branch and its reflog. The error message has been improved to suggest
+ pruning the remote if the user wants to proceed and get the latest set
+ of branches from the remote, including such 'foo/bar'.
+
* fast-export learned to export and import marks file; this can be used to
interface with fast-import incrementally.
* Original SHA-1 value for "update-ref -d" is optional now.
+* git-send-mail can talk not just over SSL but over TLS now.
+
* You can tell "git status -u" to even more aggressively omit checking
untracked files with --untracked-files=no.
---
exec >/var/tmp/1
-O=v1.5.6.1-104-ga08b868
+O=v1.5.6.1-155-gaa0c1f2
echo O=$(git describe refs/heads/master)
git shortlog --no-merges $O..refs/heads/master ^refs/heads/maint
legacy pack index used by Git versions prior to 1.5.2, and 2 for
the new pack index with capabilities for packs larger than 4 GB
as well as proper protection against the repacking of corrupted
- packs. Version 2 is selected and this config option ignored
- whenever the corresponding pack is larger than 2 GB. Otherwise
- the default is 1.
+ packs. Version 2 is the default. Note that version 2 is enforced
+ and this config option ignored whenever the corresponding pack is
+ larger than 2 GB.
++
+If you have an old git that does not understand the version 2 `{asterisk}.idx` file,
+cloning or fetching over a non native protocol (e.g. "http" and "rsync")
+that will copy both `{asterisk}.pack` file and corresponding `{asterisk}.idx` file from the
+other side may give you a repository that cannot be accessed with your
+older version of git. If the `{asterisk}.pack` file is smaller than 2 GB, however,
+you can use linkgit:git-index-pack[1] on the *.pack file to regenerate
+the `{asterisk}.idx` file.
pack.packSizeLimit::
The default maximum size of a pack. This setting only affects
<group>". See linkgit:git-remote[1].
repack.usedeltabaseoffset::
- Allow linkgit:git-repack[1] to create packs that uses
- delta-base offset. Defaults to false.
+ By default, linkgit:git-repack[1] creates packs that use
+ delta-base offset. If you need to share your repository with
+ git older than version 1.4.4, either directly or via a dumb
+ protocol such as http, then you need to set this option to
+ "false" and repack. Access from old git versions over the
+ native protocol are unaffected by this option.
showbranch.default::
The default set of branches for linkgit:git-show-branch[1].
Do not show any source or destination prefix.
For more detailed explanation on these common options, see also
-linkgit:gitdiffcore[7][diffcore documentation].
+linkgit:gitdiffcore[7].
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:35 UTC\r
+Last updated 02-Jul-2008 03:02:14 UTC\r
</div>\r
</div>\r
</body>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-add</em> [-n] [-v] [--force | -f] [--interactive | -i] [--patch | -p]\r
+<div class="content"><em>git add</em> [-n] [-v] [--force | -f] [--interactive | -i] [--patch | -p]\r
[--update | -u] [--refresh] [--ignore-errors] [--]\r
<filepattern>…</div></div>\r
</div>\r
<p>The optional configuration variable <em>core.excludesfile</em> indicates a path to a\r
file containing patterns of file names to exclude from git-add, similar to\r
$GIT_DIR/info/exclude. Patterns in the exclude file are used in addition to\r
-those in info/exclude. See <a href="gitrepository-layout.html">gitrepository-layout(5)</a>[repository layout].</p>\r
+those in info/exclude. See <a href="gitrepository-layout.html">gitrepository-layout(5)</a>.</p>\r
</div>\r
<h2>EXAMPLES</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 15-Jun-2008 05:10:05 UTC\r
+Last updated 02-Jul-2008 03:01:31 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-add' [-n] [-v] [--force | -f] [--interactive | -i] [--patch | -p]
+'git add' [-n] [-v] [--force | -f] [--interactive | -i] [--patch | -p]
[--update | -u] [--refresh] [--ignore-errors] [--]
<filepattern>...
The optional configuration variable 'core.excludesfile' indicates a path to a
file containing patterns of file names to exclude from git-add, similar to
$GIT_DIR/info/exclude. Patterns in the exclude file are used in addition to
-those in info/exclude. See linkgit:gitrepository-layout[5][repository layout].
+those in info/exclude. See linkgit:gitrepository-layout[5].
EXAMPLES
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-am</em> [--signoff] [--keep] [--utf8 | --no-utf8]\r
+<div class="content"><em>git am</em> [--signoff] [--keep] [--utf8 | --no-utf8]\r
[--3way] [--interactive] [--binary]\r
[--whitespace=<option>] [-C<n>] [-p<n>]\r
<mbox>|<Maildir>…\r
-<em>git-am</em> [--skip | --resolved]</div></div>\r
+<em>git am</em> [--skip | --resolved]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:16 UTC\r
+Last updated 02-Jul-2008 03:01:31 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-am' [--signoff] [--keep] [--utf8 | --no-utf8]
+'git am' [--signoff] [--keep] [--utf8 | --no-utf8]
[--3way] [--interactive] [--binary]
[--whitespace=<option>] [-C<n>] [-p<n>]
<mbox>|<Maildir>...
-'git-am' [--skip | --resolved]
+'git am' [--skip | --resolved]
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p>git-annotate [options] file [revision]</p>\r
+<p><em>git annotate</em> [options] file [revision]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:17 UTC\r
+Last updated 02-Jul-2008 03:01:32 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-git-annotate [options] file [revision]
+'git annotate' [options] file [revision]
DESCRIPTION
-----------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-apply</em> [--stat] [--numstat] [--summary] [--check] [--index]\r
+<div class="content"><em>git apply</em> [--stat] [--numstat] [--summary] [--check] [--index]\r
[--apply] [--no-add] [--build-fake-ancestor <file>] [-R | --reverse]\r
[--allow-binary-replacement | --binary] [--reject] [-z]\r
- [-pNUM] [-CNUM] [--inaccurate-eof] [--cached]\r
+ [-pNUM] [-CNUM] [--inaccurate-eof] [--recount] [--cached]\r
[--whitespace=<nowarn|warn|fix|error|error-all>]\r
[--exclude=PATH] [--verbose] [<patch>…]</div></div>\r
</div>\r
</dt>\r
<dd>\r
<p>\r
- Newer git-diff output has embedded <em>index information</em>\r
+ Newer <tt>git-diff</tt> output has embedded <em>index information</em>\r
for each blob to help identify the original version that\r
the patch applies to. When this flag is given, and if\r
the original versions of the blobs is available locally,\r
</dt>\r
<dd>\r
<p>\r
- For atomicity, <a href="git-apply.html">git-apply(1)</a> by default fails the whole patch and\r
+ For atomicity, <tt>git-apply</tt> by default fails the whole patch and\r
does not touch the working tree when some of the hunks\r
do not apply. This option makes it apply\r
the parts of the patch that are applicable, and leave the\r
</dt>\r
<dd>\r
<p>\r
- By default, <a href="git-apply.html">git-apply(1)</a> expects that the patch being\r
+ By default, <tt>git-apply</tt> expects that the patch being\r
applied is a unified diff with at least one line of context.\r
This provides good safety measures, but breaks down when\r
applying a diff generated with --unified=0. To bypass these\r
<dd>\r
<p>\r
If you use any of the options marked "Turns off\r
- <em>apply</em>" above, <a href="git-apply.html">git-apply(1)</a> reads and outputs the\r
+ <em>apply</em>" above, <tt>git-apply</tt> reads and outputs the\r
information you asked without actually applying the\r
patch. Give this flag after those flags to also apply\r
the patch.\r
considered whitespace errors.\r
</p>\r
<p>By default, the command outputs warning messages but applies the patch.\r
-When <a href="git-apply.html">git-apply(1)</a> is used for statistics and not applying a\r
-patch, it defaults to <tt>nowarn</tt>.</p>\r
+When <tt>git-apply is used for statistics and not applying a\r
+patch, it defaults to `nowarn</tt>.</p>\r
<p>You can use different <tt><action></tt> to control this\r
behavior:</p>\r
<ul>\r
additional information to be reported.\r
</p>\r
</dd>\r
+<dt>\r
+--recount\r
+</dt>\r
+<dd>\r
+<p>\r
+ Do not trust the line counts in the hunk headers, but infer them\r
+ by inspecting the patch (e.g. after editing the patch without\r
+ adjusting the hunk headers appropriately).\r
+</p>\r
+</dd>\r
</dl>\r
</div>\r
<h2>Configuration</h2>\r
</div>\r
<h2>Submodules</h2>\r
<div class="sectionbody">\r
-<p>If the patch contains any changes to submodules then <a href="git-apply.html">git-apply(1)</a>\r
+<p>If the patch contains any changes to submodules then <tt>git-apply</tt>\r
treats these changes as follows.</p>\r
<p>If --index is specified (explicitly or implicitly), then the submodule\r
commits must match the index exactly for the patch to apply. If any\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:18 UTC\r
+Last updated 02-Jul-2008 03:01:32 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-apply' [--stat] [--numstat] [--summary] [--check] [--index]
+'git apply' [--stat] [--numstat] [--summary] [--check] [--index]
[--apply] [--no-add] [--build-fake-ancestor <file>] [-R | --reverse]
[--allow-binary-replacement | --binary] [--reject] [-z]
- [-pNUM] [-CNUM] [--inaccurate-eof] [--cached]
+ [-pNUM] [-CNUM] [--inaccurate-eof] [--recount] [--cached]
[--whitespace=<nowarn|warn|fix|error|error-all>]
[--exclude=PATH] [--verbose] [<patch>...]
without using the working tree. This implies '--index'.
--build-fake-ancestor <file>::
- Newer git-diff output has embedded 'index information'
+ Newer `git-diff` output has embedded 'index information'
for each blob to help identify the original version that
the patch applies to. When this flag is given, and if
the original versions of the blobs is available locally,
Apply the patch in reverse.
--reject::
- For atomicity, linkgit:git-apply[1] by default fails the whole patch and
+ For atomicity, `git-apply` by default fails the whole patch and
does not touch the working tree when some of the hunks
do not apply. This option makes it apply
the parts of the patch that are applicable, and leave the
ever ignored.
--unidiff-zero::
- By default, linkgit:git-apply[1] expects that the patch being
+ By default, `git-apply` expects that the patch being
applied is a unified diff with at least one line of context.
This provides good safety measures, but breaks down when
applying a diff generated with --unified=0. To bypass these
--apply::
If you use any of the options marked "Turns off
- 'apply'" above, linkgit:git-apply[1] reads and outputs the
+ 'apply'" above, `git-apply` reads and outputs the
information you asked without actually applying the
patch. Give this flag after those flags to also apply
the patch.
considered whitespace errors.
+
By default, the command outputs warning messages but applies the patch.
-When linkgit:git-apply[1] is used for statistics and not applying a
+When `git-apply is used for statistics and not applying a
patch, it defaults to `nowarn`.
+
You can use different `<action>` to control this
current patch being applied will be printed. This option will cause
additional information to be reported.
+--recount::
+ Do not trust the line counts in the hunk headers, but infer them
+ by inspecting the patch (e.g. after editing the patch without
+ adjusting the hunk headers appropriately).
+
Configuration
-------------
Submodules
----------
-If the patch contains any changes to submodules then linkgit:git-apply[1]
+If the patch contains any changes to submodules then `git-apply`
treats these changes as follows.
If --index is specified (explicitly or implicitly), then the submodule
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-archimport</em> [-h] [-v] [-o] [-a] [-f] [-T] [-D depth] [-t tempdir]\r
+<div class="content"><em>git archimport</em> [-h] [-v] [-o] [-a] [-f] [-T] [-D depth] [-t tempdir]\r
<archive/branch>[:<git-branch>] …</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
Arch repository.\r
Make sure you have a recent version of <tt>tla</tt> available in the path. <tt>tla</tt> must\r
know about the repositories you pass to <tt>git-archimport</tt>.</p>\r
-<p>For the initial import <tt>git-archimport</tt> expects to find itself in an empty\r
+<p>For the initial import, <tt>git-archimport</tt> expects to find itself in an empty\r
directory. To follow the development of a project that uses Arch, rerun\r
<tt>git-archimport</tt> with the same parameters as the initial import to perform\r
incremental imports.</p>\r
-<p>While git-archimport will try to create sensible branch names for the\r
+<p>While <tt>git-archimport</tt> will try to create sensible branch names for the\r
archives that it imports, it is also possible to specify git branch names\r
manually. To do so, write a git branch name after each <archive/branch>\r
parameter, separated by a colon. This way, you can shorten the Arch\r
<dd>\r
<p>\r
Use this for compatibility with old-style branch names used by\r
- earlier versions of git-archimport. Old-style branch names\r
+ earlier versions of <tt>git-archimport</tt>. Old-style branch names\r
were category--branch, whereas new-style branch names are\r
archive,category--branch--version. In both cases, names given\r
on the command-line will override the automatically-generated\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:20 UTC\r
+Last updated 02-Jul-2008 03:01:32 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-archimport' [-h] [-v] [-o] [-a] [-f] [-T] [-D depth] [-t tempdir]
+'git archimport' [-h] [-v] [-o] [-a] [-f] [-T] [-D depth] [-t tempdir]
<archive/branch>[:<git-branch>] ...
DESCRIPTION
Make sure you have a recent version of `tla` available in the path. `tla` must
know about the repositories you pass to `git-archimport`.
-For the initial import `git-archimport` expects to find itself in an empty
+For the initial import, `git-archimport` expects to find itself in an empty
directory. To follow the development of a project that uses Arch, rerun
`git-archimport` with the same parameters as the initial import to perform
incremental imports.
-While git-archimport will try to create sensible branch names for the
+While `git-archimport` will try to create sensible branch names for the
archives that it imports, it is also possible to specify git branch names
manually. To do so, write a git branch name after each <archive/branch>
parameter, separated by a colon. This way, you can shorten the Arch
-o::
Use this for compatibility with old-style branch names used by
- earlier versions of git-archimport. Old-style branch names
+ earlier versions of `git-archimport`. Old-style branch names
were category--branch, whereas new-style branch names are
archive,category--branch--version. In both cases, names given
on the command-line will override the automatically-generated
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-archive</em> --format=<fmt> [--list] [--prefix=<prefix>/] [<extra>]\r
+<div class="content"><em>git archive</em> --format=<fmt> [--list] [--prefix=<prefix>/] [<extra>]\r
[--remote=<repo> [--exec=<git-upload-archive>]] <tree-ish>\r
[path…]</div></div>\r
</div>\r
structure for the named tree, and writes it out to the standard\r
output. If <prefix> is specified it is\r
prepended to the filenames in the archive.</p>\r
-<p><em>git-archive</em> behaves differently when given a tree ID versus when\r
+<p><tt>git-archive</tt> behaves differently when given a tree ID versus when\r
given a commit ID or tag ID. In the first case the current time is\r
used as modification time of each file in the archive. In the latter\r
case the commit time as recorded in the referenced commit object is\r
used instead. Additionally the commit ID is stored in a global\r
extended pax header if the tar format is used; it can be extracted\r
-using <em>git-get-tar-commit-id</em>. In ZIP files it is stored as a file\r
+using <tt>git-get-tar-commit-id</tt>. In ZIP files it is stored as a file\r
comment.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<dd>\r
<p>\r
Used with --remote to specify the path to the\r
- git-upload-archive executable on the remote side.\r
+ <tt>git-upload-archive</tt> on the remote side.\r
</p>\r
</dd>\r
<dt>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:19 UTC\r
+Last updated 02-Jul-2008 03:01:32 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git
-archive' --format=<fmt> [--list] [--prefix=<prefix>/] [<extra>]
+'git
archive' --format=<fmt> [--list] [--prefix=<prefix>/] [<extra>]
[--remote=<repo> [--exec=<git-upload-archive>]] <tree-ish>
[path...]
output. If <prefix> is specified it is
prepended to the filenames in the archive.
-'git-archive' behaves differently when given a tree ID versus when
+`git-archive` behaves differently when given a tree ID versus when
given a commit ID or tag ID. In the first case the current time is
used as modification time of each file in the archive. In the latter
case the commit time as recorded in the referenced commit object is
used instead. Additionally the commit ID is stored in a global
extended pax header if the tar format is used; it can be extracted
-using 'git-get-tar-commit-id'. In ZIP files it is stored as a file
+using `git-get-tar-commit-id`. In ZIP files it is stored as a file
comment.
OPTIONS
--exec=<git-upload-archive>::
Used with --remote to specify the path to the
- git-upload-archive executable on the remote side.
+ `git-upload-archive` on the remote side.
<tree-ish>::
The tree or commit to produce an archive for.
git bisect log\r
git bisect run <cmd>...</tt></pre>\r
</div></div>\r
-<p>This command uses <em>git-rev-list --bisect</em> option to help drive the\r
+<p>This command uses <tt>git rev-list --bisect</tt> to help drive the\r
binary search process to find which change introduced a bug, given an\r
old "good" commit object name and a later "bad" commit object name.</p>\r
<h3>Getting help</h3>\r
"revision that does not have this commit needs this patch applied to\r
work around other problem this bisection is not interested in")\r
applied to the revision being tested.</p>\r
-<p>To cope with such a situation, after the inner git-bisect finds the\r
+<p>To cope with such a situation, after the inner <tt>git-bisect</tt> finds the\r
next revision to test, with the "run" script, you can apply that tweak\r
before compiling, run the real test, and after the test decides if the\r
revision (possibly with the needed tweaks) passed the test, rewind the\r
tree to the pristine state. Finally the "run" script can exit with\r
-the status of the real test to let "git bisect run" command loop to\r
-know the outcome.</p>\r
+the status of the real test to let the "git bisect run" command loop to\r
+determine the outcome.</p>\r
</div>\r
<h2>EXAMPLES</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 15-Jun-2008 05:10:05 UTC\r
+Last updated 02-Jul-2008 03:01:32 UTC\r
</div>\r
</div>\r
</body>\r
git bisect log
git bisect run <cmd>...
-This command uses 'git-rev-list --bisect' option to help drive the
+This command uses `git rev-list --bisect` to help drive the
binary search process to find which change introduced a bug, given an
old "good" commit object name and a later "bad" commit object name.
work around other problem this bisection is not interested in")
applied to the revision being tested.
-To cope with such a situation, after the inner git-bisect finds the
+To cope with such a situation, after the inner `git-bisect` finds the
next revision to test, with the "run" script, you can apply that tweak
before compiling, run the real test, and after the test decides if the
revision (possibly with the needed tweaks) passed the test, rewind the
tree to the pristine state. Finally the "run" script can exit with
-the status of the real test to let "git bisect run" command loop to
-know the outcome.
+the status of the real test to let the "git bisect run" command loop to
+determine the outcome.
EXAMPLES
--------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-blame</em> [-c] [-b] [-l] [--root] [-t] [-f] [-n] [-s] [-p] [-w] [--incremental] [-L n,m]\r
+<div class="content"><em>git blame</em> [-c] [-b] [-l] [--root] [-t] [-f] [-n] [-s] [-p] [-w] [--incremental] [-L n,m]\r
[-S <revs-file>] [-M] [-C] [-C] [--since=<date>]\r
[<rev> | --contents <file>] [--] <file></div></div>\r
</div>\r
last modified the line. Optionally, start annotating from the given revision.</p>\r
<p>Also it can limit the range of lines annotated.</p>\r
<p>This report doesn't tell you anything about lines which have been deleted or\r
-replaced; you need to use a tool such as <a href="git-diff.html">git-diff(1)</a> or the "pickaxe"\r
+replaced; you need to use a tool such as <tt>git-diff</tt> or the "pickaxe"\r
interface briefly mentioned in the following paragraph.</p>\r
<p>Apart from supporting file annotation, git also supports searching the\r
development history for when a code snippet occurred in a change. This makes it\r
file (see <tt>-M</tt>). The first number listed is the score.\r
This is the number of alphanumeric characters detected\r
to be moved between or within files. This must be above\r
- a certain threshold for git-blame to consider those lines\r
+ a certain threshold for <tt>git-blame</tt> to consider those lines\r
of code to have been moved.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:19 UTC\r
+Last updated 02-Jul-2008 03:01:33 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-blame' [-c] [-b] [-l] [--root] [-t] [-f] [-n] [-s] [-p] [-w] [--incremental] [-L n,m]
+'git blame' [-c] [-b] [-l] [--root] [-t] [-f] [-n] [-s] [-p] [-w] [--incremental] [-L n,m]
[-S <revs-file>] [-M] [-C] [-C] [--since=<date>]
[<rev> | --contents <file>] [--] <file>
Also it can limit the range of lines annotated.
This report doesn't tell you anything about lines which have been deleted or
-replaced; you need to use a tool such as linkgit:git-diff[1] or the "pickaxe"
+replaced; you need to use a tool such as `git-diff` or the "pickaxe"
interface briefly mentioned in the following paragraph.
Apart from supporting file annotation, git also supports searching the
file (see `-M`). The first number listed is the score.
This is the number of alphanumeric characters detected
to be moved between or within files. This must be above
- a certain threshold for git-blame to consider those lines
+ a certain threshold for `git-blame` to consider those lines
of code to have been moved.
-f::
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-branch</em> [--color | --no-color] [-r | -a] [--merged | --no-merged]\r
+<div class="content"><em>git branch</em> [--color | --no-color] [-r | -a] [--merged | --no-merged]\r
[-v [--abbrev=<length> | --no-abbrev]]\r
[--contains <commit>]\r
-<em>git-branch</em> [--track | --no-track] [-l] [-f] <branchname> [<start-point>]\r
-<em>git-branch</em> (-m | -M) [<oldbranch>] <newbranch>\r
-<em>git-branch</em> (-d | -D) [-r] <branchname>…</div></div>\r
+<em>git branch</em> [--track | --no-track] [-l] [-f] <branchname> [<start-point>]\r
+<em>git branch</em> (-m | -M) [<oldbranch>] <newbranch>\r
+<em>git branch</em> (-d | -D) [-r] <branchname>…</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
working tree to it; use "git checkout <newbranch>" to switch to the\r
new branch.</p>\r
<p>When a local branch is started off a remote branch, git sets up the\r
-branch so that <a href="git-pull.html">git-pull(1)</a> will appropriately merge from\r
+branch so that <tt>git-pull</tt> will appropriately merge from\r
the remote branch. This behavior may be changed via the global\r
<tt>branch.autosetupmerge</tt> configuration flag. That setting can be\r
overridden by using the <tt>--track</tt> and <tt>--no-track</tt> options.</p>\r
has a reflog then the reflog will also be deleted.</p>\r
<p>Use -r together with -d to delete remote-tracking branches. Note, that it\r
only makes sense to delete remote-tracking branches if they no longer exist\r
-in remote repository or if <a href="git-fetch.html">git-fetch(1)</a> was configured not to fetch\r
+in remote repository or if <tt>git-fetch</tt> was configured not to fetch\r
them again. See also <em>prune</em> subcommand of <a href="git-remote.html">git-remote(1)</a> for way to\r
clean up all obsolete remote-tracking branches.</p>\r
</div>\r
</dt>\r
<dd>\r
<p>\r
- When creating a new branch, set up configuration so that git-pull\r
+ When creating a new branch, set up configuration so that <tt>git-pull</tt>\r
will automatically retrieve data from the start point, which must be\r
a branch. Use this if you always pull from the same upstream branch\r
into the new branch, and if you don't want to use "git pull\r
<repository> <refspec>" explicitly. This behavior is the default\r
when the start point is a remote branch. Set the\r
branch.autosetupmerge configuration variable to <tt>false</tt> if you want\r
- git-checkout and git-branch to always behave as if <em>--no-track</em> were\r
+ <tt>git-checkout</tt> and <tt>git-branch</tt> to always behave as if <em>--no-track</em> were\r
given. Set it to <tt>always</tt> if you want this behavior when the\r
start-point is either a local or remote branch.\r
</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:20 UTC\r
+Last updated 02-Jul-2008 03:01:33 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-branch' [--color | --no-color] [-r | -a] [--merged | --no-merged]
+'git branch' [--color | --no-color] [-r | -a] [--merged | --no-merged]
[-v [--abbrev=<length> | --no-abbrev]]
[--contains <commit>]
-'git-branch' [--track | --no-track] [-l] [-f] <branchname> [<start-point>]
-'git
-branch' (-m | -M) [<oldbranch>] <newbranch>
-'git-branch' (-d | -D) [-r] <branchname>...
+'git branch' [--track | --no-track] [-l] [-f] <branchname> [<start-point>]
+'git
branch' (-m | -M) [<oldbranch>] <newbranch>
+'git branch' (-d | -D) [-r] <branchname>...
DESCRIPTION
-----------
new branch.
When a local branch is started off a remote branch, git sets up the
-branch so that linkgit:git-pull[1] will appropriately merge from
+branch so that `git-pull` will appropriately merge from
the remote branch. This behavior may be changed via the global
`branch.autosetupmerge` configuration flag. That setting can be
overridden by using the `--track` and `--no-track` options.
Use -r together with -d to delete remote-tracking branches. Note, that it
only makes sense to delete remote-tracking branches if they no longer exist
-in remote repository or if linkgit:git-fetch[1] was configured not to fetch
+in remote repository or if `git-fetch` was configured not to fetch
them again. See also 'prune' subcommand of linkgit:git-remote[1] for way to
clean up all obsolete remote-tracking branches.
Display the full sha1s in output listing rather than abbreviating them.
--track::
- When creating a new branch, set up configuration so that git-pull
+ When creating a new branch, set up configuration so that `git-pull`
will automatically retrieve data from the start point, which must be
a branch. Use this if you always pull from the same upstream branch
into the new branch, and if you don't want to use "git pull
<repository> <refspec>" explicitly. This behavior is the default
when the start point is a remote branch. Set the
branch.autosetupmerge configuration variable to `false` if you want
- git-checkout and git-branch to always behave as if '--no-track' were
+ `git-checkout` and `git-branch` to always behave as if '--no-track' were
given. Set it to `always` if you want this behavior when the
start-point is either a local or remote branch.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-bundle</em> create <file> <git-rev-list args>\r
-<em>git-bundle</em> verify <file>\r
-<em>git-bundle</em> list-heads <file> [refname…]\r
-<em>git-bundle</em> unbundle <file> [refname…]</div></div>\r
+<div class="content"><em>git bundle</em> create <file> <git-rev-list args>\r
+<em>git bundle</em> verify <file>\r
+<em>git bundle</em> list-heads <file> [refname…]\r
+<em>git bundle</em> unbundle <file> [refname…]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
machine be replicated on another machine, but the two machines cannot\r
be directly connected so the interactive git protocols (git, ssh,\r
rsync, http) cannot be used. This command provides support for\r
-git-fetch and git-pull to operate by packaging objects and references\r
+<tt>git-fetch</tt> and <tt>git-pull</tt> to operate by packaging objects and references\r
in an archive at the originating machine, then importing those into\r
-another repository using <a href="git-fetch.html">git-fetch(1)</a> and <a href="git-pull.html">git-pull(1)</a>\r
+another repository using <tt>git-fetch</tt> and <tt>git-pull</tt>\r
after moving the archive by some means (i.e., by sneakernet). As no\r
direct connection between repositories exists, the user must specify a\r
basis for the bundle that is held by the destination repository: the\r
<dd>\r
<p>\r
Used to create a bundle named <em>file</em>. This requires the\r
- git-rev-list arguments to define the bundle contents.\r
+ <tt>git-rev-list</tt> arguments to define the bundle contents.\r
</p>\r
</dd>\r
<dt>\r
cleanly to the current repository. This includes checks on the\r
bundle format itself as well as checking that the prerequisite\r
commits exist and are fully linked in the current repository.\r
- git-bundle prints a list of missing commits, if any, and exits\r
+ <tt>git-bundle</tt> prints a list of missing commits, if any, and exits\r
with non-zero status.\r
</p>\r
</dd>\r
</dt>\r
<dd>\r
<p>\r
- Passes the objects in the bundle to <a href="git-index-pack.html">git-index-pack(1)</a>\r
+ Passes the objects in the bundle to <tt>git-index-pack</tt>\r
for storage in the repository, then prints the names of all\r
defined references. If a reflist is given, only references\r
matching those in the given list are printed. This command is\r
- really plumbing, intended to be called only by\r
- <a href="git-fetch.html">git-fetch(1)</a>.\r
+ really plumbing, intended to be called only by <tt>git-fetch</tt>.\r
</p>\r
</dd>\r
<dt>\r
</dt>\r
<dd>\r
<p>\r
- A list of arguments, acceptable to git-rev-parse and\r
- git-rev-list, that specify the specific objects and references\r
+ A list of arguments, acceptable to <tt>git-rev-parse</tt> and\r
+ <tt>git-rev-list</tt>, that specify the specific objects and references\r
to transport. For example, "master~10..master" causes the\r
current master reference to be packaged along with all objects\r
added since its 10th ancestor commit. There is no explicit\r
<dd>\r
<p>\r
A list of references used to limit the references reported as\r
- available. This is principally of use to git-fetch, which\r
+ available. This is principally of use to <tt>git-fetch</tt>, which\r
expects to receive only those references asked for and not\r
- necessarily everything in the pack (in this case, git-bundle is\r
- acting like <a href="git-fetch-pack.html">git-fetch-pack(1)</a>).\r
+ necessarily everything in the pack (in this case, <tt>git-bundle</tt> is\r
+ acting like <tt>git-fetch-pack</tt>).\r
</p>\r
</dd>\r
</dl>\r
</div>\r
<h2>SPECIFYING REFERENCES</h2>\r
<div class="sectionbody">\r
-<p>git-bundle will only package references that are shown by\r
-git-show-ref: this includes heads, tags, and remote heads. References\r
+<p><tt>git-bundle</tt> will only package references that are shown by\r
+<tt>git-show-ref</tt>: this includes heads, tags, and remote heads. References\r
such as master~1 cannot be packaged, but are perfectly suitable for\r
defining the basis. More than one reference may be packaged, and more\r
than one basis can be specified. The objects packaged are those not\r
</ul>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-bundle create mybundle master ^lastR2bundle\r
+<pre><tt>$ git bundle create mybundle master ^lastR2bundle\r
$ git tag -f lastR2bundle master</tt></pre>\r
</div></div>\r
<ul>\r
<p>Then you move mybundle from A to B, and in R2 on B:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-bundle verify mybundle\r
-$ git-fetch mybundle master:localRef</tt></pre>\r
+<pre><tt>$ git bundle verify mybundle\r
+$ git fetch mybundle master:localRef</tt></pre>\r
</div></div>\r
<p>With something like this in the config in R2:</p>\r
<div class="listingblock">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:22 UTC\r
+Last updated 02-Jul-2008 03:01:33 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-bundle' create <file> <git-rev-list args>
-'git-bundle' verify <file>
-'git-bundle' list-heads <file> [refname...]
-'git-bundle' unbundle <file> [refname...]
+'git bundle' create <file> <git-rev-list args>
+'git bundle' verify <file>
+'git bundle' list-heads <file> [refname...]
+'git bundle' unbundle <file> [refname...]
DESCRIPTION
-----------
machine be replicated on another machine, but the two machines cannot
be directly connected so the interactive git protocols (git, ssh,
rsync, http) cannot be used. This command provides support for
-git-fetch and git-pull to operate by packaging objects and references
+`git-fetch` and `git-pull` to operate by packaging objects and references
in an archive at the originating machine, then importing those into
-another repository using linkgit:git-fetch[1] and linkgit:git-pull[1]
+another repository using `git-fetch` and `git-pull`
after moving the archive by some means (i.e., by sneakernet). As no
direct connection between repositories exists, the user must specify a
basis for the bundle that is held by the destination repository: the
create <file>::
Used to create a bundle named 'file'. This requires the
- git-rev-list arguments to define the bundle contents.
+ `git-rev-list` arguments to define the bundle contents.
verify <file>::
Used to check that a bundle file is valid and will apply
cleanly to the current repository. This includes checks on the
bundle format itself as well as checking that the prerequisite
commits exist and are fully linked in the current repository.
- git-bundle prints a list of missing commits, if any, and exits
+ `git-bundle` prints a list of missing commits, if any, and exits
with non-zero status.
list-heads <file>::
printed out.
unbundle <file>::
- Passes the objects in the bundle to linkgit:git-index-pack[1]
+ Passes the objects in the bundle to `git-index-pack`
for storage in the repository, then prints the names of all
defined references. If a reflist is given, only references
matching those in the given list are printed. This command is
- really plumbing, intended to be called only by
- linkgit:git-fetch[1].
+ really plumbing, intended to be called only by `git-fetch`.
[git-rev-list-args...]::
- A list of arguments, acceptable to git-rev-parse and
- git-rev-list, that specify the specific objects and references
+ A list of arguments, acceptable to `git-rev-parse` and
+ `git-rev-list`, that specify the specific objects and references
to transport. For example, "master~10..master" causes the
current master reference to be packaged along with all objects
added since its 10th ancestor commit. There is no explicit
[refname...]::
A list of references used to limit the references reported as
- available. This is principally of use to git-fetch, which
+ available. This is principally of use to `git-fetch`, which
expects to receive only those references asked for and not
- necessarily everything in the pack (in this case, git-bundle is
- acting like linkgit:git-fetch-pack[1]).
+ necessarily everything in the pack (in this case, `git-bundle` is
+ acting like `git-fetch-pack`).
SPECIFYING REFERENCES
---------------------
-git-bundle will only package references that are shown by
-git-show-ref: this includes heads, tags, and remote heads. References
+`git-bundle` will only package references that are shown by
+`git-show-ref`: this includes heads, tags, and remote heads. References
such as master~1 cannot be packaged, but are perfectly suitable for
defining the basis. More than one reference may be packaged, and more
than one basis can be specified. The objects packaged are those not
and move it afterwards to help build the bundle.
------------
-$ git-bundle create mybundle master ^lastR2bundle
+$ git bundle create mybundle master ^lastR2bundle
$ git tag -f lastR2bundle master
------------
Then you move mybundle from A to B, and in R2 on B:
------------
-$ git-bundle verify mybundle
-$ git-fetch mybundle master:localRef
+$ git bundle verify mybundle
+$ git fetch mybundle master:localRef
------------
With something like this in the config in R2:
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-cat-file</em> [-t | -s | -e | -p | <type>] <object>\r
-<em>git-cat-file</em> [--batch | --batch-check] < <list-of-objects></div></div>\r
+<div class="content"><em>git cat-file</em> [-t | -s | -e | -p | <type>] <object>\r
+<em>git cat-file</em> [--batch | --batch-check] < <list-of-objects></div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 11-Jun-2008 07:52:11 UTC\r
+Last updated 02-Jul-2008 03:01:34 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-cat-file' [-t | -s | -e | -p | <type>] <object>
-'git-cat-file' [--batch | --batch-check] < <list-of-objects>
+'git cat-file' [-t | -s | -e | -p | <type>] <object>
+'git cat-file' [--batch | --batch-check] < <list-of-objects>
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-check-attr</em> attr… [--] pathname…</p>\r
+<p><em>git check-attr</em> attr… [--] pathname…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:23 UTC\r
+Last updated 02-Jul-2008 03:01:34 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-check-attr' attr... [--] pathname...
+'git check-attr' attr... [--] pathname...
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-check-ref-format</em> <refname></p>\r
+<p><em>git check-ref-format</em> <refname></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
colon <tt>:</tt> is used as in <tt>srcref:dstref</tt> to mean "use srcref's\r
value and store it in dstref" in fetch and push operations.\r
It may also be used to select a specific object such as with\r
- <a href="git-cat-file.html">git-cat-file(1)</a> "git-cat-file blob v1.3.3:refs.c".\r
+ <tt>git-cat-file</tt>: "git cat-file blob v1.3.3:refs.c".\r
</p>\r
</li>\r
</ol>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:25 UTC\r
+Last updated 02-Jul-2008 03:01:35 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-check-ref-format' <refname>
+'git check-ref-format' <refname>
DESCRIPTION
-----------
. colon `:` is used as in `srcref:dstref` to mean "use srcref\'s
value and store it in dstref" in fetch and push operations.
It may also be used to select a specific object such as with
- linkgit:git-cat-file[1] "git-cat-file blob v1.3.3:refs.c".
+ `git-cat-file`: "git cat-file blob v1.3.3:refs.c".
GIT
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-checkout-index</em> [-u] [-q] [-a] [-f] [-n] [--prefix=<string>]\r
+<div class="content"><em>git checkout-index</em> [-u] [-q] [-a] [-f] [-n] [--prefix=<string>]\r
[--stage=<number>|all]\r
[--temp]\r
[-z] [--stdin]\r
</dd>\r
</dl>\r
<p>The order of the flags used to matter, but not anymore.</p>\r
-<p>Just doing <tt>git-checkout-index</tt> does nothing. You probably meant\r
-<tt>git-checkout-index -a</tt>. And if you want to force it, you want\r
-<tt>git-checkout-index -f -a</tt>.</p>\r
+<p>Just doing <tt>git checkout-index</tt> does nothing. You probably meant\r
+<tt>git checkout-index -a</tt>. And if you want to force it, you want\r
+<tt>git checkout-index -f -a</tt>.</p>\r
<p>Intuitiveness is not the goal here. Repeatability is. The reason for\r
the "no arguments means no work" behavior is that from scripts you are\r
supposed to be able to do:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ find . -name '*.h' -print0 | xargs -0 git-checkout-index -f --</tt></pre>\r
+<pre><tt>$ find . -name '*.h' -print0 | xargs -0 git checkout-index -f --</tt></pre>\r
</div></div>\r
<p>which will force all existing <tt>*.h</tt> files to be replaced with their\r
cached copies. If an empty command line implied "all", then this would\r
force-refresh everything in the index, which was not the point. But\r
-since git-checkout-index accepts --stdin it would be faster to use:</p>\r
+since <tt>git-checkout-index</tt> accepts --stdin it would be faster to use:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ find . -name '*.h' -print0 | git-checkout-index -f -z --stdin</tt></pre>\r
+<pre><tt>$ find . -name '*.h' -print0 | git checkout-index -f -z --stdin</tt></pre>\r
</div></div>\r
<p>The <tt>--</tt> is just a good idea when you know the rest will be filenames;\r
it will prevent problems with a filename of, for example, <tt>-a</tt>.\r
<dd>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-checkout-index -n -f -a && git-update-index --ignore-missing --refresh</tt></pre>\r
+<pre><tt>$ git checkout-index -n -f -a && git update-index --ignore-missing --refresh</tt></pre>\r
</div></div>\r
</dd>\r
<dt>\r
</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-checkout-index --prefix=git-export-dir/ -a</tt></pre>\r
+<pre><tt>$ git checkout-index --prefix=git-export-dir/ -a</tt></pre>\r
</div></div>\r
-<p><tt>git-checkout-index</tt> will "export" the index into the specified\r
+<p><tt>git checkout-index</tt> will "export" the index into the specified\r
directory.</p>\r
<p>The final "/" is important. The exported name is literally just\r
prefixed with the specified string. Contrast this with the\r
<dd>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-checkout-index --prefix=.merged- Makefile</tt></pre>\r
+<pre><tt>$ git checkout-index --prefix=.merged- Makefile</tt></pre>\r
</div></div>\r
<p>This will check out the currently cached copy of <tt>Makefile</tt>\r
into the file <tt>.merged-Makefile</tt>.</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:21 UTC\r
+Last updated 02-Jul-2008 03:01:34 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-checkout-index' [-u] [-q] [-a] [-f] [-n] [--prefix=<string>]
+'git checkout-index' [-u] [-q] [-a] [-f] [-n] [--prefix=<string>]
[--stage=<number>|all]
[--temp]
[-z] [--stdin]
The order of the flags used to matter, but not anymore.
-Just doing `git-checkout-index` does nothing. You probably meant
-`git-checkout-index -a`. And if you want to force it, you want
-`git-checkout-index -f -a`.
+Just doing `git checkout-index` does nothing. You probably meant
+`git checkout-index -a`. And if you want to force it, you want
+`git checkout-index -f -a`.
Intuitiveness is not the goal here. Repeatability is. The reason for
the "no arguments means no work" behavior is that from scripts you are
supposed to be able to do:
----------------
-$ find . -name '*.h' -print0 | xargs -0 git-checkout-index -f --
+$ find . -name '*.h' -print0 | xargs -0 git checkout-index -f --
----------------
which will force all existing `*.h` files to be replaced with their
cached copies. If an empty command line implied "all", then this would
force-refresh everything in the index, which was not the point. But
-since git-checkout-index accepts --stdin it would be faster to use:
+since `git-checkout-index` accepts --stdin it would be faster to use:
----------------
-$ find . -name '*.h' -print0 | git-checkout-index -f -z --stdin
+$ find . -name '*.h' -print0 | git checkout-index -f -z --stdin
----------------
The `--` is just a good idea when you know the rest will be filenames;
To update and refresh only the files already checked out::
+
----------------
-$ git-checkout-index -n -f -a && git-update-index --ignore-missing --refresh
+$ git checkout-index -n -f -a && git update-index --ignore-missing --refresh
----------------
Using `git-checkout-index` to "export an entire tree"::
Just read the desired tree into the index, and do:
+
----------------
-$ git-checkout-index --prefix=git-export-dir/ -a
+$ git checkout-index --prefix=git-export-dir/ -a
----------------
+
-`git-checkout-index` will "export" the index into the specified
+`git checkout-index` will "export" the index into the specified
directory.
+
The final "/" is important. The exported name is literally just
Export files with a prefix::
+
----------------
-$ git-checkout-index --prefix=.merged- Makefile
+$ git checkout-index --prefix=.merged- Makefile
----------------
+
This will check out the currently cached copy of `Makefile`
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-checkout</em> [-q] [-f] [[--track | --no-track] -b <new_branch> [-l]] [-m] [<branch>]\r
-<em>git-checkout</em> [<tree-ish>] <paths>…</div></div>\r
+<div class="content"><em>git checkout</em> [-q] [-f] [[--track | --no-track] -b <new_branch> [-l]] [-m] [<branch>]\r
+<em>git checkout</em> [<tree-ish>] <paths>…</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
options, which will be passed to <tt>git branch</tt>.</p>\r
<p>When <paths> are given, this command does <strong>not</strong> switch\r
branches. It updates the named paths in the working tree from\r
-the index file (i.e. it runs <tt>git-checkout-index -f -u</tt>), or\r
+the index file (i.e. it runs <tt>git checkout-index -f -u</tt>), or\r
from a named commit. In\r
this case, the <tt>-f</tt> and <tt>-b</tt> options are meaningless and giving\r
either of them results in an error. <tree-ish> argument can be\r
</dt>\r
<dd>\r
<p>\r
- When creating a new branch, set up configuration so that git-pull\r
+ When creating a new branch, set up configuration so that <tt>git-pull</tt>\r
will automatically retrieve data from the start point, which must be\r
a branch. Use this if you always pull from the same upstream branch\r
into the new branch, and if you don't want to use "git pull\r
<repository> <refspec>" explicitly. This behavior is the default\r
when the start point is a remote branch. Set the\r
branch.autosetupmerge configuration variable to <tt>false</tt> if you want\r
- git-checkout and git-branch to always behave as if <em>--no-track</em> were\r
+ <tt>git-checkout</tt> and <tt>git-branch</tt> to always behave as if <em>--no-track</em> were\r
given. Set it to <tt>always</tt> if you want this behavior when the\r
start-point is either a local or remote branch.\r
</p>\r
current branch and directly point at the commit named by the tag\r
(<tt>v2.6.18</tt> in the above example).</p>\r
<p>You can use usual git commands while in this state. You can use\r
-<tt>git-reset --hard $othercommit</tt> to further move around, for\r
+<tt>git reset --hard $othercommit</tt> to further move around, for\r
example. You can make changes and create a new commit on top of\r
a detached HEAD. You can even create a merge by using <tt>git\r
merge $othercommit</tt>.</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:22 UTC\r
+Last updated 02-Jul-2008 03:01:34 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-checkout' [-q] [-f] [[--track | --no-track] -b <new_branch> [-l]] [-m] [<branch>]
-'git
-checkout' [<tree-ish>] <paths>...
+'git checkout' [-q] [-f] [[--track | --no-track] -b <new_branch> [-l]] [-m] [<branch>]
+'git
checkout' [<tree-ish>] <paths>...
DESCRIPTION
-----------
When <paths> are given, this command does *not* switch
branches. It updates the named paths in the working tree from
-the index file (i.e. it runs `git-checkout-index -f -u`), or
+the index file (i.e. it runs `git checkout-index -f -u`), or
from a named commit. In
this case, the `-f` and `-b` options are meaningless and giving
either of them results in an error. <tree-ish> argument can be
-t::
--track::
- When creating a new branch, set up configuration so that git-pull
+ When creating a new branch, set up configuration so that `git-pull`
will automatically retrieve data from the start point, which must be
a branch. Use this if you always pull from the same upstream branch
into the new branch, and if you don't want to use "git pull
<repository> <refspec>" explicitly. This behavior is the default
when the start point is a remote branch. Set the
branch.autosetupmerge configuration variable to `false` if you want
- git-checkout and git-branch to always behave as if '--no-track' were
+ `git-checkout` and `git-branch` to always behave as if '--no-track' were
given. Set it to `always` if you want this behavior when the
start-point is either a local or remote branch.
(`v2.6.18` in the above example).
You can use usual git commands while in this state. You can use
-`git-reset --hard $othercommit` to further move around, for
+`git reset --hard $othercommit` to further move around, for
example. You can make changes and create a new commit on top of
a detached HEAD. You can even create a merge by using `git
merge $othercommit`.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-cherry-pick</em> [--edit] [-n] [-m parent-number] [-s] [-x] <commit></p>\r
+<p><em>git cherry-pick</em> [--edit] [-n] [-m parent-number] [-s] [-x] <commit></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<dd>\r
<p>\r
Commit to cherry-pick.\r
- For a more complete list of ways to spell commits, see\r
+ For a more complete list of ways to spell commits, see the\r
"SPECIFYING REVISIONS" section in <a href="git-rev-parse.html">git-rev-parse(1)</a>.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:23 UTC\r
+Last updated 02-Jul-2008 03:01:35 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-cherry-pick' [--edit] [-n] [-m parent-number] [-s] [-x] <commit>
+'git cherry-pick' [--edit] [-n] [-m parent-number] [-s] [-x] <commit>
DESCRIPTION
-----------
-------
<commit>::
Commit to cherry-pick.
- For a more complete list of ways to spell commits, see
+ For a more complete list of ways to spell commits, see the
"SPECIFYING REVISIONS" section in linkgit:git-rev-parse[1].
-e::
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-cherry</em> [-v] <upstream> [<head>] [<limit>]</p>\r
+<p><em>git cherry</em> [-v] <upstream> [<head>] [<limit>]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>The changeset (or "diff") of each commit between the fork-point and <head>\r
is compared against each commit between the fork-point and <upstream>.\r
-The commits are compared with their <em>patch id</em>, obtained from <a href="git-patch-id.html">git-patch-id(1)</a>\r
-program.</p>\r
+The commits are compared with their <em>patch id</em>, obtained from\r
+the <tt>git-patch-id</tt> program.</p>\r
<p>Every commit that doesn't exist in the <upstream> branch\r
has its id (sha1) reported, prefixed by a symbol. The ones that have\r
equivalent change already\r
fork-point\r
\__*__*__<limit>__-__+__> <head></tt></pre>\r
</div></div>\r
-<p>Because git-cherry compares the changeset rather than the commit id\r
-(sha1), you can use git-cherry to find out if a commit you made locally\r
+<p>Because <tt>git-cherry</tt> compares the changeset rather than the commit id\r
+(sha1), you can use <tt>git-cherry</tt> to find out if a commit you made locally\r
has been applied <upstream> under a different commit id. For example,\r
this will happen if you're feeding patches <upstream> via email rather\r
than pushing or pulling commits directly.</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:25 UTC\r
+Last updated 02-Jul-2008 03:01:35 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-cherry' [-v] <upstream> [<head>] [<limit>]
+'git cherry' [-v] <upstream> [<head>] [<limit>]
DESCRIPTION
-----------
The changeset (or "diff") of each commit between the fork-point and <head>
is compared against each commit between the fork-point and <upstream>.
-The commits are compared with their 'patch id', obtained from linkgit:git-patch-id[1]
-program.
+The commits are compared with their 'patch id', obtained from
+the `git-patch-id` program.
Every commit that doesn't exist in the <upstream> branch
has its id (sha1) reported, prefixed by a symbol. The ones that have
\__*__*__<limit>__-__+__> <head>
-Because git-cherry compares the changeset rather than the commit id
-(sha1), you can use git-cherry to find out if a commit you made locally
+Because `git-cherry` compares the changeset rather than the commit id
+(sha1), you can use `git-cherry` to find out if a commit you made locally
has been applied <upstream> under a different commit id. For example,
this will happen if you're feeding patches <upstream> via email rather
than pushing or pulling commits directly.
<p>A Tcl/Tk based graphical interface to review modified files, stage\r
them into the index, enter a commit message and record the new\r
commit onto the current branch. This interface is an alternative\r
-to the less interactive <a href="git-commit.html">git-commit(1)</a> program.</p>\r
-<p>git-citool is actually a standard alias for <em>git gui citool</em>.\r
+to the less interactive <tt>git-commit</tt> program.</p>\r
+<p><tt>git-citool</tt> is actually a standard alias for <tt>git gui citool</tt>.\r
See <a href="git-gui.html">git-gui(1)</a> for more details.</p>\r
</div>\r
<h2>Author</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:25 UTC\r
+Last updated 02-Jul-2008 03:01:35 UTC\r
</div>\r
</div>\r
</body>\r
A Tcl/Tk based graphical interface to review modified files, stage
them into the index, enter a commit message and record the new
commit onto the current branch. This interface is an alternative
-to the less interactive linkgit:git-commit[1] program.
+to the less interactive `git-commit` program.
-git-citool is actually a standard alias for 'git gui citool'.
+`git-citool` is actually a standard alias for `git gui citool`.
See linkgit:git-gui[1] for more details.
Author
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-clean</em> [-d] [-f] [-n] [-q] [-x | -X] [--] <paths>…</div></div>\r
+<div class="content"><em>git clean</em> [-d] [-f] [-n] [-q] [-x | -X] [--] <paths>…</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<dd>\r
<p>\r
If the git configuration specifies clean.requireForce as true,\r
- git-clean will refuse to run unless given -f or -n.\r
+ <tt>git-clean</tt> will refuse to run unless given -f or -n.\r
</p>\r
</dd>\r
<dt>\r
<p>\r
Don't use the ignore rules. This allows removing all untracked\r
files, including build products. This can be used (possibly in\r
- conjunction with <a href="git-reset.html">git-reset(1)</a>) to create a pristine\r
+ conjunction with <tt>git-reset</tt>) to create a pristine\r
working directory to test a clean build.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:23 UTC\r
+Last updated 02-Jul-2008 03:01:36 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git
-clean' [-d] [-f] [-n] [-q] [-x | -X] [--] <paths>...
+'git
clean' [-d] [-f] [-n] [-q] [-x | -X] [--] <paths>...
DESCRIPTION
-----------
-f::
If the git configuration specifies clean.requireForce as true,
- git-clean will refuse to run unless given -f or -n.
+ `git-clean` will refuse to run unless given -f or -n.
-n::
--dry-run::
-x::
Don't use the ignore rules. This allows removing all untracked
files, including build products. This can be used (possibly in
- conjunction with linkgit:git-reset[1]) to create a pristine
+ conjunction with `git-reset`) to create a pristine
working directory to test a clean build.
-X::
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-clone</em> [--template=<template_directory>]\r
+<div class="content"><em>git clone</em> [--template=<template_directory>]\r
[-l] [-s] [--no-hardlinks] [-q] [-n] [--bare]\r
[-o <name>] [-u <upload-pack>] [--reference <repository>]\r
[--depth <depth>] [--] <repository> [<directory>]</div></div>\r
repository using this option and then delete branches (or use any\r
other git command that makes any existing commit unreferenced) in the\r
source repository, some objects may become unreferenced (or dangling).\r
-These objects may be removed by normal git operations (such as git-commit[1])\r
-which automatically call git-gc[1]. If these objects are removed and\r
-were referenced by the cloned repository, then the cloned repository\r
-will become corrupt.</p>\r
+These objects may be removed by normal git operations (such as <tt>git-commit</tt>)\r
+which automatically call <tt>git gc --auto</tt>. (See <a href="git-gc.html">git-gc(1)</a>.)\r
+If these objects are removed and were referenced by the cloned repository,\r
+then the cloned repository will become corrupt.</p>\r
</dd>\r
<dt>\r
--reference <repository>\r
<dd>\r
<p>\r
Operate quietly. This flag is passed to "rsync" and\r
- "git-fetch-pack" commands when given.\r
+ <tt>git-fetch-pack</tt> commands when given.\r
</p>\r
</dd>\r
<dt>\r
<dd>\r
<p>\r
When given, and the repository to clone from is handled\r
- by <em>git-fetch-pack</em>, <em>--exec=<upload-pack></em> is passed to\r
+ by <tt>git-fetch-pack</tt>, <tt>--exec=<upload-pack></tt> is passed to\r
the command to specify non-default path for the command\r
run on the other end.\r
</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:26 UTC\r
+Last updated 02-Jul-2008 03:01:36 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-clone' [--template=<template_directory>]
+'git clone' [--template=<template_directory>]
[-l] [-s] [--no-hardlinks] [-q] [-n] [--bare]
[-o <name>] [-u <upload-pack>] [--reference <repository>]
[--depth <depth>] [--] <repository> [<directory>]
repository using this option and then delete branches (or use any
other git command that makes any existing commit unreferenced) in the
source repository, some objects may become unreferenced (or dangling).
-These objects may be removed by normal git operations (such as git-commit[1])
-which automatically call git-gc[1]. If these objects are removed and
-were referenced by the cloned repository, then the cloned repository
-will become corrupt.
+These objects may be removed by normal git operations (such as `git-commit`)
+which automatically call `git gc --auto`. (See linkgit:git-gc[1].)
+If these objects are removed and were referenced by the cloned repository,
+then the cloned repository will become corrupt.
--quiet::
-q::
Operate quietly. This flag is passed to "rsync" and
- "git-fetch-pack" commands when given.
+ `git-fetch-pack` commands when given.
--no-checkout::
-n::
--upload-pack <upload-pack>::
-u <upload-pack>::
When given, and the repository to clone from is handled
- by 'git-fetch-pack', '--exec=<upload-pack>' is passed to
+ by `git-fetch-pack`, `--exec=<upload-pack>` is passed to
the command to specify non-default path for the command
run on the other end.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-commit-tree</em> <tree> [-p <parent commit>]* < changelog</p>\r
+<p><em>git commit-tree</em> <tree> [-p <parent commit>]* < changelog</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
is taken from the configuration items user.name and user.email, or, if not\r
present, system user name and fully qualified hostname.</p>\r
<p>A commit comment is read from stdin. If a changelog\r
-entry is not provided via "<" redirection, "git-commit-tree" will just wait\r
+entry is not provided via "<" redirection, <tt>git-commit-tree</tt> will just wait\r
for one to be entered and terminated with ^D.</p>\r
</div>\r
<h2>Diagnostics</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:27 UTC\r
+Last updated 02-Jul-2008 03:01:36 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-commit-tree' <tree> [-p <parent commit>]\* < changelog
+'git
commit-tree' <tree> [-p <parent commit>]\* < changelog
DESCRIPTION
-----------
present, system user name and fully qualified hostname.
A commit comment is read from stdin. If a changelog
-entry is not provided via "<" redirection, "git-commit-tree" will just wait
+entry is not provided via "<" redirection, `git-commit-tree` will just wait
for one to be entered and terminated with ^D.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-commit</em> [-a | --interactive] [-s] [-v] [-u<mode>] [--amend]\r
+<div class="content"><em>git commit</em> [-a | --interactive] [-s] [-v] [-u<mode>] [--amend]\r
[(-c | -C) <commit>] [-F <file> | -m <msg>]\r
[--allow-empty] [--no-verify] [-e] [--author=<author>]\r
[--cleanup=<mode>] [--] [[-i | -o ]<file>…]</div></div>\r
<ol>\r
<li>\r
<p>\r
-by using <a href="git-add.html">git-add(1)</a> to incrementally "add" changes to the\r
+by using <tt>git-add</tt> to incrementally "add" changes to the\r
index before using the <em>commit</em> command (Note: even modified\r
files must be "added");\r
</p>\r
</li>\r
<li>\r
<p>\r
-by using <a href="git-rm.html">git-rm(1)</a> to remove files from the working tree\r
+by using <tt>git-rm</tt> to remove files from the working tree\r
and the index, again before using the <em>commit</em> command;\r
</p>\r
</li>\r
</p>\r
</li>\r
</ol>\r
-<p>The <a href="git-status.html">git-status(1)</a> command can be used to obtain a\r
+<p>The <tt>git-status</tt> command can be used to obtain a\r
summary of what is included by any of the above for the next\r
commit by giving the same set of parameters you would give to\r
this command.</p>\r
-<p>If you make a commit and then found a mistake immediately after\r
-that, you can recover from it with <a href="git-reset.html">git-reset(1)</a>.</p>\r
+<p>If you make a commit and then find a mistake immediately after\r
+that, you can recover from it with <tt>git-reset</tt>.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
<dd>\r
<p>\r
This option bypasses the pre-commit and commit-msg hooks.\r
- See also <a href="githooks.html">githooks(5)</a>[hooks].\r
+ See also <a href="githooks.html">githooks(5)</a>.\r
</p>\r
</dd>\r
<dt>\r
<div class="sectionbody">\r
<p>When recording your own work, the contents of modified files in\r
your working tree are temporarily stored to a staging area\r
-called the "index" with <a href="git-add.html">git-add(1)</a>. A file can be\r
+called the "index" with <tt>git-add</tt>. A file can be\r
reverted back, only in the index but not in the working tree,\r
-to that of the last commit with <tt>git-reset HEAD — <file></tt>,\r
+to that of the last commit with <tt>git reset HEAD — <file></tt>,\r
which effectively reverts <tt>git-add</tt> and prevents the changes to\r
this file from participating in the next commit. After building\r
the state to be committed incrementally with these commands,\r
</div></div>\r
<p>this second commit would record the changes to <tt>hello.c</tt> and\r
<tt>hello.h</tt> as expected.</p>\r
-<p>After a merge (initiated by either <a href="git-merge.html">git-merge(1)</a> or\r
-<a href="git-pull.html">git-pull(1)</a>) stops because of conflicts, cleanly merged\r
+<p>After a merge (initiated by <tt>git-merge</tt> or <tt>git-pull</tt>) stops\r
+because of conflicts, cleanly merged\r
paths are already staged to be committed for you, and paths that\r
conflicted are left in unmerged state. You would have to first\r
-check which paths are conflicting with <a href="git-status.html">git-status(1)</a>\r
+check which paths are conflicting with <tt>git-status</tt>\r
and after fixing them manually in your working tree, you would\r
-stage the result as usual with <a href="git-add.html">git-add(1)</a>:</p>\r
+stage the result as usual with <tt>git-add</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git status | grep unmerged\r
<h2>HOOKS</h2>\r
<div class="sectionbody">\r
<p>This command can run <tt>commit-msg</tt>, <tt>prepare-commit-msg</tt>, <tt>pre-commit</tt>,\r
-and <tt>post-commit</tt> hooks. See <a href="githooks.html">githooks(5)</a>[hooks] for more\r
+and <tt>post-commit</tt> hooks. See <a href="githooks.html">githooks(5)</a> for more\r
information.</p>\r
</div>\r
<h2>SEE ALSO</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 23-Jun-2008 07:13:34 UTC\r
+Last updated 02-Jul-2008 03:01:36 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-commit' [-a | --interactive] [-s] [-v] [-u<mode>] [--amend]
+'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>...]
The content to be added can be specified in several ways:
-1. by using linkgit:git-add[1] to incrementally "add" changes to the
+1. by using `git-add` to incrementally "add" changes to the
index before using the 'commit' command (Note: even modified
files must be "added");
-2. by using linkgit:git-rm[1] to remove files from the working tree
+2. by using `git-rm` to remove files from the working tree
and the index, again before using the 'commit' command;
3. by listing files as arguments to the 'commit' command, in which
by one which files should be part of the commit, before finalizing the
operation. Currently, this is done by invoking `git-add --interactive`.
-The linkgit:git-status[1] command can be used to obtain a
+The `git-status` command can be used to obtain a
summary of what is included by any of the above for the next
commit by giving the same set of parameters you would give to
this command.
-If you make a commit and then found a mistake immediately after
-that, you can recover from it with linkgit:git-reset[1].
+If you make a commit and then find a mistake immediately after
+that, you can recover from it with `git-reset`.
OPTIONS
-n::
--no-verify::
This option bypasses the pre-commit and commit-msg hooks.
- See also linkgit:githooks[5][hooks].
+ See also linkgit:githooks[5].
--allow-empty::
Usually recording a commit that has the exact same tree as its
--------
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 linkgit:git-add[1]. A file can be
+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,
this second commit would record the changes to `hello.c` and
`hello.h` as expected.
-After a merge (initiated by either linkgit:git-merge[1] or
-linkgit:git-pull[1]) stops because of conflicts, cleanly merged
+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 linkgit:git-status[1]
+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 linkgit:git-add[1]:
+stage the result as usual with `git-add`:
------------
$ git status | grep unmerged
HOOKS
-----
This command can run `commit-msg`, `prepare-commit-msg`, `pre-commit`,
-and `post-commit` hooks. See linkgit:githooks[5][hooks] for more
+and `post-commit` hooks. See linkgit:githooks[5] for more
information.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-config</em> [<file-option>] [type] [-z|--null] name [value [value_regex]]\r
-<em>git-config</em> [<file-option>] [type] --add name value\r
-<em>git-config</em> [<file-option>] [type] --replace-all name [value [value_regex]]\r
-<em>git-config</em> [<file-option>] [type] [-z|--null] --get name [value_regex]\r
-<em>git-config</em> [<file-option>] [type] [-z|--null] --get-all name [value_regex]\r
-<em>git-config</em> [<file-option>] [type] [-z|--null] --get-regexp name_regex [value_regex]\r
-<em>git-config</em> [<file-option>] --unset name [value_regex]\r
-<em>git-config</em> [<file-option>] --unset-all name [value_regex]\r
-<em>git-config</em> [<file-option>] --rename-section old_name new_name\r
-<em>git-config</em> [<file-option>] --remove-section name\r
-<em>git-config</em> [<file-option>] [-z|--null] -l | --list\r
-<em>git-config</em> [<file-option>] --get-color name [default]\r
-<em>git-config</em> [<file-option>] --get-colorbool name [stdout-is-tty]</div></div>\r
+<div class="content"><em>git config</em> [<file-option>] [type] [-z|--null] name [value [value_regex]]\r
+<em>git config</em> [<file-option>] [type] --add name value\r
+<em>git config</em> [<file-option>] [type] --replace-all name [value [value_regex]]\r
+<em>git config</em> [<file-option>] [type] [-z|--null] --get name [value_regex]\r
+<em>git config</em> [<file-option>] [type] [-z|--null] --get-all name [value_regex]\r
+<em>git config</em> [<file-option>] [type] [-z|--null] --get-regexp name_regex [value_regex]\r
+<em>git config</em> [<file-option>] --unset name [value_regex]\r
+<em>git config</em> [<file-option>] --unset-all name [value_regex]\r
+<em>git config</em> [<file-option>] --rename-section old_name new_name\r
+<em>git config</em> [<file-option>] --remove-section name\r
+<em>git config</em> [<file-option>] [-z|--null] -l | --list\r
+<em>git config</em> [<file-option>] --get-color name [default]\r
+<em>git config</em> [<file-option>] --get-colorbool name [stdout-is-tty]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
you want to handle the lines that do <strong>not</strong> match the regex, just\r
prepend a single exclamation mark in front (see also <a href="#EXAMPLES">[EXAMPLES]</a>).</p>\r
<p>The type specifier can be either <em>--int</em> or <em>--bool</em>, which will make\r
-<em>git-config</em> ensure that the variable(s) are of the given type and\r
+<tt>git-config</tt> ensure that the variable(s) are of the given type and\r
convert the value to the canonical form (simple decimal number for int,\r
a "true" or "false" string for bool). If no type specifier is passed,\r
no checks or transformations are performed on the value.</p>\r
</dt>\r
<dd>\r
<p>\r
- git-config will ensure that the output is "true" or "false"\r
+ <tt>git-config</tt> will ensure that the output is "true" or "false"\r
</p>\r
</dd>\r
<dt>\r
</dt>\r
<dd>\r
<p>\r
- git-config will ensure that the output is a simple\r
+ <tt>git-config</tt> will ensure that the output is a simple\r
decimal number. An optional value suffix of <em>k</em>, <em>m</em>, or <em>g</em>\r
in the config file will cause the value to be multiplied\r
by 1024, 1048576, or 1073741824 prior to output.\r
<h2><a id="FILES"></a>FILES</h2>\r
<div class="sectionbody">\r
<p>If not set explicitly with <em>--file</em>, there are three files where\r
-git-config will search for configuration options:</p>\r
+<tt>git-config</tt> will search for configuration options:</p>\r
<dl>\r
<dt>\r
$GIT_DIR/config\r
<p>If no further options are given, all reading options will read all of these\r
files that are available. If the global or the system-wide configuration\r
file are not available they will be ignored. If the repository configuration\r
-file is not available or readable, git-config will exit with a non-zero\r
+file is not available or readable, <tt>git-config</tt> will exit with a non-zero\r
error code. However, in neither case will an error message be issued.</p>\r
<p>All writing options will per default write to the repository specific\r
configuration file. Note that this also affects options like <em>--replace-all</em>\r
-and <em>--unset</em>. <strong>git-config will only ever change one file at a time</strong>.</p>\r
+and <em>--unset</em>. <strong><tt>git-config</tt> will only ever change one file at a time</strong>.</p>\r
<p>You can override these rules either by command line options or by environment\r
variables. The <em>--global</em> and the <em>--system</em> options will limit the file used\r
to the global or system-wide file respectively. The GIT_CONFIG environment\r
legacy pack index used by Git versions prior to 1.5.2, and 2 for\r
the new pack index with capabilities for packs larger than 4 GB\r
as well as proper protection against the repacking of corrupted\r
- packs. Version 2 is selected and this config option ignored\r
- whenever the corresponding pack is larger than 2 GB. Otherwise\r
- the default is 1.\r
+ packs. Version 2 is the default. Note that version 2 is enforced\r
+ and this config option ignored whenever the corresponding pack is\r
+ larger than 2 GB.\r
</p>\r
+<p>If you have an old git that does not understand the version 2 <tt>*.idx</tt> file,\r
+cloning or fetching over a non native protocol (e.g. "http" and "rsync")\r
+that will copy both <tt>*.pack</tt> file and corresponding <tt>*.idx</tt> file from the\r
+other side may give you a repository that cannot be accessed with your\r
+older version of git. If the <tt>*.pack</tt> file is smaller than 2 GB, however,\r
+you can use <a href="git-index-pack.html">git-index-pack(1)</a> on the *.pack file to regenerate\r
+the <tt>*.idx</tt> file.</p>\r
</dd>\r
<dt>\r
pack.packSizeLimit\r
</dt>\r
<dd>\r
<p>\r
- Allow <a href="git-repack.html">git-repack(1)</a> to create packs that uses\r
- delta-base offset. Defaults to false.\r
+ By default, <a href="git-repack.html">git-repack(1)</a> creates packs that use\r
+ delta-base offset. If you need to share your repository with\r
+ git older than version 1.4.4, either directly or via a dumb\r
+ protocol such as http, then you need to set this option to\r
+ "false" and repack. Access from old git versions over the\r
+ native protocol are unaffected by this option.\r
</p>\r
</dd>\r
<dt>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 29-Jun-2008 08:48:21 UTC\r
+Last updated 02-Jul-2008 03:01:37 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-config' [<file-option>] [type] [-z|--null] name [value [value_regex]]
-'git-config' [<file-option>] [type] --add name value
-'git-config' [<file-option>] [type] --replace-all name [value [value_regex]]
-'git-config' [<file-option>] [type] [-z|--null] --get name [value_regex]
-'git-config' [<file-option>] [type] [-z|--null] --get-all name [value_regex]
-'git-config' [<file-option>] [type] [-z|--null] --get-regexp name_regex [value_regex]
-'git-config' [<file-option>] --unset name [value_regex]
-'git-config' [<file-option>] --unset-all name [value_regex]
-'git-config' [<file-option>] --rename-section old_name new_name
-'git-config' [<file-option>] --remove-section name
-'git-config' [<file-option>] [-z|--null] -l | --list
-'git-config' [<file-option>] --get-color name [default]
-'git-config' [<file-option>] --get-colorbool name [stdout-is-tty]
+'git config' [<file-option>] [type] [-z|--null] name [value [value_regex]]
+'git config' [<file-option>] [type] --add name value
+'git config' [<file-option>] [type] --replace-all name [value [value_regex]]
+'git config' [<file-option>] [type] [-z|--null] --get name [value_regex]
+'git config' [<file-option>] [type] [-z|--null] --get-all name [value_regex]
+'git config' [<file-option>] [type] [-z|--null] --get-regexp name_regex [value_regex]
+'git config' [<file-option>] --unset name [value_regex]
+'git config' [<file-option>] --unset-all name [value_regex]
+'git config' [<file-option>] --rename-section old_name new_name
+'git config' [<file-option>] --remove-section name
+'git config' [<file-option>] [-z|--null] -l | --list
+'git config' [<file-option>] --get-color name [default]
+'git config' [<file-option>] --get-colorbool name [stdout-is-tty]
DESCRIPTION
-----------
prepend a single exclamation mark in front (see also <<EXAMPLES>>).
The type specifier can be either '--int' or '--bool', which will make
-'git-config' ensure that the variable(s) are of the given type and
+`git-config` ensure that the variable(s) are of the given type and
convert the value to the canonical form (simple decimal number for int,
a "true" or "false" string for bool). If no type specifier is passed,
no checks or transformations are performed on the value.
List all variables set in config file.
--bool::
- git-config will ensure that the output is "true" or "false"
+ `git-config` will ensure that the output is "true" or "false"
--int::
- git-config will ensure that the output is a simple
+ `git-config` will ensure that the output is a simple
decimal number. An optional value suffix of 'k', 'm', or 'g'
in the config file will cause the value to be multiplied
by 1024, 1048576, or 1073741824 prior to output.
-----
If not set explicitly with '--file', there are three files where
-git-config will search for configuration options:
+`git-config` will search for configuration options:
$GIT_DIR/config::
Repository specific configuration file. (The filename is
If no further options are given, all reading options will read all of these
files that are available. If the global or the system-wide configuration
file are not available they will be ignored. If the repository configuration
-file is not available or readable, git-config will exit with a non-zero
+file is not available or readable, `git-config` will exit with a non-zero
error code. However, in neither case will an error message be issued.
All writing options will per default write to the repository specific
configuration file. Note that this also affects options like '--replace-all'
-and '--unset'. *git-config will only ever change one file at a time*.
+and '--unset'. *`git-config` will only ever change one file at a time*.
You can override these rules either by command line options or by environment
variables. The '--global' and the '--system' options will limit the file used
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-count-objects</em> [-v]</p>\r
+<p><em>git count-objects</em> [-v]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
In addition to the number of loose objects and disk\r
space consumed, it reports the number of in-pack\r
objects, number of packs, and number of objects that can be\r
- removed by running <tt>git-prune-packed</tt>.\r
+ removed by running <tt>git prune-packed</tt>.\r
</p>\r
</dd>\r
</dl>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:27 UTC\r
+Last updated 02-Jul-2008 03:01:37 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-count-objects' [-v]
+'git count-objects' [-v]
DESCRIPTION
-----------
In addition to the number of loose objects and disk
space consumed, it reports the number of in-pack
objects, number of packs, and number of objects that can be
- removed by running `git-prune-packed`.
+ removed by running `git prune-packed`.
Author
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-cvsexportcommit</em> [-h] [-u] [-v] [-c] [-P] [-p] [-a] [-d cvsroot] [-w cvsworkdir] [-W] [-f] [-m msgprefix] [PARENTCOMMIT] COMMITID</p>\r
+<p><em>git cvsexportcommit</em> [-h] [-u] [-v] [-c] [-P] [-p] [-a] [-d cvsroot]\r
+ [-w cvsworkdir] [-W] [-f] [-m msgprefix] [PARENTCOMMIT] COMMITID</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
unchanged and up to date in the CVS checkout, and it will not autocommit\r
by default.</p>\r
<p>Supports file additions, removals, and commits that affect binary files.</p>\r
-<p>If the commit is a merge commit, you must tell git-cvsexportcommit what parent\r
-should the changeset be done against.</p>\r
+<p>If the commit is a merge commit, you must tell <tt>git-cvsexportcommit</tt> what\r
+parent the changeset should be done against.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
<div class="content">\r
<pre><tt>$ export GIT_DIR=~/project/.git\r
$ cd ~/project_cvs_checkout\r
-$ git-cvsexportcommit -v <commit-sha1>\r
+$ git cvsexportcommit -v <commit-sha1>\r
$ cvs commit -F .msg <files></tt></pre>\r
</div></div>\r
</dd>\r
<dd>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> $ git-cvsexportcommit -v -c -w ~/project_cvs_checkout <commit-sha1></tt></pre>\r
+<pre><tt> $ git cvsexportcommit -v -c -w ~/project_cvs_checkout <commit-sha1></tt></pre>\r
</div></div>\r
</dd>\r
<dt>\r
<div class="content">\r
<pre><tt>$ export GIT_DIR=~/project/.git\r
$ cd ~/project_cvs_checkout\r
-$ git-cherry cvshead myhead | sed -n 's/^+ //p' | xargs -l1 git-cvsexportcommit -c -p -v</tt></pre>\r
+$ git cherry cvshead myhead | sed -n 's/^+ //p' | xargs -l1 git cvsexportcommit -c -p -v</tt></pre>\r
</div></div>\r
</dd>\r
</dl>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:29 UTC\r
+Last updated 02-Jul-2008 03:01:38 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-cvsexportcommit' [-h] [-u] [-v] [-c] [-P] [-p] [-a] [-d cvsroot] [-w cvsworkdir] [-W] [-f] [-m msgprefix] [PARENTCOMMIT] COMMITID
+'git cvsexportcommit' [-h] [-u] [-v] [-c] [-P] [-p] [-a] [-d cvsroot]
+ [-w cvsworkdir] [-W] [-f] [-m msgprefix] [PARENTCOMMIT] COMMITID
DESCRIPTION
Supports file additions, removals, and commits that affect binary files.
-If the commit is a merge commit, you must tell git-cvsexportcommit what parent
-should the changeset be done against.
+If the commit is a merge commit, you must tell `git-cvsexportcommit` what
+parent the changeset should be done against.
OPTIONS
-------
------------
$ export GIT_DIR=~/project/.git
$ cd ~/project_cvs_checkout
-$ git-cvsexportcommit -v <commit-sha1>
+$ git cvsexportcommit -v <commit-sha1>
$ cvs commit -F .msg <files>
------------
Merge one patch into CVS (-c and -w options). The working directory is within the Git Repo::
+
------------
- $ git-cvsexportcommit -v -c -w ~/project_cvs_checkout <commit-sha1>
+ $ git cvsexportcommit -v -c -w ~/project_cvs_checkout <commit-sha1>
------------
Merge pending patches into CVS automatically -- only if you really know what you are doing::
------------
$ export GIT_DIR=~/project/.git
$ cd ~/project_cvs_checkout
-$ git-cherry cvshead myhead | sed -n 's/^+ //p' | xargs -l1 git-cvsexportcommit -c -p -v
+$ git cherry cvshead myhead | sed -n 's/^+ //p' | xargs -l1 git cvsexportcommit -c -p -v
------------
Author
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-cvsimport</em> [-o <branch-for-HEAD>] [-h] [-v] [-d <CVSROOT>]\r
+<div class="content"><em>git cvsimport</em> [-o <branch-for-HEAD>] [-h] [-v] [-d <CVSROOT>]\r
[-A <author-conv-file>] [-p <options-for-cvsps>] [-P <file>]\r
[-C <git_repository>] [-z <fuzz>] [-i] [-k] [-u] [-s <subst>]\r
[-a] [-m] [-M <regex>] [-S <regex>] [-L <commitlimit>]\r
<p>Splitting the CVS log into patch sets is done by <em>cvsps</em>.\r
At least version 2.1 is required.</p>\r
<p>You should <strong>never</strong> do any work of your own on the branches that are\r
-created by git-cvsimport. By default initial import will create and populate a\r
+created by <tt>git-cvsimport</tt>. By default initial import will create and populate a\r
"master" branch from the CVS repository's main branch which you're free\r
-to work with; after that, you need to <em>git merge</em> incremental imports, or\r
+to work with; after that, you need to <tt>git-merge</tt> incremental imports, or\r
any CVS branches, yourself. It is advisable to specify a named remote via\r
-r to separate and protect the incoming branches.</p>\r
</div>\r
<p>\r
The root of the CVS archive. May be local (a simple path) or remote;\r
currently, only the :local:, :ext: and :pserver: access methods\r
- are supported. If not given, git-cvsimport will try to read it\r
+ are supported. If not given, <tt>git-cvsimport</tt> will try to read it\r
from <tt>CVS/Root</tt>. If no such file exists, it checks for the\r
<tt>CVSROOT</tt> environment variable.\r
</p>\r
<dd>\r
<p>\r
The CVS module you want to import. Relative to <CVSROOT>.\r
- If not given, git-cvsimport tries to read it from\r
+ If not given, <tt>git-cvsimport</tt> tries to read it from\r
<tt>CVS/Repository</tt>.\r
</p>\r
</dd>\r
<p>\r
The git remote to import this CVS repository into.\r
Moves all CVS branches into remotes/<remote>/<branch>\r
- akin to the git-clone --use-separate-remote option.\r
+ akin to the <tt>git-clone</tt> "--use-separate-remote" option.\r
</p>\r
</dd>\r
<dt>\r
from CVS is imported to the <em>origin</em> branch within the git\r
repository, as <em>HEAD</em> already has a special meaning for git.\r
When a remote is specified the <em>HEAD</em> branch is named\r
- remotes/<remote>/master mirroring git-clone behaviour.\r
+ remotes/<remote>/master mirroring <tt>git-clone</tt> behaviour.\r
Use this option if you want to import into a different\r
branch.\r
</p>\r
spawn=Simon Pawn <spawn@frog-pond.org>\r
</tt></pre>\r
</div></div>\r
-<p>git-cvsimport will make it appear as those authors had\r
+<p><tt>git-cvsimport</tt> will make it appear as those authors had\r
their GIT_AUTHOR_NAME and GIT_AUTHOR_EMAIL set properly\r
all along.</p>\r
<p>For convenience, this data is saved to <tt>$GIT_DIR/cvs-authors</tt>\r
each time the <em>-A</em> option is provided and read from that same\r
-file each time git-cvsimport is run.</p>\r
+file each time <tt>git-cvsimport</tt> is run.</p>\r
<p>It is not recommended to use this feature if you intend to\r
export changes back to CVS again later with\r
-<a href="git-cvsexportcommit.html">git-cvsexportcommit(1)</a>.</p>\r
+<tt>git-cvsexportcommit</tt>.</p>\r
</dd>\r
<dt>\r
-h\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:30 UTC\r
+Last updated 02-Jul-2008 03:01:38 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-cvsimport' [-o <branch-for-HEAD>] [-h] [-v] [-d <CVSROOT>]
+'git cvsimport' [-o <branch-for-HEAD>] [-h] [-v] [-d <CVSROOT>]
[-A <author-conv-file>] [-p <options-for-cvsps>] [-P <file>]
[-C <git_repository>] [-z <fuzz>] [-i] [-k] [-u] [-s <subst>]
[-a] [-m] [-M <regex>] [-S <regex>] [-L <commitlimit>]
At least version 2.1 is required.
You should *never* do any work of your own on the branches that are
-created by git-cvsimport. By default initial import will create and populate a
+created by `git-cvsimport`. By default initial import will create and populate a
"master" branch from the CVS repository's main branch which you're free
-to work with; after that, you need to 'git merge' incremental imports, or
+to work with; after that, you need to `git-merge` incremental imports, or
any CVS branches, yourself. It is advisable to specify a named remote via
-r to separate and protect the incoming branches.
-d <CVSROOT>::
The root of the CVS archive. May be local (a simple path) or remote;
currently, only the :local:, :ext: and :pserver: access methods
- are supported. If not given, git-cvsimport will try to read it
+ are supported. If not given, `git-cvsimport` will try to read it
from `CVS/Root`. If no such file exists, it checks for the
`CVSROOT` environment variable.
<CVS_module>::
The CVS module you want to import. Relative to <CVSROOT>.
- If not given, git-cvsimport tries to read it from
+ If not given, `git-cvsimport` tries to read it from
`CVS/Repository`.
-C <target-dir>::
-r <remote>::
The git remote to import this CVS repository into.
Moves all CVS branches into remotes/<remote>/<branch>
- akin to the git-clone --use-separate-remote option.
+ akin to the `git-clone` "--use-separate-remote" option.
-o <branch-for-HEAD>::
When no remote is specified (via -r) the 'HEAD' branch
from CVS is imported to the 'origin' branch within the git
repository, as 'HEAD' already has a special meaning for git.
When a remote is specified the 'HEAD' branch is named
- remotes/<remote>/master mirroring git-clone behaviour.
+ remotes/<remote>/master mirroring `git-clone` behaviour.
Use this option if you want to import into a different
branch.
+
---------
+
-git-cvsimport will make it appear as those authors had
+`git-cvsimport` will make it appear as those authors had
their GIT_AUTHOR_NAME and GIT_AUTHOR_EMAIL set properly
all along.
+
For convenience, this data is saved to `$GIT_DIR/cvs-authors`
each time the '-A' option is provided and read from that same
-file each time git-cvsimport is run.
+file each time `git-cvsimport` is run.
+
It is not recommended to use this feature if you intend to
export changes back to CVS again later with
-linkgit:git-cvsexportcommit[1].
+`git-cvsexportcommit`.
-h::
Print a short usage message and exit.
<div class="content">cvspserver stream tcp nowait nobody /usr/bin/git-cvsserver git-cvsserver pserver</div></div>\r
<p>Usage:</p>\r
<div class="verseblock">\r
-<div class="content"><em>git-cvsserver</em> [options] [pserver|server] [<directory> …]</div></div>\r
+<div class="content"><em>git cvsserver</em> [options] [pserver|server] [<directory> …]</div></div>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
<p>Currently cvsserver works over SSH connections for read/write clients, and\r
over pserver for anonymous CVS access.</p>\r
<p>CVS clients cannot tag, branch or perform GIT merges.</p>\r
-<p>git-cvsserver maps GIT branches to CVS modules. This is very different\r
+<p><tt>git-cvsserver</tt> maps GIT branches to CVS modules. This is very different\r
from what most CVS users would expect since in CVS modules usually represent\r
one or more directories.</p>\r
</div>\r
</div></div>\r
<p>No special setup is needed for SSH access, other than having GIT tools\r
in the PATH. If you have clients that do not accept the CVS_SERVER\r
-environment variable, you can rename git-cvsserver to cvs.</p>\r
+environment variable, you can rename <tt>git-cvsserver</tt> to <tt>cvs</tt>.</p>\r
<p>Note: Newer CVS versions (>= 1.12.11) also support specifying\r
CVS_SERVER directly in CVSROOT like</p>\r
<div class="listingblock">\r
</div></div>\r
<p>This has the advantage that it will be saved in your <em>CVS/Root</em> files and\r
you don't need to worry about always setting the correct environment\r
-variable. SSH users restricted to git-shell don't need to override the default\r
-with CVS_SERVER (and shouldn't) as git-shell understands <tt>cvs</tt> to mean\r
-git-cvsserver and pretends that the other end runs the real cvs better.</p>\r
+variable. SSH users restricted to <tt>git-shell</tt> don't need to override the default\r
+with CVS_SERVER (and shouldn't) as <tt>git-shell</tt> understands <tt>cvs</tt> to mean\r
+<tt>git-cvsserver</tt> and pretends that the other end runs the real <tt>cvs</tt> better.</p>\r
</li>\r
<li>\r
<p>\r
logfile=/path/to/logfile\r
</tt></pre>\r
</div></div>\r
-<p>Note: you need to ensure each user that is going to invoke git-cvsserver has\r
+<p>Note: you need to ensure each user that is going to invoke <tt>git-cvsserver</tt> has\r
write access to the log file and to the database (see\r
<a href="#dbbackend">Database Backend</a>. If you want to offer write access over\r
SSH, the users of course also need write access to the git repository itself.</p>\r
automatically saving it in your <em>CVS/Root</em> files, then you need to set them\r
explicitly in your environment. CVSROOT should be set as per normal, but the\r
directory should point at the appropriate git repo. As above, for SSH clients\r
- _not_ restricted to git-shell, CVS_SERVER should be set to git-cvsserver.\r
+ _not_ restricted to <tt>git-shell</tt>, CVS_SERVER should be set to <tt>git-cvsserver</tt>.\r
</p>\r
<div class="listingblock">\r
<div class="content">\r
</div>\r
<h2><a id="dbbackend"></a>Database Backend</h2>\r
<div class="sectionbody">\r
-<p>git-cvsserver uses one database per git head (i.e. CVS module) to\r
+<p><tt>git-cvsserver</tt> uses one database per git head (i.e. CVS module) to\r
store information about the repository for faster access. The\r
database doesn't contain any persistent data and can be completely\r
regenerated from the git repository at any time. The database\r
needs to be updated (i.e. written to) after every commit.</p>\r
-<p>If the commit is done directly by using git (as opposed to\r
-using git-cvsserver) the update will need to happen on the\r
-next repository access by git-cvsserver, independent of\r
+<p>If the commit is done directly by using <tt>git</tt> (as opposed to\r
+using <tt>git-cvsserver</tt>) the update will need to happen on the\r
+next repository access by <tt>git-cvsserver</tt>, independent of\r
access method and requested operation.</p>\r
<p>That means that even if you offer only read access (e.g. by using\r
-the pserver method), git-cvsserver should have write access to\r
+the pserver method), <tt>git-cvsserver</tt> should have write access to\r
the database to work reliably (otherwise you need to make sure\r
-that the database is up-to-date any time git-cvsserver is executed).</p>\r
+that the database is up-to-date any time <tt>git-cvsserver</tt> is executed).</p>\r
<p>By default it uses SQLite databases in the git directory, named\r
<tt>gitcvs.<module_name>.sqlite</tt>. Note that the SQLite backend creates\r
temporary files in the same directory as the database file on\r
write so it might not be enough to grant the users using\r
-git-cvsserver write access to the database file without granting\r
+<tt>git-cvsserver</tt> write access to the database file without granting\r
them write access to the directory, too.</p>\r
<p>You can configure the database backend with the following\r
configuration variables:</p>\r
<h3>Configuring database backend</h3>\r
-<p>git-cvsserver uses the Perl DBI module. Please also read\r
+<p><tt>git-cvsserver</tt> uses the Perl DBI module. Please also read\r
its documentation if changing these variables, especially\r
about <tt>DBI->connect()</tt>.</p>\r
<dl>\r
</dt>\r
<dd>\r
<p>\r
- Name of the user running git-cvsserver.\r
+ Name of the user running <tt>git-cvsserver</tt>.\r
If no name can be determined, the\r
numeric uid is used.\r
</p>\r
<p>Protocol notes: If you are using anonymous access via pserver, just select that.\r
Those using SSH access should choose the <em>ext</em> protocol, and configure <em>ext</em>\r
access on the Preferences->Team->CVS->ExtConnection pane. Set CVS_SERVER to\r
-<em>git-cvsserver</em>. Note that password support is not good when using <em>ext</em>,\r
+<tt>git-cvsserver</tt>. Note that password support is not good when using <em>ext</em>,\r
you will definitely want to have SSH keys setup.</p>\r
<p>Alternatively, you can just use the non-standard extssh protocol that Eclipse\r
offer. In that case CVS_SERVER is ignored, and you will have to replace\r
-the cvs utility on the server with git-cvsserver or manipulate your <tt>.bashrc</tt>\r
-so that calling <em>cvs</em> effectively calls git-cvsserver.</p>\r
+the cvs utility on the server with <tt>git-cvsserver</tt> or manipulate your <tt>.bashrc</tt>\r
+so that calling <em>cvs</em> effectively calls <tt>git-cvsserver</tt>.</p>\r
</div>\r
<h2>Clients known to work</h2>\r
<div class="sectionbody">\r
is left blank. But if <tt>gitcvs.allbinary</tt> is set to "guess", then\r
the correct <em>-k</em> mode will be guessed based on the contents of\r
the file.</p>\r
-<p>For best consistency with cvs, it is probably best to override the\r
+<p>For best consistency with <tt>cvs</tt>, it is probably best to override the\r
defaults by setting <tt>gitcvs.usecrlfattr</tt> to true,\r
and <tt>gitcvs.allbinary</tt> to "guess".</p>\r
</div>\r
<h2>Dependencies</h2>\r
<div class="sectionbody">\r
-<p>git-cvsserver depends on DBD::SQLite.</p>\r
+<p><tt>git-cvsserver</tt> depends on DBD::SQLite.</p>\r
</div>\r
<h2>Copyright and Authors</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:28 UTC\r
+Last updated 02-Jul-2008 03:01:39 UTC\r
</div>\r
</div>\r
</body>\r
Usage:
[verse]
-'git-cvsserver' [options] [pserver|server] [<directory> ...]
+'git cvsserver' [options] [pserver|server] [<directory> ...]
OPTIONS
-------
CVS clients cannot tag, branch or perform GIT merges.
-git-cvsserver maps GIT branches to CVS modules. This is very different
+`git-cvsserver` maps GIT branches to CVS modules. This is very different
from what most CVS users would expect since in CVS modules usually represent
one or more directories.
------
No special setup is needed for SSH access, other than having GIT tools
in the PATH. If you have clients that do not accept the CVS_SERVER
-environment variable, you can rename git-cvsserver to cvs.
+environment variable, you can rename `git-cvsserver` to `cvs`.
Note: Newer CVS versions (>= 1.12.11) also support specifying
CVS_SERVER directly in CVSROOT like
------
This has the advantage that it will be saved in your 'CVS/Root' files and
you don't need to worry about always setting the correct environment
-variable. SSH users restricted to git-shell don't need to override the default
-with CVS_SERVER (and shouldn't) as git-shell understands `cvs` to mean
-git-cvsserver and pretends that the other end runs the real cvs better.
+variable. SSH users restricted to `git-shell` don't need to override the default
+with CVS_SERVER (and shouldn't) as `git-shell` understands `cvs` to mean
+`git-cvsserver` and pretends that the other end runs the real `cvs` better.
--
2. For each repo that you want accessible from CVS you need to edit config in
the repo and add the following section.
logfile=/path/to/logfile
------
-Note: you need to ensure each user that is going to invoke git-cvsserver has
+Note: you need to ensure each user that is going to invoke `git-cvsserver` has
write access to the log file and to the database (see
<<dbbackend,Database Backend>>. If you want to offer write access over
SSH, the users of course also need write access to the git repository itself.
automatically saving it in your 'CVS/Root' files, then you need to set them
explicitly in your environment. CVSROOT should be set as per normal, but the
directory should point at the appropriate git repo. As above, for SSH clients
- _not_ restricted to git-shell, CVS_SERVER should be set to git-cvsserver.
+ _not_ restricted to `git-shell`, CVS_SERVER should be set to `git-cvsserver`.
+
--
------
Database Backend
----------------
-git-cvsserver uses one database per git head (i.e. CVS module) to
+`git-cvsserver` uses one database per git head (i.e. CVS module) to
store information about the repository for faster access. The
database doesn't contain any persistent data and can be completely
regenerated from the git repository at any time. The database
needs to be updated (i.e. written to) after every commit.
-If the commit is done directly by using git (as opposed to
-using git-cvsserver) the update will need to happen on the
-next repository access by git-cvsserver, independent of
+If the commit is done directly by using `git` (as opposed to
+using `git-cvsserver`) the update will need to happen on the
+next repository access by `git-cvsserver`, independent of
access method and requested operation.
That means that even if you offer only read access (e.g. by using
-the pserver method), git-cvsserver should have write access to
+the pserver method), `git-cvsserver` should have write access to
the database to work reliably (otherwise you need to make sure
-that the database is up-to-date any time git-cvsserver is executed).
+that the database is up-to-date any time `git-cvsserver` is executed).
By default it uses SQLite databases in the git directory, named
`gitcvs.<module_name>.sqlite`. Note that the SQLite backend creates
temporary files in the same directory as the database file on
write so it might not be enough to grant the users using
-git-cvsserver write access to the database file without granting
+`git-cvsserver` write access to the database file without granting
them write access to the directory, too.
You can configure the database backend with the following
Configuring database backend
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-git-cvsserver uses the Perl DBI module. Please also read
+`git-cvsserver` uses the Perl DBI module. Please also read
its documentation if changing these variables, especially
about `DBI->connect()`.
%a::
access method (one of "ext" or "pserver")
%u::
- Name of the user running git-cvsserver.
+ Name of the user running `git-cvsserver`.
If no name can be determined, the
numeric uid is used.
Protocol notes: If you are using anonymous access via pserver, just select that.
Those using SSH access should choose the 'ext' protocol, and configure 'ext'
access on the Preferences->Team->CVS->ExtConnection pane. Set CVS_SERVER to
-'git-cvsserver'. Note that password support is not good when using 'ext',
+`git-cvsserver`. Note that password support is not good when using 'ext',
you will definitely want to have SSH keys setup.
Alternatively, you can just use the non-standard extssh protocol that Eclipse
offer. In that case CVS_SERVER is ignored, and you will have to replace
-the cvs utility on the server with git-cvsserver or manipulate your `.bashrc`
-so that calling 'cvs' effectively calls git-cvsserver.
+the cvs utility on the server with `git-cvsserver` or manipulate your `.bashrc`
+so that calling 'cvs' effectively calls `git-cvsserver`.
Clients known to work
---------------------
the correct '-k' mode will be guessed based on the contents of
the file.
-For best consistency with cvs, it is probably best to override the
+For best consistency with `cvs`, it is probably best to override the
defaults by setting `gitcvs.usecrlfattr` to true,
and `gitcvs.allbinary` to "guess".
Dependencies
------------
-
-git-cvsserver depends on DBD::SQLite.
+`git-cvsserver` depends on DBD::SQLite.
Copyright and Authors
---------------------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-daemon</em> [--verbose] [--syslog] [--export-all]\r
+<div class="content"><em>git daemon</em> [--verbose] [--syslog] [--export-all]\r
[--timeout=n] [--init-timeout=n] [--strict-paths]\r
[--base-path=path] [--user-path | --user-path=path]\r
[--interpolated-path=pathtemplate]\r
<p>It verifies that the directory has the magic file "git-daemon-export-ok", and\r
it will refuse to export any git directory that hasn't explicitly been marked\r
for export this way (unless the <em>--export-all</em> parameter is specified). If you\r
-pass some directory paths as <em>git-daemon</em> arguments, you can further restrict\r
+pass some directory paths as <tt>git-daemon</tt> arguments, you can further restrict\r
the offers to a whitelist comprising of those.</p>\r
<p>By default, only <tt>upload-pack</tt> service is enabled, which serves\r
<tt>git-fetch-pack</tt> and <tt>git-ls-remote</tt> clients, which are invoked\r
<p>\r
Match paths exactly (i.e. don't allow "/foo/repo" when the real path is\r
"/foo/repo.git" or "/foo/repo/.git") and don't do user-relative paths.\r
- git-daemon will refuse to start when this option is enabled and no\r
+ <tt>git-daemon</tt> will refuse to start when this option is enabled and no\r
whitelist is specified.\r
</p>\r
</dd>\r
<dd>\r
<p>\r
Remap all the path requests as relative to the given path.\r
- This is sort of "GIT root" - if you run git-daemon with\r
+ This is sort of "GIT root" - if you run <tt>git-daemon</tt> with\r
<em>--base-path=/srv/git</em> on example.com, then if you later try to pull\r
<em>git://example.com/hello.git</em>, <tt>git-daemon</tt> will interpret the path\r
as <em>/srv/git/hello.git</em>.\r
</div></div>\r
</dd>\r
<dt>\r
-git-daemon as inetd server\r
+<tt>git-daemon</tt> as inetd server\r
</dt>\r
<dd>\r
<p>\r
</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> git stream tcp nowait nobody /usr/bin/git-daemon\r
- git-daemon --inetd --verbose --export-all\r
+<pre><tt> git stream tcp nowait nobody /usr/bin/git\r
+ git daemon --inetd --verbose --export-all\r
/pub/foo /pub/bar</tt></pre>\r
</div></div>\r
</dd>\r
<dt>\r
-git-daemon as inetd server for virtual hosts\r
+<tt>git-daemon</tt> as inetd server for virtual hosts\r
</dt>\r
<dd>\r
<p>\r
</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> git stream tcp nowait nobody /usr/bin/git-daemon\r
- git-daemon --inetd --verbose --export-all\r
+<pre><tt> git stream tcp nowait nobody /usr/bin/git\r
+ git daemon --inetd --verbose --export-all\r
--interpolated-path=/pub/%H%D\r
/pub/www.example.org/software\r
/pub/www.example.com/software\r
default repository could be made as well.</p>\r
</dd>\r
<dt>\r
-git-daemon as regular daemon for virtual hosts\r
+<tt>git-daemon</tt> as regular daemon for virtual hosts\r
</dt>\r
<dd>\r
<p>\r
</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> git-daemon --verbose --export-all\r
+<pre><tt> git daemon --verbose --export-all\r
--interpolated-path=/pub/%IP/%D\r
/pub/192.168.1.200/software\r
/pub/10.10.220.23/software</tt></pre>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:31 UTC\r
+Last updated 02-Jul-2008 03:01:39 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-daemon' [--verbose] [--syslog] [--export-all]
- [--timeout=n] [--init-timeout=n] [--strict-paths]
- [--base-path=path] [--user-path | --user-path=path]
- [--interpolated-path=pathtemplate]
- [--reuseaddr] [--detach] [--pid-file=file]
- [--enable=service] [--disable=service]
+'git daemon' [--verbose] [--syslog] [--export-all]
+ [--timeout=n] [--init-timeout=n] [--strict-paths]
+ [--base-path=path] [--user-path | --user-path=path]
+ [--interpolated-path=pathtemplate]
+ [--reuseaddr] [--detach] [--pid-file=file]
+ [--enable=service] [--disable=service]
[--allow-override=service] [--forbid-override=service]
[--inetd | [--listen=host_or_ipaddr] [--port=n] [--user=user [--group=group]]
[directory...]
It verifies that the directory has the magic file "git-daemon-export-ok", and
it will refuse to export any git directory that hasn't explicitly been marked
for export this way (unless the '--export-all' parameter is specified). If you
-pass some directory paths as 'git-daemon' arguments, you can further restrict
+pass some directory paths as `git-daemon` arguments, you can further restrict
the offers to a whitelist comprising of those.
By default, only `upload-pack` service is enabled, which serves
--strict-paths::
Match paths exactly (i.e. don't allow "/foo/repo" when the real path is
"/foo/repo.git" or "/foo/repo/.git") and don't do user-relative paths.
- git-daemon will refuse to start when this option is enabled and no
+ `git-daemon` will refuse to start when this option is enabled and no
whitelist is specified.
--base-path::
Remap all the path requests as relative to the given path.
- This is sort of "GIT root" - if you run git-daemon with
+ This is sort of "GIT root" - if you run `git-daemon` with
'--base-path=/srv/git' on example.com, then if you later try to pull
'git://example.com/hello.git', `git-daemon` will interpret the path
as '/srv/git/hello.git'.
git 9418/tcp # Git Version Control System
------------
-git-daemon as inetd server::
+`git-daemon` as inetd server::
To set up `git-daemon` as an inetd service that handles any
repository under the whitelisted set of directories, /pub/foo
and /pub/bar, place an entry like the following into
/etc/inetd all on one line:
+
------------------------------------------------
- git stream tcp nowait nobody /usr/bin/git-daemon
- git-daemon --inetd --verbose --export-all
+ git stream tcp nowait nobody /usr/bin/git
+ git daemon --inetd --verbose --export-all
/pub/foo /pub/bar
------------------------------------------------
-git-daemon as inetd server for virtual hosts::
+`git-daemon` as inetd server for virtual hosts::
To set up `git-daemon` as an inetd service that handles
repositories for different virtual hosts, `www.example.com`
and `www.example.org`, place an entry like the following into
`/etc/inetd` all on one line:
+
------------------------------------------------
- git stream tcp nowait nobody /usr/bin/git-daemon
- git-daemon --inetd --verbose --export-all
+ git stream tcp nowait nobody /usr/bin/git
+ git daemon --inetd --verbose --export-all
--interpolated-path=/pub/%H%D
/pub/www.example.org/software
/pub/www.example.com/software
default repository could be made as well.
-git-daemon as regular daemon for virtual hosts::
+`git-daemon` as regular daemon for virtual hosts::
To set up `git-daemon` as a regular, non-inetd service that
handles repositories for multiple virtual hosts based on
their IP addresses, start the daemon like this:
+
------------------------------------------------
- git-daemon --verbose --export-all
+ git daemon --verbose --export-all
--interpolated-path=/pub/%IP/%D
/pub/192.168.1.200/software
/pub/10.10.220.23/software
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-describe</em> [--all] [--tags] [--contains] [--abbrev=<n>] <committish>…</p>\r
+<p><em>git describe</em> [--all] [--tags] [--contains] [--abbrev=<n>] <committish>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>With something like git.git current tree, I get:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>[torvalds@g5 git]$ git-describe parent\r
+<pre><tt>[torvalds@g5 git]$ git describe parent\r
v1.0.4-14-g2414721</tt></pre>\r
</div></div>\r
<p>i.e. the current head of my "parent" branch is based on v1.0.4,\r
of commits which would be displayed by "git log v1.0.4..parent".\r
The hash suffix is "-g" + 7-char abbreviation for the tip commit\r
of parent (which was <tt>2414721b194453f058079d897d13c4e377f92dc6</tt>).</p>\r
-<p>Doing a "git-describe" on a tag-name will just show the tag name:</p>\r
+<p>Doing a <tt>git-describe</tt> on a tag-name will just show the tag name:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>[torvalds@g5 git]$ git-describe v1.0.4\r
+<pre><tt>[torvalds@g5 git]$ git describe v1.0.4\r
v1.0.4</tt></pre>\r
</div></div>\r
<p>With --all, the command can use branch heads as references, so\r
</div>\r
<h2>SEARCH STRATEGY</h2>\r
<div class="sectionbody">\r
-<p>For each committish supplied "git describe" will first look for\r
+<p>For each committish supplied, <tt>git-describe</tt> will first look for\r
a tag which tags exactly that commit. Annotated tags will always\r
be preferred over lightweight tags, and tags with newer dates will\r
always be preferred over tags with older dates. If an exact match\r
is found, its name will be output and searching will stop.</p>\r
-<p>If an exact match was not found "git describe" will walk back\r
+<p>If an exact match was not found, <tt>git-describe</tt> will walk back\r
through the commit history to locate an ancestor commit which\r
has been tagged. The ancestor's tag will be output along with an\r
abbreviation of the input committish's SHA1.</p>\r
<p>If multiple tags were found during the walk then the tag which\r
has the fewest commits different from the input committish will be\r
selected and output. Here fewest commits different is defined as\r
-the number of commits which would be shown by "git log tag..input"\r
+the number of commits which would be shown by <tt>git log tag..input</tt>\r
will be the smallest number of commits possible.</p>\r
</div>\r
<h2>Author</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:32 UTC\r
+Last updated 02-Jul-2008 03:01:40 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-describe' [--all] [--tags] [--contains] [--abbrev=<n>] <committish>...
+'git describe' [--all] [--tags] [--contains] [--abbrev=<n>] <committish>...
DESCRIPTION
-----------
With something like git.git current tree, I get:
- [torvalds@g5 git]$ git-describe parent
+ [torvalds@g5 git]$ git describe parent
v1.0.4-14-g2414721
i.e. the current head of my "parent" branch is based on v1.0.4,
The hash suffix is "-g" + 7-char abbreviation for the tip commit
of parent (which was `2414721b194453f058079d897d13c4e377f92dc6`).
-Doing a "git-describe" on a tag-name will just show the tag name:
+Doing a `git-describe` on a tag-name will just show the tag name:
- [torvalds@g5 git]$ git-describe v1.0.4
+ [torvalds@g5 git]$ git describe v1.0.4
v1.0.4
With --all, the command can use branch heads as references, so
SEARCH STRATEGY
---------------
-For each committish supplied "git describe" will first look for
+For each committish supplied, `git-describe` will first look for
a tag which tags exactly that commit. Annotated tags will always
be preferred over lightweight tags, and tags with newer dates will
always be preferred over tags with older dates. If an exact match
is found, its name will be output and searching will stop.
-If an exact match was not found "git describe" will walk back
+If an exact match was not found, `git-describe` will walk back
through the commit history to locate an ancestor commit which
has been tagged. The ancestor's tag will be output along with an
abbreviation of the input committish's SHA1.
If multiple tags were found during the walk then the tag which
has the fewest commits different from the input committish will be
selected and output. Here fewest commits different is defined as
-the number of commits which would be shown by "git log tag..input"
+the number of commits which would be shown by `git log tag..input`
will be the smallest number of commits possible.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-diff-files</em> [-q] [-0|-1|-2|-3|-c|--cc] [<common diff options>] [<path>…]</p>\r
+<p><em>git diff-files</em> [-q] [-0|-1|-2|-3|-c|--cc] [<common diff options>] [<path>…]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Compares the files in the working tree and the index. When paths\r
are specified, compares only those named paths. Otherwise all\r
entries in the index are compared. The output format is the\r
-same as "git-diff-index" and "git-diff-tree".</p>\r
+same as for <tt>git-diff-index</tt> and <tt>git-diff-tree</tt>.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
</dd>\r
</dl>\r
<p>For more detailed explanation on these common options, see also\r
-<a href="gitdiffcore.html">gitdiffcore(7)</a>[diffcore documentation].</p>\r
+<a href="gitdiffcore.html">gitdiffcore(7)</a>.</p>\r
<dl>\r
<dt>\r
-1 -2 -3 or --base --ours --theirs, and -0\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:33 UTC\r
+Last updated 02-Jul-2008 03:01:40 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-diff-files' [-q] [-0|-1|-2|-3|-c|--cc] [<common diff options>] [<path>...]
+'git
diff-files' [-q] [-0|-1|-2|-3|-c|--cc] [<common diff options>] [<path>...]
DESCRIPTION
-----------
Compares the files in the working tree and the index. When paths
are specified, compares only those named paths. Otherwise all
entries in the index are compared. The output format is the
-same as "git-diff-index" and "git-diff-tree".
+same as for `git-diff-index` and `git-diff-tree`.
OPTIONS
-------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-diff-index</em> [-m] [--cached] [<common diff options>] <tree-ish> [<path>…]</p>\r
+<p><em>git diff-index</em> [-m] [--cached] [<common diff options>] <tree-ish> [<path>…]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</dd>\r
</dl>\r
<p>For more detailed explanation on these common options, see also\r
-<a href="gitdiffcore.html">gitdiffcore(7)</a>[diffcore documentation].</p>\r
+<a href="gitdiffcore.html">gitdiffcore(7)</a>.</p>\r
<dl>\r
<dt>\r
<tree-ish>\r
<p>\r
By default, files recorded in the index but not checked\r
out are reported as deleted. This flag makes\r
- "git-diff-index" say that all non-checked-out files are up\r
+ <tt>git-diff-index</tt> say that all non-checked-out files are up\r
to date.\r
</p>\r
</dd>\r
<div class="literalblock">\r
<div class="content">\r
<pre><tt>show me the differences between HEAD and the current index\r
-contents (the ones I'd write with a "git-write-tree")</tt></pre>\r
+contents (the ones I'd write using `git-write-tree`)</tt></pre>\r
</div></div>\r
<p>For example, let's say that you have worked on your working directory, updated\r
some files in the index and are ready to commit. You want to see exactly\r
object and compare it that way, and to do that, you just do</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-diff-index --cached HEAD</tt></pre>\r
+<pre><tt>git diff-index --cached HEAD</tt></pre>\r
</div></div>\r
<p>Example: let's say I had renamed <tt>commit.c</tt> to <tt>git-commit.c</tt>, and I had\r
-done an "git-update-index" to make that effective in the index file.\r
-"git-diff-files" wouldn't show anything at all, since the index file\r
-matches my working directory. But doing a "git-diff-index" does:</p>\r
+done an <tt>update-index</tt> to make that effective in the index file.\r
+<tt>git diff-files</tt> wouldn't show anything at all, since the index file\r
+matches my working directory. But doing a <tt>git-diff-index</tt> does:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>torvalds@ppc970:~/git> git-diff-index --cached HEAD\r
+<pre><tt>torvalds@ppc970:~/git> git diff-index --cached HEAD\r
-100644 blob 4161aecc6700a2eb579e842af0b7f22b98443f74 commit.c\r
+100644 blob 4161aecc6700a2eb579e842af0b7f22b98443f74 git-commit.c</tt></pre>\r
</div></div>\r
<p>You can see easily that the above is a rename.</p>\r
-<p>In fact, "git-diff-index --cached" <strong>should</strong> always be entirely equivalent to\r
-actually doing a "git-write-tree" and comparing that. Except this one is much\r
+<p>In fact, <tt>git diff-index --cached</tt> <strong>should</strong> always be entirely equivalent to\r
+actually doing a <tt>git-write-tree</tt> and comparing that. Except this one is much\r
nicer for the case where you just want to check where you are.</p>\r
-<p>So doing a "git-diff-index --cached" is basically very useful when you are\r
+<p>So doing a <tt>git-diff-index --cached</tt> is basically very useful when you are\r
asking yourself "what have I already marked for being committed, and\r
what's the difference to a previous tree".</p>\r
</div>\r
<div class="sectionbody">\r
<p>The "non-cached" mode takes a different approach, and is potentially\r
the more useful of the two in that what it does can't be emulated with\r
-a "git-write-tree" + "git-diff-tree". Thus that's the default mode.\r
+a <tt>git-write-tree</tt> + <tt>git-diff-tree</tt>. Thus that's the default mode.\r
The non-cached version asks the question:</p>\r
<div class="literalblock">\r
<div class="content">\r
tree - index contents _and_ files that aren't up-to-date</tt></pre>\r
</div></div>\r
<p>which is obviously a very useful question too, since that tells you what\r
-you <strong>could</strong> commit. Again, the output matches the "git-diff-tree -r"\r
+you <strong>could</strong> commit. Again, the output matches the <tt>git-diff-tree -r</tt>\r
output to a tee, but with a twist.</p>\r
<p>The twist is that if some file doesn't match the index, we don't have\r
a backing store thing for it, and we use the magic "all-zero" sha1 to\r
show that. So let's say that you have edited <tt>kernel/sched.c</tt>, but\r
-have not actually done a "git-update-index" on it yet - there is no\r
+have not actually done a <tt>git-update-index</tt> on it yet - there is no\r
"object" associated with the new state, and you get:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>torvalds@ppc970:~/v2.6/linux> git-diff-index HEAD\r
+<pre><tt>torvalds@ppc970:~/v2.6/linux> git diff-index HEAD\r
*100644->100664 blob 7476bb......->000000...... kernel/sched.c</tt></pre>\r
</div></div>\r
<p>i.e., it shows that the tree has changed, and that <tt>kernel/sched.c</tt> has is\r
<td class="icon">\r
<div class="title">Note</div>\r
</td>\r
-<td class="content">As with other commands of this type, "git-diff-index" does not\r
+<td class="content">As with other commands of this type, <tt>git-diff-index</tt> does not\r
actually look at the contents of the file at all. So maybe\r
<tt>kernel/sched.c</tt> hasn't actually changed, and it's just that you\r
touched it. In either case, it's a note that you need to\r
-"git-update-index" it to make the index be in sync.</td>\r
+<tt>git-update-index</tt> it to make the index be in sync.</td>\r
</tr></table>\r
</div>\r
<div class="admonitionblock">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:34 UTC\r
+Last updated 02-Jul-2008 03:01:40 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-diff-index' [-m] [--cached] [<common diff options>] <tree-ish> [<path>...]
+'git
diff-index' [-m] [--cached] [<common diff options>] <tree-ish> [<path>...]
DESCRIPTION
-----------
-m::
By default, files recorded in the index but not checked
out are reported as deleted. This flag makes
- "git-diff-index" say that all non-checked-out files are up
+ `git-diff-index` say that all non-checked-out files are up
to date.
Output format
If '--cached' is specified, it allows you to ask:
show me the differences between HEAD and the current index
- contents (the ones I'd write with a "git-write-tree")
+ contents (the ones I'd write using `git-write-tree`)
For example, let's say that you have worked on your working directory, updated
some files in the index and are ready to commit. You want to see exactly
*what* you are going to commit, without having to write a new tree
object and compare it that way, and to do that, you just do
- git-diff-index --cached HEAD
+ git diff-index --cached HEAD
Example: let's say I had renamed `commit.c` to `git-commit.c`, and I had
-done an "git-update-index" to make that effective in the index file.
-"git-diff-files" wouldn't show anything at all, since the index file
-matches my working directory. But doing a "git-diff-index" does:
+done an `update-index` to make that effective in the index file.
+`git diff-files` wouldn't show anything at all, since the index file
+matches my working directory. But doing a `git-diff-index` does:
- torvalds@ppc970:~/git> git-diff-index --cached HEAD
+ torvalds@ppc970:~/git> git diff-index --cached HEAD
-100644 blob 4161aecc6700a2eb579e842af0b7f22b98443f74 commit.c
+100644 blob 4161aecc6700a2eb579e842af0b7f22b98443f74 git-commit.c
You can see easily that the above is a rename.
-In fact, "git-diff-index --cached" *should* always be entirely equivalent to
-actually doing a "git-write-tree" and comparing that. Except this one is much
+In fact, `git diff-index --cached` *should* always be entirely equivalent to
+actually doing a `git-write-tree` and comparing that. Except this one is much
nicer for the case where you just want to check where you are.
-So doing a "git-diff-index --cached" is basically very useful when you are
+So doing a `git-diff-index --cached` is basically very useful when you are
asking yourself "what have I already marked for being committed, and
what's the difference to a previous tree".
---------------
The "non-cached" mode takes a different approach, and is potentially
the more useful of the two in that what it does can't be emulated with
-a "git-write-tree" + "git-diff-tree". Thus that's the default mode.
+a `git-write-tree` + `git-diff-tree`. Thus that's the default mode.
The non-cached version asks the question:
show me the differences between HEAD and the currently checked out
tree - index contents _and_ files that aren't up-to-date
which is obviously a very useful question too, since that tells you what
-you *could* commit. Again, the output matches the "git-diff-tree -r"
+you *could* commit. Again, the output matches the `git-diff-tree -r`
output to a tee, but with a twist.
The twist is that if some file doesn't match the index, we don't have
a backing store thing for it, and we use the magic "all-zero" sha1 to
show that. So let's say that you have edited `kernel/sched.c`, but
-have not actually done a "git-update-index" on it yet - there is no
+have not actually done a `git-update-index` on it yet - there is no
"object" associated with the new state, and you get:
- torvalds@ppc970:~/v2.6/linux> git-diff-index HEAD
+ torvalds@ppc970:~/v2.6/linux> git diff-index HEAD
*100644->100664 blob 7476bb......->000000...... kernel/sched.c
i.e., it shows that the tree has changed, and that `kernel/sched.c` has is
get the real diff, you need to look at the object in the working directory
directly rather than do an object-to-object diff.
-NOTE: As with other commands of this type, "git-diff-index" does not
+NOTE: As with other commands of this type, `git-diff-index` does not
actually look at the contents of the file at all. So maybe
`kernel/sched.c` hasn't actually changed, and it's just that you
touched it. In either case, it's a note that you need to
-"git-update-index" it to make the index be in sync.
+`git-update-index` it to make the index be in sync.
NOTE: You can have a mixture of files show up as "has been updated"
and "is still dirty in the working directory" together. You can always
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-diff-tree</em> [--stdin] [-m] [-s] [-v] [--no-commit-id] [--pretty]\r
+<div class="content"><em>git diff-tree</em> [--stdin] [-m] [-s] [-v] [--no-commit-id] [--pretty]\r
[-t] [-r] [-c | --cc] [--root] [<common diff options>]\r
<tree-ish> [<tree-ish>] [<path>…]</div></div>\r
</div>\r
<p>Compares the content and mode of the blobs found via two tree objects.</p>\r
<p>If there is only one <tree-ish> given, the commit is compared with its parents\r
(see --stdin below).</p>\r
-<p>Note that "git-diff-tree" can use the tree encapsulated in a commit object.</p>\r
+<p>Note that <tt>git-diff-tree</tt> can use the tree encapsulated in a commit object.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
</dd>\r
</dl>\r
<p>For more detailed explanation on these common options, see also\r
-<a href="gitdiffcore.html">gitdiffcore(7)</a>[diffcore documentation].</p>\r
+<a href="gitdiffcore.html">gitdiffcore(7)</a>.</p>\r
<dl>\r
<dt>\r
<tree-ish>\r
</dt>\r
<dd>\r
<p>\r
- By default, "git-diff-tree --stdin" does not show\r
+ By default, <tt>git-diff-tree --stdin</tt> does not show\r
differences for merge commits. With this flag, it shows\r
differences to that commit from all of its parents. See\r
also <em>-c</em>.\r
</dt>\r
<dd>\r
<p>\r
- By default, "git-diff-tree --stdin" shows differences,\r
+ By default, <tt>git-diff-tree --stdin</tt> shows differences,\r
either in machine-readable form (without <em>-p</em>) or in patch\r
form (with <em>-p</em>). This output can be suppressed. It is\r
only useful with <em>-v</em> flag.\r
</dt>\r
<dd>\r
<p>\r
- This flag causes "git-diff-tree --stdin" to also show\r
+ This flag causes <tt>git-diff-tree --stdin</tt> to also show\r
the commit message before the differences.\r
</p>\r
</dd>\r
</dt>\r
<dd>\r
<p>\r
- git-diff-tree outputs a line with the commit ID when\r
+ <tt>git-diff-tree</tt> outputs a line with the commit ID when\r
applicable. This flag suppressed the commit ID output.\r
</p>\r
</dd>\r
example some architecture-specific files, you might do:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-diff-tree -r <tree-ish> <tree-ish> arch/ia64 include/asm-ia64</tt></pre>\r
+<pre><tt>git diff-tree -r <tree-ish> <tree-ish> arch/ia64 include/asm-ia64</tt></pre>\r
</div></div>\r
<p>and it will only show you what changed in those two directories.</p>\r
<p>Or if you are searching for what changed in just <tt>kernel/sched.c</tt>, just do</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-diff-tree -r <tree-ish> <tree-ish> kernel/sched.c</tt></pre>\r
+<pre><tt>git diff-tree -r <tree-ish> <tree-ish> kernel/sched.c</tt></pre>\r
</div></div>\r
<p>and it will ignore all differences to other files.</p>\r
<p>The pattern is always the prefix, and is matched exactly. There are no\r
<p>An example of normal usage is:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>torvalds@ppc970:~/git> git-diff-tree 5319e4......\r
+<pre><tt>torvalds@ppc970:~/git> git diff-tree 5319e4......\r
*100664->100664 blob ac348b.......->a01513....... git-fsck-objects.c</tt></pre>\r
</div></div>\r
<p>which tells you that the last commit changed just one file (it's from\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 13-Jun-2008 10:02:41 UTC\r
+Last updated 02-Jul-2008 03:01:41 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-diff-tree' [--stdin] [-m] [-s] [-v] [--no-commit-id] [--pretty]
+'git diff-tree' [--stdin] [-m] [-s] [-v] [--no-commit-id] [--pretty]
[-t] [-r] [-c | --cc] [--root] [<common diff options>]
<tree-ish> [<tree-ish>] [<path>...]
If there is only one <tree-ish> given, the commit is compared with its parents
(see --stdin below).
-Note that "git-diff-tree" can use the tree encapsulated in a commit object.
+Note that `git-diff-tree` can use the tree encapsulated in a commit object.
OPTIONS
-------
separated with a single space are given.
-m::
- By default, "git-diff-tree --stdin" does not show
+ By default, `git-diff-tree --stdin` does not show
differences for merge commits. With this flag, it shows
differences to that commit from all of its parents. See
also '-c'.
-s::
- By default, "git-diff-tree --stdin" shows differences,
+ By default, `git-diff-tree --stdin` shows differences,
either in machine-readable form (without '-p') or in patch
form (with '-p'). This output can be suppressed. It is
only useful with '-v' flag.
-v::
- This flag causes "git-diff-tree --stdin" to also show
+ This flag causes `git-diff-tree --stdin` to also show
the commit message before the differences.
include::pretty-options.txt[]
--no-commit-id::
- git-diff-tree outputs a line with the commit ID when
+ `git-diff-tree` outputs a line with the commit ID when
applicable. This flag suppressed the commit ID output.
-c::
If you're only interested in differences in a subset of files, for
example some architecture-specific files, you might do:
- git-diff-tree -r <tree-ish> <tree-ish> arch/ia64 include/asm-ia64
+ git diff-tree -r <tree-ish> <tree-ish> arch/ia64 include/asm-ia64
and it will only show you what changed in those two directories.
Or if you are searching for what changed in just `kernel/sched.c`, just do
- git-diff-tree -r <tree-ish> <tree-ish> kernel/sched.c
+ git diff-tree -r <tree-ish> <tree-ish> kernel/sched.c
and it will ignore all differences to other files.
An example of normal usage is:
- torvalds@ppc970:~/git> git-diff-tree 5319e4......
+ torvalds@ppc970:~/git> git diff-tree 5319e4......
*100664->100664 blob ac348b.......->a01513....... git-fsck-objects.c
which tells you that the last commit changed just one file (it's from
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-diff</em> [<common diff options>] <commit>{0,2} [--] [<path>…]</p>\r
+<p><em>git diff</em> [<common diff options>] <commit>{0,2} [--] [<path>…]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
tree and the index file, or the index file and the working tree.</p>\r
<dl>\r
<dt>\r
-<em>git-diff</em> [--options] [--] [<path>…]\r
+<em>git diff</em> [--options] [--] [<path>…]\r
</dt>\r
<dd>\r
<p>\r
forced by --no-index.</p>\r
</dd>\r
<dt>\r
-<em>git-diff</em> [--options] --cached [<commit>] [--] [<path>…]\r
+<em>git diff</em> [--options] --cached [<commit>] [--] [<path>…]\r
</dt>\r
<dd>\r
<p>\r
</p>\r
</dd>\r
<dt>\r
-<em>git-diff</em> [--options] <commit> [--] [<path>…]\r
+<em>git diff</em> [--options] <commit> [--] [<path>…]\r
</dt>\r
<dd>\r
<p>\r
</p>\r
</dd>\r
<dt>\r
-<em>git-diff</em> [--options] <commit> <commit> [--] [<path>…]\r
+<em>git diff</em> [--options] <commit> <commit> [--] [<path>…]\r
</dt>\r
<dd>\r
<p>\r
</p>\r
</dd>\r
<dt>\r
-<em>git-diff</em> [--options] <commit>..<commit> [--] [<path>…]\r
+<em>git diff</em> [--options] <commit>..<commit> [--] [<path>…]\r
</dt>\r
<dd>\r
<p>\r
</p>\r
</dd>\r
<dt>\r
-<em>git-diff</em> [--options] <commit>...<commit> [--] [<path>…]\r
+<em>git diff</em> [--options] <commit>...<commit> [--] [<path>…]\r
</dt>\r
<dd>\r
<p>\r
This form is to view the changes on the branch containing\r
and up to the second <commit>, starting at a common ancestor\r
- of both <commit>. "git-diff A...B" is equivalent to\r
- "git-diff $(git-merge-base A B) B". You can omit any one\r
+ of both <commit>. "git diff A...B" is equivalent to\r
+ "git diff $(git-merge-base A B) B". You can omit any one\r
of <commit>, which has the same effect as using HEAD instead.\r
</p>\r
</dd>\r
</dd>\r
</dl>\r
<p>For more detailed explanation on these common options, see also\r
-<a href="gitdiffcore.html">gitdiffcore(7)</a>[diffcore documentation].</p>\r
+<a href="gitdiffcore.html">gitdiffcore(7)</a>.</p>\r
<dl>\r
<dt>\r
<path>…\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:36 UTC\r
+Last updated 02-Jul-2008 03:01:41 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-diff' [<common diff options>] <commit>{0,2} [--] [<path>...]
+'git
diff' [<common diff options>] <commit>{0,2} [--] [<path>...]
DESCRIPTION
-----------
Show changes between two trees, a tree and the working tree, a
tree and the index file, or the index file and the working tree.
-'git
-diff' [--options] [--] [<path>...]::
+'git
diff' [--options] [--] [<path>...]::
This form is to view the changes you made relative to
the index (staging area for the next commit). In other
compare the two files / directories. This behavior can be
forced by --no-index.
-'git
-diff' [--options] --cached [<commit>] [--] [<path>...]::
+'git
diff' [--options] --cached [<commit>] [--] [<path>...]::
This form is to view the changes you staged for the next
commit relative to the named <commit>. Typically you
would want comparison with the latest commit, so if you
do not give <commit>, it defaults to HEAD.
-'git
-diff' [--options] <commit> [--] [<path>...]::
+'git
diff' [--options] <commit> [--] [<path>...]::
This form is to view the changes you have in your
working tree relative to the named <commit>. You can
branch name to compare with the tip of a different
branch.
-'git
-diff' [--options] <commit> <commit> [--] [<path>...]::
+'git
diff' [--options] <commit> <commit> [--] [<path>...]::
This is to view the changes between two arbitrary
<commit>.
-'git
-diff' [--options] <commit>..<commit> [--] [<path>...]::
+'git
diff' [--options] <commit>..<commit> [--] [<path>...]::
This is synonymous to the previous form. If <commit> on
one side is omitted, it will have the same effect as
using HEAD instead.
-'git
-diff' [--options] <commit>\...<commit> [--] [<path>...]::
+'git
diff' [--options] <commit>\...<commit> [--] [<path>...]::
This form is to view the changes on the branch containing
and up to the second <commit>, starting at a common ancestor
- of both <commit>. "git-diff A\...B" is equivalent to
- "git-diff $(git-merge-base A B) B". You can omit any one
+ of both <commit>. "git diff A\...B" is equivalent to
+ "git diff $(git-merge-base A B) B". You can omit any one
of <commit>, which has the same effect as using HEAD instead.
Just in case if you are doing something exotic, it should be
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-fast-export [options]</em> | <em>git-fast-import</em></p>\r
+<p><em>git fast-export [options]</em> | <em>git fast-import</em></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>This program dumps the given revisions in a form suitable to be piped\r
-into <a href="git-fast-import.html">git-fast-import(1)</a>.</p>\r
+into <tt>git-fast-import</tt>.</p>\r
<p>You can use it as a human readable bundle replacement (see\r
<a href="git-bundle.html">git-bundle(1)</a>), or as a kind of an interactive\r
-<a href="git-filter-branch.html">git-filter-branch(1)</a>.</p>\r
+<tt>git-filter-branch</tt>.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
<dd>\r
<p>\r
Insert <em>progress</em> statements every <n> objects, to be shown by\r
- <a href="git-fast-import.html">git-fast-import(1)</a> during import.\r
+ <tt>git-fast-import</tt> during import.\r
</p>\r
</dd>\r
<dt>\r
</div>\r
<h2>Limitations</h2>\r
<div class="sectionbody">\r
-<p>Since <a href="git-fast-import.html">git-fast-import(1)</a> cannot tag trees, you will not be\r
+<p>Since <tt>git-fast-import</tt> cannot tag trees, you will not be\r
able to export the linux-2.6.git repository completely, as it contains\r
a tag referencing a tree instead of a commit.</p>\r
</div>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 23-Jun-2008 07:13:35 UTC\r
+Last updated 02-Jul-2008 03:01:42 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-fast-export [options]' | 'git-fast-import'
+'git fast-export [options]' | 'git fast-import'
DESCRIPTION
-----------
This program dumps the given revisions in a form suitable to be piped
-into linkgit:git-fast-import[1].
+into `git-fast-import`.
You can use it as a human readable bundle replacement (see
linkgit:git-bundle[1]), or as a kind of an interactive
-linkgit:git-filter-branch[1].
+`git-filter-branch`.
OPTIONS
-------
--progress=<n>::
Insert 'progress' statements every <n> objects, to be shown by
- linkgit:git-fast-import[1] during import.
+ `git-fast-import` during import.
--signed-tags=(verbatim|warn|strip|abort)::
Specify how to handle signed tags. Since any transformation
Limitations
-----------
-Since linkgit:git-fast-import[1] cannot tag trees, you will not be
+Since `git-fast-import` cannot tag trees, you will not be
able to export the linux-2.6.git repository completely, as it contains
a tag referencing a tree instead of a commit.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p>frontend | <em>git-fast-import</em> [options]</p>\r
+<p>frontend | <em>git fast-import</em> [options]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>This program is usually not what the end user wants to run directly.\r
Most end users want to use one of the existing frontend programs,\r
which parses a specific type of foreign source and feeds the contents\r
-stored there to git-fast-import.</p>\r
+stored there to <tt>git-fast-import</tt>.</p>\r
<p>fast-import reads a mixed command/data stream from standard input and\r
writes one or more packfiles directly into the current repository.\r
When EOF is received on standard input, fast import writes out\r
updated branch and tag refs, fully updating the current repository\r
with the newly imported data.</p>\r
<p>The fast-import backend itself can import into an empty repository (one that\r
-has already been initialized by <a href="git-init.html">git-init(1)</a>) or incrementally\r
+has already been initialized by <tt>git-init</tt>) or incrementally\r
update an existing populated repository. Whether or not incremental\r
imports are supported from a particular foreign source depends on\r
the frontend program in use.</p>\r
This information may be useful after importing projects\r
whose total object set exceeds the 4 GiB packfile limit,\r
as these commits can be used as edge points during calls\r
- to <a href="git-pack-objects.html">git-pack-objects(1)</a>.\r
+ to <tt>git-pack-objects</tt>.\r
</p>\r
</dd>\r
<dt>\r
<div class="sectionbody">\r
<p>Like <tt>git-push</tt> or <tt>git-fetch</tt>, imports handled by fast-import are safe to\r
run alongside parallel <tt>git repack -a -d</tt> or <tt>git gc</tt> invocations,\r
-or any other Git operation (including <tt>git prune</tt>, as loose objects\r
+or any other Git operation (including <tt>git-prune</tt>, as loose objects\r
are never used by fast-import).</p>\r
<p>fast-import does not lock the branch or tag refs it is actively importing.\r
After the import, during its ref update phase, fast-import tests each\r
</p>\r
<p>An example value is “Tue Feb 6 11:22:18 2007 -0500”. The Git\r
parser is accurate, but a little on the lenient side. It is the\r
-same parser used by <a href="git-am.html">git-am(1)</a> when applying patches\r
+same parser used by <tt>git-am</tt> when applying patches\r
received from email.</p>\r
<p>Some malformed strings may be accepted as valid dates. In some of\r
these cases Git will still be able to obtain the correct date from\r
<p>This particular format is supplied as its short to implement and\r
may be useful to a process that wants to create a new commit\r
right now, without needing to use a working directory or\r
-<a href="git-update-index.html">git-update-index(1)</a>.</p>\r
+<tt>git-update-index</tt>.</p>\r
<p>If separate <tt>author</tt> and <tt>committer</tt> commands are used in a <tt>commit</tt>\r
the timestamps may not match, as the system clock will be polled\r
twice (once for each command). The only way to ensure that both\r
complete set of bytes which normally goes into such a signature.\r
If signing is required, create lightweight tags from within fast-import with\r
<tt>reset</tt>, then create the annotated versions of those tags offline\r
-with the standard <a href="git-tag.html">git-tag(1)</a> process.</p>\r
+with the standard <tt>git-tag</tt> process.</p>\r
<h3><tt>reset</tt></h3>\r
<p>Creates (or recreates) the named branch, optionally starting from\r
a specific revision. The reset command allows a frontend to issue\r
<div class="exampleblock-content">\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>frontend | git-fast-import | sed 's/^progress //'</tt></pre>\r
+<pre><tt>frontend | git fast-import | sed 's/^progress //'</tt></pre>\r
</div></div>\r
</div></div>\r
<p>Placing a <tt>progress</tt> command immediately after a <tt>checkpoint</tt> will\r
</div></div>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>$ git-fast-import <in\r
+<pre><tt>$ git fast-import <in\r
fatal: Corrupt mode: M 777 inline bob\r
fast-import: dumping crash report to .git/fast_import_crash_8434</tt></pre>\r
</div></div>\r
is not <tt>refs/heads/TAG_FIXUP</tt>).</p>\r
<p>When committing fixups, consider using <tt>merge</tt> to connect the\r
commit(s) which are supplying file revisions to the fixup branch.\r
-Doing so will allow tools such as <a href="git-blame.html">git-blame(1)</a> to track\r
+Doing so will allow tools such as <tt>git-blame</tt> to track\r
through the real commit history and properly annotate the source\r
files.</p>\r
<p>After fast-import terminates the frontend will need to do <tt>rm .git/TAG_FIXUP</tt>\r
<h3>Repacking Historical Data</h3>\r
<p>If you are repacking very old imported data (e.g. older than the\r
last year), consider expending some extra CPU time and supplying\r
---window=50 (or higher) when you run <a href="git-repack.html">git-repack(1)</a>.\r
+--window=50 (or higher) when you run <tt>git-repack</tt>.\r
This will take longer, but will also produce a smaller packfile.\r
You only need to expend the effort once, and everyone using your\r
project will benefit from the smaller repository.</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:38 UTC\r
+Last updated 02-Jul-2008 03:01:43 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-frontend | 'git-fast-import' [options]
+frontend | 'git fast-import' [options]
DESCRIPTION
-----------
This program is usually not what the end user wants to run directly.
Most end users want to use one of the existing frontend programs,
which parses a specific type of foreign source and feeds the contents
-stored there to git-fast-import.
+stored there to `git-fast-import`.
fast-import reads a mixed command/data stream from standard input and
writes one or more packfiles directly into the current repository.
with the newly imported data.
The fast-import backend itself can import into an empty repository (one that
-has already been initialized by linkgit:git-init[1]) or incrementally
+has already been initialized by `git-init`) or incrementally
update an existing populated repository. Whether or not incremental
imports are supported from a particular foreign source depends on
the frontend program in use.
This information may be useful after importing projects
whose total object set exceeds the 4 GiB packfile limit,
as these commits can be used as edge points during calls
- to linkgit:git-pack-objects[1].
+ to `git-pack-objects`.
--quiet::
Disable all non-fatal output, making fast-import silent when it
------------------
Like `git-push` or `git-fetch`, imports handled by fast-import are safe to
run alongside parallel `git repack -a -d` or `git gc` invocations,
-or any other Git operation (including `git prune`, as loose objects
+or any other Git operation (including `git-prune`, as loose objects
are never used by fast-import).
fast-import does not lock the branch or tag refs it is actively importing.
+
An example value is ``Tue Feb 6 11:22:18 2007 -0500''. The Git
parser is accurate, but a little on the lenient side. It is the
-same parser used by linkgit:git-am[1] when applying patches
+same parser used by `git-am` when applying patches
received from email.
+
Some malformed strings may be accepted as valid dates. In some of
This particular format is supplied as its short to implement and
may be useful to a process that wants to create a new commit
right now, without needing to use a working directory or
-linkgit:git-update-index[1].
+`git-update-index`.
+
If separate `author` and `committer` commands are used in a `commit`
the timestamps may not match, as the system clock will be polled
complete set of bytes which normally goes into such a signature.
If signing is required, create lightweight tags from within fast-import with
`reset`, then create the annotated versions of those tags offline
-with the standard linkgit:git-tag[1] process.
+with the standard `git-tag` process.
`reset`
~~~~~~~
remove the leading part of the line, for example:
====
- frontend | git-fast-import | sed 's/^progress //'
+ frontend | git fast-import | sed 's/^progress //'
====
Placing a `progress` command immediately after a `checkpoint` will
M 777 inline bob
END_OF_INPUT
- $ git-fast-import <in
+ $ git fast-import <in
fatal: Corrupt mode: M 777 inline bob
fast-import: dumping crash report to .git/fast_import_crash_8434
When committing fixups, consider using `merge` to connect the
commit(s) which are supplying file revisions to the fixup branch.
-Doing so will allow tools such as linkgit:git-blame[1] to track
+Doing so will allow tools such as `git-blame` to track
through the real commit history and properly annotate the source
files.
~~~~~~~~~~~~~~~~~~~~~~~~~
If you are repacking very old imported data (e.g. older than the
last year), consider expending some extra CPU time and supplying
-\--window=50 (or higher) when you run linkgit:git-repack[1].
+\--window=50 (or higher) when you run `git-repack`.
This will take longer, but will also produce a smaller packfile.
You only need to expend the effort once, and everyone using your
project will benefit from the smaller repository.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-fetch-pack</em> [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>…]</p>\r
+<p><em>git fetch-pack</em> [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>…]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>Usually you would want to use <a href="git-fetch.html">git-fetch(1)</a> which is a\r
-higher level wrapper of this command instead.</p>\r
-<p>Invokes <em>git-upload-pack</em> on a potentially remote repository,\r
+<p>Usually you would want to use <tt>git-fetch</tt>, which is a\r
+higher level wrapper of this command, instead.</p>\r
+<p>Invokes <tt>git-upload-pack</tt> on a possibly remote repository\r
and asks it to send objects missing from this repository, to\r
update the named heads. The list of commits available locally\r
is found out by scanning local $GIT_DIR/refs/ and sent to\r
-<em>git-upload-pack</em> running on the other end.</p>\r
+<tt>git-upload-pack</tt> running on the other end.</p>\r
<p>This command degenerates to download everything to complete the\r
asked refs from the remote side when the local side does not\r
have a common ancestor commit.</p>\r
</dt>\r
<dd>\r
<p>\r
- Pass <em>-q</em> flag to <em>git-unpack-objects</em>; this makes the\r
+ Pass <em>-q</em> flag to <tt>git-unpack-objects</tt>; this makes the\r
cloning process less verbose.\r
</p>\r
</dd>\r
</dt>\r
<dd>\r
<p>\r
- Do not invoke <em>git-unpack-objects</em> on received data, but\r
+ Do not invoke <tt>git-unpack-objects</tt> on received data, but\r
create a single packfile out of it instead, and store it\r
in the object database. If provided twice then the pack is\r
locked against repacking.\r
</dt>\r
<dd>\r
<p>\r
- Use this to specify the path to <em>git-upload-pack</em> on the\r
+ Use this to specify the path to <tt>git-upload-pack</tt> on the\r
remote side, if is not found on your $PATH.\r
Installations of sshd ignores the user's environment\r
setup scripts for login shells (e.g. .bash_profile) and\r
<dd>\r
<p>\r
A remote host that houses the repository. When this\r
- part is specified, <em>git-upload-pack</em> is invoked via\r
+ part is specified, <tt>git-upload-pack</tt> is invoked via\r
ssh.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:34 UTC\r
+Last updated 02-Jul-2008 03:01:43 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-fetch-pack' [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]
+'git fetch-pack' [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]
DESCRIPTION
-----------
-Usually you would want to use linkgit:git-fetch[1] which is a
-higher level wrapper of this command instead.
+Usually you would want to use `git-fetch`, which is a
+higher level wrapper of this command, instead.
-Invokes 'git-upload-pack' on a potentially remote repository,
+Invokes `git-upload-pack` on a possibly remote repository
and asks it to send objects missing from this repository, to
update the named heads. The list of commits available locally
is found out by scanning local $GIT_DIR/refs/ and sent to
-'git-upload-pack' running on the other end.
+`git-upload-pack` running on the other end.
This command degenerates to download everything to complete the
asked refs from the remote side when the local side does not
-q::
--quiet::
- Pass '-q' flag to 'git-unpack-objects'; this makes the
+ Pass '-q' flag to `git-unpack-objects`; this makes the
cloning process less verbose.
-k::
--keep::
- Do not invoke 'git-unpack-objects' on received data, but
+ Do not invoke `git-unpack-objects` on received data, but
create a single packfile out of it instead, and store it
in the object database. If provided twice then the pack is
locked against repacking.
otherwise determine the tags this option made available.
--upload-pack=<git-upload-pack>::
- Use this to specify the path to 'git-upload-pack' on the
+ Use this to specify the path to `git-upload-pack` on the
remote side, if is not found on your $PATH.
Installations of sshd ignores the user's environment
setup scripts for login shells (e.g. .bash_profile) and
<host>::
A remote host that houses the repository. When this
- part is specified, 'git-upload-pack' is invoked via
+ part is specified, `git-upload-pack` is invoked via
ssh.
<directory>::
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-fetch</em> <options> <repository> <refspec>…</p>\r
+<p><em>git fetch</em> <options> <repository> <refspec>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
the objects necessary to complete them.</p>\r
<p>The ref names and their object names of fetched refs are stored\r
in <tt>.git/FETCH_HEAD</tt>. This information is left for a later merge\r
-operation done by "git merge".</p>\r
+operation done by <tt>git-merge</tt>.</p>\r
<p>When <refspec> stores the fetched result in tracking branches,\r
the tags that point at these branches are automatically\r
followed. This is done by first fetching from the remote using\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:36 UTC\r
+Last updated 02-Jul-2008 03:01:44 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-fetch' <options> <repository> <refspec>...
+'git fetch' <options> <repository> <refspec>...
DESCRIPTION
The ref names and their object names of fetched refs are stored
in `.git/FETCH_HEAD`. This information is left for a later merge
-operation done by "git merge".
+operation done by `git-merge`.
When <refspec> stores the fetched result in tracking branches,
the tags that point at these branches are automatically
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-filter-branch</em> [--env-filter <command>] [--tree-filter <command>]\r
+<div class="content"><em>git filter-branch</em> [--env-filter <command>] [--tree-filter <command>]\r
[--index-filter <command>] [--parent-filter <command>]\r
[--msg-filter <command>] [--commit-filter <command>]\r
[--tag-name-filter <command>] [--subdirectory-filter <directory>]\r
This is the filter for rewriting the commit's parent list.\r
It will receive the parent string on stdin and shall output\r
the new parent string on stdout. The parent string is in\r
-
a format accepted by <a href="git-commit-tree.html">git-commit-tree(1)</a>: empty for
\r+
the format described in <a href="git-commit-tree.html">git-commit-tree(1)</a>: empty for
\r the initial commit, "-p parent" for a normal commit and\r
"-p parent1 -p parent2 -p parent3 …" for a merge commit.\r
</p>\r
<p>\r
This is the filter for performing the commit.\r
If this filter is specified, it will be called instead of the\r
- <a href="git-commit-tree.html">git-commit-tree(1)</a> command, with arguments of the form\r
+ <tt>git-commit-tree</tt> command, with arguments of the form\r
"<TREE_ID> [-p <PARENT_COMMIT_ID>]…" and the log message on\r
stdin. The commit id is expected on stdout.\r
</p>\r
<p>You can use the <em>map</em> convenience function in this filter, and other\r
convenience functions, too. For example, calling <em>skip_commit "$@"</em>\r
will leave out the current commit (but not its changes! If you want\r
-that, use <a href="git-rebase.html">git-rebase(1)</a> instead).</p>\r
+that, use <tt>git-rebase</tt> instead).</p>\r
</dd>\r
<dt>\r
--tag-name-filter <command>\r
<dd>\r
<p>\r
When options are given after the new branch name, they will\r
- be passed to <a href="git-rev-list.html">git-rev-list(1)</a>. Only commits in the resulting\r
+ be passed to <tt>git-rev-list</tt>. Only commits in the resulting\r
output will be filtered, although the filtered commits can still\r
reference parents which are outside of that set.\r
</p>\r
</div></div>\r
<p>To restrict rewriting to only part of the history, specify a revision\r
range in addition to the new branch name. The new branch name will\r
-point to the top-most revision that a <em>git rev-list</em> of this range\r
+point to the top-most revision that a <tt>git-rev-list</tt> of this range\r
will print.</p>\r
<p><strong>NOTE</strong> the changes introduced by the commits, and which are not reverted\r
by subsequent commits, will still be in the rewritten branch. If you want\r
to throw out _changes_ together with the commits, you should use the\r
-interactive mode of <a href="git-rebase.html">git-rebase(1)</a>.</p>\r
+interactive mode of <tt>git-rebase</tt>.</p>\r
<p>Consider this history:</p>\r
<div class="listingblock">\r
<div class="content">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:37 UTC\r
+Last updated 02-Jul-2008 03:01:45 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-filter-branch' [--env-filter <command>] [--tree-filter <command>]
+'git filter-branch' [--env-filter <command>] [--tree-filter <command>]
[--index-filter <command>] [--parent-filter <command>]
[--msg-filter <command>] [--commit-filter <command>]
[--tag-name-filter <command>] [--subdirectory-filter <directory>]
This is the filter for rewriting the commit's parent list.
It will receive the parent string on stdin and shall output
the new parent string on stdout. The parent string is in
- a format accepted by linkgit:git-commit-tree[1]: empty for
+ the format described in linkgit:git-commit-tree[1]: empty for
the initial commit, "-p parent" for a normal commit and
"-p parent1 -p parent2 -p parent3 ..." for a merge commit.
--commit-filter <command>::
This is the filter for performing the commit.
If this filter is specified, it will be called instead of the
- linkgit:git-commit-tree[1] command, with arguments of the form
+ `git-commit-tree` command, with arguments of the form
"<TREE_ID> [-p <PARENT_COMMIT_ID>]..." and the log message on
stdin. The commit id is expected on stdout.
+
You can use the 'map' convenience function in this filter, and other
convenience functions, too. For example, calling 'skip_commit "$@"'
will leave out the current commit (but not its changes! If you want
-that, use linkgit:git-rebase[1] instead).
+that, use `git-rebase` instead).
--tag-name-filter <command>::
This is the filter for rewriting tag names. When passed,
<rev-list-options>::
When options are given after the new branch name, they will
- be passed to linkgit:git-rev-list[1]. Only commits in the resulting
+ be passed to `git-rev-list`. Only commits in the resulting
output will be filtered, although the filtered commits can still
reference parents which are outside of that set.
To restrict rewriting to only part of the history, specify a revision
range in addition to the new branch name. The new branch name will
-point to the top-most revision that a 'git rev-list' of this range
+point to the top-most revision that a `git-rev-list` of this range
will print.
*NOTE* the changes introduced by the commits, and which are not reverted
by subsequent commits, will still be in the rewritten branch. If you want
to throw out _changes_ together with the commits, you should use the
-interactive mode of linkgit:git-rebase[1].
+interactive mode of `git-rebase`.
Consider this history:
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content">git-fmt-merge-msg [--log | --no-log] <$GIT_DIR/FETCH_HEAD\r
-git-fmt-merge-msg [--log | --no-log] -F <file></div></div>\r
+<div class="content"><em>git fmt-merge-msg</em> [--log | --no-log] <$GIT_DIR/FETCH_HEAD\r
+<em>git fmt-merge-msg</em> [--log | --no-log] -F <file></div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:38 UTC\r
+Last updated 02-Jul-2008 03:01:46 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-git-fmt-merge-msg [--log | --no-log] <$GIT_DIR/FETCH_HEAD
-git-fmt-merge-msg [--log | --no-log] -F <file>
+'git fmt-merge-msg' [--log | --no-log] <$GIT_DIR/FETCH_HEAD
+'git fmt-merge-msg' [--log | --no-log] -F <file>
DESCRIPTION
-----------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-for-each-ref</em> [--count=<count>] [--shell|--perl|--python|--tcl]\r
+<div class="content"><em>git for-each-ref</em> [--count=<count>] [--shell|--perl|--python|--tcl]\r
[--sort=<key>]* [--format=<format>] [<pattern>…]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="content">\r
<pre><tt>#!/bin/sh\r
\r
-git-for-each-ref --count=3 --sort='-*authordate' \\r
+git for-each-ref --count=3 --sort='-*authordate' \\r
--format='From: %(*authorname) %(*authoremail)\r
Subject: %(*subject)\r
Date: %(*authordate)\r
<div class="content">\r
<pre><tt>#!/bin/sh\r
\r
-git-for-each-ref --shell --format="ref=%(refname)" refs/heads | \\r
+git for-each-ref --shell --format="ref=%(refname)" refs/heads | \\r
while read entry\r
do\r
eval "$entry"\r
fi\r
'\r
\r
-eval=`git-for-each-ref --shell --format="$fmt" \\r
+eval=`git for-each-ref --shell --format="$fmt" \\r
--sort='*objecttype' \\r
--sort=-taggerdate \\r
refs/tags`\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:39 UTC\r
+Last updated 02-Jul-2008 03:01:46 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-for-each-ref' [--count=<count>] [--shell|--perl|--python|--tcl]
+'git for-each-ref' [--count=<count>] [--shell|--perl|--python|--tcl]
[--sort=<key>]\* [--format=<format>] [<pattern>...]
DESCRIPTION
------------
#!/bin/sh
-git-for-each-ref --count=3 --sort='-*authordate' \
+git for-each-ref --count=3 --sort='-*authordate' \
--format='From: %(*authorname) %(*authoremail)
Subject: %(*subject)
Date: %(*authordate)
------------
#!/bin/sh
-git-for-each-ref --shell --format="ref=%(refname)" refs/heads | \
+git for-each-ref --shell --format="ref=%(refname)" refs/heads | \
while read entry
do
eval "$entry"
fi
'
-eval=`git-for-each-ref --shell --format="$fmt" \
+eval=`git for-each-ref --shell --format="$fmt" \
--sort='*objecttype' \
--sort=-taggerdate \
refs/tags`
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-format-patch</em> [-k] [-o <dir> | --stdout] [--thread]\r
+<div class="content"><em>git format-patch</em> [-k] [-o <dir> | --stdout] [--thread]\r
[--attach[=<boundary>] | --inline[=<boundary>]]\r
[-s | --signoff] [<common diff options>]\r
[-n | --numbered | -N | --no-numbered]\r
<p>Prepare each commit with its patch in\r
one file per commit, formatted to resemble UNIX mailbox format.\r
The output of this command is convenient for e-mail submission or\r
-for use with <a href="git-am.html">git-am(1)</a>.</p>\r
+for use with <tt>git-am</tt>.</p>\r
<p>There are two ways to specify which commits to operate on.</p>\r
<ol>\r
<li>\r
they are created in the current working directory.</p>\r
<p>If -n is specified, instead of "[PATCH] Subject", the first line\r
is formatted as "[PATCH n/m] Subject".</p>\r
-<p>If given --thread, git-format-patch will generate In-Reply-To and\r
+<p>If given --thread, <tt>git-format-patch</tt> will generate In-Reply-To and\r
References headers to make the second and subsequent patch mails appear\r
as replies to the first mail; this also generates a Message-Id header to\r
reference.</p>\r
</dd>\r
</dl>\r
<p>For more detailed explanation on these common options, see also\r
-<a href="gitdiffcore.html">gitdiffcore(7)</a>[diffcore documentation].</p>\r
+<a href="gitdiffcore.html">gitdiffcore(7)</a>.</p>\r
<dl>\r
<dt>\r
-<n>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:40 UTC\r
+Last updated 02-Jul-2008 03:01:46 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-format-patch' [-k] [-o <dir> | --stdout] [--thread]
+'git format-patch' [-k] [-o <dir> | --stdout] [--thread]
[--attach[=<boundary>] | --inline[=<boundary>]]
[-s | --signoff] [<common diff options>]
[-n | --numbered | -N | --no-numbered]
Prepare each commit with its patch in
one file per commit, formatted to resemble UNIX mailbox format.
The output of this command is convenient for e-mail submission or
-for use with linkgit:git-am[1].
+for use with `git-am`.
There are two ways to specify which commits to operate on.
If -n is specified, instead of "[PATCH] Subject", the first line
is formatted as "[PATCH n/m] Subject".
-If given --thread, git-format-patch will generate In-Reply-To and
+If given --thread, `git-format-patch` will generate In-Reply-To and
References headers to make the second and subsequent patch mails appear
as replies to the first mail; this also generates a Message-Id header to
reference.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-fsck-objects</em> …</p>\r
+<p><em>git fsck-objects</em> …</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:43 UTC\r
+Last updated 02-Jul-2008 03:01:46 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-fsck-objects' ...
+'git fsck-objects' ...
DESCRIPTION
-----------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-fsck</em> [--tags] [--root] [--unreachable] [--cache] [--no-reflogs]\r
+<div class="content"><em>git fsck</em> [--tags] [--root] [--unreachable] [--cache] [--no-reflogs]\r
[--full] [--strict] [--verbose] [--lost-found] [<object>*]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<p>\r
An object to treat as the head of an unreachability trace.\r
</p>\r
-<p>If no objects are given, git-fsck defaults to using the\r
+<p>If no objects are given, <tt>git-fsck</tt> defaults to using the\r
index file, all SHA1 references in .git/refs/*, and all reflogs (unless\r
--no-reflogs is given) as heads.</p>\r
</dd>\r
<p>So for example</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-fsck --unreachable HEAD $(cat .git/refs/heads/*)</tt></pre>\r
+<pre><tt>git fsck --unreachable HEAD $(cat .git/refs/heads/*)</tt></pre>\r
</div></div>\r
<p>will do quite a _lot_ of verification on the tree. There are a few\r
extra validity tests to be added (make sure that tree objects are\r
-sorted properly etc), but on the whole if "git-fsck" is happy, you\r
+sorted properly etc), but on the whole if <tt>git-fsck</tt> is happy, you\r
do have a valid tree.</p>\r
<p>Any corrupt objects you will have to find in backups or other archives\r
-(i.e., you can just remove them and do an "rsync" with some other site in\r
+(i.e., you can just remove them and do an <tt>rsync</tt> with some other site in\r
the hopes that somebody else has the object you have corrupted).</p>\r
<p>Of course, "valid tree" doesn't mean that it wasn't generated by some\r
evil person, and the end result might be crap. git is a revision\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:43 UTC\r
+Last updated 02-Jul-2008 03:01:46 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-fsck' [--tags] [--root] [--unreachable] [--cache] [--no-reflogs]
+'git fsck' [--tags] [--root] [--unreachable] [--cache] [--no-reflogs]
[--full] [--strict] [--verbose] [--lost-found] [<object>*]
DESCRIPTION
<object>::
An object to treat as the head of an unreachability trace.
+
-If no objects are given, git-fsck defaults to using the
+If no objects are given, `git-fsck` defaults to using the
index file, all SHA1 references in .git/refs/*, and all reflogs (unless
--no-reflogs is given) as heads.
So for example
- git-fsck --unreachable HEAD $(cat .git/refs/heads/*)
+ git fsck --unreachable HEAD $(cat .git/refs/heads/*)
will do quite a _lot_ of verification on the tree. There are a few
extra validity tests to be added (make sure that tree objects are
-sorted properly etc), but on the whole if "git-fsck" is happy, you
+sorted properly etc), but on the whole if `git-fsck` is happy, you
do have a valid tree.
Any corrupt objects you will have to find in backups or other archives
-(i.e., you can just remove them and do an "rsync" with some other site in
+(i.e., you can just remove them and do an `rsync` with some other site in
the hopes that somebody else has the object you have corrupted).
Of course, "valid tree" doesn't mean that it wasn't generated by some
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-gc</em> [--aggressive] [--auto] [--quiet]</p>\r
+<p><em>git gc</em> [--aggressive] [--auto] [--quiet]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Runs a number of housekeeping tasks within the current repository,\r
such as compressing file revisions (to reduce disk space and increase\r
performance) and removing unreachable objects which may have been\r
-created from prior invocations of <a href="git-add.html">git-add(1)</a>.</p>\r
+created from prior invocations of <tt>git-add</tt>.</p>\r
<p>Users are encouraged to run this task on a regular basis within\r
each repository to maintain good disk space utilization and good\r
operating performance.</p>\r
</dt>\r
<dd>\r
<p>\r
- Usually <em>git-gc</em> runs very quickly while providing good disk\r
+ Usually <tt>git-gc</tt> runs very quickly while providing good disk\r
space utilization and performance. This option will cause\r
- git-gc to more aggressively optimize the repository at the expense\r
+ <tt>git-gc</tt> to more aggressively optimize the repository at the expense\r
of taking much more time. The effects of this optimization are\r
persistent, so this option only needs to be used occasionally; every\r
few hundred changesets or so.\r
</dt>\r
<dd>\r
<p>\r
- With this option, <tt>git gc</tt> checks whether any housekeeping is\r
+ With this option, <tt>git-gc</tt> checks whether any housekeeping is\r
required; if not, it exits without performing any work.\r
Some git commands run <tt>git gc --auto</tt> after performing\r
operations that could create many loose objects.\r
how long records of conflicted merge you have not resolved are\r
kept. This defaults to 15 days.</p>\r
<p>The optional configuration variable <em>gc.packrefs</em> determines if\r
-<tt>git gc</tt> runs <tt>git-pack-refs</tt>. This can be set to "nobare" to enable\r
+<tt>git-gc</tt> runs <tt>git-pack-refs</tt>. This can be set to "nobare" to enable\r
it within all non-bare repos or it can be set to a boolean value.\r
This defaults to true.</p>\r
<p>The optional configuration variable <em>gc.aggressiveWindow</em> controls how\r
</div>\r
<h2>Notes</h2>\r
<div class="sectionbody">\r
-<p>git-gc tries very hard to be safe about the garbage it collects. In\r
+<p><tt>git-gc</tt> tries very hard to be safe about the garbage it collects. In\r
particular, it will keep not only objects referenced by your current set\r
of branches and tags, but also objects referenced by the index, remote\r
-tracking branches, refs saved by <a href="git-filter-branch.html">git-filter-branch(1)</a> in\r
+tracking branches, refs saved by <tt>git-filter-branch</tt> in\r
refs/original/, or reflogs (which may references commits in branches\r
that were later amended or rewound).</p>\r
<p>If you are expecting some objects to be collected and they aren't, check\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:43 UTC\r
+Last updated 02-Jul-2008 03:01:47 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-gc' [--aggressive] [--auto] [--quiet]
+'git gc' [--aggressive] [--auto] [--quiet]
DESCRIPTION
-----------
Runs a number of housekeeping tasks within the current repository,
such as compressing file revisions (to reduce disk space and increase
performance) and removing unreachable objects which may have been
-created from prior invocations of linkgit:git-add[1].
+created from prior invocations of `git-add`.
Users are encouraged to run this task on a regular basis within
each repository to maintain good disk space utilization and good
-------
--aggressive::
- Usually 'git-gc' runs very quickly while providing good disk
+ Usually `git-gc` runs very quickly while providing good disk
space utilization and performance. This option will cause
- git-gc to more aggressively optimize the repository at the expense
+ `git-gc` to more aggressively optimize the repository at the expense
of taking much more time. The effects of this optimization are
persistent, so this option only needs to be used occasionally; every
few hundred changesets or so.
--auto::
- With this option, `git gc` checks whether any housekeeping is
+ With this option, `git-gc` checks whether any housekeeping is
required; if not, it exits without performing any work.
Some git commands run `git gc --auto` after performing
operations that could create many loose objects.
kept. This defaults to 15 days.
The optional configuration variable 'gc.packrefs' determines if
-`git gc` runs `git-pack-refs`. This can be set to "nobare" to enable
+`git-gc` runs `git-pack-refs`. This can be set to "nobare" to enable
it within all non-bare repos or it can be set to a boolean value.
This defaults to true.
Notes
-----
-git-gc tries very hard to be safe about the garbage it collects. In
+`git-gc` tries very hard to be safe about the garbage it collects. In
particular, it will keep not only objects referenced by your current set
of branches and tags, but also objects referenced by the index, remote
-tracking branches, refs saved by linkgit:git-filter-branch[1] in
+tracking branches, refs saved by `git-filter-branch` in
refs/original/, or reflogs (which may references commits in branches
that were later amended or rewound).
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-get-tar-commit-id</em> < <tarfile></p>\r
+<p><em>git get-tar-commit-id</em> < <tarfile></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Acts as a filter, extracting the commit ID stored in archives created by\r
-<a href="git-archive.html">git-archive(1)</a>. It reads only the first 1024 bytes of input, thus its\r
+<tt>git-archive</tt>. It reads only the first 1024 bytes of input, thus its\r
runtime is not influenced by the size of <tarfile> very much.</p>\r
-<p>If no commit ID is found, git-get-tar-commit-id quietly exists with a\r
+<p>If no commit ID is found, <tt>git-get-tar-commit-id</tt> quietly exists with a\r
return code of 1. This can happen if <tarfile> had not been created\r
-using git-archive or if the first parameter of git-archive had been\r
+using <tt>git-archive</tt> or if the first parameter of <tt>git-archive</tt> had been\r
a tree ID instead of a commit ID or tag.</p>\r
</div>\r
<h2>Author</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:44 UTC\r
+Last updated 02-Jul-2008 03:01:47 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-get-tar-commit-id' < <tarfile>
+'git get-tar-commit-id' < <tarfile>
DESCRIPTION
-----------
Acts as a filter, extracting the commit ID stored in archives created by
-linkgit:git-archive[1]. It reads only the first 1024 bytes of input, thus its
+`git-archive`. It reads only the first 1024 bytes of input, thus its
runtime is not influenced by the size of <tarfile> very much.
-If no commit ID is found, git-get-tar-commit-id quietly exists with a
+If no commit ID is found, `git-get-tar-commit-id` quietly exists with a
return code of 1. This can happen if <tarfile> had not been created
-using git-archive or if the first parameter of git-archive had been
+using `git-archive` or if the first parameter of `git-archive` had been
a tree ID instead of a commit ID or tag.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-grep</em> [--cached]\r
+<div class="content"><em>git grep</em> [--cached]\r
[-a | --text] [-I] [-i | --ignore-case] [-w | --word-regexp]\r
[-v | --invert-match] [-h|-H] [--full-name]\r
[-E | --extended-regexp] [-G | --basic-regexp]\r
<p>\r
Instead of showing every matched line, show only the\r
names of files that contain (or do not contain) matches.\r
- For better compatibility with git-diff, --name-only is a\r
+ For better compatibility with <tt>git-diff</tt>, --name-only is a\r
synonym for --files-with-matches.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:41 UTC\r
+Last updated 02-Jul-2008 03:01:47 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-grep' [--cached]
+'git grep' [--cached]
[-a | --text] [-I] [-i | --ignore-case] [-w | --word-regexp]
[-v | --invert-match] [-h|-H] [--full-name]
[-E | --extended-regexp] [-G | --basic-regexp]
--files-without-match::
Instead of showing every matched line, show only the
names of files that contain (or do not contain) matches.
- For better compatibility with git-diff, --name-only is a
+ For better compatibility with `git-diff`, --name-only is a
synonym for --files-with-matches.
-c::
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>A Tcl/Tk based graphical user interface to Git. git-gui focuses\r
+<p>A Tcl/Tk based graphical user interface to Git. <tt>git-gui</tt> focuses\r
on allowing users to make changes to their repository by making\r
new commits, amending existing ones, creating branches, performing\r
local merges, and fetching/pushing to remote repositories.</p>\r
-<p>Unlike <a href="gitk.html">gitk(1)</a>, git-gui focuses on commit generation\r
-and single file annotation, and does not show project history.\r
-It does however supply menu actions to start a gitk session from\r
-within git-gui.</p>\r
-<p>git-gui is known to work on all popular UNIX systems, Mac OS X,\r
+<p>Unlike <tt>gitk</tt>, <tt>git-gui</tt> focuses on commit generation\r
+and single file annotation and does not show project history.\r
+It does however supply menu actions to start a <tt>gitk</tt> session from\r
+within <tt>git-gui</tt>.</p>\r
+<p><tt>git-gui</tt> is known to work on all popular UNIX systems, Mac OS X,\r
and Windows (under both Cygwin and MSYS). To the extent possible\r
-OS specific user interface guidelines are followed, making git-gui\r
+OS specific user interface guidelines are followed, making <tt>git-gui</tt>\r
a fairly native interface for users.</p>\r
</div>\r
<h2>COMMANDS</h2>\r
</dt>\r
<dd>\r
<p>\r
- Start git-gui and arrange to make exactly one commit before\r
+ Start <tt>git-gui</tt> and arrange to make exactly one commit before\r
exiting and returning to the shell. The interface is limited\r
to only commit actions, slightly reducing the application's\r
startup time and simplifying the menubar.\r
</dt>\r
<dd>\r
<p>\r
- Display the currently running version of git-gui.\r
+ Display the currently running version of <tt>git-gui</tt>.\r
</p>\r
</dd>\r
</dl>\r
<p>\r
The git repository browser. Shows branches, commit history\r
and file differences. gitk is the utility started by\r
- git-gui's Repository Visualize actions.\r
+ <tt>git-gui</tt>'s Repository Visualize actions.\r
</p>\r
</dd>\r
</dl>\r
</div>\r
<h2>Other</h2>\r
<div class="sectionbody">\r
-<p>git-gui is actually maintained as an independent project, but stable\r
+<p><tt>git-gui</tt> is actually maintained as an independent project, but stable\r
versions are distributed as part of the Git suite for the convenience\r
of end users.</p>\r
-<p>A git-gui development repository can be obtained from:</p>\r
+<p>A <tt>git-gui</tt> development repository can be obtained from:</p>\r
<div class="literalblock">\r
<div class="content">\r
<pre><tt>git clone git://repo.or.cz/git-gui.git</tt></pre>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:45 UTC\r
+Last updated 02-Jul-2008 03:01:47 UTC\r
</div>\r
</div>\r
</body>\r
DESCRIPTION
-----------
-A Tcl/Tk based graphical user interface to Git. git-gui focuses
+A Tcl/Tk based graphical user interface to Git. `git-gui` focuses
on allowing users to make changes to their repository by making
new commits, amending existing ones, creating branches, performing
local merges, and fetching/pushing to remote repositories.
-Unlike linkgit:gitk[1], git-gui focuses on commit generation
-and single file annotation, and does not show project history.
-It does however supply menu actions to start a gitk session from
-within git-gui.
+Unlike `gitk`, `git-gui` focuses on commit generation
+and single file annotation and does not show project history.
+It does however supply menu actions to start a `gitk` session from
+within `git-gui`.
-git-gui is known to work on all popular UNIX systems, Mac OS X,
+`git-gui` is known to work on all popular UNIX systems, Mac OS X,
and Windows (under both Cygwin and MSYS). To the extent possible
-OS specific user interface guidelines are followed, making git-gui
+OS specific user interface guidelines are followed, making `git-gui`
a fairly native interface for users.
COMMANDS
browser are opened in the blame viewer.
citool::
- Start git-gui and arrange to make exactly one commit before
+ Start `git-gui` and arrange to make exactly one commit before
exiting and returning to the shell. The interface is limited
to only commit actions, slightly reducing the application's
startup time and simplifying the menubar.
version::
- Display the currently running version of git-gui.
+ Display the currently running version of `git-gui`.
Examples
linkgit:gitk[1]::
The git repository browser. Shows branches, commit history
and file differences. gitk is the utility started by
- git-gui's Repository Visualize actions.
+ `git-gui`'s Repository Visualize actions.
Other
-----
-git-gui is actually maintained as an independent project, but stable
+`git-gui` is actually maintained as an independent project, but stable
versions are distributed as part of the Git suite for the convenience
of end users.
-A git-gui development repository can be obtained from:
+A `git-gui` development repository can be obtained from:
git clone git://repo.or.cz/git-gui.git
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-hash-object</em> [-t <type>] [-w] [--stdin | --stdin-paths] [--] <file>…</p>\r
+<p><em>git hash-object</em> [-t <type>] [-w] [--stdin | --stdin-paths] [--] <file>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
with the contents of the named file (which can be outside of the\r
work tree), and optionally writes the resulting object into the\r
object database. Reports its object ID to its standard output.\r
-This is used by "git-cvsimport" to update the index\r
+This is used by <tt>git-cvsimport</tt> to update the index\r
without modifying files in the work tree. When <type> is not\r
specified, it defaults to "blob".</p>\r
</div>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:45 UTC\r
+Last updated 02-Jul-2008 03:01:48 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-hash-object' [-t <type>] [-w] [--stdin | --stdin-paths] [--] <file>...
+'git hash-object' [-t <type>] [-w] [--stdin | --stdin-paths] [--] <file>...
DESCRIPTION
-----------
with the contents of the named file (which can be outside of the
work tree), and optionally writes the resulting object into the
object database. Reports its object ID to its standard output.
-This is used by "git-cvsimport" to update the index
+This is used by `git-cvsimport` to update the index
without modifying files in the work tree. When <type> is not
specified, it defaults to "blob".
</p>\r
<p>The web browser can be specified using the configuration variable\r
<em>help.browser</em>, or <em>web.browser</em> if the former is not set. If none of\r
-these config variables is set, the <em>git-web--browse</em> helper script\r
-(called by <em>git-help</em>) will pick a suitable default. See\r
+these config variables is set, the <tt>git-web--browse</tt> helper script\r
+(called by <tt>git-help</tt>) will pick a suitable default. See\r
<a href="git-web--browse.html">git-web--browse(1)</a> for more information about this.</p>\r
</dd>\r
</dl>\r
<h3>help.format</h3>\r
<p>If no command line option is passed, the <em>help.format</em> configuration\r
variable will be checked. The following values are supported for this\r
-variable; they make <em>git-help</em> behave as their corresponding command\r
+variable; they make <tt>git-help</tt> behave as their corresponding command\r
line option:</p>\r
<ul>\r
<li>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:42 UTC\r
+Last updated 02-Jul-2008 03:01:48 UTC\r
</div>\r
</div>\r
</body>\r
+
The web browser can be specified using the configuration variable
'help.browser', or 'web.browser' if the former is not set. If none of
-these config variables is set, the 'git-web--browse' helper script
-(called by 'git-help') will pick a suitable default. See
+these config variables is set, the `git-web--browse` helper script
+(called by `git-help`) will pick a suitable default. See
linkgit:git-web--browse[1] for more information about this.
CONFIGURATION VARIABLES
If no command line option is passed, the 'help.format' configuration
variable will be checked. The following values are supported for this
-variable; they make 'git-help' behave as their corresponding command
+variable; they make `git-help` behave as their corresponding command
line option:
* "man" corresponds to '-m|--man',
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-http-fetch</em> [-c] [-t] [-a] [-d] [-v] [-w filename] [--recover] [--stdin] <commit> <url></p>\r
+<p><em>git http-fetch</em> [-c] [-t] [-a] [-d] [-v] [-w filename] [--recover] [--stdin] <commit> <url></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<dd>\r
<p>\r
Instead of a commit id on the command line (which is not expected in this\r
- case), <em>git-http-fetch</em> expects lines on stdin in the format\r
+ case), <tt>git-http-fetch</tt> expects lines on stdin in the format\r
</p>\r
<div class="literalblock">\r
<div class="content">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:46 UTC\r
+Last updated 02-Jul-2008 03:01:48 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-http-fetch' [-c] [-t] [-a] [-d] [-v] [-w filename] [--recover] [--stdin] <commit> <url>
+'git http-fetch' [-c] [-t] [-a] [-d] [-v] [-w filename] [--recover] [--stdin] <commit> <url>
DESCRIPTION
-----------
--stdin::
Instead of a commit id on the command line (which is not expected in this
- case), 'git-http-fetch' expects lines on stdin in the format
+ case), `git-http-fetch` expects lines on stdin in the format
<commit-id>['\t'<filename-as-in--w>]
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-http-push</em> [--all] [--dry-run] [--force] [--verbose] <url> <ref> [<ref>…]</p>\r
+<p><em>git http-push</em> [--all] [--dry-run] [--force] [--verbose] <url> <ref> [<ref>…]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 16-Jun-2008 01:52:17 UTC\r
+Last updated 02-Jul-2008 03:01:49 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-http-push' [--all] [--dry-run] [--force] [--verbose] <url> <ref> [<ref>...]
+'git http-push' [--all] [--dry-run] [--force] [--verbose] <url> <ref> [<ref>...]
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-imap-send</em></p>\r
+<p><em>git imap-send</em></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
other email is sent with mail clients that cannot read mailbox\r
files directly.</p>\r
<p>Typical usage is something like:</p>\r
-<p>git-format-patch --signoff --stdout --attach origin | git-imap-send</p>\r
+<p>git format-patch --signoff --stdout --attach origin | git imap-send</p>\r
</div>\r
<h2>CONFIGURATION</h2>\r
<div class="sectionbody">\r
-<p>git-imap-send requires the following values in the repository\r
+<p><tt>git-imap-send</tt> requires the following values in the repository\r
configuration file (shown with examples):</p>\r
<div class="literalblock">\r
<div class="content">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:47 UTC\r
+Last updated 02-Jul-2008 03:01:49 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-imap-send'
+'git imap-send'
DESCRIPTION
Typical usage is something like:
-git-format-patch --signoff --stdout --attach origin | git-imap-send
+git format-patch --signoff --stdout --attach origin | git imap-send
CONFIGURATION
-------------
-git-imap-send requires the following values in the repository
+`git-imap-send` requires the following values in the repository
configuration file (shown with examples):
..........................
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-index-pack</em> [-v] [-o <index-file>] <pack-file>\r
-<em>git-index-pack</em> --stdin [--fix-thin] [--keep] [-v] [-o <index-file>]\r
+<div class="content"><em>git index-pack</em> [-v] [-o <index-file>] <pack-file>\r
+<em>git index-pack</em> --stdin [--fix-thin] [--keep] [-v] [-o <index-file>]\r
[<pack-file>]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
a default name determined from the pack content. If\r
<pack-file> is not specified consider using --keep to\r
prevent a race condition between this process and\r
- <a href="git-repack.html">git-repack(1)</a>.\r
+ <tt>git-repack</tt>.\r
</p>\r
</dd>\r
<dt>\r
</dt>\r
<dd>\r
<p>\r
- It is possible for <a href="git-pack-objects.html">git-pack-objects(1)</a> to build\r
+ It is possible for <tt>git-pack-objects</tt> to build\r
"thin" pack, which records objects in deltified form based on\r
objects not included in the pack to reduce network traffic.\r
Those objects are expected to be present on the receiving end\r
Before moving the index into its final destination\r
create an empty .keep file for the associated pack file.\r
This option is usually necessary with --stdin to prevent a\r
- simultaneous <a href="git-repack.html">git-repack(1)</a> process from deleting\r
+ simultaneous <tt>git-repack</tt> process from deleting\r
the newly constructed pack and index before refs can be\r
updated to use objects contained in the pack.\r
</p>\r
and the SHA1 hash of that list is printed to stdout. If --stdin was\r
also used then this is prefixed by either "pack\t", or "keep\t" if a\r
new .keep file was successfully created. This is useful to remove a\r
-.keep file used as a lock to prevent the race with <a href="git-repack.html">git-repack(1)</a>\r
+.keep file used as a lock to prevent the race with <tt>git-repack</tt>\r
mentioned above.</p>\r
</div>\r
<h2>Author</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:47 UTC\r
+Last updated 02-Jul-2008 03:01:49 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git
-index-pack' [-v] [-o <index-file>] <pack-file>
-'git-index-pack' --stdin [--fix-thin] [--keep] [-v] [-o <index-file>]
+'git
index-pack' [-v] [-o <index-file>] <pack-file>
+'git index-pack' --stdin [--fix-thin] [--keep] [-v] [-o <index-file>]
[<pack-file>]
a default name determined from the pack content. If
<pack-file> is not specified consider using --keep to
prevent a race condition between this process and
- linkgit:git-repack[1].
+ `git-repack`.
--fix-thin::
- It is possible for linkgit:git-pack-objects[1] to build
+ It is possible for `git-pack-objects` to build
"thin" pack, which records objects in deltified form based on
objects not included in the pack to reduce network traffic.
Those objects are expected to be present on the receiving end
Before moving the index into its final destination
create an empty .keep file for the associated pack file.
This option is usually necessary with --stdin to prevent a
- simultaneous linkgit:git-repack[1] process from deleting
+ simultaneous `git-repack` process from deleting
the newly constructed pack and index before refs can be
updated to use objects contained in the pack.
and the SHA1 hash of that list is printed to stdout. If --stdin was
also used then this is prefixed by either "pack\t", or "keep\t" if a
new .keep file was successfully created. This is useful to remove a
-.keep file used as a lock to prevent the race with linkgit:git-repack[1]
+.keep file used as a lock to prevent the race with `git-repack`
mentioned above.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-init-db</em> [-q | --quiet] [--template=<template_directory>] [--shared[=<permissions>]]</p>\r
+<p><em>git init-db</em> [-q | --quiet] [--template=<template_directory>] [--shared[=<permissions>]]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:47 UTC\r
+Last updated 02-Jul-2008 03:01:49 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-init-db' [-q | --quiet] [--template=<template_directory>] [--shared[=<permissions>]]
+'git
init-db' [-q | --quiet] [--template=<template_directory>] [--shared[=<permissions>]]
DESCRIPTION
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-init</em> [-q | --quiet] [--bare] [--template=<template_directory>] [--shared[=<permissions>]]</p>\r
+<p><em>git init</em> [-q | --quiet] [--bare] [--template=<template_directory>] [--shared[=<permissions>]]</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ cd /path/to/my/codebase\r
-$ git-init <b>(1)</b>\r
-$ git-add . <b>(2)</b></tt></pre>\r
+$ git init <b>(1)</b>\r
+$ git add . <b>(2)</b></tt></pre>\r
</div></div>\r
<ol>\r
<li>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:43 UTC\r
+Last updated 02-Jul-2008 03:01:49 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-init' [-q | --quiet] [--bare] [--template=<template_directory>] [--shared[=<permissions>]]
+'git
init' [-q | --quiet] [--bare] [--template=<template_directory>] [--shared[=<permissions>]]
OPTIONS
+
----------------
$ cd /path/to/my/codebase
-$ git-init <1>
-$ git-add . <2>
+$ git init <1>
+$ git add . <2>
----------------
+
<1> prepare /path/to/my/codebase/.git directory
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-instaweb</em> [--local] [--httpd=<httpd>] [--port=<port>]\r
+<div class="content"><em>git instaweb</em> [--local] [--httpd=<httpd>] [--port=<port>]\r
[--browser=<browser>]\r
-<em>git-instaweb</em> [--start] [--stop] [--restart]</div></div>\r
+<em>git instaweb</em> [--start] [--stop] [--restart]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>A simple script to setup gitweb and a web server for browsing the local\r
+<p>A simple script to set up <tt>gitweb</tt> and a web server for browsing the local\r
repository.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<dd>\r
<p>\r
The web browser that should be used to view the gitweb\r
- page. This will be passed to the <em>git-web--browse</em> helper\r
+ page. This will be passed to the <tt>git-web--browse</tt> helper\r
script along with the URL of the gitweb instance. See\r
<a href="git-web--browse.html">git-web--browse(1)</a> for more information about this. If\r
the script fails, the URL will be printed to stdout.\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:44 UTC\r
+Last updated 02-Jul-2008 03:01:50 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git
-instaweb' [--local] [--httpd=<httpd>] [--port=<port>]
+'git
instaweb' [--local] [--httpd=<httpd>] [--port=<port>]
[--browser=<browser>]
-'git-instaweb' [--start] [--stop] [--restart]
+'git instaweb' [--start] [--stop] [--restart]
DESCRIPTION
-----------
-A simple script to setup gitweb and a web server for browsing the local
+A simple script to set up `gitweb` and a web server for browsing the local
repository.
OPTIONS
-b::
--browser::
The web browser that should be used to view the gitweb
- page. This will be passed to the 'git-web--browse' helper
+ page. This will be passed to the `git-web--browse` helper
script along with the URL of the gitweb instance. See
linkgit:git-web--browse[1] for more information about this. If
the script fails, the URL will be printed to stdout.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-log</em> <option>…</p>\r
+<p><em>git log</em> <option>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Shows the commit logs.</p>\r
-<p>The command takes options applicable to the <a href="git-rev-list.html">git-rev-list(1)</a>\r
+<p>The command takes options applicable to the <tt>git-rev-list</tt>\r
command to control what is shown and how, and options applicable to\r
-the <a href="git-diff-tree.html">git-diff-tree(1)</a> commands to control how the changes\r
+the <tt>git-diff-*</tt> commands to control how the changes\r
each commit introduces are shown.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
</dd>\r
</dl>\r
<p>For more detailed explanation on these common options, see also\r
-<a href="gitdiffcore.html">gitdiffcore(7)</a>[diffcore documentation].</p>\r
+<a href="gitdiffcore.html">gitdiffcore(7)</a>.</p>\r
<dl>\r
<dt>\r
-<n>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 13-Jun-2008 10:02:41 UTC\r
+Last updated 02-Jul-2008 03:01:50 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-log' <option>...
+'git log' <option>...
DESCRIPTION
-----------
Shows the commit logs.
-The command takes options applicable to the linkgit:git-rev-list[1]
+The command takes options applicable to the `git-rev-list`
command to control what is shown and how, and options applicable to
-the linkgit:git-diff-tree[1] commands to control how the changes
+the `git-diff-*` commands to control how the changes
each commit introduces are shown.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-lost-found</em></p>\r
+<p><em>git lost-found</em></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:49 UTC\r
+Last updated 02-Jul-2008 03:01:50 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-lost-found'
+'git lost-found'
DESCRIPTION
-----------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-ls-files</em> [-z] [-t] [-v]\r
+<div class="content"><em>git ls-files</em> [-z] [-t] [-v]\r
(--[cached|deleted|others|ignored|stage|unmerged|killed|modified])*\r
(-[c|d|o|i|s|u|k|m])*\r
[-x <pattern>|--exclude=<pattern>]\r
<div class="content">\r
<pre><tt>[<tag> ]<mode> <object> <stage> <file></tt></pre>\r
</div></div>\r
-<p>"git-ls-files --unmerged" and "git-ls-files --stage" can be used to examine\r
+<p><tt>git-ls-files --unmerged</tt> and <tt>git-ls-files --stage</tt> can be used to examine\r
detailed information on unmerged paths.</p>\r
<p>For an unmerged path, instead of recording a single mode/SHA1 pair,\r
the index records up to three such pairs; one from tree O in stage\r
1, A in stage 2, and B in stage 3. This information can be used by\r
the user (or the porcelain) to see what should eventually be recorded at the\r
-path. (see git-read-tree for more information on state)</p>\r
+path. (see <a href="git-read-tree.html">git-read-tree(1)</a> for more information on state)</p>\r
<p>When <tt>-z</tt> option is not used, TAB, LF, and backslash characters\r
in pathnames are represented as <tt>\t</tt>, <tt>\n</tt>, and <tt>\\</tt>,\r
respectively.</p>\r
</div>\r
<h2>Exclude Patterns</h2>\r
<div class="sectionbody">\r
-<p><em>git-ls-files</em> can use a list of "exclude patterns" when\r
+<p><tt>git-ls-files</tt> can use a list of "exclude patterns" when\r
traversing the directory tree and finding files to show when the\r
flags --others or --ignored are specified. <a href="gitignore.html">gitignore(5)</a>\r
specifies the format of exclude patterns.</p>\r
<li>\r
<p>\r
command line flag --exclude-per-directory=<name> specifies\r
- a name of the file in each directory <em>git-ls-files</em>\r
+ a name of the file in each directory <tt>git-ls-files</tt>\r
examines, normally <tt>.gitignore</tt>. Files in deeper\r
directories take precedence. Patterns are ordered in the\r
same order they appear in the files.\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:45 UTC\r
+Last updated 02-Jul-2008 03:01:50 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-ls-files' [-z] [-t] [-v]
+'git ls-files' [-z] [-t] [-v]
(--[cached|deleted|others|ignored|stage|unmerged|killed|modified])\*
(-[c|d|o|i|s|u|k|m])\*
[-x <pattern>|--exclude=<pattern>]
[<tag> ]<mode> <object> <stage> <file>
-"git-ls-files --unmerged" and "git-ls-files --stage" can be used to examine
+`git-ls-files --unmerged` and `git-ls-files --stage` can be used to examine
detailed information on unmerged paths.
For an unmerged path, instead of recording a single mode/SHA1 pair,
the index records up to three such pairs; one from tree O in stage
1, A in stage 2, and B in stage 3. This information can be used by
the user (or the porcelain) to see what should eventually be recorded at the
-path. (see git-read-tree for more information on state)
+path. (see linkgit:git-read-tree[1] for more information on state)
When `-z` option is not used, TAB, LF, and backslash characters
in pathnames are represented as `\t`, `\n`, and `\\`,
Exclude Patterns
----------------
-'git-ls-files' can use a list of "exclude patterns" when
+`git-ls-files` can use a list of "exclude patterns" when
traversing the directory tree and finding files to show when the
flags --others or --ignored are specified. linkgit:gitignore[5]
specifies the format of exclude patterns.
in the same order they appear in the file.
3. command line flag --exclude-per-directory=<name> specifies
- a name of the file in each directory 'git-ls-files'
+ a name of the file in each directory `git-ls-files`
examines, normally `.gitignore`. Files in deeper
directories take precedence. Patterns are ordered in the
same order they appear in the files.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-ls-remote</em> [--heads] [--tags] [-u <exec> | --upload-pack <exec>]\r
+<div class="content"><em>git ls-remote</em> [--heads] [--tags] [-u <exec> | --upload-pack <exec>]\r
<repository> <refs>…</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
</dt>\r
<dd>\r
<p>\r
- Specify the full path of <a href="git-upload-pack.html">git-upload-pack(1)</a> on the remote\r
+ Specify the full path of <tt>git-upload-pack</tt> on the remote\r
host. This allows listing references from repositories accessed via\r
SSH and where the SSH daemon does not use the PATH configured by the\r
user.\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:47 UTC\r
+Last updated 02-Jul-2008 03:01:51 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-ls-remote' [--heads] [--tags] [-u <exec> | --upload-pack <exec>]
+'git ls-remote' [--heads] [--tags] [-u <exec> | --upload-pack <exec>]
<repository> <refs>...
DESCRIPTION
-u <exec>::
--upload-pack=<exec>::
- Specify the full path of linkgit:git-upload-pack[1] on the remote
+ Specify the full path of `git-upload-pack` on the remote
host. This allows listing references from repositories accessed via
SSH and where the SSH daemon does not use the PATH configured by the
user.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-ls-tree</em> [-d] [-r] [-t] [-l] [-z]\r
+<div class="content"><em>git ls-tree</em> [-d] [-r] [-t] [-l] [-z]\r
[--name-only] [--name-status] [--full-name] [--abbrev=[<n>]]\r
<tree-ish> [paths…]</div></div>\r
</div>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:51 UTC\r
+Last updated 02-Jul-2008 03:01:51 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-ls-tree' [-d] [-r] [-t] [-l] [-z]
+'git ls-tree' [-d] [-r] [-t] [-l] [-z]
[--name-only] [--name-status] [--full-name] [--abbrev=[<n>]]
<tree-ish> [paths...]
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-mailinfo</em> [-k] [-u | --encoding=<encoding>] <msg> <patch></p>\r
+<p><em>git mailinfo</em> [-k] [-u | --encoding=<encoding>] <msg> <patch></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Reading a single e-mail message from the standard input, and\r
writes the commit log message in <msg> file, and the patches in\r
<patch> file. The author name, e-mail and e-mail subject are\r
-written out to the standard output to be used by git-am\r
+written out to the standard output to be used by <tt>git-am</tt>\r
to create a commit. It is usually not necessary to use this\r
command directly. See <a href="git-am.html">git-am(1)</a> instead.</p>\r
</div>\r
among which (1) remove <em>Re:</em> or <em>re:</em>, (2) leading\r
whitespaces, (3) <em>[</em> up to <em>]</em>, typically <em>[PATCH]</em>, and\r
then prepends "[PATCH] ". This flag forbids this\r
- munging, and is most useful when used to read back <em>git\r
- format-patch -k</em> output.\r
+ munging, and is most useful when used to read back\r
+ <tt>git-format-patch -k</tt> output.\r
</p>\r
</dd>\r
<dt>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:52 UTC\r
+Last updated 02-Jul-2008 03:01:52 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-mailinfo' [-k] [-u | --encoding=<encoding>] <msg> <patch>
+'git
mailinfo' [-k] [-u | --encoding=<encoding>] <msg> <patch>
DESCRIPTION
Reading a single e-mail message from the standard input, and
writes the commit log message in <msg> file, and the patches in
<patch> file. The author name, e-mail and e-mail subject are
-written out to the standard output to be used by git-am
+written out to the standard output to be used by `git-am`
to create a commit. It is usually not necessary to use this
command directly. See linkgit:git-am[1] instead.
among which (1) remove 'Re:' or 're:', (2) leading
whitespaces, (3) '[' up to ']', typically '[PATCH]', and
then prepends "[PATCH] ". This flag forbids this
- munging, and is most useful when used to read back 'git
- format-patch -k' output.
+ munging, and is most useful when used to read back
+ `git-format-patch -k` output.
-u::
The commit log message, author name and author email are
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-mailsplit</em> [-b] [-f<nn>] [-d<prec>] -o<directory> [--] [<mbox>|<Maildir>…]</p>\r
+<p><em>git mailsplit</em> [-b] [-f<nn>] [-d<prec>] -o<directory> [--] [<mbox>|<Maildir>…]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:52 UTC\r
+Last updated 02-Jul-2008 03:01:52 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-mailsplit' [-b] [-f<nn>] [-d<prec>] -o<directory> [--] [<mbox>|<Maildir>...]
+'git
mailsplit' [-b] [-f<nn>] [-d<prec>] -o<directory> [--] [<mbox>|<Maildir>...]
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-merge-base</em> [--all] <commit> <commit></p>\r
+<p><em>git merge-base</em> [--all] <commit> <commit></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>"git-merge-base" finds as good a common ancestor as possible between\r
-the two commits. That is, given two commits A and B <em>git-merge-base A\r
-B</em> will output a commit which is reachable from both A and B through\r
+<p><tt>git-merge-base</tt> finds as good a common ancestor as possible between\r
+the two commits. That is, given two commits A and B, <tt>git merge-base A\r
+B</tt> will output a commit which is reachable from both A and B through\r
the parent relationship.</p>\r
<p>Given a selection of equally good common ancestors it should not be\r
relied on to decide in any particular way.</p>\r
-<p>The "git-merge-base" algorithm is still in flux - use the source…</p>\r
+<p>The <tt>git-merge-base</tt> algorithm is still in flux - use the source…</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:52 UTC\r
+Last updated 02-Jul-2008 03:01:52 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-merge-base' [--all] <commit> <commit>
+'git merge-base' [--all] <commit> <commit>
DESCRIPTION
-----------
-"git-merge-base" finds as good a common ancestor as possible between
-the two commits. That is, given two commits A and B 'git-merge-base A
-B' will output a commit which is reachable from both A and B through
+`git-merge-base` finds as good a common ancestor as possible between
+the two commits. That is, given two commits A and B, `git merge-base A
+B` will output a commit which is reachable from both A and B through
the parent relationship.
Given a selection of equally good common ancestors it should not be
relied on to decide in any particular way.
-The "git-merge-base" algorithm is still in flux - use the source...
+The `git-merge-base` algorithm is still in flux - use the source...
OPTIONS
-------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-merge-file</em> [-L <current-name> [-L <base-name> [-L <other-name>]]]\r
+<div class="content"><em>git merge-file</em> [-L <current-name> [-L <base-name> [-L <other-name>]]]\r
[-p|--stdout] [-q|--quiet] <current-file> <base-file> <other-file></div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>git-file-merge incorporates all changes that lead from the <tt><base-file></tt>\r
+<p><tt>git-file-merge</tt> incorporates all changes that lead from the <tt><base-file></tt>\r
to <tt><other-file></tt> into <tt><current-file></tt>. The result ordinarily goes into\r
-<tt><current-file></tt>. git-merge-file is useful for combining separate changes\r
+<tt><current-file></tt>. <tt>git-merge-file</tt> is useful for combining separate changes\r
to an original. Suppose <tt><base-file></tt> is the original, and both\r
<tt><current-file></tt> and <tt><other-file></tt> are modifications of <tt><base-file></tt>.\r
-Then git-merge-file combines both changes.</p>\r
+Then <tt>git-merge-file</tt> combines both changes.</p>\r
<p>A conflict occurs if both <tt><current-file></tt> and <tt><other-file></tt> have changes\r
-in a common segment of lines. If a conflict is found, git-merge-file\r
+in a common segment of lines. If a conflict is found, <tt>git-merge-file</tt>\r
normally outputs a warning and brackets the conflict with <<<<<<< and\r
>>>>>>> lines. A typical conflict will look like this:</p>\r
<div class="literalblock">\r
the alternatives.</p>\r
<p>The exit value of this program is negative on error, and the number of\r
conflicts otherwise. If the merge was clean, the exit value is 0.</p>\r
-<p>git-merge-file is designed to be a minimal clone of RCS merge, that is, it\r
+<p><tt>git-merge-file</tt> is designed to be a minimal clone of RCS <tt>merge</tt>; that is, it\r
implements all of RCS merge's functionality which is needed by\r
<a href="git.html">git(1)</a>.</p>\r
</div>\r
This option may be given up to three times, and\r
specifies labels to be used in place of the\r
corresponding file names in conflict reports. That is,\r
- <tt>git-merge-file -L x -L y -L z a b c</tt> generates output that\r
+ <tt>git merge-file -L x -L y -L z a b c</tt> generates output that\r
looks like it came from files x, y and z instead of\r
from files a, b and c.\r
</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:53 UTC\r
+Last updated 02-Jul-2008 03:01:52 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-merge-file' [-L <current-name> [-L <base-name> [-L <other-name>]]]
+'git merge-file' [-L <current-name> [-L <base-name> [-L <other-name>]]]
[-p|--stdout] [-q|--quiet] <current-file> <base-file> <other-file>
DESCRIPTION
-----------
-git-file-merge incorporates all changes that lead from the `<base-file>`
+`git-file-merge` incorporates all changes that lead from the `<base-file>`
to `<other-file>` into `<current-file>`. The result ordinarily goes into
-`<current-file>`. git-merge-file is useful for combining separate changes
+`<current-file>`. `git-merge-file` is useful for combining separate changes
to an original. Suppose `<base-file>` is the original, and both
`<current-file>` and `<other-file>` are modifications of `<base-file>`.
-Then git-merge-file combines both changes.
+Then `git-merge-file` combines both changes.
A conflict occurs if both `<current-file>` and `<other-file>` have changes
-in a common segment of lines. If a conflict is found, git-merge-file
+in a common segment of lines. If a conflict is found, `git-merge-file`
normally outputs a warning and brackets the conflict with <<<<<<< and
>>>>>>> lines. A typical conflict will look like this:
The exit value of this program is negative on error, and the number of
conflicts otherwise. If the merge was clean, the exit value is 0.
-git-merge-file is designed to be a minimal clone of RCS merge, that is, it
+`git-merge-file` is designed to be a minimal clone of RCS `merge`; that is, it
implements all of RCS merge's functionality which is needed by
linkgit:git[1].
This option may be given up to three times, and
specifies labels to be used in place of the
corresponding file names in conflict reports. That is,
- `git-merge-file -L x -L y -L z a b c` generates output that
+ `git merge-file -L x -L y -L z a b c` generates output that
looks like it came from files x, y and z instead of
from files a, b and c.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-merge-index</em> [-o] [-q] <merge-program> (-a | [--] <file>*)</p>\r
+<p><em>git merge-index</em> [-o] [-q] <merge-program> (-a | [--] <file>*)</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</p>\r
</dd>\r
</dl>\r
-<p>If "git-merge-index" is called with multiple <file>s (or -a) then it\r
+<p>If <tt>git-merge-index</tt> is called with multiple <file>s (or -a) then it\r
processes them in turn only stopping if merge returns a non-zero exit\r
code.</p>\r
<p>Typically this is run with a script calling git's imitation of\r
the merge command from the RCS package.</p>\r
-<p>A sample script called "git-merge-one-file" is included in the\r
+<p>A sample script called <tt>git-merge-one-file</tt> is included in the\r
distribution.</p>\r
<p>ALERT ALERT ALERT! The git "merge object order" is different from the\r
-RCS "merge" program merge object order. In the above ordering, the\r
+RCS <tt>merge</tt> program merge object order. In the above ordering, the\r
original is first. But the argument order to the 3-way merge program\r
-"merge" is to have the original in the middle. Don't ask me why.</p>\r
+<tt>merge</tt> is to have the original in the middle. Don't ask me why.</p>\r
<p>Examples:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>torvalds@ppc970:~/merge-test> git-merge-index cat MM\r
+<pre><tt>torvalds@ppc970:~/merge-test> git merge-index cat MM\r
This is MM from the original tree. # original\r
This is modified MM in the branch A. # merge1\r
This is modified MM in the branch B. # merge2\r
<p>or</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>torvalds@ppc970:~/merge-test> git-merge-index cat AA MM\r
+<pre><tt>torvalds@ppc970:~/merge-test> git merge-index cat AA MM\r
cat: : No such file or directory\r
This is added AA in the branch A.\r
This is added AA in the branch B.\r
This is added AA in the branch B.\r
fatal: merge program failed</tt></pre>\r
</div></div>\r
-<p>where the latter example shows how "git-merge-index" will stop trying to\r
-merge once anything has returned an error (i.e., "cat" returned an error\r
+<p>where the latter example shows how <tt>git-merge-index</tt> will stop trying to\r
+merge once anything has returned an error (i.e., <tt>cat</tt> returned an error\r
for the AA file, because it didn't exist in the original, and thus\r
-"git-merge-index" didn't even try to merge the MM thing).</p>\r
+<tt>git-merge-index</tt> didn't even try to merge the MM thing).</p>\r
</div>\r
<h2>Author</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:53 UTC\r
+Last updated 02-Jul-2008 03:01:53 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-merge-index' [-o] [-q] <merge-program> (-a | [--] <file>\*)
+'git merge-index' [-o] [-q] <merge-program> (-a | [--] <file>\*)
DESCRIPTION
-----------
failure usually indicates conflicts during merge). This is for
porcelains which might want to emit custom messages.
-If "git-merge-index" is called with multiple <file>s (or -a) then it
+If `git-merge-index` is called with multiple <file>s (or -a) then it
processes them in turn only stopping if merge returns a non-zero exit
code.
Typically this is run with a script calling git's imitation of
the merge command from the RCS package.
-A sample script called "git-merge-one-file" is included in the
+A sample script called `git-merge-one-file` is included in the
distribution.
ALERT ALERT ALERT! The git "merge object order" is different from the
-RCS "merge" program merge object order. In the above ordering, the
+RCS `merge` program merge object order. In the above ordering, the
original is first. But the argument order to the 3-way merge program
-"merge" is to have the original in the middle. Don't ask me why.
+`merge` is to have the original in the middle. Don't ask me why.
Examples:
- torvalds@ppc970:~/merge-test> git-merge-index cat MM
+ torvalds@ppc970:~/merge-test> git merge-index cat MM
This is MM from the original tree. # original
This is modified MM in the branch A. # merge1
This is modified MM in the branch B. # merge2
or
- torvalds@ppc970:~/merge-test> git-merge-index cat AA MM
+ torvalds@ppc970:~/merge-test> git merge-index cat AA MM
cat: : No such file or directory
This is added AA in the branch A.
This is added AA in the branch B.
This is added AA in the branch B.
fatal: merge program failed
-where the latter example shows how "git-merge-index" will stop trying to
-merge once anything has returned an error (i.e., "cat" returned an error
+where the latter example shows how `git-merge-index` will stop trying to
+merge once anything has returned an error (i.e., `cat` returned an error
for the AA file, because it didn't exist in the original, and thus
-"git-merge-index" didn't even try to merge the MM thing).
+`git-merge-index` didn't even try to merge the MM thing).
Author
------
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>This is the standard helper program to use with "git-merge-index"\r
-to resolve a merge after the trivial merge done with "git-read-tree -m".</p>\r
+<p>This is the standard helper program to use with <tt>git-merge-index</tt>\r
+to resolve a merge after the trivial merge done with <tt>git-read-tree -m</tt>.</p>\r
</div>\r
<h2>Author</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:54 UTC\r
+Last updated 02-Jul-2008 03:01:53 UTC\r
</div>\r
</div>\r
</body>\r
DESCRIPTION
-----------
-This is the standard helper program to use with "git-merge-index"
-to resolve a merge after the trivial merge done with "git-read-tree -m".
+This is the standard helper program to use with `git-merge-index`
+to resolve a merge after the trivial merge done with `git-read-tree -m`.
Author
------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-merge-tree</em> <base-tree> <branch1> <branch2></p>\r
+<p><em>git merge-tree</em> <base-tree> <branch1> <branch2></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:54 UTC\r
+Last updated 02-Jul-2008 03:01:53 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-merge-tree' <base-tree> <branch1> <branch2>
+'git merge-tree' <base-tree> <branch1> <branch2>
DESCRIPTION
-----------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-merge</em> [-n] [--stat] [--no-commit] [--squash] [-s <strategy>]…\r
+<div class="content"><em>git merge</em> [-n] [--stat] [--no-commit] [--squash] [-s <strategy>]…\r
[-m <msg>] <remote> <remote>…\r
-<em>git-merge</em> <msg> HEAD <remote>…</div></div>\r
+<em>git merge</em> <msg> HEAD <remote>…</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</dd>\r
</dl>\r
<p>If you tried a merge which resulted in a complex conflicts and\r
-would want to start over, you can recover with\r
-<a href="git-reset.html">git-reset(1)</a>.</p>\r
+would want to start over, you can recover with <tt>git-reset</tt>.</p>\r
</div>\r
<h2>CONFIGURATION</h2>\r
<div class="sectionbody">\r
<dd>\r
<p>\r
Sets default options for merging into branch <name>. The syntax and\r
- supported options are equal to that of git-merge, but option values\r
+ supported options are equal to that of <tt>git-merge</tt>, but option values\r
containing whitespace characters are currently not supported.\r
</p>\r
</dd>\r
commits (usually, branch head or tag), and the index file must\r
exactly match the\r
tree of <tt>HEAD</tt> commit (i.e. the contents of the last commit) when\r
-it happens. In other words, <tt>git-diff --cached HEAD</tt> must\r
+it happens. In other words, <tt>git diff --cached HEAD</tt> must\r
report no changes.</p>\r
<div class="admonitionblock">\r
<table><tr>\r
For conflicting paths, the index file records up to three\r
versions; stage1 stores the version from the common ancestor,\r
stage2 from <tt>HEAD</tt>, and stage3 from the remote branch (you\r
- can inspect the stages with <tt>git-ls-files -u</tt>). The working\r
+ can inspect the stages with <tt>git ls-files -u</tt>). The working\r
tree files have the result of "merge" program; i.e. 3-way\r
merge result with familiar conflict markers <tt><<< === >>></tt>.\r
</p>\r
</li>\r
<li>\r
<p>\r
-Resolve the conflicts. <tt>git-diff</tt> would report only the\r
- conflicting paths because of the above 2. and 3.. Edit the\r
+Resolve the conflicts. <tt>git diff</tt> would report only the\r
+ conflicting paths because of the above 2. and 3. Edit the\r
working tree files into a desirable shape, <tt>git-add</tt> or <tt>git-rm</tt>\r
them, to make the index file contain what the merge result\r
should be, and run <tt>git-commit</tt> to commit the result.\r
<h2>SEE ALSO</h2>\r
<div class="sectionbody">\r
<p><a href="git-fmt-merge-msg.html">git-fmt-merge-msg(1)</a>, <a href="git-pull.html">git-pull(1)</a>,\r
-<a href="gitattributes.html">gitattributes(5)</a></p>\r
+<a href="gitattributes.html">gitattributes(5)</a>,\r
+<a href="git-reset.html">git-reset(1)</a>,\r
+<a href="git-diff.html">git-diff(1)</a>, <a href="git-ls-files.html">git-ls-files(1)</a>,\r
+<a href="git-add.html">git-add(1)</a>, <a href="git-rm.html">git-rm(1)</a>,\r
+<a href="git-mergetool.html">git-mergetool(1)</a></p>\r
</div>\r
<h2>Author</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:48 UTC\r
+Last updated 02-Jul-2008 03:01:53 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-merge' [-n] [--stat] [--no-commit] [--squash] [-s <strategy>]...
+'git merge' [-n] [--stat] [--no-commit] [--squash] [-s <strategy>]...
[-m <msg>] <remote> <remote>...
-'git-merge' <msg> HEAD <remote>...
+'git merge' <msg> HEAD <remote>...
DESCRIPTION
-----------
If you tried a merge which resulted in a complex conflicts and
-would want to start over, you can recover with
-linkgit:git-reset[1].
+would want to start over, you can recover with `git-reset`.
CONFIGURATION
-------------
branch.<name>.mergeoptions::
Sets default options for merging into branch <name>. The syntax and
- supported options are equal to that of git-merge, but option values
+ supported options are equal to that of `git-merge`, but option values
containing whitespace characters are currently not supported.
HOW MERGE WORKS
commits (usually, branch head or tag), and the index file must
exactly match the
tree of `HEAD` commit (i.e. the contents of the last commit) when
-it happens. In other words, `git-diff --cached HEAD` must
+it happens. In other words, `git diff --cached HEAD` must
report no changes.
[NOTE]
3. For conflicting paths, the index file records up to three
versions; stage1 stores the version from the common ancestor,
stage2 from `HEAD`, and stage3 from the remote branch (you
- can inspect the stages with `git-ls-files -u`). The working
+ can inspect the stages with `git ls-files -u`). The working
tree files have the result of "merge" program; i.e. 3-way
merge result with familiar conflict markers `<<< === >>>`.
up working tree changes made by 2. and 3.; `git-reset` can
be used for this.
- * Resolve the conflicts. `git-diff` would report only the
- conflicting paths because of the above 2. and 3.. Edit the
+ * Resolve the conflicts. `git diff` would report only the
+ conflicting paths because of the above 2. and 3. Edit the
working tree files into a desirable shape, `git-add` or `git-rm`
them, to make the index file contain what the merge result
should be, and run `git-commit` to commit the result.
SEE ALSO
--------
linkgit:git-fmt-merge-msg[1], linkgit:git-pull[1],
-linkgit:gitattributes[5]
-
+linkgit:gitattributes[5],
+linkgit:git-reset[1],
+linkgit:git-diff[1], linkgit:git-ls-files[1],
+linkgit:git-add[1], linkgit:git-rm[1],
+linkgit:git-mergetool[1]
Author
------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-mergetool</em> [--tool=<tool>] [<file>]…</p>\r
+<p><em>git mergetool</em> [--tool=<tool>] [<file>]…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Use <tt>git mergetool</tt> to run one of several merge utilities to resolve\r
-merge conflicts. It is typically run after <a href="git-merge.html">git-merge(1)</a>.</p>\r
+merge conflicts. It is typically run after <tt>git-merge</tt>.</p>\r
<p>If one or more <file> parameters are given, the merge tool program will\r
be run to resolve differences on each file. If no <file> names are\r
-specified, <tt>git mergetool</tt> will run the merge tool program on every file\r
+specified, <tt>git-mergetool</tt> will run the merge tool program on every file\r
with merge conflicts.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
Valid merge tools are:\r
kdiff3, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, and opendiff\r
</p>\r
-<p>If a merge resolution program is not specified, <tt>git mergetool</tt>\r
+<p>If a merge resolution program is not specified, <tt>git-mergetool</tt>\r
will use the configuration variable <tt>merge.tool</tt>. If the\r
-configuration variable <tt>merge.tool</tt> is not set, <tt>git mergetool</tt>\r
+configuration variable <tt>merge.tool</tt> is not set, <tt>git-mergetool</tt>\r
will pick a suitable default.</p>\r
<p>You can explicitly provide a full path to the tool by setting the\r
configuration variable <tt>mergetool.<tool>.path</tt>. For example, you\r
can configure the absolute path to kdiff3 by setting\r
-<tt>mergetool.kdiff3.path</tt>. Otherwise, <tt>git mergetool</tt> assumes the\r
+<tt>mergetool.kdiff3.path</tt>. Otherwise, <tt>git-mergetool</tt> assumes the\r
tool is available in PATH.</p>\r
<p>Instead of running one of the known merge tool programs\r
-<tt>git mergetool</tt> can be customized to run an alternative program\r
+<tt>git-mergetool</tt> can be customized to run an alternative program\r
by specifying the command line to invoke in a configration\r
variable <tt>mergetool.<tool>.cmd</tt>.</p>\r
-<p>When <tt>git mergetool</tt> is invoked with this tool (either through the\r
+<p>When <tt>git-mergetool</tt> is invoked with this tool (either through the\r
<tt>-t</tt> or <tt>--tool</tt> option or the <tt>merge.tool</tt> configuration\r
variable) the configured command line will be invoked with <tt>$BASE</tt>\r
set to the name of a temporary file containing the common base for\r
<p>If the custom merge tool correctly indicates the success of a\r
merge resolution with its exit code then the configuration\r
variable <tt>mergetool.<tool>.trustExitCode</tt> can be set to <tt>true</tt>.\r
-Otherwise, <tt>git mergetool</tt> will prompt the user to indicate the\r
+Otherwise, <tt>git-mergetool</tt> will prompt the user to indicate the\r
success of the resolution after the custom tool has exited.</p>\r
</dd>\r
</dl>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:54 UTC\r
+Last updated 02-Jul-2008 03:01:53 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-mergetool' [--tool=<tool>] [<file>]...
+'git mergetool' [--tool=<tool>] [<file>]...
DESCRIPTION
-----------
Use `git mergetool` to run one of several merge utilities to resolve
-merge conflicts. It is typically run after linkgit:git-merge[1].
+merge conflicts. It is typically run after `git-merge`.
If one or more <file> parameters are given, the merge tool program will
be run to resolve differences on each file. If no <file> names are
-specified, `git mergetool` will run the merge tool program on every file
+specified, `git-mergetool` will run the merge tool program on every file
with merge conflicts.
OPTIONS
Valid merge tools are:
kdiff3, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, and opendiff
+
-If a merge resolution program is not specified, `git mergetool`
+If a merge resolution program is not specified, `git-mergetool`
will use the configuration variable `merge.tool`. If the
-configuration variable `merge.tool` is not set, `git mergetool`
+configuration variable `merge.tool` is not set, `git-mergetool`
will pick a suitable default.
+
You can explicitly provide a full path to the tool by setting the
configuration variable `mergetool.<tool>.path`. For example, you
can configure the absolute path to kdiff3 by setting
-`mergetool.kdiff3.path`. Otherwise, `git mergetool` assumes the
+`mergetool.kdiff3.path`. Otherwise, `git-mergetool` assumes the
tool is available in PATH.
+
Instead of running one of the known merge tool programs
-`git mergetool` can be customized to run an alternative program
+`git-mergetool` can be customized to run an alternative program
by specifying the command line to invoke in a configration
variable `mergetool.<tool>.cmd`.
+
-When `git mergetool` is invoked with this tool (either through the
+When `git-mergetool` is invoked with this tool (either through the
`-t` or `--tool` option or the `merge.tool` configuration
variable) the configured command line will be invoked with `$BASE`
set to the name of a temporary file containing the common base for
If the custom merge tool correctly indicates the success of a
merge resolution with its exit code then the configuration
variable `mergetool.<tool>.trustExitCode` can be set to `true`.
-Otherwise, `git mergetool` will prompt the user to indicate the
+Otherwise, `git-mergetool` will prompt the user to indicate the
success of the resolution after the custom tool has exited.
Author
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-mktag</em> < signature_file</p>\r
+<p><em>git mktag</em> < signature_file</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:55 UTC\r
+Last updated 02-Jul-2008 03:01:54 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-mktag' < signature_file
+'git mktag' < signature_file
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-mktree</em> [-z]</p>\r
+<p><em>git mktree</em> [-z]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:56 UTC\r
+Last updated 02-Jul-2008 03:01:54 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-mktree' [-z]
+'git mktree' [-z]
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-mv</em> <options>… <args>…</p>\r
+<p><em>git mv</em> <options>… <args>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>This script is used to move or rename a file, directory or symlink.</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-mv [-f] [-n] <source> <destination>\r
-git-mv [-f] [-n] [-k] <source> ... <destination directory></tt></pre>\r
+<pre><tt>git mv [-f] [-n] <source> <destination>\r
+git mv [-f] [-n] [-k] <source> ... <destination directory></tt></pre>\r
</div></div>\r
<p>In the first form, it renames <source>, which must exist and be either\r
a file, symlink or directory, to <destination>.\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:50 UTC\r
+Last updated 02-Jul-2008 03:01:54 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-mv' <options>... <args>...
+'git
mv' <options>... <args>...
DESCRIPTION
-----------
This script is used to move or rename a file, directory or symlink.
- git-mv [-f] [-n] <source> <destination>
- git-mv [-f] [-n] [-k] <source> ... <destination directory>
+ git mv [-f] [-n] <source> <destination>
+ git mv [-f] [-n] [-k] <source> ... <destination directory>
In the first form, it renames <source>, which must exist and be either
a file, symlink or directory, to <destination>.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-name-rev</em> [--tags] [--refs=<pattern>]\r
+<div class="content"><em>git name-rev</em> [--tags] [--refs=<pattern>]\r
( --all | --stdin | <committish>… )</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Finds symbolic names suitable for human digestion for revisions given in any\r
-format parsable by git-rev-parse.</p>\r
+format parsable by <tt>git-rev-parse</tt>.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
Instead of printing both the SHA-1 and the name, print only\r
the name. If given with --tags the usual tag prefix of\r
"tags/" is also omitted from the name, matching the output\r
- of <a href="git-describe.html">git-describe(1)</a> more closely. This option\r
+ of <tt>git-describe</tt> more closely. This option\r
cannot be combined with --stdin.\r
</p>\r
</dd>\r
wrote you about that fantastic commit 33db5f4d9027a10e477ccf054b2c1ab94f74c85a.\r
Of course, you look into the commit, but that only tells you what happened, but\r
not the context.</p>\r
-<p>Enter git-name-rev:</p>\r
+<p>Enter <tt>git-name-rev</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>% git name-rev 33db5f4d9027a10e477ccf054b2c1ab94f74c85a\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:50 UTC\r
+Last updated 02-Jul-2008 03:01:54 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git
-name-rev' [--tags] [--refs=<pattern>]
+'git
name-rev' [--tags] [--refs=<pattern>]
( --all | --stdin | <committish>... )
DESCRIPTION
-----------
Finds symbolic names suitable for human digestion for revisions given in any
-format parsable by git-rev-parse.
+format parsable by `git-rev-parse`.
OPTIONS
Instead of printing both the SHA-1 and the name, print only
the name. If given with --tags the usual tag prefix of
"tags/" is also omitted from the name, matching the output
- of linkgit:git-describe[1] more closely. This option
+ of `git-describe` more closely. This option
cannot be combined with --stdin.
--no-undefined::
Of course, you look into the commit, but that only tells you what happened, but
not the context.
-Enter git-name-rev:
+Enter `git-name-rev`:
------------
% git name-rev 33db5f4d9027a10e477ccf054b2c1ab94f74c85a
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-pack-objects</em> [-q] [--no-reuse-delta] [--delta-base-offset] [--non-empty]\r
+<div class="content"><em>git pack-objects</em> [-q] [--no-reuse-delta] [--delta-base-offset] [--non-empty]\r
[--local] [--incremental] [--window=N] [--depth=N] [--all-progress]\r
[--revs [--unpacked | --all]*] [--stdout | base-name] < object-list</div></div>\r
</div>\r
<p>Placing both in the pack/ subdirectory of $GIT_OBJECT_DIRECTORY (or\r
any of the directories on $GIT_ALTERNATE_OBJECT_DIRECTORIES)\r
enables git to read from such an archive.</p>\r
-<p><em>git-unpack-objects</em> command can read the packed archive and\r
+<p>The <tt>git-unpack-objects</tt> command can read the packed archive and\r
expand the objects contained in the pack into "one-file\r
one-object" format; this is typically done by the smart-pull\r
commands when a pack is created on-the-fly for efficient network\r
<p>\r
Read the revision arguments from the standard input, instead of\r
individual object names. The revision arguments are processed\r
- the same way as <a href="git-rev-list.html">git-rev-list(1)</a> with <tt>--objects</tt> flag\r
+ the same way as <tt>git-rev-list</tt> with the <tt>--objects</tt> flag\r
uses its <tt>commit</tt> arguments to build the list of objects it\r
outputs. The objects on the resulting list are packed.\r
</p>\r
A packed archive can express base object of a delta as\r
either 20-byte object name or as an offset in the\r
stream, but older version of git does not understand the\r
- latter. By default, git-pack-objects only uses the\r
+ latter. By default, <tt>git-pack-objects</tt> only uses the\r
former format for better compatibility. This option\r
allows the command to use the latter format for\r
compactness. Depending on the average delta chain\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:51 UTC\r
+Last updated 02-Jul-2008 03:01:54 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-pack-objects' [-q] [--no-reuse-delta] [--delta-base-offset] [--non-empty]
+'git pack-objects' [-q] [--no-reuse-delta] [--delta-base-offset] [--non-empty]
[--local] [--incremental] [--window=N] [--depth=N] [--all-progress]
[--revs [--unpacked | --all]*] [--stdout | base-name] < object-list
any of the directories on $GIT_ALTERNATE_OBJECT_DIRECTORIES)
enables git to read from such an archive.
-'git-unpack-objects' command can read the packed archive and
+The `git-unpack-objects` command can read the packed archive and
expand the objects contained in the pack into "one-file
one-object" format; this is typically done by the smart-pull
commands when a pack is created on-the-fly for efficient network
--revs::
Read the revision arguments from the standard input, instead of
individual object names. The revision arguments are processed
- the same way as linkgit:git-rev-list[1] with `--objects` flag
+ the same way as `git-rev-list` with the `--objects` flag
uses its `commit` arguments to build the list of objects it
outputs. The objects on the resulting list are packed.
generated pack. If not specified, pack compression level is
determined first by pack.compression, then by core.compression,
and defaults to -1, the zlib default, if neither is set.
- Add \--no-reuse-object if you want to force a uniform compression
+ Add --no-reuse-object if you want to force a uniform compression
level on all data no matter the source.
--delta-base-offset::
A packed archive can express base object of a delta as
either 20-byte object name or as an offset in the
stream, but older version of git does not understand the
- latter. By default, git-pack-objects only uses the
+ latter. By default, `git-pack-objects` only uses the
former format for better compatibility. This option
allows the command to use the latter format for
compactness. Depending on the average delta chain
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-pack-redundant</em> [ --verbose ] [ --alt-odb ] < --all | .pack filename … ></p>\r
+<p><em>git pack-redundant</em> [ --verbose ] [ --alt-odb ] < --all | .pack filename … ></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>This program computes which packs in your repository\r
are redundant. The output is suitable for piping to\r
-<em>xargs rm</em> if you are in the root of the repository.</p>\r
-<p>git-pack-redundant accepts a list of objects on standard input. Any objects\r
+<tt>xargs rm</tt> if you are in the root of the repository.</p>\r
+<p><tt>git-pack-redundant</tt> accepts a list of objects on standard input. Any objects\r
given will be ignored when checking which packs are required. This makes the\r
following command useful when wanting to remove packs which contain unreachable\r
objects.</p>\r
-<p>git-fsck --full --unreachable | cut -d <em> </em> -f3 | git-pack-redundant --all | xargs rm</p>\r
+<p>git fsck --full --unreachable | cut -d <em> </em> -f3 | git pack-redundant --all | xargs rm</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:57 UTC\r
+Last updated 02-Jul-2008 03:01:55 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-pack-redundant' [ --verbose ] [ --alt-odb ] < --all | .pack filename ... >
+'git pack-redundant' [ --verbose ] [ --alt-odb ] < --all | .pack filename ... >
DESCRIPTION
-----------
This program computes which packs in your repository
are redundant. The output is suitable for piping to
-'xargs rm' if you are in the root of the repository.
+`xargs rm` if you are in the root of the repository.
-git-pack-redundant accepts a list of objects on standard input. Any objects
+`git-pack-redundant` accepts a list of objects on standard input. Any objects
given will be ignored when checking which packs are required. This makes the
following command useful when wanting to remove packs which contain unreachable
objects.
-git-fsck --full --unreachable | cut -d ' ' -f3 | \
-git-pack-redundant --all | xargs rm
+git fsck --full --unreachable | cut -d ' ' -f3 | \
+git pack-redundant --all | xargs rm
OPTIONS
-------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-pack-refs</em> [--all] [--no-prune]</p>\r
+<p><em>git pack-refs</em> [--all] [--no-prune]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<tt>$GIT_DIR/refs</tt> hierarchy.</p>\r
<p>A recommended practice to deal with a repository with too many\r
refs is to pack its refs with <tt>--all --prune</tt> once, and\r
-occasionally run <tt>git-pack-refs --prune</tt>. Tags are by\r
+occasionally run <tt>git pack-refs --prune</tt>. Tags are by\r
definition stationary and are not expected to change. Branch\r
heads will be packed with the initial <tt>pack-refs --all</tt>, but\r
only the currently active branch heads will become unpacked,\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:52 UTC\r
+Last updated 02-Jul-2008 03:01:55 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-pack-refs' [--all] [--no-prune]
+'git pack-refs' [--all] [--no-prune]
DESCRIPTION
-----------
A recommended practice to deal with a repository with too many
refs is to pack its refs with `--all --prune` once, and
-occasionally run `git-pack-refs \--prune`. Tags are by
+occasionally run `git pack-refs \--prune`. Tags are by
definition stationary and are not expected to change. Branch
heads will be packed with the initial `pack-refs --all`, but
only the currently active branch heads will become unpacked,
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 30-Jun-2008 09:04:38 UTC\r
+Last updated 02-Jul-2008 03:01:55 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-patch-id</em> < <patch></p>\r
+<p><em>git patch-id</em> < <patch></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
the same time also reasonably unique, i.e., two patches that have the same "patch\r
ID" are almost guaranteed to be the same thing.</p>\r
<p>IOW, you can use this thing to look for likely duplicate commits.</p>\r
-<p>When dealing with git-diff-tree output, it takes advantage of\r
+<p>When dealing with <tt>git-diff-tree</tt> output, it takes advantage of\r
the fact that the patch is prefixed with the object name of the\r
commit, and outputs two 40-byte hexadecimal string. The first\r
string is the patch ID, and the second string is the commit ID.\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:59 UTC\r
+Last updated 02-Jul-2008 03:01:55 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-patch-id' < <patch>
+'git
patch-id' < <patch>
DESCRIPTION
-----------
IOW, you can use this thing to look for likely duplicate commits.
-When dealing with git-diff-tree output, it takes advantage of
+When dealing with `git-diff-tree` output, it takes advantage of
the fact that the patch is prefixed with the object name of the
commit, and outputs two 40-byte hexadecimal string. The first
string is the patch ID, and the second string is the commit ID.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-peek-remote</em> [--upload-pack=<git-upload-pack>] [<host>:]<directory></p>\r
+<p><em>git peek-remote</em> [--upload-pack=<git-upload-pack>] [<host>:]<directory></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</dt>\r
<dd>\r
<p>\r
- Use this to specify the path to <em>git-upload-pack</em> on the\r
+ Use this to specify the path to <tt>git-upload-pack</tt> on the\r
remote side, if it is not found on your $PATH. Some\r
installations of sshd ignores the user's environment\r
setup scripts for login shells (e.g. .bash_profile) and\r
<dd>\r
<p>\r
A remote host that houses the repository. When this\r
- part is specified, <em>git-upload-pack</em> is invoked via\r
+ part is specified, <tt>git-upload-pack</tt> is invoked via\r
ssh.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:53 UTC\r
+Last updated 02-Jul-2008 03:01:55 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-peek-remote' [--upload-pack=<git-upload-pack>] [<host>:]<directory>
+'git peek-remote' [--upload-pack=<git-upload-pack>] [<host>:]<directory>
DESCRIPTION
-----------
OPTIONS
-------
--upload-pack=<git-upload-pack>::
- Use this to specify the path to 'git-upload-pack' on the
+ Use this to specify the path to `git-upload-pack` on the
remote side, if it is not found on your $PATH. Some
installations of sshd ignores the user's environment
setup scripts for login shells (e.g. .bash_profile) and
<host>::
A remote host that houses the repository. When this
- part is specified, 'git-upload-pack' is invoked via
+ part is specified, `git-upload-pack` is invoked via
ssh.
<directory>::
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-prune-packed</em> [-n] [-q]</p>\r
+<p><em>git prune-packed</em> [-n] [-q]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:33:59 UTC\r
+Last updated 02-Jul-2008 03:01:56 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-prune-packed' [-n] [-q]
+'git prune-packed' [-n] [-q]
DESCRIPTION
<td class="icon">\r
<div class="title">Note</div>\r
</td>\r
-<td class="content">In most cases, users should run <a href="git-gc.html">git-gc(1)</a>, which calls\r
-git-prune. See the section "NOTES", below.</td>\r
+<td class="content">In most cases, users should run <tt>git-gc</tt>, which calls\r
+<tt>git-prune</tt>. See the section "NOTES", below.</td>\r
</tr></table>\r
</div>\r
<p>This runs <tt>git-fsck --unreachable</tt> using all the refs\r
objects unreachable from any of these head objects from the object database.\r
In addition, it\r
prunes the unpacked objects that are also found in packs by\r
-running <tt>git prune-packed</tt>.</p>\r
+running <tt>git-prune-packed</tt>.</p>\r
<p>Note that unreachable, packed objects will remain. If this is\r
not desired, see <a href="git-repack.html">git-repack(1)</a>.</p>\r
</div>\r
<tt>.git/objects/info/alternates</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git prune $(cd ../another && $(git-rev-parse --all))</tt></pre>\r
+<pre><tt>$ git prune $(cd ../another && $(git rev-parse --all))</tt></pre>\r
</div></div>\r
</div>\r
<h2>Notes</h2>\r
<div class="sectionbody">\r
-<p>In most cases, users will not need to call git-prune directly, but\r
-should instead call <a href="git-gc.html">git-gc(1)</a>, which handles pruning along with\r
+<p>In most cases, users will not need to call <tt>git-prune</tt> directly, but\r
+should instead call <tt>git-gc</tt>, which handles pruning along with\r
many other housekeeping tasks.</p>\r
<p>For a description of which objects are considered for pruning, see\r
-git-fsck's --unreachable option.</p>\r
+<tt>git-fsck</tt>'s --unreachable option.</p>\r
</div>\r
<h2>SEE ALSO</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:53 UTC\r
+Last updated 02-Jul-2008 03:01:56 UTC\r
</div>\r
</div>\r
</body>\r
DESCRIPTION
-----------
-NOTE: In most cases, users should run linkgit:git-gc[1], which calls
-git-prune. See the section "NOTES", below.
+NOTE: In most cases, users should run `git-gc`, which calls
+`git-prune`. See the section "NOTES", below.
This runs `git-fsck --unreachable` using all the refs
available in `$GIT_DIR/refs`, optionally with additional set of
objects unreachable from any of these head objects from the object database.
In addition, it
prunes the unpacked objects that are also found in packs by
-running `git prune-packed`.
+running `git-prune-packed`.
Note that unreachable, packed objects will remain. If this is
not desired, see linkgit:git-repack[1].
`.git/objects/info/alternates`:
------------
-$ git prune $(cd ../another && $(git-rev-parse --all))
+$ git prune $(cd ../another && $(git rev-parse --all))
------------
Notes
-----
-In most cases, users will not need to call git-prune directly, but
-should instead call linkgit:git-gc[1], which handles pruning along with
+In most cases, users will not need to call `git-prune` directly, but
+should instead call `git-gc`, which handles pruning along with
many other housekeeping tasks.
For a description of which objects are considered for pruning, see
-git-fsck's --unreachable option.
+`git-fsck`'s --unreachable option.
SEE ALSO
--------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-pull</em> <options> <repository> <refspec>…</p>\r
+<p><em>git pull</em> <options> <repository> <refspec>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</li>\r
</ul>\r
<p>If you tried a pull which resulted in a complex conflicts and\r
-would want to start over, you can recover with\r
-<a href="git-reset.html">git-reset(1)</a>.</p>\r
+would want to start over, you can recover with <tt>git-reset</tt>.</p>\r
</div>\r
<h2>SEE ALSO</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 13-Jun-2008 10:02:42 UTC\r
+Last updated 02-Jul-2008 03:01:56 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-pull' <options> <repository> <refspec>...
+'git pull' <options> <repository> <refspec>...
DESCRIPTION
If you tried a pull which resulted in a complex conflicts and
-would want to start over, you can recover with
-linkgit:git-reset[1].
+would want to start over, you can recover with `git-reset`.
SEE ALSO
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-push</em> [--all] [--dry-run] [--tags] [--receive-pack=<git-receive-pack>]\r
+<div class="content"><em>git push</em> [--all] [--dry-run] [--tags] [--receive-pack=<git-receive-pack>]\r
[--repo=all] [-f | --force] [-v | --verbose] [<repository> <refspec>…]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
</dt>\r
<dd>\r
<p>\r
- Path to the <em>git-receive-pack</em> program on the remote\r
+ Path to the <tt>git-receive-pack</tt> program on the remote\r
end. Sometimes useful when pushing to a remote\r
repository over ssh, and you do not have the program in\r
a directory on the default $PATH.\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 21-Jun-2008 09:40:20 UTC\r
+Last updated 02-Jul-2008 03:01:56 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-push' [--all] [--dry-run] [--tags] [--receive-pack=<git-receive-pack>]
+'git push' [--all] [--dry-run] [--tags] [--receive-pack=<git-receive-pack>]
[--repo=all] [-f | --force] [-v | --verbose] [<repository> <refspec>...]
DESCRIPTION
line.
--receive-pack=<git-receive-pack>::
- Path to the 'git-receive-pack' program on the remote
+ Path to the `git-receive-pack` program on the remote
end. Sometimes useful when pushing to a remote
repository over ssh, and you do not have the program in
a directory on the default $PATH.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-quiltimport</em> [--dry-run] [--author <author>] [--patches <dir>]</div></div>\r
+<div class="content"><em>git quiltimport</em> [--dry-run] [--author <author>] [--patches <dir>]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:56 UTC\r
+Last updated 02-Jul-2008 03:01:57 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git
-quiltimport' [--dry-run] [--author <author>] [--patches <dir>]
+'git
quiltimport' [--dry-run] [--author <author>] [--patches <dir>]
DESCRIPTION
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-read-tree</em> (<tree-ish> | [[-m [--trivial] [--aggressive] | --reset | --prefix=<prefix>] [-u | -i]] [--exclude-per-directory=<gitignore>] [--index-output=<file>] <tree-ish1> [<tree-ish2> [<tree-ish3>]])</p>\r
+<p><em>git read-tree</em> (<tree-ish> | [[-m [--trivial] [--aggressive] | --reset | --prefix=<prefix>] [-u | -i]] [--exclude-per-directory=<gitignore>] [--index-output=<file>] <tree-ish1> [<tree-ish2> [<tree-ish3>]])</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
fast-forward merge with 2 trees, or a 3-way merge if 3 trees are\r
provided.</p>\r
<h3>Single Tree Merge</h3>\r
-<p>If only 1 tree is specified, git-read-tree operates as if the user did not\r
+<p>If only 1 tree is specified, <tt>git-read-tree</tt> operates as if the user did not\r
specify <tt>-m</tt>, except that if the original index has an entry for a\r
given pathname, and the contents of the path matches with the tree\r
being read, the stat info from the index is used. (In other words, the\r
index's stat()s take precedence over the merged tree's).</p>\r
-<p>That means that if you do a <tt>git-read-tree -m <newtree></tt> followed by a\r
-<tt>git-checkout-index -f -u -a</tt>, the <tt>git-checkout-index</tt> only checks out\r
+<p>That means that if you do a <tt>git read-tree -m <newtree></tt> followed by a\r
+<tt>git checkout-index -f -u -a</tt>, the <tt>git-checkout-index</tt> only checks out\r
the stuff that really changed.</p>\r
<p>This is used to avoid unnecessary false hits when <tt>git-diff-files</tt> is\r
run after <tt>git-read-tree</tt>.</p>\r
<h3>Two Tree Merge</h3>\r
-<p>Typically, this is invoked as <tt>git-read-tree -m $H $M</tt>, where $H\r
+<p>Typically, this is invoked as <tt>git read-tree -m $H $M</tt>, where $H\r
is the head commit of the current repository, and $M is the head\r
of a foreign tree, which is simply ahead of $H (i.e. we are in a\r
fast forward situation).</p>\r
-<p>When two trees are specified, the user is telling git-read-tree\r
+<p>When two trees are specified, the user is telling <tt>git-read-tree</tt>\r
the following:</p>\r
<ol>\r
<li>\r
</p>\r
</li>\r
</ol>\r
-<p>In this case, the <tt>git-read-tree -m $H $M</tt> command makes sure\r
+<p>In this case, the <tt>git read-tree -m $H $M</tt> command makes sure\r
that no local change is lost as the result of this "merge".\r
Here are the "carry forward" rules:</p>\r
<div class="literalblock">\r
</div></div>\r
<p>In all "keep index" cases, the index entry stays as in the\r
original index file. If the entry were not up to date,\r
-git-read-tree keeps the copy in the work tree intact when\r
+<tt>git-read-tree</tt> keeps the copy in the work tree intact when\r
operating under the -u flag.</p>\r
-<p>When this form of git-read-tree returns successfully, you can\r
+<p>When this form of <tt>git-read-tree</tt> returns successfully, you can\r
see what "local changes" you made are carried forward by running\r
-<tt>git-diff-index --cached $M</tt>. Note that this does not\r
-necessarily match <tt>git-diff-index --cached $H</tt> would have\r
+<tt>git diff-index --cached $M</tt>. Note that this does not\r
+necessarily match <tt>git diff-index --cached $H</tt> would have\r
produced before such a two tree merge. This is because of cases\r
18 and 19 --- if you already had the changes in $M (e.g. maybe\r
-you picked it up via e-mail in a patch form), <tt>git-diff-index\r
+you picked it up via e-mail in a patch form), <tt>git diff-index\r
--cached $H</tt> would have told you about the change before this\r
-merge, but it would not show in <tt>git-diff-index --cached $M</tt>\r
+merge, but it would not show in <tt>git diff-index --cached $M</tt>\r
output after two-tree merge.</p>\r
<h3>3-Way Merge</h3>\r
<p>Each "index" entry has two bits worth of "stage" state. stage 0 is the\r
<p>This means that you can do</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-read-tree -m <tree1> <tree2> <tree3></tt></pre>\r
+<pre><tt>$ git read-tree -m <tree1> <tree2> <tree3></tt></pre>\r
</div></div>\r
<p>and you will end up with an index with all of the <tree1> entries in\r
"stage1", all of the <tree2> entries in "stage2" and all of the\r
<li>\r
<p>\r
if a file exists in identical format in all three trees, it will\r
- automatically collapse to "merged" state by git-read-tree.\r
+ automatically collapse to "merged" state by <tt>git-read-tree</tt>.\r
</p>\r
</li>\r
<li>\r
committed last to your repository:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ JC=`git-rev-parse --verify "HEAD^0"`\r
-$ git-checkout-index -f -u -a $JC</tt></pre>\r
+<pre><tt>$ JC=`git rev-parse --verify "HEAD^0"`\r
+$ git checkout-index -f -u -a $JC</tt></pre>\r
</div></div>\r
-<p>You do random edits, without running git-update-index. And then\r
+<p>You do random edits, without running <tt>git-update-index</tt>. And then\r
you notice that the tip of your "upstream" tree has advanced\r
since you pulled from him:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-fetch git://.... linus\r
+<pre><tt>$ git fetch git://.... linus\r
$ LT=`cat .git/FETCH_HEAD`</tt></pre>\r
</div></div>\r
<p>Your work tree is still based on your HEAD ($JC), but you have\r
then does the right thing. So with the following sequence:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-read-tree -m -u `git-merge-base $JC $LT` $JC $LT\r
-$ git-merge-index git-merge-one-file -a\r
+<pre><tt>$ git read-tree -m -u `git merge-base $JC $LT` $JC $LT\r
+$ git merge-index git-merge-one-file -a\r
$ echo "Merge with Linus" | \\r
- git-commit-tree `git-write-tree` -p $JC -p $LT</tt></pre>\r
+ git commit-tree `git write-tree` -p $JC -p $LT</tt></pre>\r
</div></div>\r
<p>what you would commit is a pure merge between $JC and $LT without\r
your work-in-progress changes, and your work tree would be\r
updated to the result of the merge.</p>\r
<p>However, if you have local changes in the working tree that\r
-would be overwritten by this merge,<tt>git-read-tree</tt> will refuse\r
+would be overwritten by this merge, <tt>git-read-tree</tt> will refuse\r
to run to prevent your changes from being lost.</p>\r
<p>In other words, there is no need to worry about what exists only\r
in the working tree. When you have local changes in a part of\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 10-Jun-2008 04:10:01 UTC\r
+Last updated 02-Jul-2008 03:01:57 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-read-tree' (<tree-ish> | [[-m [--trivial] [--aggressive] | --reset | --prefix=<prefix>] [-u | -i]] [--exclude-per-directory=<gitignore>] [--index-output=<file>] <tree-ish1> [<tree-ish2> [<tree-ish3>]])
+'git
read-tree' (<tree-ish> | [[-m [--trivial] [--aggressive] | --reset | --prefix=<prefix>] [-u | -i]] [--exclude-per-directory=<gitignore>] [--index-output=<file>] <tree-ish1> [<tree-ish2> [<tree-ish3>]])
DESCRIPTION
Single Tree Merge
~~~~~~~~~~~~~~~~~
-If only 1 tree is specified, git-read-tree operates as if the user did not
+If only 1 tree is specified, `git-read-tree` operates as if the user did not
specify `-m`, except that if the original index has an entry for a
given pathname, and the contents of the path matches with the tree
being read, the stat info from the index is used. (In other words, the
index's stat()s take precedence over the merged tree's).
-That means that if you do a `git-read-tree -m <newtree>` followed by a
-`git-checkout-index -f -u -a`, the `git-checkout-index` only checks out
+That means that if you do a `git read-tree -m <newtree>` followed by a
+`git checkout-index -f -u -a`, the `git-checkout-index` only checks out
the stuff that really changed.
This is used to avoid unnecessary false hits when `git-diff-files` is
Two Tree Merge
~~~~~~~~~~~~~~
-Typically, this is invoked as `git-read-tree -m $H $M`, where $H
+Typically, this is invoked as `git read-tree -m $H $M`, where $H
is the head commit of the current repository, and $M is the head
of a foreign tree, which is simply ahead of $H (i.e. we are in a
fast forward situation).
-When two trees are specified, the user is telling git-read-tree
+When two trees are specified, the user is telling `git-read-tree`
the following:
1. The current index and work tree is derived from $H, but
2. The user wants to fast-forward to $M.
-In this case, the `git-read-tree -m $H $M` command makes sure
+In this case, the `git read-tree -m $H $M` command makes sure
that no local change is lost as the result of this "merge".
Here are the "carry forward" rules:
In all "keep index" cases, the index entry stays as in the
original index file. If the entry were not up to date,
-git-read-tree keeps the copy in the work tree intact when
+`git-read-tree` keeps the copy in the work tree intact when
operating under the -u flag.
-When this form of git-read-tree returns successfully, you can
+When this form of `git-read-tree` returns successfully, you can
see what "local changes" you made are carried forward by running
-`git-diff-index --cached $M`. Note that this does not
-necessarily match `git-diff-index --cached $H` would have
+`git diff-index --cached $M`. Note that this does not
+necessarily match `git diff-index --cached $H` would have
produced before such a two tree merge. This is because of cases
18 and 19 --- if you already had the changes in $M (e.g. maybe
-you picked it up via e-mail in a patch form), `git-diff-index
+you picked it up via e-mail in a patch form), `git diff-index
--cached $H` would have told you about the change before this
-merge, but it would not show in `git-diff-index --cached $M`
+merge, but it would not show in `git diff-index --cached $M`
output after two-tree merge.
This means that you can do
----------------
-$ git-read-tree -m <tree1> <tree2> <tree3>
+$ git read-tree -m <tree1> <tree2> <tree3>
----------------
and you will end up with an index with all of the <tree1> entries in
populated. Here is an outline of how the algorithm works:
- if a file exists in identical format in all three trees, it will
- automatically collapse to "merged" state by git-read-tree.
+ automatically collapse to "merged" state by `git-read-tree`.
- a file that has _any_ difference what-so-ever in the three trees
will stay as separate entries in the index. It's up to "porcelain
committed last to your repository:
----------------
-$ JC=`git-rev-parse --verify "HEAD^0"`
-$ git-checkout-index -f -u -a $JC
+$ JC=`git rev-parse --verify "HEAD^0"`
+$ git checkout-index -f -u -a $JC
----------------
-You do random edits, without running git-update-index. And then
+You do random edits, without running `git-update-index`. And then
you notice that the tip of your "upstream" tree has advanced
since you pulled from him:
----------------
-$ git-fetch git://.... linus
+$ git fetch git://.... linus
$ LT=`cat .git/FETCH_HEAD`
----------------
then does the right thing. So with the following sequence:
----------------
-$ git-read-tree -m -u `git-merge-base $JC $LT` $JC $LT
-$ git-merge-index git-merge-one-file -a
+$ git read-tree -m -u `git merge-base $JC $LT` $JC $LT
+$ git merge-index git-merge-one-file -a
$ echo "Merge with Linus" | \
- git-commit-tree `git-write-tree` -p $JC -p $LT
+ git commit-tree `git write-tree` -p $JC -p $LT
----------------
what you would commit is a pure merge between $JC and $LT without
updated to the result of the merge.
However, if you have local changes in the working tree that
-would be overwritten by this merge,`git-read-tree` will refuse
+would be overwritten by this merge, `git-read-tree` will refuse
to run to prevent your changes from being lost.
In other words, there is no need to worry about what exists only
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-rebase</em> [-i | --interactive] [-v | --verbose] [-m | --merge]\r
+<div class="content"><em>git rebase</em> [-i | --interactive] [-v | --verbose] [-m | --merge]\r
[-s <strategy> | --strategy=<strategy>]\r
[-C<n>] [ --whitespace=<option>] [-p | --preserve-merges]\r
[--onto <newbase>] <upstream> [<branch>]\r
-<em>git-rebase</em> --continue | --skip | --abort</div></div>\r
+<em>git rebase</em> --continue | --skip | --abort</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>If <branch> is specified, git-rebase will perform an automatic\r
+<p>If <branch> is specified, <tt>git-rebase</tt> will perform an automatic\r
<tt>git checkout <branch></tt> before doing anything else. Otherwise\r
it remains on the current branch.</p>\r
<p>All changes made by commits in the current branch but that are not\r
<p>From this point, the result of either of the following commands:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-rebase master\r
-git-rebase master topic</tt></pre>\r
+<pre><tt>git rebase master\r
+git rebase master topic</tt></pre>\r
</div></div>\r
<p>would be:</p>\r
<div class="listingblock">\r
followed by <tt>git rebase master</tt>.</p>\r
<p>If the upstream branch already contains a change you have made (e.g.,\r
because you mailed a patch which was applied upstream), then that commit\r
-will be skipped. For example, running <tt>git-rebase master</tt> on the\r
+will be skipped. For example, running <tt>git rebase master</tt> on the\r
following history (in which A' and A introduce the same set of changes,\r
but have different committer information):</p>\r
<div class="listingblock">\r
<p>We can get this using the following command:</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-rebase --onto master next topic</tt></pre>\r
+<pre><tt>git rebase --onto master next topic</tt></pre>\r
</div></div>\r
<p>Another example of --onto option is to rebase part of a\r
branch. If we have the following situation:</p>\r
<p>then the command</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-rebase --onto master topicA topicB</tt></pre>\r
+<pre><tt>git rebase --onto master topicA topicB</tt></pre>\r
</div></div>\r
<p>would result in:</p>\r
<div class="listingblock">\r
<p>then the command</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-rebase --onto topicA~5 topicA~3 topicA</tt></pre>\r
+<pre><tt>git rebase --onto topicA~5 topicA~3 topicA</tt></pre>\r
</div></div>\r
<p>would result in the removal of commits F and G:</p>\r
<div class="listingblock">\r
<p>This is useful if F and G were flawed in some way, or should not be\r
part of topicA. Note that the argument to --onto and the <upstream>\r
parameter can be any valid commit-ish.</p>\r
-<p>In case of conflict, git-rebase will stop at the first problematic commit\r
-and leave conflict markers in the tree. You can use git diff to locate\r
+<p>In case of conflict, <tt>git-rebase</tt> will stop at the first problematic commit\r
+and leave conflict markers in the tree. You can use <tt>git-diff</tt> to locate\r
the markers (<<<<<<) and make edits to resolve the conflict. For each\r
file you edit, you need to tell git that the conflict has been resolved,\r
typically this would be done with</p>\r
<div class="content">\r
<pre><tt>git rebase --continue</tt></pre>\r
</div></div>\r
-<p>Alternatively, you can undo the git-rebase with</p>\r
+<p>Alternatively, you can undo the <tt>git-rebase</tt> with</p>\r
<div class="literalblock">\r
<div class="content">\r
<pre><tt>git rebase --abort</tt></pre>\r
<h2>SPLITTING COMMITS</h2>\r
<div class="sectionbody">\r
<p>In interactive mode, you can mark commits with the action "edit". However,\r
-this does not necessarily mean that <em>git rebase</em> expects the result of this\r
+this does not necessarily mean that <tt>git-rebase</tt> expects the result of this\r
edit to be exactly one commit. Indeed, you can undo the commit, or you can\r
add other commits. This can be used to split a commit into two:</p>\r
<ul>\r
<li>\r
<p>\r
-Start an interactive rebase with <em>git rebase -i <commit>^</em>, where\r
+Start an interactive rebase with <tt>git rebase -i <commit>^</tt>, where\r
<commit> is the commit you want to split. In fact, any commit range\r
will do, as long as it contains that commit.\r
</p>\r
</li>\r
<li>\r
<p>\r
-When it comes to editing that commit, execute <em>git reset HEAD^</em>. The\r
+When it comes to editing that commit, execute <tt>git reset HEAD^</tt>. The\r
effect is that the HEAD is rewound by one, and the index follows suit.\r
However, the working tree stays the same.\r
</p>\r
<li>\r
<p>\r
Now add the changes to the index that you want to have in the first\r
- commit. You can use <a href="git-add.html">git-add(1)</a> (possibly interactively) and/or\r
- <a href="git-gui.html">git-gui(1)</a> to do that.\r
+ commit. You can use <tt>git add</tt> (possibly interactively) or\r
+ <tt>git-gui</tt> (or both) to do that.\r
</p>\r
</li>\r
<li>\r
</li>\r
<li>\r
<p>\r
-Continue the rebase with <em>git rebase --continue</em>.\r
+Continue the rebase with <tt>git rebase --continue</tt>.\r
</p>\r
</li>\r
</ul>\r
<p>If you are not absolutely sure that the intermediate revisions are\r
consistent (they compile, pass the testsuite, etc.) you should use\r
-<a href="git-stash.html">git-stash(1)</a> to stash away the not-yet-committed changes\r
+<tt>git-stash</tt> to stash away the not-yet-committed changes\r
after each commit, test, and amend the commit if fixes are necessary.</p>\r
</div>\r
<h2>Authors</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:57 UTC\r
+Last updated 02-Jul-2008 03:01:57 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-rebase' [-i | --interactive] [-v | --verbose] [-m | --merge]
+'git rebase' [-i | --interactive] [-v | --verbose] [-m | --merge]
[-s <strategy> | --strategy=<strategy>]
[-C<n>] [ --whitespace=<option>] [-p | --preserve-merges]
[--onto <newbase>] <upstream> [<branch>]
-'git-rebase' --continue | --skip | --abort
+'git rebase' --continue | --skip | --abort
DESCRIPTION
-----------
-If <branch> is specified, git-rebase will perform an automatic
+If <branch> is specified, `git-rebase` will perform an automatic
`git checkout <branch>` before doing anything else. Otherwise
it remains on the current branch.
From this point, the result of either of the following commands:
- git-rebase master
- git-rebase master topic
+ git rebase master
+ git rebase master topic
would be:
If the upstream branch already contains a change you have made (e.g.,
because you mailed a patch which was applied upstream), then that commit
-will be skipped. For example, running `git-rebase master` on the
+will be skipped. For example, running `git rebase master` on the
following history (in which A' and A introduce the same set of changes,
but have different committer information):
We can get this using the following command:
- git-rebase --onto master next topic
+ git rebase --onto master next topic
Another example of --onto option is to rebase part of a
then the command
- git-rebase --onto master topicA topicB
+ git rebase --onto master topicA topicB
would result in:
then the command
- git-rebase --onto topicA~5 topicA~3 topicA
+ git rebase --onto topicA~5 topicA~3 topicA
would result in the removal of commits F and G:
part of topicA. Note that the argument to --onto and the <upstream>
parameter can be any valid commit-ish.
-In case of conflict, git-rebase will stop at the first problematic commit
-and leave conflict markers in the tree. You can use git diff to locate
+In case of conflict, `git-rebase` will stop at the first problematic commit
+and leave conflict markers in the tree. You can use `git-diff` to locate
the markers (<<<<<<) and make edits to resolve the conflict. For each
file you edit, you need to tell git that the conflict has been resolved,
typically this would be done with
git rebase --continue
-Alternatively, you can undo the git-rebase with
+Alternatively, you can undo the `git-rebase` with
git rebase --abort
-----------------
In interactive mode, you can mark commits with the action "edit". However,
-this does not necessarily mean that 'git rebase' expects the result of this
+this does not necessarily mean that `git-rebase` expects the result of this
edit to be exactly one commit. Indeed, you can undo the commit, or you can
add other commits. This can be used to split a commit into two:
-- Start an interactive rebase with 'git rebase -i <commit>^', where
+- Start an interactive rebase with `git rebase -i <commit>^`, where
<commit> is the commit you want to split. In fact, any commit range
will do, as long as it contains that commit.
- Mark the commit you want to split with the action "edit".
-- When it comes to editing that commit, execute 'git reset HEAD^'. The
+- When it comes to editing that commit, execute `git reset HEAD^`. The
effect is that the HEAD is rewound by one, and the index follows suit.
However, the working tree stays the same.
- Now add the changes to the index that you want to have in the first
- commit. You can use linkgit:git-add[1] (possibly interactively) and/or
- linkgit:git-gui[1] to do that.
+ commit. You can use `git add` (possibly interactively) or
+ `git-gui` (or both) to do that.
- Commit the now-current index with whatever commit message is appropriate
now.
- Repeat the last two steps until your working tree is clean.
-- Continue the rebase with 'git rebase --continue'.
+- Continue the rebase with `git rebase --continue`.
If you are not absolutely sure that the intermediate revisions are
consistent (they compile, pass the testsuite, etc.) you should use
-linkgit:git-stash[1] to stash away the not-yet-committed changes
+`git-stash` to stash away the not-yet-committed changes
after each commit, test, and amend the commit if fixes are necessary.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-receive-pack</em> <directory></p>\r
+<p><em>git receive-pack</em> <directory></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>Invoked by <em>git-send-pack</em> and updates the repository with the\r
+<p>Invoked by <tt>git-send-pack</tt> and updates the repository with the\r
information fed from the remote end.</p>\r
<p>This command is usually not invoked directly by the end user.\r
-The UI for the protocol is on the <em>git-send-pack</em> side, and the\r
+The UI for the protocol is on the <tt>git-send-pack</tt> side, and the\r
program pair is meant to be used to push updates to remote\r
-repository. For pull operations, see <em>git-fetch-pack</em>.</p>\r
+repository. For pull operations, see <a href="git-fetch-pack.html">git-fetch-pack(1)</a>.</p>\r
<p>The command allows for creation and fast forwarding of sha1 refs\r
(heads/tags) on the remote end (strictly speaking, it is the\r
-local end receive-pack runs, but to the user who is sitting at\r
+local end <tt>git-receive-pack</tt> runs, but to the user who is sitting at\r
the send-pack end, it is updating the remote. Confused?)</p>\r
<p>There are other real-world examples of using update and\r
post-update hooks found in the Documentation/howto directory.</p>\r
-<p>git-receive-pack honours the receive.denyNonFastForwards config\r
+<p><tt>git-receive-pack</tt> honours the receive.denyNonFastForwards config\r
option, which tells it if updates to a ref should be denied if they\r
are not fast-forwards.</p>\r
</div>\r
if expr "$oval" : '0*$' >/dev/null\r
then\r
echo "Created a new ref, with the following commits:"\r
- git-rev-list --pretty "$nval"\r
+ git rev-list --pretty "$nval"\r
else\r
echo "New commits:"\r
- git-rev-list --pretty "$nval" "^$oval"\r
+ git rev-list --pretty "$nval" "^$oval"\r
fi |\r
mail -s "Changes to ref $ref" commit-list@mydomain\r
done\r
non-zero exit code will generate an error message.</p>\r
<p>Note that it is possible for refname to not have sha1-new when this\r
hook runs. This can easily occur if another user modifies the ref\r
-after it was updated by receive-pack, but before the hook was able\r
+after it was updated by <tt>git-receive-pack</tt>, but before the hook was able\r
to evaluate it. It is recommended that hooks rely on sha1-new\r
rather than the current value of refname.</p>\r
</div>\r
post-update will called with the list of refs that have been updated.\r
This can be used to implement any repository wide cleanup tasks.</p>\r
<p>The exit code from this hook invocation is ignored; the only thing\r
-left for git-receive-pack to do at that point is to exit itself\r
+left for <tt>git-receive-pack</tt> to do at that point is to exit itself\r
anyway.</p>\r
-<p>This hook can be used, for example, to run "git-update-server-info"\r
+<p>This hook can be used, for example, to run <tt>git update-server-info</tt>\r
if the repository is packed and is served via a dumb transport.</p>\r
<div class="literalblock">\r
<div class="content">\r
<pre><tt>#!/bin/sh\r
-exec git-update-server-info</tt></pre>\r
+exec git update-server-info</tt></pre>\r
</div></div>\r
</div>\r
<h2>SEE ALSO</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:03 UTC\r
+Last updated 02-Jul-2008 03:01:58 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-receive-pack' <directory>
+'git receive-pack' <directory>
DESCRIPTION
-----------
-Invoked by 'git-send-pack' and updates the repository with the
+Invoked by `git-send-pack` and updates the repository with the
information fed from the remote end.
This command is usually not invoked directly by the end user.
-The UI for the protocol is on the 'git-send-pack' side, and the
+The UI for the protocol is on the `git-send-pack` side, and the
program pair is meant to be used to push updates to remote
-repository. For pull operations, see 'git-fetch-pack'.
+repository. For pull operations, see linkgit:git-fetch-pack[1].
The command allows for creation and fast forwarding of sha1 refs
(heads/tags) on the remote end (strictly speaking, it is the
-local end receive-pack runs, but to the user who is sitting at
+local end `git-receive-pack` runs, but to the user who is sitting at
the send-pack end, it is updating the remote. Confused?)
There are other real-world examples of using update and
post-update hooks found in the Documentation/howto directory.
-git-receive-pack honours the receive.denyNonFastForwards config
+`git-receive-pack` honours the receive.denyNonFastForwards config
option, which tells it if updates to a ref should be denied if they
are not fast-forwards.
if expr "$oval" : '0*$' >/dev/null
then
echo "Created a new ref, with the following commits:"
- git-rev-list --pretty "$nval"
+ git rev-list --pretty "$nval"
else
echo "New commits:"
- git-rev-list --pretty "$nval" "^$oval"
+ git rev-list --pretty "$nval" "^$oval"
fi |
mail -s "Changes to ref $ref" commit-list@mydomain
done
Note that it is possible for refname to not have sha1-new when this
hook runs. This can easily occur if another user modifies the ref
-after it was updated by receive-pack, but before the hook was able
+after it was updated by `git-receive-pack`, but before the hook was able
to evaluate it. It is recommended that hooks rely on sha1-new
rather than the current value of refname.
This can be used to implement any repository wide cleanup tasks.
The exit code from this hook invocation is ignored; the only thing
-left for git-receive-pack to do at that point is to exit itself
+left for `git-receive-pack` to do at that point is to exit itself
anyway.
-This hook can be used, for example, to run "git-update-server-info"
+This hook can be used, for example, to run `git update-server-info`
if the repository is packed and is served via a dumb transport.
#!/bin/sh
- exec git-update-server-info
+ exec git update-server-info
SEE ALSO
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:03 UTC\r
+Last updated 02-Jul-2008 03:01:58 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-relink</em> [--safe] <dir> [<dir>]* <master_dir></p>\r
+<p><em>git relink</em> [--safe] <dir> [<dir>]* <master_dir></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:04 UTC\r
+Last updated 02-Jul-2008 03:01:58 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-relink' [--safe] <dir> [<dir>]\* <master_dir>
+'git relink' [--safe] <dir> [<dir>]\* <master_dir>
DESCRIPTION
-----------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-remote</em> [-v | --verbose]\r
-<em>git-remote</em> add [-t <branch>] [-m <master>] [-f] [--mirror] <name> <url>\r
-<em>git-remote</em> rm <name>\r
-<em>git-remote</em> show [-n] <name>\r
-<em>git-remote</em> prune [-n | --dry-run] <name>\r
-<em>git-remote</em> update [group]</div></div>\r
+<div class="content"><em>git remote</em> [-v | --verbose]\r
+<em>git remote</em> add [-t <branch>] [-m <master>] [-f] [--mirror] <name> <url>\r
+<em>git remote</em> rm <name>\r
+<em>git remote</em> show [-n] <name>\r
+<em>git remote</em> prune [-n | --dry-run] <name>\r
+<em>git remote</em> update [group]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 13-Jun-2008 10:02:42 UTC\r
+Last updated 02-Jul-2008 03:01:59 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-remote' [-v | --verbose]
-'git-remote' add [-t <branch>] [-m <master>] [-f] [--mirror] <name> <url>
-'git-remote' rm <name>
-'git-remote' show [-n] <name>
-'git-remote' prune [-n | --dry-run] <name>
-'git-remote' update [group]
+'git remote' [-v | --verbose]
+'git remote' add [-t <branch>] [-m <master>] [-f] [--mirror] <name> <url>
+'git remote' rm <name>
+'git remote' show [-n] <name>
+'git remote' prune [-n | --dry-run] <name>
+'git remote' update [group]
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-repack</em> [-a] [-A] [-d] [-f] [-l] [-n] [-q] [--window=N] [--depth=N]</p>\r
+<p><em>git repack</em> [-a] [-A] [-d] [-f] [-l] [-n] [-q] [--window=N] [--depth=N]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
deleted by way of being left in the old pack and then\r
removed. Instead, the loose unreachable objects\r
will be pruned according to normal expiry rules\r
- with the next <a href="git-gc.html">git-gc(1)</a>.\r
+ with the next <tt>git-gc</tt> invocation. See <a href="git-gc.html">git-gc(1)</a>.\r
</p>\r
</dd>\r
<dt>\r
<p>\r
After packing, if the newly created packs make some\r
existing packs redundant, remove the redundant packs.\r
- Also runs <a href="git-prune-packed.html">git-prune-packed(1)</a>.\r
+ Also run <tt>git-prune-packed</tt> to remove redundant\r
+ loose object files.\r
</p>\r
</dd>\r
<dt>\r
</dt>\r
<dd>\r
<p>\r
- Pass the <tt>--local</tt> option to <tt>git pack-objects</tt>, see\r
+ Pass the <tt>--local</tt> option to <tt>git-pack-objects</tt>. See\r
<a href="git-pack-objects.html">git-pack-objects(1)</a>.\r
</p>\r
</dd>\r
</dt>\r
<dd>\r
<p>\r
- Pass the <tt>--no-reuse-delta</tt> option to <tt>git pack-objects</tt>, see\r
+ Pass the <tt>--no-reuse-delta</tt> option to <tt>git-pack-objects</tt>. See\r
<a href="git-pack-objects.html">git-pack-objects(1)</a>.\r
</p>\r
</dd>\r
</dt>\r
<dd>\r
<p>\r
- Pass the <tt>-q</tt> option to <tt>git pack-objects</tt>, see\r
+ Pass the <tt>-q</tt> option to <tt>git-pack-objects</tt>. See\r
<a href="git-pack-objects.html">git-pack-objects(1)</a>.\r
</p>\r
</dd>\r
<dd>\r
<p>\r
Do not update the server information with\r
- <tt>git update-server-info</tt>. This option skips\r
+ <tt>git-update-server-info</tt>. This option skips\r
updating local catalog files needed to publish\r
this repository (or a direct copy of it)\r
over HTTP or FTP. See .\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:58 UTC\r
+Last updated 02-Jul-2008 03:01:59 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-repack' [-a] [-A] [-d] [-f] [-l] [-n] [-q] [--window=N] [--depth=N]
+'git repack' [-a] [-A] [-d] [-f] [-l] [-n] [-q] [--window=N] [--depth=N]
DESCRIPTION
-----------
deleted by way of being left in the old pack and then
removed. Instead, the loose unreachable objects
will be pruned according to normal expiry rules
- with the next linkgit:git-gc[1].
+ with the next `git-gc` invocation. See linkgit:git-gc[1].
-d::
After packing, if the newly created packs make some
existing packs redundant, remove the redundant packs.
- Also runs linkgit:git-prune-packed[1].
+ Also run `git-prune-packed` to remove redundant
+ loose object files.
-l::
- Pass the `--local` option to `git pack-objects`, see
+ Pass the `--local` option to `git-pack-objects`. See
linkgit:git-pack-objects[1].
-f::
- Pass the `--no-reuse-delta` option to `git pack-objects`, see
+ Pass the `--no-reuse-delta` option to `git-pack-objects`. See
linkgit:git-pack-objects[1].
-q::
- Pass the `-q` option to `git pack-objects`, see
+ Pass the `-q` option to `git-pack-objects`. See
linkgit:git-pack-objects[1].
-n::
Do not update the server information with
- `git update-server-info`. This option skips
+ `git-update-server-info`. This option skips
updating local catalog files needed to publish
this repository (or a direct copy of it)
over HTTP or FTP. See gitlink:git-update-server-info[1].
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-repo-config</em> …</p>\r
+<p><em>git repo-config</em> …</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:05 UTC\r
+Last updated 02-Jul-2008 03:01:59 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-repo-config' ...
+'git repo-config' ...
DESCRIPTION
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-request-pull</em> <start> <url> [<end>]</p>\r
+<p><em>git request-pull</em> <start> <url> [<end>]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:06 UTC\r
+Last updated 02-Jul-2008 03:01:59 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-request-pull' <start> <url> [<end>]
+'git request-pull' <start> <url> [<end>]
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-rerere</em> [clear|diff|status|gc]</p>\r
+<p><em>git rerere</em> [clear|diff|status|gc]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<h2>COMMANDS</h2>\r
<div class="sectionbody">\r
-<p>Normally, git-rerere is run without arguments or user-intervention.\r
+<p>Normally, <tt>git-rerere</tt> is run without arguments or user-intervention.\r
However, it has several commands that allow it to interact with\r
its working state.</p>\r
<dl>\r
<dd>\r
<p>\r
This resets the metadata used by rerere if a merge resolution is to be\r
-is aborted. Calling <a href="git-am.html">git-am(1)</a> --skip or <a href="git-rebase.html">git-rebase(1)</a>\r
-[--skip|--abort] will automatically invoke this command.\r
+is aborted. Calling <tt>git-am --skip</tt> or <tt>git-rebase [--skip|--abort]</tt>\r
+will automatically invoke this command.\r
</p>\r
</dd>\r
<dt>\r
This displays diffs for the current state of the resolution. It is\r
useful for tracking what has changed while the user is resolving\r
conflicts. Additional arguments are passed directly to the system\r
-diff(1) command installed in PATH.\r
+<tt>diff</tt> command installed in PATH.\r
</p>\r
</dd>\r
<dt>\r
blew away. <tt>git-rerere</tt> command helps you to resolve this final\r
conflicted merge using the information from your earlier hand\r
resolve.</p>\r
-<p>Running <tt>git-rerere</tt> command immediately after a conflicted\r
+<p>Running the <tt>git-rerere</tt> command immediately after a conflicted\r
automerge records the conflicted working tree files, with the\r
usual conflict markers <tt><<<<<<<</tt>, <tt>=======</tt>, and <tt>>>>>>>></tt> in\r
them. Later, after you are done resolving the conflicts,\r
up-to-date even before your topic is ready to be sent upstream.\r
This would result in falling back to three-way merge, and it\r
would conflict the same way the test merge you resolved earlier.\r
-<tt>git-rerere</tt> is run by <tt>git rebase</tt> to help you resolve this\r
+<tt>git-rerere</tt> is run by <tt>git-rebase</tt> to help you resolve this\r
conflict.</p>\r
</div>\r
<h2>Author</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:06 UTC\r
+Last updated 02-Jul-2008 03:01:59 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-rerere' [clear|diff|status|gc]
+'git rerere' [clear|diff|status|gc]
DESCRIPTION
-----------
COMMANDS
--------
-Normally, git-rerere is run without arguments or user-intervention.
+Normally, `git-rerere` is run without arguments or user-intervention.
However, it has several commands that allow it to interact with
its working state.
'clear'::
This resets the metadata used by rerere if a merge resolution is to be
-is aborted. Calling linkgit:git-am[1] --skip or linkgit:git-rebase[1]
-[--skip|--abort] will automatically invoke this command.
+is aborted. Calling `git-am --skip` or `git-rebase [--skip|--abort]`
+will automatically invoke this command.
'diff'::
This displays diffs for the current state of the resolution. It is
useful for tracking what has changed while the user is resolving
conflicts. Additional arguments are passed directly to the system
-diff(1) command installed in PATH.
+`diff` command installed in PATH.
'status'::
conflicted merge using the information from your earlier hand
resolve.
-Running `git-rerere` command immediately after a conflicted
+Running the `git-rerere` command immediately after a conflicted
automerge records the conflicted working tree files, with the
usual conflict markers `<<<<<<<`, `=======`, and `>>>>>>>` in
them. Later, after you are done resolving the conflicts,
up-to-date even before your topic is ready to be sent upstream.
This would result in falling back to three-way merge, and it
would conflict the same way the test merge you resolved earlier.
-`git-rerere` is run by `git rebase` to help you resolve this
+`git-rerere` is run by `git-rebase` to help you resolve this
conflict.
<p>\r
Does not touch the index file nor the working tree at all, but\r
requires them to be in a good order. This leaves all your changed\r
- files "Changes to be committed", as <a href="git-status.html">git-status(1)</a> would\r
+ files "Changes to be committed", as <tt>git-status</tt> would\r
put it.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:07 UTC\r
+Last updated 02-Jul-2008 03:01:59 UTC\r
</div>\r
</div>\r
</body>\r
--soft::
Does not touch the index file nor the working tree at all, but
requires them to be in a good order. This leaves all your changed
- files "Changes to be committed", as linkgit:git-status[1] would
+ files "Changes to be committed", as `git-status` would
put it.
--hard::
command:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> $ git-rev-list foo bar ^baz</tt></pre>\r
+<pre><tt> $ git rev-list foo bar ^baz</tt></pre>\r
</div></div>\r
<p>means "list all the commits which are included in <em>foo</em> and <em>bar</em>, but\r
not in <em>baz</em>".</p>\r
the following may be used interchangeably:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> $ git-rev-list origin..HEAD\r
- $ git-rev-list HEAD ^origin</tt></pre>\r
+<pre><tt> $ git rev-list origin..HEAD\r
+ $ git rev-list HEAD ^origin</tt></pre>\r
</div></div>\r
<p>Another special notation is "<em><commit1></em>…<em><commit2></em>" which is useful\r
for merges. The resulting set of commits is the symmetric difference\r
between the two operands. The following two commands are equivalent:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> $ git-rev-list A B --not $(git-merge-base --all A B)\r
- $ git-rev-list A...B</tt></pre>\r
+<pre><tt> $ git rev-list A B --not $(git merge-base --all A B)\r
+ $ git rev-list A...B</tt></pre>\r
</div></div>\r
-<p><a href="git-rev-list.html">git-rev-list(1)</a> is a very essential git program, since it\r
+<p><tt>git-rev-list</tt> is a very essential git program, since it\r
provides the ability to build and traverse commit ancestry graphs. For\r
this reason, it has a lot of different options that enables it to be\r
-used by commands as different as <a href="git-bisect.html">git-bisect(1)</a> and\r
-<a href="git-repack.html">git-repack(1)</a>.</p>\r
+used by commands as different as <tt>git-bisect</tt> and\r
+<tt>git-repack</tt>.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 13-Jun-2008 10:02:43 UTC\r
+Last updated 02-Jul-2008 03:02:00 UTC\r
</div>\r
</div>\r
</body>\r
command:
-----------------------------------------------------------------------
- $ git-rev-list foo bar ^baz
+ $ git rev-list foo bar ^baz
-----------------------------------------------------------------------
means "list all the commits which are included in 'foo' and 'bar', but
the following may be used interchangeably:
-----------------------------------------------------------------------
- $ git-rev-list origin..HEAD
- $ git-rev-list HEAD ^origin
+ $ git rev-list origin..HEAD
+ $ git rev-list HEAD ^origin
-----------------------------------------------------------------------
Another special notation is "'<commit1>'...'<commit2>'" which is useful
between the two operands. The following two commands are equivalent:
-----------------------------------------------------------------------
- $ git-rev-list A B --not $(git-merge-base --all A B)
- $ git-rev-list A...B
+ $ git rev-list A B --not $(git merge-base --all A B)
+ $ git rev-list A...B
-----------------------------------------------------------------------
-linkgit:git-rev-list[1] is a very essential git program, since it
+`git-rev-list` is a very essential git program, since it
provides the ability to build and traverse commit ancestry graphs. For
this reason, it has a lot of different options that enables it to be
-used by commands as different as linkgit:git-bisect[1] and
-linkgit:git-repack[1].
+used by commands as different as `git-bisect` and
+`git-repack`.
OPTIONS
-------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-rev-parse</em> [ --option ] <args>…</p>\r
+<p><em>git rev-parse</em> [ --option ] <args>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Many git porcelainish commands take mixture of flags\r
(i.e. parameters that begin with a dash <em>-</em>) and parameters\r
-meant for underlying <tt>git-rev-list</tt> command they use internally\r
-and flags and parameters for other commands they use as the\r
+meant for the underlying <tt>git-rev-list</tt> command they use internally\r
+and flags and parameters for the other commands they use\r
downstream of <tt>git-rev-list</tt>. This command is used to\r
distinguish between them.</p>\r
</div>\r
</dt>\r
<dd>\r
<p>\r
- Parses the date string, and outputs corresponding\r
- --max-age= parameter for git-rev-list command.\r
+ Parse the date string, and output the corresponding\r
+ --max-age= parameter for <tt>git-rev-list</tt>.\r
</p>\r
</dd>\r
<dt>\r
</dt>\r
<dd>\r
<p>\r
- Parses the date string, and outputs corresponding\r
- --min-age= parameter for git-rev-list command.\r
+ Parse the date string, and output the corresponding\r
+ --min-age= parameter for <tt>git-rev-list</tt>.\r
</p>\r
</dd>\r
<dt>\r
<tt>r2</tt>).</p>\r
<p>A similar notation "<tt>r1...r2</tt>" is called symmetric difference\r
of <tt>r1</tt> and <tt>r2</tt> and is defined as\r
-"<tt>r1 r2 --not $(git-merge-base --all r1 r2)</tt>".\r
+"<tt>r1 r2 --not $(git merge-base --all r1 r2)</tt>".\r
It is the set of commits that are reachable from either one of\r
<tt>r1</tt> or <tt>r2</tt> but not from both.</p>\r
<p>Two other shorthands for naming a set that is formed by a commit\r
An option group Header\r
C? option C with an optional argument"\r
\r
-eval `echo "$OPTS_SPEC" | git-rev-parse --parseopt -- "$@" || echo exit $?`</tt></pre>\r
+eval `echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?`</tt></pre>\r
</div></div>\r
</div>\r
<h2>EXAMPLES</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 30-Jun-2008 09:04:38 UTC\r
+Last updated 02-Jul-2008 03:02:00 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-rev-parse' [ --option ] <args>...
+'git
rev-parse' [ --option ] <args>...
DESCRIPTION
-----------
Many git porcelainish commands take mixture of flags
(i.e. parameters that begin with a dash '-') and parameters
-meant for underlying `git-rev-list` command they use internally
-and flags and parameters for other commands they use as the
+meant for the underlying `git-rev-list` command they use internally
+and flags and parameters for the other commands they use
downstream of `git-rev-list`. This command is used to
distinguish between them.
--since=datestring::
--after=datestring::
- Parses the date string, and outputs corresponding
- --max-age= parameter for git-rev-list command.
+ Parse the date string, and output the corresponding
+ --max-age= parameter for `git-rev-list`.
--until=datestring::
--before=datestring::
- Parses the date string, and outputs corresponding
- --min-age= parameter for git-rev-list command.
+ Parse the date string, and output the corresponding
+ --min-age= parameter for `git-rev-list`.
<args>...::
Flags and parameters to be parsed.
A similar notation "`r1\...r2`" is called symmetric difference
of `r1` and `r2` and is defined as
-"`r1 r2 --not $(git-merge-base --all r1 r2)`".
+"`r1 r2 --not $(git merge-base --all r1 r2)`".
It is the set of commits that are reachable from either one of
`r1` or `r2` but not from both.
An option group Header
C? option C with an optional argument"
-eval `echo "$OPTS_SPEC" | git-rev-parse --parseopt -- "$@" || echo exit $?`
+eval `echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?`
------------
EXAMPLES
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-revert</em> [--edit | --no-edit] [-n] [-m parent-number] [-s] <commit></p>\r
+<p><em>git revert</em> [--edit | --no-edit] [-n] [-m parent-number] [-s] <commit></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:46:58 UTC\r
+Last updated 02-Jul-2008 03:02:00 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-revert' [--edit | --no-edit] [-n] [-m parent-number] [-s] <commit>
+'git revert' [--edit | --no-edit] [-n] [-m parent-number] [-s] <commit>
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-rm</em> [-f] [-n] [-r] [--cached] [--ignore-unmatch] [--quiet] [--] <file>…</p>\r
+<p><em>git rm</em> [-f] [-n] [-r] [--cached] [--ignore-unmatch] [--quiet] [--] <file>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Remove files from the index, or from the working tree and the index.\r
-<tt>git rm</tt> will not remove a file from just your working directory.\r
+<tt>git-rm</tt> will not remove a file from just your working directory.\r
(There is no option to remove a file only from the work tree\r
and yet keep it in the index; use <tt>/bin/rm</tt> if you want to do that.)\r
The files being removed have to be identical to the tip of the branch,\r
</dt>\r
<dd>\r
<p>\r
- git-rm normally outputs one line (in the form of an "rm" command)\r
+ <tt>git-rm</tt> normally outputs one line (in the form of an "rm" command)\r
for each file removed. This option suppresses that output.\r
</p>\r
</dd>\r
<div class="sectionbody">\r
<dl>\r
<dt>\r
-git-rm Documentation/\*.txt\r
+git rm Documentation/\*.txt\r
</dt>\r
<dd>\r
<p>\r
of files and subdirectories under the <tt>Documentation/</tt> directory.</p>\r
</dd>\r
<dt>\r
-git-rm -f git-*.sh\r
+git rm -f git-*.sh\r
</dt>\r
<dd>\r
<p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:00 UTC\r
+Last updated 02-Jul-2008 03:02:01 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-rm' [-f] [-n] [-r] [--cached] [--ignore-unmatch] [--quiet] [--] <file>...
+'git rm' [-f] [-n] [-r] [--cached] [--ignore-unmatch] [--quiet] [--] <file>...
DESCRIPTION
-----------
Remove files from the index, or from the working tree and the index.
-`git rm` will not remove a file from just your working directory.
+`git-rm` will not remove a file from just your working directory.
(There is no option to remove a file only from the work tree
and yet keep it in the index; use `/bin/rm` if you want to do that.)
The files being removed have to be identical to the tip of the branch,
-q::
--quiet::
- git-rm normally outputs one line (in the form of an "rm" command)
+ `git-rm` normally outputs one line (in the form of an "rm" command)
for each file removed. This option suppresses that output.
EXAMPLES
--------
-git-rm Documentation/\\*.txt::
+git rm Documentation/\\*.txt::
Removes all `\*.txt` files from the index that are under the
`Documentation` directory and any of its subdirectories.
+
example; this lets git, and not the shell, expand the pathnames
of files and subdirectories under the `Documentation/` directory.
-git-rm -f git-*.sh::
+git rm -f git-*.sh::
Because this example lets the shell expand the asterisk
(i.e. you are listing the files explicitly), it
does not remove `subdir/git-foo.sh`.
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-send-email</em> [options] <file|directory> [… file|directory]</p>\r
+<p><em>git send-email</em> [options] <file|directory> [… file|directory]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
user is prompted for a password while the input is masked for privacy.</p>\r
</dd>\r
<dt>\r
+--smtp-encryption\r
+</dt>\r
+<dd>\r
+<p>\r
+ Specify the encryption to use, either <em>ssl</em> or <em>tls</em>. Any other\r
+ value reverts to plain SMTP. Default is the value of\r
+ <em>sendemail.smtpencryption</em>.\r
+</p>\r
+</dd>\r
+<dt>\r
--smtp-ssl\r
</dt>\r
<dd>\r
<p>\r
- If set, connects to the SMTP server using SSL.\r
- Default is the value of the <em>sendemail.smtpssl</em> configuration value;\r
- if that is unspecified, does not use SSL.\r
+ Legacy alias for <em>--smtp-encryption=ssl</em>.\r
</p>\r
</dd>\r
<dt>\r
</p>\r
</dd>\r
<dt>\r
+sendemail.smtpencryption\r
+</dt>\r
+<dd>\r
+<p>\r
+ Default encryption method. Use <em>ssl</em> for SSL (and specify an\r
+ appropriate port), or <em>tls</em> for TLS. Takes precedence over\r
+ <em>smtpssl</em> if both are specified.\r
+</p>\r
+</dd>\r
+<dt>\r
sendemail.smtpssl\r
</dt>\r
<dd>\r
<p>\r
- Boolean value specifying the default to the <em>--smtp-ssl</em> parameter.\r
+ Legacy boolean that sets <em>smtpencryption=ssl</em> if enabled.\r
</p>\r
</dd>\r
</dl>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:00 UTC\r
+Last updated 02-Jul-2008 03:02:01 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-send-email' [options] <file|directory> [... file|directory]
+'git send-email' [options] <file|directory> [... file|directory]
specified (with --smtp-pass or a configuration variable), then the
user is prompted for a password while the input is masked for privacy.
+--smtp-encryption::
+ Specify the encryption to use, either 'ssl' or 'tls'. Any other
+ value reverts to plain SMTP. Default is the value of
+ 'sendemail.smtpencryption'.
+
--smtp-ssl::
- If set, connects to the SMTP server using SSL.
- Default is the value of the 'sendemail.smtpssl' configuration value;
- if that is unspecified, does not use SSL.
+ Legacy alias for '--smtp-encryption=ssl'.
--subject::
Specify the initial subject of the email thread.
sendemail.smtppass::
Default SMTP-AUTH password.
+sendemail.smtpencryption::
+ Default encryption method. Use 'ssl' for SSL (and specify an
+ appropriate port), or 'tls' for TLS. Takes precedence over
+ 'smtpssl' if both are specified.
+
sendemail.smtpssl::
- Boolean value specifying the default to the '--smtp-ssl' parameter.
+ Legacy boolean that sets 'smtpencryption=ssl' if enabled.
Author
------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-send-pack</em> [--all] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>…]</p>\r
+<p><em>git send-pack</em> [--all] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>…]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>Usually you would want to use <a href="git-push.html">git-push(1)</a> which is a\r
-higher level wrapper of this command instead.</p>\r
-<p>Invokes <em>git-receive-pack</em> on a possibly remote repository, and\r
+<p>Usually you would want to use <tt>git-push</tt>, which is a\r
+higher-level wrapper of this command, instead. See <a href="git-push.html">git-push(1)</a>.</p>\r
+<p>Invokes <tt>git-receive-pack</tt> on a possibly remote repository, and\r
updates it from the current repository, sending named refs.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
</dt>\r
<dd>\r
<p>\r
- Path to the <em>git-receive-pack</em> program on the remote\r
+ Path to the <tt>git-receive-pack</tt> program on the remote\r
end. Sometimes useful when pushing to a remote\r
repository over ssh, and you do not have the program in\r
a directory on the default $PATH.\r
<dd>\r
<p>\r
A remote host to house the repository. When this\r
- part is specified, <em>git-receive-pack</em> is invoked via\r
+ part is specified, <tt>git-receive-pack</tt> is invoked via\r
ssh.\r
</p>\r
</dd>\r
pushed is determined by finding a match that matches the source\r
side, and where it is pushed is determined by using the\r
destination side. The rules used to match a ref are the same\r
-rules used by <a href="git-rev-parse.html">git-rev-parse(1)</a> to resolve a symbolic ref\r
-name.</p>\r
+rules used by <tt>git-rev-parse</tt> to resolve a symbolic ref\r
+name. See <a href="git-rev-parse.html">git-rev-parse(1)</a>.</p>\r
<ul>\r
<li>\r
<p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:01 UTC\r
+Last updated 02-Jul-2008 03:02:02 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-send-pack' [--all] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]
+'git send-pack' [--all] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]
DESCRIPTION
-----------
-Usually you would want to use linkgit:git-push[1] which is a
-higher level wrapper of this command instead.
+Usually you would want to use `git-push`, which is a
+higher-level wrapper of this command, instead. See linkgit:git-push[1].
-Invokes 'git-receive-pack' on a possibly remote repository, and
+Invokes `git-receive-pack` on a possibly remote repository, and
updates it from the current repository, sending named refs.
OPTIONS
-------
--receive-pack=<git-receive-pack>::
- Path to the 'git-receive-pack' program on the remote
+ Path to the `git-receive-pack` program on the remote
end. Sometimes useful when pushing to a remote
repository over ssh, and you do not have the program in
a directory on the default $PATH.
<host>::
A remote host to house the repository. When this
- part is specified, 'git-receive-pack' is invoked via
+ part is specified, `git-receive-pack` is invoked via
ssh.
<directory>::
pushed is determined by finding a match that matches the source
side, and where it is pushed is determined by using the
destination side. The rules used to match a ref are the same
-rules used by linkgit:git-rev-parse[1] to resolve a symbolic ref
-name.
+rules used by `git-rev-parse` to resolve a symbolic ref
+name. See linkgit:git-rev-parse[1].
- It is an error if <src> does not match exactly one of the
local refs.
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 30-Jun-2008 09:04:39 UTC\r
+Last updated 02-Jul-2008 03:02:03 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-shell</em> -c <command> <argument></p>\r
+<p><em>$(git --exec-path)/git-shell</em> -c <command> <argument></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:11 UTC\r
+Last updated 02-Jul-2008 03:02:02 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-shell' -c <command> <argument>
+'
$(git --exec-path)/git-shell' -c <command> <argument>
DESCRIPTION
-----------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content">git-log --pretty=short | <em>git-shortlog</em> [-h] [-n] [-s] [-e] [-w]\r
-git-shortlog [-n|--numbered] [-s|--summary] [-e|--email] [-w[<width>[,<indent1>[,<indent2>]]]] [<committish>…]</div></div>\r
+<div class="content">git log --pretty=short | <em>git shortlog</em> [-h] [-n] [-s] [-e] [-w]\r
+git shortlog [-n|--numbered] [-s|--summary] [-e|--email] [-w[<width>[,<indent1>[,<indent2>]]]] [<committish>…]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>Summarizes <em>git log</em> output in a format suitable for inclusion\r
+<p>Summarizes <tt>git-log</tt> output in a format suitable for inclusion\r
in release announcements. Each commit will be grouped by author and\r
the first line of the commit message will be shown.</p>\r
<p>Additionally, "[PATCH]" will be stripped from the commit description.</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:01 UTC\r
+Last updated 02-Jul-2008 03:02:02 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-git-log --pretty=short | 'git-shortlog' [-h] [-n] [-s] [-e] [-w]
-git-shortlog [-n|--numbered] [-s|--summary] [-e|--email] [-w[<width>[,<indent1>[,<indent2>]]]] [<committish>...]
+git log --pretty=short | 'git shortlog' [-h] [-n] [-s] [-e] [-w]
+git shortlog [-n|--numbered] [-s|--summary] [-e|--email] [-w[<width>[,<indent1>[,<indent2>]]]] [<committish>...]
DESCRIPTION
-----------
-Summarizes 'git log' output in a format suitable for inclusion
+Summarizes `git-log` output in a format suitable for inclusion
in release announcements. Each commit will be grouped by author and
the first line of the commit message will be shown.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-show-branch</em> [--all] [--remotes] [--topo-order] [--current]\r
+<div class="content"><em>git show-branch</em> [--all] [--remotes] [--topo-order] [--current]\r
[--more=<n> | --list | --independent | --merge-base]\r
[--no-name | --sha1-name] [--topics] [<rev> | <glob>]…\r
-<em>git-show-branch</em> (-g|--reflog)[=<n>[,<base>]] [--list] [<ref>]</div></div>\r
+<em>git show-branch</em> (-g|--reflog)[=<n>[,<base>]] [--list] [<ref>]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</dt>\r
<dd>\r
<p>\r
- Arbitrary extended SHA1 expression (see <tt>git-rev-parse</tt>)\r
+ Arbitrary extended SHA1 expression (see <a href="git-rev-parse.html">git-rev-parse(1)</a>)\r
that typically names a branch HEAD or a tag.\r
</p>\r
</dd>\r
<dd>\r
<p>\r
Instead of showing the commit list, just act like the\r
- <em>git-merge-base -a</em> command, except that it can accept\r
+ <tt>git-merge-base -a</tt> command, except that it can accept\r
more than two heads.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:01 UTC\r
+Last updated 02-Jul-2008 03:02:02 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-show-branch' [--all] [--remotes] [--topo-order] [--current]
+'git show-branch' [--all] [--remotes] [--topo-order] [--current]
[--more=<n> | --list | --independent | --merge-base]
[--no-name | --sha1-name] [--topics] [<rev> | <glob>]...
-'git-show-branch' (-g|--reflog)[=<n>[,<base>]] [--list] [<ref>]
+'git show-branch' (-g|--reflog)[=<n>[,<base>]] [--list] [<ref>]
DESCRIPTION
-----------
OPTIONS
-------
<rev>::
- Arbitrary extended SHA1 expression (see `git-rev-parse`)
+ Arbitrary extended SHA1 expression (see linkgit:git-rev-parse[1])
that typically names a branch HEAD or a tag.
<glob>::
--merge-base::
Instead of showing the commit list, just act like the
- 'git-merge-base -a' command, except that it can accept
+ `git-merge-base -a` command, except that it can accept
more than two heads.
--independent::
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-show-index</em> < idx-file</p>\r
+<p><em>git show-index</em> < idx-file</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Reads given idx file for packed git archive created with\r
-git-pack-objects command, and dumps its contents.</p>\r
+<tt>git-pack-objects</tt> command, and dumps its contents.</p>\r
<p>The information it outputs is subset of what you can get from\r
-<em>git-verify-pack -v</em>; this command only shows the packfile\r
+<tt>git-verify-pack -v</tt>; this command only shows the packfile\r
offset and SHA1 of each object.</p>\r
</div>\r
<h2>Author</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:13 UTC\r
+Last updated 02-Jul-2008 03:02:02 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-show-index' < idx-file
+'git show-index' < idx-file
DESCRIPTION
-----------
Reads given idx file for packed git archive created with
-git-pack-objects command, and dumps its contents.
+`git-pack-objects` command, and dumps its contents.
The information it outputs is subset of what you can get from
-'git-verify-pack -v'; this command only shows the packfile
+`git-verify-pack -v`; this command only shows the packfile
offset and SHA1 of each object.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-show-ref</em> [-q|--quiet] [--verify] [-h|--head] [-d|--dereference]\r
+<div class="content"><em>git show-ref</em> [-q|--quiet] [--verify] [-h|--head] [-d|--dereference]\r
[-s|--hash] [--abbrev] [--tags] [--heads] [--] <pattern>…\r
-<em>git-show-ref</em> --exclude-existing[=pattern]</div></div>\r
+<em>git show-ref</em> --exclude-existing[=pattern]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</dt>\r
<dd>\r
<p>\r
- Make git-show-ref act as a filter that reads refs from stdin of the\r
+ Make <tt>git-show-ref</tt> act as a filter that reads refs from stdin of the\r
form "<sup>(?:<anything>\s)?<refname>(?:\</sup>{})?$" and performs the\r
following actions on each:\r
(1) strip "^{}" at the end of line if any;\r
<pre><tt> git show-ref --verify refs/heads/master</tt></pre>\r
</div></div>\r
<p>will only match the exact branch called "master".</p>\r
-<p>If nothing matches, <a href="git-show-ref.html">git-show-ref(1)</a> will return an error code of 1,\r
+<p>If nothing matches, <tt>git-show-ref</tt> will return an error code of 1,\r
and in the case of verification, it will show an error message.</p>\r
<p>For scripting, you can ask it to be quiet with the "--quiet" flag, which\r
allows you to do things like</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> git-show-ref --quiet --verify -- "refs/heads/$headname" ||\r
+<pre><tt> git show-ref --quiet --verify -- "refs/heads/$headname" ||\r
echo "$headname is not a valid branch"</tt></pre>\r
</div></div>\r
<p>to check whether a particular branch exists or not (notice how we don't\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:01 UTC\r
+Last updated 02-Jul-2008 03:02:03 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-show-ref' [-q|--quiet] [--verify] [-h|--head] [-d|--dereference]
+'git show-ref' [-q|--quiet] [--verify] [-h|--head] [-d|--dereference]
[-s|--hash] [--abbrev] [--tags] [--heads] [--] <pattern>...
-'git-show-ref' --exclude-existing[=pattern]
+'git show-ref' --exclude-existing[=pattern]
DESCRIPTION
-----------
--exclude-existing::
--exclude-existing=pattern::
- Make git-show-ref act as a filter that reads refs from stdin of the
+ Make `git-show-ref` act as a filter that reads refs from stdin of the
form "^(?:<anything>\s)?<refname>(?:\^\{\})?$" and performs the
following actions on each:
(1) strip "^{}" at the end of line if any;
will only match the exact branch called "master".
-If nothing matches, linkgit:git-show-ref[1] will return an error code of 1,
+If nothing matches, `git-show-ref` will return an error code of 1,
and in the case of verification, it will show an error message.
For scripting, you can ask it to be quiet with the "--quiet" flag, which
allows you to do things like
-----------------------------------------------------------------------------
- git-show-ref --quiet --verify -- "refs/heads/$headname" ||
+ git show-ref --quiet --verify -- "refs/heads/$headname" ||
echo "$headname is not a valid branch"
-----------------------------------------------------------------------------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-show</em> [options] <object>…</p>\r
+<p><em>git show</em> [options] <object>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Shows one or more objects (blobs, trees, tags and commits).</p>\r
<p>For commits it shows the log message and textual diff. It also\r
presents the merge commit in a special format as produced by\r
-<em>git-diff-tree --cc</em>.</p>\r
+<tt>git-diff-tree --cc</tt>.</p>\r
<p>For tags, it shows the tag message and the referenced objects.</p>\r
-<p>For trees, it shows the names (equivalent to <a href="git-ls-tree.html">git-ls-tree(1)</a>\r
+<p>For trees, it shows the names (equivalent to <tt>git-ls-tree</tt>\r
with --name-only).</p>\r
<p>For plain blobs, it shows the plain contents.</p>\r
-<p>The command takes options applicable to the <a href="git-diff-tree.html">git-diff-tree(1)</a> command to\r
+<p>The command takes options applicable to the <tt>git-diff-tree</tt> command to\r
control how the changes the commit introduces are shown.</p>\r
<p>This manual page describes only the most frequently used options.</p>\r
</div>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 13-Jun-2008 10:02:43 UTC\r
+Last updated 02-Jul-2008 03:02:03 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-show' [options] <object>...
+'git show' [options] <object>...
DESCRIPTION
-----------
For commits it shows the log message and textual diff. It also
presents the merge commit in a special format as produced by
-'git-diff-tree --cc'.
+`git-diff-tree --cc`.
For tags, it shows the tag message and the referenced objects.
-For trees, it shows the names (equivalent to linkgit:git-ls-tree[1]
+For trees, it shows the names (equivalent to `git-ls-tree`
with \--name-only).
For plain blobs, it shows the plain contents.
-The command takes options applicable to the linkgit:git-diff-tree[1] command to
+The command takes options applicable to the `git-diff-tree` command to
control how the changes the commit introduces are shown.
This manual page describes only the most frequently used options.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-stash</em> (list | show [<stash>] | apply [<stash>] | clear | drop [<stash>] | pop [<stash>])\r
-<em>git-stash</em> [save [<message>]]</div></div>\r
+<div class="content"><em>git stash</em> (list | show [<stash>] | apply [<stash>] | clear | drop [<stash>] | pop [<stash>])\r
+<em>git stash</em> [save [<message>]]</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>Use <em>git-stash</em> when you want to record the current state of the\r
+<p>Use <em>git stash</em> when you want to record the current state of the\r
working directory and the index, but want to go back to a clean\r
working directory. The command saves your local modifications away\r
and reverts the working directory to match the <tt>HEAD</tt> commit.</p>\r
<p>The modifications stashed away by this command can be listed with\r
-<tt>git-stash list</tt>, inspected with <tt>git-stash show</tt>, and restored\r
-(potentially on top of a different commit) with <tt>git-stash apply</tt>.\r
-Calling git-stash without any arguments is equivalent to <tt>git-stash\r
-save</tt>. A stash is by default listed as "WIP on <em>branchname</em> …", but\r
+<tt>git stash list</tt>, inspected with <tt>git stash show</tt>, and restored\r
+(potentially on top of a different commit) with <tt>git stash apply</tt>.\r
+Calling <tt>git stash</tt> without any arguments is equivalent to <tt>git stash save</tt>.\r
+A stash is by default listed as "WIP on <em>branchname</em> …", but\r
you can give a more descriptive message on the command line when\r
you create one.</p>\r
<p>The latest stash you created is stored in <tt>$GIT_DIR/refs/stash</tt>; older\r
</dt>\r
<dd>\r
<p>\r
- Save your local modifications to a new <em>stash</em>, and run <tt>git-reset\r
+ Save your local modifications to a new <em>stash</em>, and run <tt>git reset\r
--hard</tt> to revert them. This is the default action when no\r
subcommand is given. The <message> part is optional and gives\r
the description along with the stashed state.\r
<pre><tt>stash@{0}: WIP on submit: 6ebd0e2... Update git-stash documentation\r
stash@{1}: On master: 9cc0589... Add git-stash</tt></pre>\r
</div></div>\r
-<p>The command takes options applicable to the <a href="git-log.html">git-log(1)</a>\r
-command to control what is shown and how.</p>\r
+<p>The command takes options applicable to the <tt>git-log</tt>\r
+command to control what is shown and how. See <a href="git-log.html">git-log(1)</a>.</p>\r
</dd>\r
<dt>\r
show [<stash>]\r
Show the changes recorded in the stash as a diff between the\r
stashed state and its original parent. When no <tt><stash></tt> is given,\r
shows the latest one. By default, the command shows the diffstat, but\r
- it will accept any format known to <tt>git-diff</tt> (e.g., <tt>git-stash show\r
+ it will accept any format known to <tt>git-diff</tt> (e.g., <tt>git stash show\r
-p stash@{1}</tt> to view the second most recent stash in patch form).\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:16 UTC\r
+Last updated 02-Jul-2008 03:02:03 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-stash' (list | show [<stash>] | apply [<stash>] | clear | drop [<stash>] | pop [<stash>])
-'git-stash' [save [<message>]]
+'git stash' (list | show [<stash>] | apply [<stash>] | clear | drop [<stash>] | pop [<stash>])
+'git stash' [save [<message>]]
DESCRIPTION
-----------
-Use 'git-stash' when you want to record the current state of the
+Use 'git stash' when you want to record the current state of the
working directory and the index, but want to go back to a clean
working directory. The command saves your local modifications away
and reverts the working directory to match the `HEAD` commit.
The modifications stashed away by this command can be listed with
-`git-stash list`, inspected with `git-stash show`, and restored
-(potentially on top of a different commit) with `git-stash apply`.
-Calling git-stash without any arguments is equivalent to `git-stash
-save`. A stash is by default listed as "WIP on 'branchname' ...", but
+`git stash list`, inspected with `git stash show`, and restored
+(potentially on top of a different commit) with `git stash apply`.
+Calling `git stash` without any arguments is equivalent to `git stash save`.
+A stash is by default listed as "WIP on 'branchname' ...", but
you can give a more descriptive message on the command line when
you create one.
save [<message>]::
- Save your local modifications to a new 'stash', and run `git-reset
+ Save your local modifications to a new 'stash', and run `git reset
--hard` to revert them. This is the default action when no
subcommand is given. The <message> part is optional and gives
the description along with the stashed state.
stash@{1}: On master: 9cc0589... Add git-stash
----------------------------------------------------------------
+
-The command takes options applicable to the linkgit:git-log[1]
-command to control what is shown and how.
+The command takes options applicable to the `git-log`
+command to control what is shown and how. See linkgit:git-log[1].
show [<stash>]::
Show the changes recorded in the stash as a diff between the
stashed state and its original parent. When no `<stash>` is given,
shows the latest one. By default, the command shows the diffstat, but
- it will accept any format known to `git-diff` (e.g., `git-stash show
+ it will accept any format known to `git-diff` (e.g., `git stash show
-p stash@\{1}` to view the second most recent stash in patch form).
apply [--index] [<stash>]::
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-status</em> <options>…</p>\r
+<p><em>git status</em> <options>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
tree and the index file, and paths in the working tree that are not\r
tracked by git (and are not ignored by <a href="gitignore.html">gitignore(5)</a>). The first\r
are what you _would_ commit by running <tt>git commit</tt>; the second and\r
-third are what you _could_ commit by running <tt>git add</tt> before running\r
+third are what you _could_ commit by running <tt>git-add</tt> before running\r
<tt>git commit</tt>.</p>\r
<p>The command takes the same set of options as <tt>git-commit</tt>; it\r
shows what would be committed if the same options are given to\r
<tt>git-commit</tt>.</p>\r
<p>If there is no path that is different between the index file and\r
the current HEAD commit (i.e., there is nothing to commit by running\r
-<tt>git-commit</tt>), the command exits with non-zero status.</p>\r
+<tt>git commit</tt>), the command exits with non-zero status.</p>\r
</div>\r
<h2>OUTPUT</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:16 UTC\r
+Last updated 02-Jul-2008 03:02:04 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-status' <options>...
+'git status' <options>...
DESCRIPTION
-----------
tree and the index file, and paths in the working tree that are not
tracked by git (and are not ignored by linkgit:gitignore[5]). The first
are what you _would_ commit by running `git commit`; the second and
-third are what you _could_ commit by running `git add` before running
+third are what you _could_ commit by running `git-add` before running
`git commit`.
The command takes the same set of options as `git-commit`; it
If there is no path that is different between the index file and
the current HEAD commit (i.e., there is nothing to commit by running
-`git-commit`), the command exits with non-zero status.
+`git commit`), the command exits with non-zero status.
OUTPUT
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-stripspace</em> [-s | --strip-comments] < <stream></p>\r
+<p><em>git stripspace</em> [-s | --strip-comments] < <stream></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:02 UTC\r
+Last updated 02-Jul-2008 03:02:04 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-stripspace' [-s | --strip-comments] < <stream>
+'git stripspace' [-s | --strip-comments] < <stream>
DESCRIPTION
-----------
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-submodule</em> [--quiet] add [-b branch] [--] <repository> [<path>]\r
-<em>git-submodule</em> [--quiet] status [--cached] [--] [<path>…]\r
-<em>git-submodule</em> [--quiet] init [--] [<path>…]\r
-<em>git-submodule</em> [--quiet] update [--init] [--] [<path>…]\r
-<em>git-submodule</em> [--quiet] summary [--summary-limit <n>] [commit] [--] [<path>…]</div></div>\r
+<div class="content"><em>git submodule</em> [--quiet] add [-b branch] [--] <repository> [<path>]\r
+<em>git submodule</em> [--quiet] status [--cached] [--] [<path>…]\r
+<em>git submodule</em> [--quiet] init [--] [<path>…]\r
+<em>git submodule</em> [--quiet] update [--init] [--] [<path>…]\r
+<em>git submodule</em> [--quiet] summary [--summary-limit <n>] [commit] [--] [<path>…]</div></div>\r
</div>\r
<h2>COMMANDS</h2>\r
<div class="sectionbody">\r
<p>\r
Show the status of the submodules. This will print the SHA-1 of the\r
currently checked out commit for each submodule, along with the\r
- submodule path and the output of <a href="git-describe.html">git-describe(1)</a> for the\r
+ submodule path and the output of <tt>git-describe</tt> for the\r
SHA-1. Each SHA-1 will be prefixed with <tt>-</tt> if the submodule is not\r
initialized and <tt>+</tt> if the currently checked out submodule commit\r
does not match the SHA-1 found in the index of the containing\r
- repository. This command is the default command for git-submodule.\r
+ repository. This command is the default command for <tt>git-submodule</tt>.\r
</p>\r
</dd>\r
<dt>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:02 UTC\r
+Last updated 02-Jul-2008 03:02:04 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git
-submodule' [--quiet] add [-b branch] [--] <repository> [<path>]
-'git
-submodule' [--quiet] status [--cached] [--] [<path>...]
-'git
-submodule' [--quiet] init [--] [<path>...]
-'git
-submodule' [--quiet] update [--init] [--] [<path>...]
-'git
-submodule' [--quiet] summary [--summary-limit <n>] [commit] [--] [<path>...]
+'git
submodule' [--quiet] add [-b branch] [--] <repository> [<path>]
+'git
submodule' [--quiet] status [--cached] [--] [<path>...]
+'git
submodule' [--quiet] init [--] [<path>...]
+'git
submodule' [--quiet] update [--init] [--] [<path>...]
+'git
submodule' [--quiet] summary [--summary-limit <n>] [commit] [--] [<path>...]
COMMANDS
status::
Show the status of the submodules. This will print the SHA-1 of the
currently checked out commit for each submodule, along with the
- submodule path and the output of linkgit:git-describe[1] for the
+ submodule path and the output of `git-describe` for the
SHA-1. Each SHA-1 will be prefixed with `-` if the submodule is not
initialized and `+` if the currently checked out submodule commit
does not match the SHA-1 found in the index of the containing
- repository. This command is the default command for git-submodule.
+ repository. This command is the default command for `git-submodule`.
init::
Initialize the submodules, i.e. register in .git/config each submodule
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-svn</em> <command> [options] [arguments]</p>\r
+<p><em>git svn</em> <command> [options] [arguments]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>git-svn is a simple conduit for changesets between Subversion and git.\r
+<p><tt>git-svn</tt> is a simple conduit for changesets between Subversion and git.\r
It is not to be confused with <a href="git-svnimport.html">git-svnimport(1)</a>, which is\r
read-only.</p>\r
-<p>git-svn was originally designed for an individual developer who wants a\r
+<p><tt>git-svn</tt> was originally designed for an individual developer who wants a\r
bidirectional flow of changesets between a single branch in Subversion\r
and an arbitrary number of branches in git. Since its inception,\r
-git-svn has gained the ability to track multiple branches in a manner\r
-similar to git-svnimport.</p>\r
-<p>git-svn is especially useful when it comes to tracking repositories\r
+<tt>git-svn</tt> has gained the ability to track multiple branches in a manner\r
+similar to <tt>git-svnimport</tt>.</p>\r
+<p><tt>git-svn</tt> is especially useful when it comes to tracking repositories\r
not organized in the way Subversion developers recommend (trunk,\r
branches, tags directories).</p>\r
</div>\r
<dd>\r
<p>\r
Initializes an empty git repository with additional\r
- metadata directories for git-svn. The Subversion URL\r
+ metadata directories for <tt>git-svn</tt>. The Subversion URL\r
may be specified as a command-line argument, or as full\r
URL arguments to -T/-t/-b. Optionally, the target\r
directory to operate on can be specified as a second\r
This fetches revisions from the SVN parent of the current HEAD\r
and rebases the current (uncommitted to SVN) work against it.\r
</p>\r
-<p>This works similarly to <em>svn update</em> or <em>git-pull</em> except that\r
-it preserves linear history with <em>git-rebase</em> instead of\r
-<em>git-merge</em> for ease of dcommiting with git-svn.</p>\r
-<p>This accepts all options that <em>git-svn fetch</em> and <em>git-rebase</em>\r
-accepts. However <em>--fetch-all</em> only fetches from the current\r
+<p>This works similarly to <tt>svn update</tt> or <tt>git-pull</tt> except that\r
+it preserves linear history with <tt>git-rebase</tt> instead of\r
+<tt>git-merge</tt> for ease of dcommiting with <tt>git-svn</tt>.</p>\r
+<p>This accepts all options that <tt>git-svn fetch</tt> and <tt>git-rebase</tt>\r
+accept. However, <em>--fetch-all</em> only fetches from the current\r
[svn-remote], and not all [svn-remote] definitions.</p>\r
-<p>Like <em>git-rebase</em>; this requires that the working tree be clean\r
+<p>Like <tt>git-rebase</tt>; this requires that the working tree be clean\r
and have no uncommitted changes.</p>\r
<dl>\r
<dt>\r
</dt>\r
<dd>\r
<p>\r
- Do not fetch remotely; only run <em>git-rebase</em> against the\r
+ Do not fetch remotely; only run <tt>git-rebase</tt> against the\r
last fetched commit from the upstream SVN.\r
</p>\r
</dd>\r
repository, and then rebase or reset (depending on whether or\r
not there is a diff between SVN and head). This will create\r
a revision in SVN for each commit in git.\r
- It is recommended that you run git-svn fetch and rebase (not\r
+ It is recommended that you run <tt>git-svn</tt> fetch and rebase (not\r
pull or merge) your commits against the latest changes in the\r
SVN repository.\r
An optional command-line argument may be specified as an\r
environment). This command has the same behaviour.</td>\r
</tr></table>\r
</div>\r
-<p>Any other arguments are passed directly to `git log'</p>\r
+<p>Any other arguments are passed directly to <tt>git-log</tt></p>\r
</dd>\r
<dt>\r
<em>blame</em>\r
<p>\r
Show what revision and author last modified each line of a file. The\r
output of this mode is format-compatible with the output of\r
- `svn blame' by default. Like the SVN blame command,\r
+ <tt>svn blame' by default. Like the SVN blame command,\r
local uncommitted changes in the working copy are ignored;\r
the version of the file in the HEAD revision is annotated. Unknown\r
- arguments are passed directly to git-blame.\r
+ arguments are passed directly to `git-blame</tt>.\r
</p>\r
<dl>\r
<dt>\r
</dt>\r
<dd>\r
<p>\r
- Produce output in the same format as `git blame', but with\r
+ Produce output in the same format as <tt>git-blame</tt>, but with\r
SVN revision numbers instead of git commit hashes. In this mode,\r
changes that haven't been committed to SVN (including local\r
working-copy edits) are shown as revision 0.\r
absolutely no attempts to do patching when committing to SVN, it\r
simply overwrites files with those specified in the tree or\r
commit. All merging is assumed to have taken place\r
- independently of git-svn functions.\r
+ independently of <tt>git-svn</tt> functions.\r
</p>\r
</dd>\r
<dt>\r
<p>\r
Commits the diff of two tree-ish arguments from the\r
command-line. This command is intended for interoperability with\r
- git-svnimport and does not rely on being inside an git-svn\r
- init-ed repository. This command takes three arguments, (a) the\r
+ <tt>git-svnimport</tt> and does not rely on being inside an <tt>git-svn\r
+ init</tt>-ed repository. This command takes three arguments, (a) the\r
original tree to diff against, (b) the new tree result, (c) the\r
URL of the target Subversion repository. The final argument\r
- (URL) may be omitted if you are working from a git-svn-aware\r
- repository (that has been init-ed with git-svn).\r
+ (URL) may be omitted if you are working from a <tt>git-svn</tt>-aware\r
+ repository (that has been <tt>init</tt>-ed with <tt>git-svn</tt>).\r
The -r<revision> option is required for this.\r
</p>\r
</dd>\r
<dd>\r
<p>\r
Only used with the <em>init</em> command.\r
- These are passed directly to <a href="git-init.html">git-init(1)</a>.\r
+ These are passed directly to <tt>git-init</tt>.\r
</p>\r
</dd>\r
<dt>\r
</p>\r
<p>Read a list of commits from stdin and commit them in reverse\r
order. Only the leading sha1 is read from each line, so\r
-git-rev-list --pretty=oneline output can be used.</p>\r
+<tt>git-rev-list --pretty=oneline</tt> output can be used.</p>\r
</dd>\r
<dt>\r
--rmdir\r
<p>\r
Only used with the <em>dcommit</em>, <em>set-tree</em> and <em>commit-diff</em> commands.\r
</p>\r
-<p>They are both passed directly to git-diff-tree see\r
+<p>They are both passed directly to <tt>git-diff-tree</tt>; see\r
<a href="git-diff-tree.html">git-diff-tree(1)</a> for more information.</p>\r
<div class="verseblock">\r
<div class="content">config key: svn.l\r
</dt>\r
<dd>\r
<p>\r
-Syntax is compatible with the files used by git-svnimport and\r
-git-cvsimport:\r
+Syntax is compatible with the files used by <tt>git-svnimport</tt> and\r
+<tt>git-cvsimport</tt>:\r
</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt> loginname = Joe User <user@example.com></tt></pre>\r
</div></div>\r
-<p>If this option is specified and git-svn encounters an SVN\r
-committer name that does not exist in the authors-file, git-svn\r
+<p>If this option is specified and <tt>git-svn</tt> encounters an SVN\r
+committer name that does not exist in the authors-file, <tt>git-svn</tt>\r
will abort operation. The user will then have to add the\r
-appropriate entry. Re-running the previous git-svn command\r
+appropriate entry. Re-running the previous <tt>git-svn</tt> command\r
after the authors-file is modified should continue operation.</p>\r
<p>config key: svn.authorsfile</p>\r
</dd>\r
</dt>\r
<dd>\r
<p>\r
- Make git-svn less verbose.\r
+ Make <tt>git-svn</tt> less verbose.\r
</p>\r
</dd>\r
<dt>\r
<p>--repack takes an optional argument for the number of revisions\r
to fetch before repacking. This defaults to repacking every\r
1000 commits fetched if no argument is specified.</p>\r
-<p>--repack-flags are passed directly to <a href="git-repack.html">git-repack(1)</a>.</p>\r
+<p>--repack-flags are passed directly to <tt>git-repack</tt>.</p>\r
<div class="verseblock">\r
<div class="content">config key: svn.repack\r
config key: svn.repackflags</div></div>\r
<p>\r
These are only used with the <em>dcommit</em> and <em>rebase</em> commands.\r
</p>\r
-<p>Passed directly to git-rebase when using <em>dcommit</em> if a\r
-<em>git-reset</em> cannot be used (see dcommit).</p>\r
+<p>Passed directly to <tt>git-rebase</tt> when using <em>dcommit</em> if a\r
+<tt>git-reset</tt> cannot be used (see <em>dcommit</em>).</p>\r
</dd>\r
<dt>\r
-n\r
</dt>\r
<dd>\r
<p>\r
-This gets rid of the git-svn-id: lines at the end of every commit.\r
+This gets rid of the <em>git-svn-id:</em> lines at the end of every commit.\r
</p>\r
-<p>If you lose your .git/svn/git-svn/.rev_db file, git-svn will not\r
+<p>If you lose your .git/svn/git-svn/.rev_db file, <tt>git-svn</tt> will not\r
be able to rebuild it and you won't be able to fetch again,\r
either. This is fine for one-shot imports.</p>\r
-<p>The <em>git-svn log</em> command will not work on repositories using\r
+<p>The <tt>git-svn log</tt> command will not work on repositories using\r
this, either. Using this conflicts with the <em>useSvmProps</em>\r
option for (hopefully) obvious reasons.</p>\r
</dd>\r
</dt>\r
<dd>\r
<p>\r
-This allows git-svn to re-map repository URLs and UUIDs from\r
+This allows <tt>git-svn</tt> to re-map repository URLs and UUIDs from\r
mirrors created using SVN::Mirror (or svk) for metadata.\r
</p>\r
<p>If an SVN revision has a property, "svm:headrev", it is likely\r
<dd>\r
<p>\r
This allows users to create repositories from alternate\r
- URLs. For example, an administrator could run git-svn on the\r
+ URLs. For example, an administrator could run <tt>git-svn</tt> on the\r
server locally (accessing via file://) but wish to distribute\r
the repository with a public http:// or svn:// URL in the\r
metadata so users of it will see the public URL.\r
</dd>\r
</dl>\r
<p>Since the noMetadata, rewriteRoot, useSvnsyncProps and useSvmProps\r
-options all affect the metadata generated and used by git-svn; they\r
+options all affect the metadata generated and used by <tt>git-svn</tt>; they\r
<strong>must</strong> be set in the configuration file before any history is imported\r
and these settings should never be changed once they are set.</p>\r
<p>Additionally, only one of these four options can be used per-svn-remote\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt># Clone a repo (like git clone):\r
- git-svn clone http://svn.foo.org/project/trunk\r
+ git svn clone http://svn.foo.org/project/trunk\r
# Enter the newly cloned directory:\r
cd trunk\r
# You should be on master branch, double-check with git-branch\r
git commit ...\r
# Something is committed to SVN, rebase your local changes against the\r
# latest changes in SVN:\r
- git-svn rebase\r
+ git svn rebase\r
# Now commit your changes (that were committed previously using git) to SVN,\r
# as well as automatically updating your working HEAD:\r
- git-svn dcommit\r
+ git svn dcommit\r
# Append svn:ignore settings to the default git exclude file:\r
- git-svn show-ignore >> .git/info/exclude</tt></pre>\r
+ git svn show-ignore >> .git/info/exclude</tt></pre>\r
</div></div>\r
<p>Tracking and contributing to an entire Subversion-managed project\r
(complete with a trunk, tags and branches):</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt># Clone a repo (like git clone):\r
- git-svn clone http://svn.foo.org/project -T trunk -b branches -t tags\r
+ git svn clone http://svn.foo.org/project -T trunk -b branches -t tags\r
# View all branches and tags you have cloned:\r
git branch -r\r
# Reset your master to trunk (or any other branch, replacing 'trunk'\r
# You may only dcommit to one branch/tag/trunk at a time. The usage\r
# of dcommit/rebase/show-ignore should be the same as above.</tt></pre>\r
</div></div>\r
-<p>The initial <em>git-svn clone</em> can be quite time-consuming\r
+<p>The initial <tt>git-svn clone</tt> can be quite time-consuming\r
(especially for large Subversion repositories). If multiple\r
people (or one person with multiple machines) want to use\r
-git-svn to interact with the same Subversion repository, you can\r
-do the initial <em>git-svn clone</em> to a repository on a server and\r
-have each person clone that repository with <em>git clone</em>:</p>\r
+<tt>git-svn</tt> to interact with the same Subversion repository, you can\r
+do the initial <tt>git-svn clone</tt> to a repository on a server and\r
+have each person clone that repository with <tt>git-clone</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt># Do the initial import on a server\r
- ssh server "cd /pub && git-svn clone http://svn.foo.org/project\r
+ ssh server "cd /pub && git svn clone http://svn.foo.org/project\r
# Clone locally - make sure the refs/remotes/ space matches the server\r
mkdir project\r
cd project\r
- git-init\r
+ git init\r
git remote add origin server:/pub/project\r
git config --add remote.origin.fetch '+refs/remotes/*:refs/remotes/*'\r
git fetch\r
# Initialize git-svn locally (be sure to use the same URL and -T/-b/-t options as were used on server)\r
- git-svn init http://svn.foo.org/project\r
+ git svn init http://svn.foo.org/project\r
# Pull the latest changes from Subversion\r
- git-svn rebase</tt></pre>\r
+ git svn rebase</tt></pre>\r
</div></div>\r
</div>\r
<h2>REBASE VS. PULL/MERGE</h2>\r
<div class="sectionbody">\r
-<p>Originally, git-svn recommended that the remotes/git-svn branch be\r
+<p>Originally, <tt>git-svn</tt> recommended that the <em>remotes/git-svn</em> branch be\r
pulled or merged from. This is because the author favored\r
-<em>git-svn set-tree B</em> to commit a single head rather than the\r
-<em>git-svn set-tree A..B</em> notation to commit multiple commits.</p>\r
-<p>If you use <em>git-svn set-tree A..B</em> to commit several diffs and you do\r
+<tt>git svn set-tree B</tt> to commit a single head rather than the\r
+<tt>git svn set-tree A..B</tt> notation to commit multiple commits.</p>\r
+<p>If you use <tt>git svn set-tree A..B</tt> to commit several diffs and you do\r
not have the latest remotes/git-svn merged into my-branch, you should\r
-use <em>git-svn rebase</em> to update your work branch instead of <em>git pull</em> or\r
-<em>git merge</em>. <em>pull/merge</em> can cause non-linear history to be flattened\r
+use <tt>git svn rebase</tt> to update your work branch instead of <tt>git pull</tt> or\r
+<tt>git merge</tt>. <tt>pull</tt>/`merge' can cause non-linear history to be flattened\r
when committing into SVN, which can lead to merge commits reversing\r
previous commits in SVN.</p>\r
</div>\r
<h2>DESIGN PHILOSOPHY</h2>\r
<div class="sectionbody">\r
<p>Merge tracking in Subversion is lacking and doing branched development\r
-with Subversion can be cumbersome as a result. While git-svn can track\r
+with Subversion can be cumbersome as a result. While <tt>git-svn</tt> can track\r
copy history (including branches and tags) for repositories adopting a\r
standard layout, it cannot yet represent merge history that happened\r
inside git back upstream to SVN users. Therefore it is advised that\r
<h2>CAVEATS</h2>\r
<div class="sectionbody">\r
<p>For the sake of simplicity and interoperating with a less-capable system\r
-(SVN), it is recommended that all git-svn users clone, fetch and dcommit\r
-directly from the SVN server, and avoid all git-clone/pull/merge/push\r
+(SVN), it is recommended that all <tt>git-svn</tt> users clone, fetch and dcommit\r
+directly from the SVN server, and avoid all <tt>git-clone</tt>/<tt>pull</tt>/<tt>merge</tt>/<tt>push</tt>\r
operations between git repositories and branches. The recommended\r
method of exchanging code between git branches and users is\r
-git-format-patch and git-am, or just dcommiting to the SVN repository.</p>\r
-<p>Running <em>git-merge</em> or <em>git-pull</em> is NOT recommended on a branch you\r
-plan to dcommit from. Subversion does not represent merges in any\r
+<tt>git-format-patch</tt> and <tt>git-am</tt>, or just 'dcommit'ing to the SVN repository.</p>\r
+<p>Running <tt>git-merge</tt> or <tt>git-pull</tt> is NOT recommended on a branch you\r
+plan to <em>dcommit</em> from. Subversion does not represent merges in any\r
reasonable or useful fashion; so users using Subversion cannot see any\r
merges you've made. Furthermore, if you merge or pull from a git branch\r
-that is a mirror of an SVN branch, dcommit may commit to the wrong\r
+that is a mirror of an SVN branch, <em>dcommit</em> may commit to the wrong\r
branch.</p>\r
-<p><em>git-clone</em> does not clone branches under the refs/remotes/ hierarchy or\r
-any git-svn metadata, or config. So repositories created and managed with\r
-using git-svn should use rsync(1) for cloning, if cloning is to be done\r
+<p><tt>git-clone</tt> does not clone branches under the refs/remotes/ hierarchy or\r
+any <tt>git-svn</tt> metadata, or config. So repositories created and managed with\r
+using <tt>git-svn</tt> should use <tt>rsync</tt> for cloning, if cloning is to be done\r
at all.</p>\r
-<p>Since <em>dcommit</em> uses rebase internally, any git branches you git-push to\r
-before dcommit on will require forcing an overwrite of the existing ref\r
+<p>Since <em>dcommit</em> uses rebase internally, any git branches you <tt>git-push</tt> to\r
+before <em>dcommit</em> on will require forcing an overwrite of the existing ref\r
on the remote repository. This is generally considered bad practice,\r
-see the git-push(1) documentation for details.</p>\r
-<p>Do not use the --amend option of git-commit(1) on a change you've\r
+see the <a href="git-push.html">git-push(1)</a> documentation for details.</p>\r
+<p>Do not use the --amend option of <a href="git-commit.html">git-commit(1)</a> on a change you've\r
already dcommitted. It is considered bad practice to --amend commits\r
you've already pushed to a remote repository for other users, and\r
dcommit with SVN is analogous to that.</p>\r
</div>\r
<h2>CONFIGURATION</h2>\r
<div class="sectionbody">\r
-<p>git-svn stores [svn-remote] configuration information in the\r
+<p><tt>git-svn</tt> stores [svn-remote] configuration information in the\r
repository .git/config file. It is similar the core git\r
[remote] sections except <em>fetch</em> keys do not accept glob\r
arguments; but they are instead handled by the <em>branches</em>\r
however the remote wildcard may be anywhere as long as it's own\r
independent path component (surrounded by <em>/</em> or EOL). This\r
type of configuration is not automatically created by <em>init</em> and\r
-should be manually entered with a text-editor or using\r
-<a href="git-config.html">git-config(1)</a></p>\r
+should be manually entered with a text-editor or using <tt>git-config</tt>.</p>\r
</div>\r
<h2>SEE ALSO</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 29-Jun-2008 08:48:21 UTC\r
+Last updated 02-Jul-2008 03:02:04 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-svn' <command> [options] [arguments]
+'git svn' <command> [options] [arguments]
DESCRIPTION
-----------
-git-svn is a simple conduit for changesets between Subversion and git.
+`git-svn` is a simple conduit for changesets between Subversion and git.
It is not to be confused with linkgit:git-svnimport[1], which is
read-only.
-git-svn was originally designed for an individual developer who wants a
+`git-svn` was originally designed for an individual developer who wants a
bidirectional flow of changesets between a single branch in Subversion
and an arbitrary number of branches in git. Since its inception,
-git-svn has gained the ability to track multiple branches in a manner
-similar to git-svnimport.
+`git-svn` has gained the ability to track multiple branches in a manner
+similar to `git-svnimport`.
-git-svn is especially useful when it comes to tracking repositories
+`git-svn` is especially useful when it comes to tracking repositories
not organized in the way Subversion developers recommend (trunk,
branches, tags directories).
'init'::
Initializes an empty git repository with additional
- metadata directories for git-svn. The Subversion URL
+ metadata directories for `git-svn`. The Subversion URL
may be specified as a command-line argument, or as full
URL arguments to -T/-t/-b. Optionally, the target
directory to operate on can be specified as a second
This fetches revisions from the SVN parent of the current HEAD
and rebases the current (uncommitted to SVN) work against it.
-This works similarly to 'svn update' or 'git-pull' except that
-it preserves linear history with 'git-rebase' instead of
-'git-merge' for ease of dcommiting with git-svn.
+This works similarly to `svn update` or `git-pull` except that
+it preserves linear history with `git-rebase` instead of
+`git-merge` for ease of dcommiting with `git-svn`.
-This accepts all options that 'git-svn fetch' and 'git-rebase'
-accepts. However '--fetch-all' only fetches from the current
+This accepts all options that `git-svn fetch` and `git-rebase`
+accept. However, '--fetch-all' only fetches from the current
[svn-remote], and not all [svn-remote] definitions.
-Like 'git-rebase'; this requires that the working tree be clean
+Like `git-rebase`; this requires that the working tree be clean
and have no uncommitted changes.
-l;;
--local;;
- Do not fetch remotely; only run 'git-rebase' against the
+ Do not fetch remotely; only run `git-rebase` against the
last fetched commit from the upstream SVN.
'dcommit'::
repository, and then rebase or reset (depending on whether or
not there is a diff between SVN and head). This will create
a revision in SVN for each commit in git.
- It is recommended that you run git-svn fetch and rebase (not
+ It is recommended that you run `git-svn` fetch and rebase (not
pull or merge) your commits against the latest changes in the
SVN repository.
An optional command-line argument may be specified as an
client converts the UTC time to the local time (or based on the TZ=
environment). This command has the same behaviour.
+
-Any other arguments are passed directly to `git log'
+Any other arguments are passed directly to `git-log`
'blame'::
Show what revision and author last modified each line of a file. The
`svn blame' by default. Like the SVN blame command,
local uncommitted changes in the working copy are ignored;
the version of the file in the HEAD revision is annotated. Unknown
- arguments are passed directly to git-blame.
+ arguments are passed directly to `git-blame`.
+
--git-format;;
- Produce output in the same format as `git blame', but with
+ Produce output in the same format as `git-blame`, but with
SVN revision numbers instead of git commit hashes. In this mode,
changes that haven't been committed to SVN (including local
working-copy edits) are shown as revision 0.
absolutely no attempts to do patching when committing to SVN, it
simply overwrites files with those specified in the tree or
commit. All merging is assumed to have taken place
- independently of git-svn functions.
+ independently of `git-svn` functions.
'create-ignore'::
Recursively finds the svn:ignore property on directories and
'commit-diff'::
Commits the diff of two tree-ish arguments from the
command-line. This command is intended for interoperability with
- git-svnimport and does not rely on being inside an git-svn
- init-ed repository. This command takes three arguments, (a) the
+ `git-svnimport` and does not rely on being inside an `git-svn
+ init`-ed repository. This command takes three arguments, (a) the
original tree to diff against, (b) the new tree result, (c) the
URL of the target Subversion repository. The final argument
- (URL) may be omitted if you are working from a git-svn-aware
- repository (that has been init-ed with git-svn).
+ (URL) may be omitted if you are working from a `git-svn`-aware
+ repository (that has been `init`-ed with `git-svn`).
The -r<revision> option is required for this.
'info'::
--shared[={false|true|umask|group|all|world|everybody}]::
--template=<template_directory>::
Only used with the 'init' command.
- These are passed directly to linkgit:git-init[1].
+ These are passed directly to `git-init`.
-r <ARG>::
--revision <ARG>::
Read a list of commits from stdin and commit them in reverse
order. Only the leading sha1 is read from each line, so
-git-rev-list --pretty=oneline output can be used.
+`git-rev-list --pretty=oneline` output can be used.
--rmdir::
Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands.
-They are both passed directly to git-diff-tree see
+They are both passed directly to `git-diff-tree`; see
linkgit:git-diff-tree[1] for more information.
[verse]
-A<filename>::
--authors-file=<filename>::
-Syntax is compatible with the files used by git-svnimport and
-git-cvsimport:
+Syntax is compatible with the files used by `git-svnimport` and
+`git-cvsimport`:
------------------------------------------------------------------------
loginname = Joe User <user@example.com>
------------------------------------------------------------------------
-If this option is specified and git-svn encounters an SVN
-committer name that does not exist in the authors-file, git-svn
+If this option is specified and `git-svn` encounters an SVN
+committer name that does not exist in the authors-file, `git-svn`
will abort operation. The user will then have to add the
-appropriate entry. Re-running the previous git-svn command
+appropriate entry. Re-running the previous `git-svn` command
after the authors-file is modified should continue operation.
config key: svn.authorsfile
-q::
--quiet::
- Make git-svn less verbose.
+ Make `git-svn` less verbose.
--repack[=<n>]::
--repack-flags=<flags>::
to fetch before repacking. This defaults to repacking every
1000 commits fetched if no argument is specified.
---repack-flags are passed directly to linkgit:git-repack[1].
+--repack-flags are passed directly to `git-repack`.
[verse]
config key: svn.repack
These are only used with the 'dcommit' and 'rebase' commands.
-Passed directly to git-rebase when using 'dcommit' if a
-'git-reset' cannot be used (see dcommit).
+Passed directly to `git-rebase` when using 'dcommit' if a
+`git-reset` cannot be used (see 'dcommit').
-n::
--dry-run::
svn.noMetadata::
svn-remote.<name>.noMetadata::
-This gets rid of the git-svn-id: lines at the end of every commit.
+This gets rid of the 'git-svn-id:' lines at the end of every commit.
-If you lose your .git/svn/git-svn/.rev_db file, git-svn will not
+If you lose your .git/svn/git-svn/.rev_db file, `git-svn` will not
be able to rebuild it and you won't be able to fetch again,
either. This is fine for one-shot imports.
-The 'git-svn log' command will not work on repositories using
+The `git-svn log` command will not work on repositories using
this, either. Using this conflicts with the 'useSvmProps'
option for (hopefully) obvious reasons.
svn.useSvmProps::
svn-remote.<name>.useSvmProps::
-This allows git-svn to re-map repository URLs and UUIDs from
+This allows `git-svn` to re-map repository URLs and UUIDs from
mirrors created using SVN::Mirror (or svk) for metadata.
If an SVN revision has a property, "svm:headrev", it is likely
svn-remote.<name>.rewriteRoot::
This allows users to create repositories from alternate
- URLs. For example, an administrator could run git-svn on the
+ URLs. For example, an administrator could run `git-svn` on the
server locally (accessing via file://) but wish to distribute
the repository with a public http:// or svn:// URL in the
metadata so users of it will see the public URL.
--
Since the noMetadata, rewriteRoot, useSvnsyncProps and useSvmProps
-options all affect the metadata generated and used by git-svn; they
+options all affect the metadata generated and used by `git-svn`; they
*must* be set in the configuration file before any history is imported
and these settings should never be changed once they are set.
------------------------------------------------------------------------
# Clone a repo (like git clone):
- git-svn clone http://svn.foo.org/project/trunk
+ git svn clone http://svn.foo.org/project/trunk
# Enter the newly cloned directory:
cd trunk
# You should be on master branch, double-check with git-branch
git commit ...
# Something is committed to SVN, rebase your local changes against the
# latest changes in SVN:
- git-svn rebase
+ git svn rebase
# Now commit your changes (that were committed previously using git) to SVN,
# as well as automatically updating your working HEAD:
- git-svn dcommit
+ git svn dcommit
# Append svn:ignore settings to the default git exclude file:
- git-svn show-ignore >> .git/info/exclude
+ git svn show-ignore >> .git/info/exclude
------------------------------------------------------------------------
Tracking and contributing to an entire Subversion-managed project
------------------------------------------------------------------------
# Clone a repo (like git clone):
- git-svn clone http://svn.foo.org/project -T trunk -b branches -t tags
+ git svn clone http://svn.foo.org/project -T trunk -b branches -t tags
# View all branches and tags you have cloned:
git branch -r
# Reset your master to trunk (or any other branch, replacing 'trunk'
# of dcommit/rebase/show-ignore should be the same as above.
------------------------------------------------------------------------
-The initial 'git-svn clone' can be quite time-consuming
+The initial `git-svn clone` can be quite time-consuming
(especially for large Subversion repositories). If multiple
people (or one person with multiple machines) want to use
-git-svn to interact with the same Subversion repository, you can
-do the initial 'git-svn clone' to a repository on a server and
-have each person clone that repository with 'git clone':
+`git-svn` to interact with the same Subversion repository, you can
+do the initial `git-svn clone` to a repository on a server and
+have each person clone that repository with `git-clone`:
------------------------------------------------------------------------
# Do the initial import on a server
- ssh server "cd /pub && git-svn clone http://svn.foo.org/project
+ ssh server "cd /pub && git svn clone http://svn.foo.org/project
# Clone locally - make sure the refs/remotes/ space matches the server
mkdir project
cd project
- git-init
+ git init
git remote add origin server:/pub/project
git config --add remote.origin.fetch '+refs/remotes/*:refs/remotes/*'
git fetch
# Initialize git-svn locally (be sure to use the same URL and -T/-b/-t options as were used on server)
- git-svn init http://svn.foo.org/project
+ git svn init http://svn.foo.org/project
# Pull the latest changes from Subversion
- git-svn rebase
+ git svn rebase
------------------------------------------------------------------------
REBASE VS. PULL/MERGE
---------------------
-Originally, git-svn recommended that the remotes/git-svn branch be
+Originally, `git-svn` recommended that the 'remotes/git-svn' branch be
pulled or merged from. This is because the author favored
-'git-svn set-tree B' to commit a single head rather than the
-'git-svn set-tree A..B' notation to commit multiple commits.
+`git svn set-tree B` to commit a single head rather than the
+`git svn set-tree A..B` notation to commit multiple commits.
-If you use 'git-svn set-tree A..B' to commit several diffs and you do
+If you use `git svn set-tree A..B` to commit several diffs and you do
not have the latest remotes/git-svn merged into my-branch, you should
-use 'git-svn rebase' to update your work branch instead of 'git pull' or
-'git merge'. 'pull/merge' can cause non-linear history to be flattened
+use `git svn rebase` to update your work branch instead of `git pull` or
+`git merge`. `pull`/`merge' can cause non-linear history to be flattened
when committing into SVN, which can lead to merge commits reversing
previous commits in SVN.
DESIGN PHILOSOPHY
-----------------
Merge tracking in Subversion is lacking and doing branched development
-with Subversion can be cumbersome as a result. While git-svn can track
+with Subversion can be cumbersome as a result. While `git-svn` can track
copy history (including branches and tags) for repositories adopting a
standard layout, it cannot yet represent merge history that happened
inside git back upstream to SVN users. Therefore it is advised that
-------
For the sake of simplicity and interoperating with a less-capable system
-(SVN), it is recommended that all git-svn users clone, fetch and dcommit
-directly from the SVN server, and avoid all git-clone/pull/merge/push
+(SVN), it is recommended that all `git-svn` users clone, fetch and dcommit
+directly from the SVN server, and avoid all `git-clone`/`pull`/`merge`/`push`
operations between git repositories and branches. The recommended
method of exchanging code between git branches and users is
-git-format-patch and git-am, or just dcommiting to the SVN repository.
+`git-format-patch` and `git-am`, or just 'dcommit'ing to the SVN repository.
-Running 'git-merge' or 'git-pull' is NOT recommended on a branch you
-plan to dcommit from. Subversion does not represent merges in any
+Running `git-merge` or `git-pull` is NOT recommended on a branch you
+plan to 'dcommit' from. Subversion does not represent merges in any
reasonable or useful fashion; so users using Subversion cannot see any
merges you've made. Furthermore, if you merge or pull from a git branch
-that is a mirror of an SVN branch, dcommit may commit to the wrong
+that is a mirror of an SVN branch, 'dcommit' may commit to the wrong
branch.
-'git-clone' does not clone branches under the refs/remotes/ hierarchy or
-any git-svn metadata, or config. So repositories created and managed with
-using git-svn should use rsync(1) for cloning, if cloning is to be done
+`git-clone` does not clone branches under the refs/remotes/ hierarchy or
+any `git-svn` metadata, or config. So repositories created and managed with
+using `git-svn` should use `rsync` for cloning, if cloning is to be done
at all.
-Since 'dcommit' uses rebase internally, any git branches you git-push to
-before dcommit on will require forcing an overwrite of the existing ref
+Since 'dcommit' uses rebase internally, any git branches you `git-push` to
+before 'dcommit' on will require forcing an overwrite of the existing ref
on the remote repository. This is generally considered bad practice,
-see the git-push(1) documentation for details.
+see the linkgit:git-push[1] documentation for details.
-Do not use the --amend option of git-commit(1) on a change you've
+Do not use the --amend option of linkgit:git-commit[1] on a change you've
already dcommitted. It is considered bad practice to --amend commits
you've already pushed to a remote repository for other users, and
dcommit with SVN is analogous to that.
CONFIGURATION
-------------
-git-svn stores [svn-remote] configuration information in the
+`git-svn` stores [svn-remote] configuration information in the
repository .git/config file. It is similar the core git
[remote] sections except 'fetch' keys do not accept glob
arguments; but they are instead handled by the 'branches'
however the remote wildcard may be anywhere as long as it's own
independent path component (surrounded by '/' or EOL). This
type of configuration is not automatically created by 'init' and
-should be manually entered with a text-editor or using
-linkgit:git-config[1]
+should be manually entered with a text-editor or using `git-config`.
SEE ALSO
--------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-symbolic-ref</em> [-q] [-m <reason>] <name> [<ref>]</p>\r
+<p><em>git symbolic-ref</em> [-q] [-m <reason>] <name> [<ref>]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
cumbersome. On some platforms, <tt>ln -sf</tt> does not even work as\r
advertised (horrors). Therefore symbolic links are now deprecated\r
and symbolic refs are used by default.</p>\r
-<p>git-symbolic-ref will exit with status 0 if the contents of the\r
+<p><tt>git-symbolic-ref</tt> will exit with status 0 if the contents of the\r
symbolic ref were printed correctly, with status 1 if the requested\r
name is not a symbolic ref, or 128 if another error occurs.</p>\r
</div>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:02 UTC\r
+Last updated 02-Jul-2008 03:02:04 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-symbolic-ref' [-q] [-m <reason>] <name> [<ref>]
+'git symbolic-ref' [-q] [-m <reason>] <name> [<ref>]
DESCRIPTION
-----------
advertised (horrors). Therefore symbolic links are now deprecated
and symbolic refs are used by default.
-git-symbolic-ref will exit with status 0 if the contents of the
+`git-symbolic-ref` will exit with status 0 if the contents of the
symbolic ref were printed correctly, with status 1 if the requested
name is not a symbolic ref, or 128 if another error occurs.
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-tag</em> [-a | -s | -u <key-id>] [-f] [-m <msg> | -F <file>] <name> [<head>]\r
-<em>git-tag</em> -d <name>…\r
-<em>git-tag</em> [-n[<num>]] -l [<pattern>]\r
-<em>git-tag</em> -v <name>…</div></div>\r
+<div class="content"><em>git tag</em> [-a | -s | -u <key-id>] [-f] [-m <msg> | -F <file>] <name> [<head>]\r
+<em>git tag</em> -d <name>…\r
+<em>git tag</em> [-n[<num>]] -l [<pattern>]\r
+<em>git tag</em> -v <name>…</div></div>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<h2>CONFIGURATION</h2>\r
<div class="sectionbody">\r
-<p>By default, git-tag in sign-with-default mode (-s) will use your\r
+<p>By default, <tt>git-tag</tt> in sign-with-default mode (-s) will use your\r
committer identity (of the form "Your Name <your@email.address>") to\r
find a key. If you want to use a different default key, you can specify\r
it in the repository configuration as follows:</p>\r
<p>\r
The insane thing.\r
You really want to call the new version "X" too, <em>even though</em>\r
-others have already seen the old one. So just use "git tag -f"\r
+others have already seen the old one. So just use <tt>git-tag -f</tt>\r
again, as if you hadn't already published the old one.\r
</p>\r
</li>\r
</ol>\r
<p>However, Git does <strong>not</strong> (and it should not) change tags behind\r
-users back. So if somebody already got the old tag, doing a "git\r
-pull" on your tree shouldn't just make them overwrite the old\r
+users back. So if somebody already got the old tag, doing a\r
+<tt>git-pull</tt> on your tree shouldn't just make them overwrite the old\r
one.</p>\r
<p>If somebody got a release tag from you, you cannot just change\r
the tag for them by updating your own one. This is a big\r
private anchor point tags from the other person.</p>\r
<p>You would notice "please pull" messages on the mailing list says\r
repo URL and branch name alone. This is designed to be easily\r
-cut&pasted to "git fetch" command line:</p>\r
+cut&pasted to a <tt>git-fetch</tt> command line:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>Linus, please pull from\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:18 UTC\r
+Last updated 02-Jul-2008 03:02:05 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-tag' [-a | -s | -u <key-id>] [-f] [-m <msg> | -F <file>] <name> [<head>]
-'git-tag' -d <name>...
-'git
-tag' [-n[<num>]] -l [<pattern>]
-'git-tag' -v <name>...
+'git tag' [-a | -s | -u <key-id>] [-f] [-m <msg> | -F <file>] <name> [<head>]
+'git tag' -d <name>...
+'git
tag' [-n[<num>]] -l [<pattern>]
+'git tag' -v <name>...
DESCRIPTION
-----------
CONFIGURATION
-------------
-By default, git-tag in sign-with-default mode (-s) will use your
+By default, `git-tag` in sign-with-default mode (-s) will use your
committer identity (of the form "Your Name <your@email.address>") to
find a key. If you want to use a different default key, you can specify
it in the repository configuration as follows:
. The insane thing.
You really want to call the new version "X" too, 'even though'
-others have already seen the old one. So just use "git tag -f"
+others have already seen the old one. So just use `git-tag -f`
again, as if you hadn't already published the old one.
However, Git does *not* (and it should not) change tags behind
-users back. So if somebody already got the old tag, doing a "git
-pull" on your tree shouldn't just make them overwrite the old
+users back. So if somebody already got the old tag, doing a
+`git-pull` on your tree shouldn't just make them overwrite the old
one.
If somebody got a release tag from you, you cannot just change
You would notice "please pull" messages on the mailing list says
repo URL and branch name alone. This is designed to be easily
-cut&pasted to "git fetch" command line:
+cut&pasted to a `git-fetch` command line:
------------
Linus, please pull from
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-tar-tree</em> [--remote=<repo>] <tree-ish> [ <base> ]</p>\r
+<p><em>git tar-tree</em> [--remote=<repo>] <tree-ish> [ <base> ]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Creates a tar archive containing the tree structure for the named tree.\r
When <base> is specified it is added as a leading path to the files in the\r
generated tar archive.</p>\r
-<p>git-tar-tree behaves differently when given a tree ID versus when given\r
+<p><tt>git-tar-tree</tt> behaves differently when given a tree ID versus when given\r
a commit ID or tag ID. In the first case the current time is used as\r
modification time of each file in the archive. In the latter case the\r
commit time as recorded in the referenced commit object is used instead.\r
Additionally the commit ID is stored in a global extended pax header.\r
-It can be extracted using git-get-tar-commit-id.</p>\r
+It can be extracted using <tt>git-get-tar-commit-id</tt>.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:20 UTC\r
+Last updated 02-Jul-2008 03:02:05 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-tar-tree' [--remote=<repo>] <tree-ish> [ <base> ]
+'git tar-tree' [--remote=<repo>] <tree-ish> [ <base> ]
DESCRIPTION
-----------
When <base> is specified it is added as a leading path to the files in the
generated tar archive.
-git-tar-tree behaves differently when given a tree ID versus when given
+`git-tar-tree` behaves differently when given a tree ID versus when given
a commit ID or tag ID. In the first case the current time is used as
modification time of each file in the archive. In the latter case the
commit time as recorded in the referenced commit object is used instead.
Additionally the commit ID is stored in a global extended pax header.
-It can be extracted using git-get-tar-commit-id.
+It can be extracted using `git-get-tar-commit-id`.
OPTIONS
-------
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:36 UTC\r
+Last updated 02-Jul-2008 03:02:15 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-unpack-file</em> <blob></p>\r
+<p><em>git unpack-file</em> <blob></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:20 UTC\r
+Last updated 02-Jul-2008 03:02:05 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-unpack-file' <blob>
+'git unpack-file' <blob>
DESCRIPTION
-----------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-unpack-objects</em> [-n] [-q] [-r] [--strict] <pack-file</p>\r
+<p><em>git unpack-objects</em> [-n] [-q] [-r] [--strict] <pack-file</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Objects that already exist in the repository will <strong>not</strong> be unpacked\r
from the pack-file. Therefore, nothing will be unpacked if you use\r
this command on a pack-file that exists within the target repository.</p>\r
-<p>Please see the <tt>git-repack</tt> documentation for options to generate\r
+<p>See <a href="git-repack.html">git-repack(1)</a> for options to generate\r
new packs and replace existing ones.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:20 UTC\r
+Last updated 02-Jul-2008 03:02:06 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-unpack-objects' [-n] [-q] [-r] [--strict] <pack-file
+'git
unpack-objects' [-n] [-q] [-r] [--strict] <pack-file
DESCRIPTION
from the pack-file. Therefore, nothing will be unpacked if you use
this command on a pack-file that exists within the target repository.
-Please see the `git-repack` documentation for options to generate
+See linkgit:git-repack[1] for options to generate
new packs and replace existing ones.
OPTIONS
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
<div class="verseblock">\r
-<div class="content"><em>git-update-index</em>\r
+<div class="content"><em>git update-index</em>\r
[--add] [--remove | --force-remove] [--replace]\r
[--refresh] [-q] [--unmerged] [--ignore-missing]\r
[--cacheinfo <mode> <object> <file>]*\r
cleared.</p>\r
<p>See also <a href="git-add.html">git-add(1)</a> for a more user-friendly way to do some of\r
the most common operations on the index.</p>\r
-<p>The way "git-update-index" handles files it is told about can be modified\r
+<p>The way <tt>git-update-index</tt> handles files it is told about can be modified\r
using the various options:</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<p>\r
Quiet. If --refresh finds that the index needs an update, the\r
default behavior is to error out. This option makes\r
- git-update-index continue anyway.\r
+ <tt>git-update-index</tt> continue anyway.\r
</p>\r
</dd>\r
</dl>\r
<dd>\r
<p>\r
If --refresh finds unmerged changes in the index, the default\r
- behavior is to error out. This option makes git-update-index\r
+ behavior is to error out. This option makes <tt>git-update-index</tt>\r
continue anyway.\r
</p>\r
</dd>\r
<dd>\r
<p>\r
By default, when a file <tt>path</tt> exists in the index,\r
- git-update-index refuses an attempt to add <tt>path/file</tt>.\r
+ <tt>git-update-index</tt> refuses an attempt to add <tt>path/file</tt>.\r
Similarly if a file <tt>path/file</tt> exists, a file <tt>path</tt>\r
cannot be added. With --replace flag, existing entries\r
that conflicts with the entry being added are\r
"re-match" the stat information of a file with the index, so that you\r
can refresh the index for a file that hasn't been changed but where\r
the stat entry is out of date.</p>\r
-<p>For example, you'd want to do this after doing a "git-read-tree", to link\r
+<p>For example, you'd want to do this after doing a <tt>git-read-tree</tt>, to link\r
up the stat index details with the proper files.</p>\r
</div>\r
<h2>Using --cacheinfo or --info-only</h2>\r
<p>To pretend you have a file with mode and sha1 at path, say:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-update-index --cacheinfo mode sha1 path</tt></pre>\r
+<pre><tt>$ git update-index --cacheinfo mode sha1 path</tt></pre>\r
</div></div>\r
<p><em>--info-only</em> is used to register files without placing them in the object\r
database. This is useful for status-only repositories.</p>\r
<p>\r
mode SP type SP sha1 TAB path\r
</p>\r
-<p>The second format is to stuff git-ls-tree output\r
+<p>The second format is to stuff <tt>git-ls-tree</tt> output\r
into the index file.</p>\r
</li>\r
<li>\r
mode SP sha1 SP stage TAB path\r
</p>\r
<p>This format is to put higher order stages into the\r
-index file and matches git-ls-files --stage output.</p>\r
+index file and matches <tt>git-ls-files --stage</tt> output.</p>\r
</li>\r
</ol>\r
<p>To place a higher stage entry to the index, the path should\r
<p>In order to set "assume unchanged" bit, use <tt>--assume-unchanged</tt>\r
option. To unset, use <tt>--no-assume-unchanged</tt>.</p>\r
<p>The command looks at <tt>core.ignorestat</tt> configuration variable. When\r
-this is true, paths updated with <tt>git-update-index paths…</tt> and\r
+this is true, paths updated with <tt>git update-index paths…</tt> and\r
paths updated with other git commands that update both index and\r
working tree (e.g. <tt>git-apply --index</tt>, <tt>git-checkout-index -u</tt>,\r
and <tt>git-read-tree -u</tt>) are automatically marked as "assume\r
unchanged". Note that "assume unchanged" bit is <strong>not</strong> set if\r
-<tt>git-update-index --refresh</tt> finds the working tree file matches\r
-the index (use <tt>git-update-index --really-refresh</tt> if you want\r
+<tt>git update-index --refresh</tt> finds the working tree file matches\r
+the index (use <tt>git update-index --really-refresh</tt> if you want\r
to mark them as "assume unchanged").</p>\r
</div>\r
<h2>Examples</h2>\r
<p>To update and refresh only the files already checked out:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-checkout-index -n -f -a && git-update-index --ignore-missing --refresh</tt></pre>\r
+<pre><tt>$ git checkout-index -n -f -a && git update-index --ignore-missing --refresh</tt></pre>\r
</div></div>\r
<dl>\r
<dt>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:03 UTC\r
+Last updated 02-Jul-2008 03:02:06 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
[verse]
-'git-update-index'
+'git update-index'
[--add] [--remove | --force-remove] [--replace]
[--refresh] [-q] [--unmerged] [--ignore-missing]
[--cacheinfo <mode> <object> <file>]\*
See also linkgit:git-add[1] for a more user-friendly way to do some of
the most common operations on the index.
-The way "git-update-index" handles files it is told about can be modified
+The way `git-update-index` handles files it is told about can be modified
using the various options:
OPTIONS
-q::
Quiet. If --refresh finds that the index needs an update, the
default behavior is to error out. This option makes
- git-update-index continue anyway.
+ `git-update-index` continue anyway.
--ignore-submodules:
Do not try to update submodules. This option is only respected
--unmerged::
If --refresh finds unmerged changes in the index, the default
- behavior is to error out. This option makes git-update-index
+ behavior is to error out. This option makes `git-update-index`
continue anyway.
--ignore-missing::
--replace::
By default, when a file `path` exists in the index,
- git-update-index refuses an attempt to add `path/file`.
+ `git-update-index` refuses an attempt to add `path/file`.
Similarly if a file `path/file` exists, a file `path`
cannot be added. With --replace flag, existing entries
that conflicts with the entry being added are
can refresh the index for a file that hasn't been changed but where
the stat entry is out of date.
-For example, you'd want to do this after doing a "git-read-tree", to link
+For example, you'd want to do this after doing a `git-read-tree`, to link
up the stat index details with the proper files.
Using --cacheinfo or --info-only
To pretend you have a file with mode and sha1 at path, say:
----------------
-$ git-update-index --cacheinfo mode sha1 path
+$ git update-index --cacheinfo mode sha1 path
----------------
'--info-only' is used to register files without placing them in the object
. mode SP type SP sha1 TAB path
+
-The second format is to stuff git-ls-tree output
+The second format is to stuff `git-ls-tree` output
into the index file.
. mode SP sha1 SP stage TAB path
+
This format is to put higher order stages into the
-index file and matches git-ls-files --stage output.
+index file and matches `git-ls-files --stage` output.
To place a higher stage entry to the index, the path should
first be removed by feeding a mode=0 entry for the path, and
option. To unset, use `--no-assume-unchanged`.
The command looks at `core.ignorestat` configuration variable. When
-this is true, paths updated with `git-update-index paths...` and
+this is true, paths updated with `git update-index paths...` and
paths updated with other git commands that update both index and
working tree (e.g. `git-apply --index`, `git-checkout-index -u`,
and `git-read-tree -u`) are automatically marked as "assume
unchanged". Note that "assume unchanged" bit is *not* set if
-`git-update-index --refresh` finds the working tree file matches
-the index (use `git-update-index --really-refresh` if you want
+`git update-index --refresh` finds the working tree file matches
+the index (use `git update-index --really-refresh` if you want
to mark them as "assume unchanged").
To update and refresh only the files already checked out:
----------------
-$ git-checkout-index -n -f -a && git-update-index --ignore-missing --refresh
+$ git checkout-index -n -f -a && git update-index --ignore-missing --refresh
----------------
On an inefficient filesystem with `core.ignorestat` set::
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-update-ref</em> [-m <reason>] (-d <ref> [<oldvalue>] | [--no-deref] <ref> <newvalue> [<oldvalue>])</p>\r
+<p><em>git update-ref</em> [-m <reason>] (-d <ref> [<oldvalue>] | [--no-deref] <ref> <newvalue> [<oldvalue>])</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Given two arguments, stores the <newvalue> in the <ref>, possibly\r
-dereferencing the symbolic refs. E.g. <tt>git-update-ref HEAD\r
+dereferencing the symbolic refs. E.g. <tt>git update-ref HEAD\r
<newvalue></tt> updates the current branch head to the new object.</p>\r
<p>Given three arguments, stores the <newvalue> in the <ref>,\r
possibly dereferencing the symbolic refs, after verifying that\r
the current value of the <ref> matches <oldvalue>.\r
-E.g. <tt>git-update-ref refs/heads/master <newvalue> <oldvalue></tt>\r
+E.g. <tt>git update-ref refs/heads/master <newvalue> <oldvalue></tt>\r
updates the master branch head to <newvalue> only if its current\r
value is <oldvalue>. You can specify 40 "0" or an empty string\r
as <oldvalue> to make sure that the ref you are creating does\r
<p>In general, using</p>\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>git-update-ref HEAD "$head"</tt></pre>\r
+<pre><tt>git update-ref HEAD "$head"</tt></pre>\r
</div></div>\r
<p>should be a _lot_ safer than doing</p>\r
<div class="literalblock">\r
<h2>Logging Updates</h2>\r
<div class="sectionbody">\r
<p>If config parameter "core.logAllRefUpdates" is true or the file\r
-"$GIT_DIR/logs/<ref>" exists then <tt>git-update-ref</tt> will append\r
+"$GIT_DIR/logs/<ref>" exists then <tt>git update-ref</tt> will append\r
a line to the log file "$GIT_DIR/logs/<ref>" (dereferencing all\r
symbolic refs before creating the log name) describing the change\r
in ref value. Log lines are formatted as:</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 23-Jun-2008 07:13:36 UTC\r
+Last updated 02-Jul-2008 03:02:06 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-update-ref' [-m <reason>] (-d <ref> [<oldvalue>] | [--no-deref] <ref> <newvalue> [<oldvalue>])
+'git
update-ref' [-m <reason>] (-d <ref> [<oldvalue>] | [--no-deref] <ref> <newvalue> [<oldvalue>])
DESCRIPTION
-----------
Given two arguments, stores the <newvalue> in the <ref>, possibly
-dereferencing the symbolic refs. E.g. `git-update-ref HEAD
+dereferencing the symbolic refs. E.g. `git update-ref HEAD
<newvalue>` updates the current branch head to the new object.
Given three arguments, stores the <newvalue> in the <ref>,
possibly dereferencing the symbolic refs, after verifying that
the current value of the <ref> matches <oldvalue>.
-E.g. `git
-update-ref refs/heads/master <newvalue> <oldvalue>`
+E.g. `git
update-ref refs/heads/master <newvalue> <oldvalue>`
updates the master branch head to <newvalue> only if its current
value is <oldvalue>. You can specify 40 "0" or an empty string
as <oldvalue> to make sure that the ref you are creating does
In general, using
- git-update-ref HEAD "$head"
+ git update-ref HEAD "$head"
should be a _lot_ safer than doing
Logging Updates
---------------
If config parameter "core.logAllRefUpdates" is true or the file
-"$GIT_DIR/logs/<ref>" exists then `git-update-ref` will append
+"$GIT_DIR/logs/<ref>" exists then `git update-ref` will append
a line to the log file "$GIT_DIR/logs/<ref>" (dereferencing all
symbolic refs before creating the log name) describing the change
in ref value. Log lines are formatted as:
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-update-server-info</em> [--force]</p>\r
+<p><em>git update-server-info</em> [--force]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<h2>OUTPUT</h2>\r
<div class="sectionbody">\r
<p>Currently the command updates the following files. Please see\r
-<a href="gitrepository-layout.html">gitrepository-layout(5)</a>[repository-layout] for description of\r
+<a href="gitrepository-layout.html">gitrepository-layout(5)</a> for description of\r
what they are for:</p>\r
<ul>\r
<li>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:03 UTC\r
+Last updated 02-Jul-2008 03:02:06 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-update-server-info' [--force]
+'git update-server-info' [--force]
DESCRIPTION
-----------
------
Currently the command updates the following files. Please see
-linkgit:gitrepository-layout[5][repository-layout] for description of
+linkgit:gitrepository-layout[5] for description of
what they are for:
* objects/info/packs
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-upload-archive</em> <directory></p>\r
+<p><em>git upload-archive</em> <directory></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Invoked by <em>git-archive --remote</em> and sends a generated archive to the\r
other end over the git protocol.</p>\r
<p>This command is usually not invoked directly by the end user. The UI\r
-for the protocol is on the <em>git-archive</em> side, and the program pair\r
+for the protocol is on the <tt>git-archive</tt> side, and the program pair\r
is meant to be used to get an archive from a remote repository.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:22 UTC\r
+Last updated 02-Jul-2008 03:02:07 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-upload-archive' <directory>
+'git upload-archive' <directory>
DESCRIPTION
-----------
other end over the git protocol.
This command is usually not invoked directly by the end user. The UI
-for the protocol is on the 'git-archive' side, and the program pair
+for the protocol is on the `git-archive` side, and the program pair
is meant to be used to get an archive from a remote repository.
OPTIONS
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-upload-pack</em> [--strict] [--timeout=<n>] <directory></p>\r
+<p><em>git upload-pack</em> [--strict] [--timeout=<n>] <directory></p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>Invoked by <em>git-fetch-pack</em>, learns what\r
+<p>Invoked by <tt>git-fetch-pack</tt>, learns what\r
objects the other side is missing, and sends them after packing.</p>\r
<p>This command is usually not invoked directly by the end user.\r
-The UI for the protocol is on the <em>git-fetch-pack</em> side, and the\r
+The UI for the protocol is on the <tt>git-fetch-pack</tt> side, and the\r
program pair is meant to be used to pull updates from a remote\r
-repository. For push operations, see <em>git-send-pack</em>.</p>\r
+repository. For push operations, see <tt>git-send-pack</tt>.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:04 UTC\r
+Last updated 02-Jul-2008 03:02:07 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-upload-pack' [--strict] [--timeout=<n>] <directory>
+'git upload-pack' [--strict] [--timeout=<n>] <directory>
DESCRIPTION
-----------
-Invoked by 'git-fetch-pack', learns what
+Invoked by `git-fetch-pack`, learns what
objects the other side is missing, and sends them after packing.
This command is usually not invoked directly by the end user.
-The UI for the protocol is on the 'git-fetch-pack' side, and the
+The UI for the protocol is on the `git-fetch-pack` side, and the
program pair is meant to be used to pull updates from a remote
-repository. For push operations, see 'git-send-pack'.
+repository. For push operations, see `git-send-pack`.
OPTIONS
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-var</em> [ -l | <variable> ]</p>\r
+<p><em>git var</em> [ -l | <variable> ]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<div class="sectionbody">\r
<div class="literalblock">\r
<div class="content">\r
-<pre><tt>$ git-var GIT_AUTHOR_IDENT\r
+<pre><tt>$ git var GIT_AUTHOR_IDENT\r
Eric W. Biederman <ebiederm@lnxi.com> 1121223278 -0600</tt></pre>\r
</div></div>\r
</div>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:22 UTC\r
+Last updated 02-Jul-2008 03:02:07 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-var' [ -l | <variable> ]
+'git var' [ -l | <variable> ]
DESCRIPTION
-----------
EXAMPLE
--------
- $ git-var GIT_AUTHOR_IDENT
+ $ git var GIT_AUTHOR_IDENT
Eric W. Biederman <ebiederm@lnxi.com> 1121223278 -0600
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-verify-pack</em> [-v] [--] <pack>.idx …</p>\r
+<p><em>git verify-pack</em> [-v] [--] <pack>.idx …</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>Reads given idx file for packed git archive created with\r
-git-pack-objects command and verifies idx file and the\r
+<p>Reads given idx file for packed git archive created with the\r
+<tt>git-pack-objects</tt> command and verifies idx file and the\r
corresponding pack file.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:23 UTC\r
+Last updated 02-Jul-2008 03:02:07 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-verify-pack' [-v] [--] <pack>.idx ...
+'git
verify-pack' [-v] [--] <pack>.idx ...
DESCRIPTION
-----------
-Reads given idx file for packed git archive created with
-git-pack-objects command and verifies idx file and the
+Reads given idx file for packed git archive created with the
+`git-pack-objects` command and verifies idx file and the
corresponding pack file.
OPTIONS
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-verify-tag</em> <tag>…</p>\r
+<p><em>git verify-tag</em> <tag>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>Validates the gpg signature created by git-tag.</p>\r
+<p>Validates the gpg signature created by <tt>git-tag</tt>.</p>\r
</div>\r
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:23 UTC\r
+Last updated 02-Jul-2008 03:02:07 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-verify-tag' <tag>...
+'git verify-tag' <tag>...
DESCRIPTION
-----------
-Validates the gpg signature created by git-tag.
+Validates the gpg signature created by `git-tag`.
OPTIONS
-------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-web--browse</em> [OPTIONS] URL/FILE …</p>\r
+<p><em>git web--browse</em> [OPTIONS] URL/FILE …</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>You can explicitly provide a full path to your preferred browser by\r
setting the configuration variable <em>browser.<tool>.path</em>. For example,\r
you can configure the absolute path to firefox by setting\r
-<em>browser.firefox.path</em>. Otherwise, <em>git-web--browse</em> assumes the tool\r
+<em>browser.firefox.path</em>. Otherwise, <tt>git-web--browse</tt> assumes the tool\r
is available in PATH.</p>\r
<h3>browser.<tool>.cmd</h3>\r
<p>When the browser, specified by options or configuration variables, is\r
not among the supported ones, then the corresponding\r
<em>browser.<tool>.cmd</em> configuration variable will be looked up. If this\r
-variable exists then "git web--browse" will treat the specified tool\r
+variable exists then <tt>git-web--browse</tt> will treat the specified tool\r
as a custom command and will use a shell eval to run the command with\r
the URLs passed as arguments.</p>\r
</div>\r
[browser "konq"]\r
cmd = A_PATH_TO/konqueror</tt></pre>\r
</div></div>\r
-<h3>Note about git config --global</h3>\r
+<h3>Note about git-config --global</h3>\r
<p>Note that these configuration variables should probably be set using\r
the <em>--global</em> flag, for example like this:</p>\r
<div class="listingblock">\r
<h2>Author</h2>\r
<div class="sectionbody">\r
<p>Written by Christian Couder <chriscool@tuxfamily.org> and the git-list\r
-<git@vger.kernel.org>, based on git-mergetool by Theodore Y. Ts'o.</p>\r
+<git@vger.kernel.org>, based on <tt>git-mergetool</tt> by Theodore Y. Ts'o.</p>\r
</div>\r
<h2>Documentation</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:04 UTC\r
+Last updated 02-Jul-2008 03:02:08 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-web--browse' [OPTIONS] URL/FILE ...
+'git web--browse' [OPTIONS] URL/FILE ...
DESCRIPTION
-----------
You can explicitly provide a full path to your preferred browser by
setting the configuration variable 'browser.<tool>.path'. For example,
you can configure the absolute path to firefox by setting
-'browser.firefox.path'. Otherwise, 'git-web--browse' assumes the tool
+'browser.firefox.path'. Otherwise, `git-web--browse` assumes the tool
is available in PATH.
browser.<tool>.cmd
When the browser, specified by options or configuration variables, is
not among the supported ones, then the corresponding
'browser.<tool>.cmd' configuration variable will be looked up. If this
-variable exists then "git web--browse" will treat the specified tool
+variable exists then `git-web--browse` will treat the specified tool
as a custom command and will use a shell eval to run the command with
the URLs passed as arguments.
cmd = A_PATH_TO/konqueror
------------------------------------------------
-Note about git config --global
+Note about git-config --global
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Note that these configuration variables should probably be set using
Author
------
Written by Christian Couder <chriscool@tuxfamily.org> and the git-list
-<git@vger.kernel.org>, based on git-mergetool by Theodore Y. Ts'o.
+<git@vger.kernel.org>, based on `git-mergetool` by Theodore Y. Ts'o.
Documentation
-------------
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-whatchanged</em> <option>…</p>\r
+<p><em>git whatchanged</em> <option>…</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
<p>Shows commit logs and diff output each commit introduces. The\r
-command internally invokes <em>git-rev-list</em> piped to\r
-<em>git-diff-tree</em>, and takes command line options for both of\r
+command internally invokes <tt>git-rev-list</tt> piped to\r
+<tt>git-diff-tree</tt>, and takes command line options for both of\r
these commands.</p>\r
<p>This manual page describes only the most frequently used options.</p>\r
</div>\r
<div class="sectionbody">\r
<dl>\r
<dt>\r
-git-whatchanged -p v2.6.12.. include/scsi drivers/scsi\r
+git whatchanged -p v2.6.12.. include/scsi drivers/scsi\r
</dt>\r
<dd>\r
<p>\r
</p>\r
</dd>\r
<dt>\r
-git-whatchanged --since="2 weeks ago" -- gitk\r
+git whatchanged --since="2 weeks ago" -- gitk\r
</dt>\r
<dd>\r
<p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 13-Jun-2008 10:02:45 UTC\r
+Last updated 02-Jul-2008 03:02:08 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git-whatchanged' <option>...
+'git whatchanged' <option>...
DESCRIPTION
-----------
Shows commit logs and diff output each commit introduces. The
-command internally invokes 'git-rev-list' piped to
-'git-diff-tree', and takes command line options for both of
+command internally invokes `git-rev-list` piped to
+`git-diff-tree`, and takes command line options for both of
these commands.
This manual page describes only the most frequently used options.
Examples
--------
-git-whatchanged -p v2.6.12.. include/scsi drivers/scsi::
+git whatchanged -p v2.6.12.. include/scsi drivers/scsi::
Show as patches the commits since version 'v2.6.12' that changed
any file in the include/scsi or drivers/scsi subdirectories
-git-whatchanged --since="2 weeks ago" \-- gitk::
+git whatchanged --since="2 weeks ago" \-- gitk::
Show the changes during the last two weeks to the file 'gitk'.
The "--" is necessary to avoid confusion with the *branch* named
</div>\r
<h2>SYNOPSIS</h2>\r
<div class="sectionbody">\r
-<p><em>git-write-tree</em> [--missing-ok] [--prefix=<prefix>/]</p>\r
+<p><em>git write-tree</em> [--missing-ok] [--prefix=<prefix>/]</p>\r
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:25 UTC\r
+Last updated 02-Jul-2008 03:02:08 UTC\r
</div>\r
</div>\r
</body>\r
SYNOPSIS
--------
-'git
-write-tree' [--missing-ok] [--prefix=<prefix>/]
+'git
write-tree' [--missing-ok] [--prefix=<prefix>/]
DESCRIPTION
-----------
<p>Git is a fast, scalable, distributed revision control system with an\r
unusually rich command set that provides both high-level operations\r
and full access to internals.</p>\r
-<p>See this <a href="gittutorial.html">gittutorial(7)</a>[tutorial] to get started, then see\r
+<p>See <a href="gittutorial.html">gittutorial(7)</a> to get started, then see\r
<a href="everyday.html">Everyday Git</a> for a useful minimum set of commands, and\r
"man git-commandname" for documentation of each command. CVS users may\r
-also want to read <a href="gitcvs-migration.html">gitcvs-migration(7)</a>[CVS migration]. See\r
-<a href="user-manual.html">Git User's Manual</a> for a more in-depth\r
+also want to read <a href="gitcvs-migration.html">gitcvs-migration(7)</a>. See\r
+
the <a href="user-manual.html">Git User's Manual</a> for a more in-depth
\r introduction.</p>\r
<p>The COMMAND is either a name of a Git command (see below) or an alias\r
as defined in the configuration file (see <a href="git-config.html">git-config(1)</a>).</p>\r
<p>See the references above to get started using git. The following is\r
probably more detail than necessary for a first-time user.</p>\r
<p>The <a href="user-manual.html#git-concepts">git concepts chapter of the\r
-user-manual</a> and the <a href="gitcore-tutorial.html">gitcore-tutorial(7)</a>[Core tutorial] both provide\r
+user-manual</a> and <a href="gitcore-tutorial.html">gitcore-tutorial(7)</a> both provide\r
introductions to the underlying git architecture.</p>\r
<p>See also the <a href="howto-index.html">howto</a> documents for some useful\r
examples.</p>\r
-<p>The internals are documented <a href="technical/api-index.html">here</a>.</p>\r
+<p>The internals are documented in the\r
+<a href="technical/api-index.html">GIT API documentation</a>.</p>\r
</div>\r
<h2>GIT COMMANDS</h2>\r
<div class="sectionbody">\r
</div>\r
<h2>File/Directory Structure</h2>\r
<div class="sectionbody">\r
-<p>Please see the <a href="gitrepository-layout.html">gitrepository-layout(5)</a>[repository layout]\r
-document.</p>\r
-<p>Read <a href="githooks.html">githooks(5)</a>[hooks] for more details about each hook.</p>\r
+<p>Please see the <a href="gitrepository-layout.html">gitrepository-layout(5)</a> document.</p>\r
+<p>Read <a href="githooks.html">githooks(5)</a> for more details about each hook.</p>\r
<p>Higher level SCMs may provide and manage additional information in the\r
<tt>$GIT_DIR</tt>.</p>\r
</div>\r
<h2>Terminology</h2>\r
<div class="sectionbody">\r
-<p>Please see the <a href="gitglossary.html">gitglossary(7)</a>[glossary] document.</p>\r
+<p>Please see <a href="gitglossary.html">gitglossary(7)</a>.</p>\r
</div>\r
<h2>Environment Variables</h2>\r
<div class="sectionbody">\r
</dt>\r
<dd>\r
<p>\r
- If this environment variable is set then <a href="git-fetch.html">git-fetch(1)</a>\r
- and <a href="git-push.html">git-push(1)</a> will use this command instead\r
+ If this environment variable is set then <tt>git-fetch</tt>\r
+ and <tt>git-push</tt> will use this command instead\r
of <tt>ssh</tt> when they need to connect to a remote system.\r
- The <em>GIT_SSH</em> command will be given exactly two arguments:\r
+ The <em>$GIT_SSH</em> command will be given exactly two arguments:\r
the <em>username@host</em> (or just <em>host</em>) from the URL and the\r
shell command to execute on that remote system.\r
</p>\r
<dd>\r
<p>\r
If this environment variable is set to "1", then commands such\r
- as git-blame (in incremental mode), git-rev-list, git-log,\r
- git-whatchanged, etc., will force a flush of the output stream\r
+ as <tt>git-blame</tt> (in incremental mode), <tt>git-rev-list</tt>, <tt>git-log</tt>,\r
+ and <tt>git-whatchanged</tt> will force a flush of the output stream\r
after each commit-oriented record have been flushed. If this\r
variable is set to "0", the output of these commands will be done\r
using completely buffered I/O. If this environment variable is\r
<div class="sectionbody">\r
<p>More detail on the following is available from the\r
<a href="user-manual.html#git-concepts">git concepts chapter of the\r
-user-manual</a> and the <a href="gitcore-tutorial.html">gitcore-tutorial(7)</a>[Core tutorial].</p>\r
+user-manual</a> and <a href="gitcore-tutorial.html">gitcore-tutorial(7)</a>.</p>\r
<p>A git project normally consists of a working directory with a ".git"\r
subdirectory at the top level. The .git directory contains, among other\r
things, a compressed object database representing the complete history\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 26-Jun-2008 06:33:11 UTC\r
+Last updated 02-Jul-2008 03:02:08 UTC\r
</div>\r
</div>\r
</body>\r
unusually rich command set that provides both high-level operations
and full access to internals.
-See this linkgit:gittutorial[7][tutorial] to get started, then see
+See linkgit:gittutorial[7] to get started, then see
link:everyday.html[Everyday Git] for a useful minimum set of commands, and
"man git-commandname" for documentation of each command. CVS users may
-also want to read linkgit:gitcvs-migration[7][CVS migration]. See
-link:user-manual.html[Git User's Manual] for a more in-depth
+also want to read linkgit:gitcvs-migration[7]. See
+the link:user-manual.html[Git User's Manual] for a more in-depth
introduction.
The COMMAND is either a name of a Git command (see below) or an alias
probably more detail than necessary for a first-time user.
The link:user-manual.html#git-concepts[git concepts chapter of the
-user-manual] and the linkgit:gitcore-tutorial[7][Core tutorial] both provide
+user-manual] and linkgit:gitcore-tutorial[7] both provide
introductions to the underlying git architecture.
See also the link:howto-index.html[howto] documents for some useful
examples.
-The internals are documented link:technical/api-index.html[here].
+The internals are documented in the
+link:technical/api-index.html[GIT API documentation].
GIT COMMANDS
------------
File/Directory Structure
------------------------
-Please see the linkgit:gitrepository-layout[5][repository layout]
-document.
+Please see the linkgit:gitrepository-layout[5] document.
-Read linkgit:githooks[5][hooks] for more details about each hook.
+Read linkgit:githooks[5] for more details about each hook.
Higher level SCMs may provide and manage additional information in the
`$GIT_DIR`.
Terminology
-----------
-Please see the linkgit:gitglossary[7][glossary] document.
+Please see linkgit:gitglossary[7].
Environment Variables
a pager.
'GIT_SSH'::
- If this environment variable is set then linkgit:git-fetch[1]
- and linkgit:git-push[1] will use this command instead
+ If this environment variable is set then `git-fetch`
+ and `git-push` will use this command instead
of `ssh` when they need to connect to a remote system.
- The 'GIT_SSH' command will be given exactly two arguments:
+ The '$GIT_SSH' command will be given exactly two arguments:
the 'username@host' (or just 'host') from the URL and the
shell command to execute on that remote system.
+
'GIT_FLUSH'::
If this environment variable is set to "1", then commands such
- as git-blame (in incremental mode), git-rev-list, git-log,
- git-whatchanged, etc., will force a flush of the output stream
+ as `git-blame` (in incremental mode), `git-rev-list`, `git-log`,
+ and `git-whatchanged` will force a flush of the output stream
after each commit-oriented record have been flushed. If this
variable is set to "0", the output of these commands will be done
using completely buffered I/O. If this environment variable is
More detail on the following is available from the
link:user-manual.html#git-concepts[git concepts chapter of the
-user-manual] and the linkgit:gitcore-tutorial[7][Core tutorial].
+user-manual] and linkgit:gitcore-tutorial[7].
A git project normally consists of a working directory with a ".git"
subdirectory at the top level. The .git directory contains, among other
<h3>Checking-out and checking-in</h3>\r
<p>These attributes affect how the contents stored in the\r
repository are copied to the working tree files when commands\r
-such as <tt>git checkout</tt> and <tt>git merge</tt> run. They also affect how\r
+such as <tt>git-checkout</tt> and <tt>git-merge</tt> run. They also affect how\r
git stores the contents you prepare in the working tree in the\r
-repository upon <tt>git add</tt> and <tt>git commit</tt>.</p>\r
+repository upon <tt>git-add</tt> and <tt>git-commit</tt>.</p>\r
<h4><tt>crlf</tt></h4>\r
<p>This attribute controls the line-ending convention.</p>\r
<dl>\r
<ul>\r
<li>\r
<p>\r
-"git add" itself does not touch the files in the work tree, the\r
+<tt>git-add</tt> itself does not touch the files in the work tree, the\r
next checkout would, so the safety triggers;\r
</p>\r
</li>\r
<li>\r
<p>\r
-"git apply" to update a text file with a patch does touch the files\r
+<tt>git-apply</tt> to update a text file with a patch does touch the files\r
in the work tree, but the operation is about text files and CRLF\r
conversion is about fixing the line ending inconsistencies, so the\r
safety does not trigger;\r
</li>\r
<li>\r
<p>\r
-"git diff" itself does not touch the files in the work tree, it is\r
- often run to inspect the changes you intend to next "git add". To\r
+<tt>git-diff</tt> itself does not touch the files in the work tree, it is\r
+ often run to inspect the changes you intend to next <tt>git-add</tt>. To\r
catch potential problems early, safety triggers.\r
</p>\r
</li>\r
<p>In the check-out codepath, the blob content is first converted\r
with <tt>crlf</tt>, and then <tt>ident</tt> and fed to <tt>filter</tt>.</p>\r
<h3>Generating diff text</h3>\r
-<p>The attribute <tt>diff</tt> affects if <tt>git diff</tt> generates textual\r
+<p>The attribute <tt>diff</tt> affects if <tt>git-diff</tt> generates textual\r
patch for the path or just says <tt>Binary files differ</tt>. It also\r
can affect what line is shown on the hunk header <tt>@@ -k,l +n,m @@</tt>\r
line.</p>\r
<h4><tt>export-subst</tt></h4>\r
<p>If the attribute <tt>export-subst</tt> is set for a file then git will expand\r
several placeholders when adding this file to an archive. The\r
-expansion depends on the availability of a commit ID, i.e. if\r
-<a href="git-archive.html">git-archive(1)</a> has been given a tree instead of a commit or a\r
+expansion depends on the availability of a commit ID, i.e., if\r
+<tt>git-archive</tt> has been given a tree instead of a commit or a\r
tag then no replacement will be done. The placeholders are the same\r
as those for the option <tt>--pretty=format:</tt> of <a href="git-log.html">git-log(1)</a>,\r
except that they need to be wrapped like this: <tt>$Format:PLACEHOLDERS$</tt>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 23-Jun-2008 07:13:37 UTC\r
+Last updated 02-Jul-2008 03:02:09 UTC\r
</div>\r
</div>\r
</body>\r
These attributes affect how the contents stored in the
repository are copied to the working tree files when commands
-such as `git checkout` and `git merge` run. They also affect how
+such as `git-checkout` and `git-merge` run. They also affect how
git stores the contents you prepare in the working tree in the
-repository upon `git add` and `git commit`.
+repository upon `git-add` and `git-commit`.
`crlf`
^^^^^^
a conversion done to the files in the work tree, but there are a
few exceptions. Even though...
-- "git add" itself does not touch the files in the work tree, the
+- `git-add` itself does not touch the files in the work tree, the
next checkout would, so the safety triggers;
-- "git apply" to update a text file with a patch does touch the files
+- `git-apply` to update a text file with a patch does touch the files
in the work tree, but the operation is about text files and CRLF
conversion is about fixing the line ending inconsistencies, so the
safety does not trigger;
-- "git diff" itself does not touch the files in the work tree, it is
- often run to inspect the changes you intend to next "git add". To
+- `git-diff` itself does not touch the files in the work tree, it is
+ often run to inspect the changes you intend to next `git-add`. To
catch potential problems early, safety triggers.
Generating diff text
~~~~~~~~~~~~~~~~~~~~
-The attribute `diff` affects if `git diff` generates textual
+The attribute `diff` affects if `git-diff` generates textual
patch for the path or just says `Binary files differ`. It also
can affect what line is shown on the hunk header `@@ -k,l +n,m @@`
line.
If the attribute `export-subst` is set for a file then git will expand
several placeholders when adding this file to an archive. The
-expansion depends on the availability of a commit ID, i.e. if
-linkgit:git-archive[1] has been given a tree instead of a commit or a
+expansion depends on the availability of a commit ID, i.e., if
+`git-archive` has been given a tree instead of a commit or a
tag then no replacement will be done. The placeholders are the same
as those for the option `--pretty=format:` of linkgit:git-log[1],
except that they need to be wrapped like this: `$Format:PLACEHOLDERS$`
$ git describe --abbrev 10 HEAD # NOT WHAT YOU MEANT</tt></pre>\r
</div></div>\r
</div>\r
+<h2>NOTES ON FREQUENTLY CONFUSED OPTIONS</h2>\r
+<div class="sectionbody">\r
+<p>Many commands that can work on files in the working tree\r
+and/or in the index can take <tt>--cached</tt> and/or <tt>--index</tt>\r
+options. Sometimes people incorrectly think that, because\r
+the index was originally called cache, these two are\r
+synonyms. They are <strong>not</strong> — these two options mean very\r
+different things.</p>\r
+<ul>\r
+<li>\r
+<p>\r
+The <tt>--cached</tt> option is used to ask a command that\r
+ usually works on files in the working tree to <strong>only</strong> work\r
+ with the index. For example, <tt>git grep</tt>, when used\r
+ without a commit to specify from which commit to look for\r
+ strings in, usually works on files in the working tree,\r
+ but with the <tt>--cached</tt> option, it looks for strings in\r
+ the index.\r
+</p>\r
+</li>\r
+<li>\r
+<p>\r
+The <tt>--index</tt> option is used to ask a command that\r
+ usually works on files in the working tree to <strong>also</strong>\r
+ affect the index. For example, <tt>git stash apply</tt> usually\r
+ merges changes recorded in a stash to the working tree,\r
+ but with the <tt>--index</tt> option, it also merges changes to\r
+ the index as well.\r
+</p>\r
+</li>\r
+</ul>\r
+<p><tt>git apply</tt> command can be used with <tt>--cached</tt> and\r
+<tt>--index</tt> (but not at the same time). Usually the command\r
+only affects the files in the working tree, but with\r
+<tt>--index</tt>, it patches both the files and their index\r
+entries, and with <tt>--cached</tt>, it modifies only the index\r
+entries.</p>\r
+<p>See also http://marc.info/?l=git&m=116563135620359 and\r
+http://marc.info/?l=git&m=119150393620273 for further\r
+information.</p>\r
+</div>\r
<h2>Documentation</h2>\r
<div class="sectionbody">\r
-<p>Documentation by Pierre Habouzit.</p>\r
+<p>Documentation by Pierre Habouzit and the git-list <git@vger.kernel.org>.</p>\r
</div>\r
<h2>GIT</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 28-Jun-2008 10:07:02 UTC\r
+Last updated 02-Jul-2008 03:02:11 UTC\r
</div>\r
</div>\r
</body>\r
----------------------------
+NOTES ON FREQUENTLY CONFUSED OPTIONS
+------------------------------------
+
+Many commands that can work on files in the working tree
+and/or in the index can take `--cached` and/or `--index`
+options. Sometimes people incorrectly think that, because
+the index was originally called cache, these two are
+synonyms. They are *not* -- these two options mean very
+different things.
+
+ * The `--cached` option is used to ask a command that
+ usually works on files in the working tree to *only* work
+ with the index. For example, `git grep`, when used
+ without a commit to specify from which commit to look for
+ strings in, usually works on files in the working tree,
+ but with the `--cached` option, it looks for strings in
+ the index.
+
+ * The `--index` option is used to ask a command that
+ usually works on files in the working tree to *also*
+ affect the index. For example, `git stash apply` usually
+ merges changes recorded in a stash to the working tree,
+ but with the `--index` option, it also merges changes to
+ the index as well.
+
+`git apply` command can be used with `--cached` and
+`--index` (but not at the same time). Usually the command
+only affects the files in the working tree, but with
+`--index`, it patches both the files and their index
+entries, and with `--cached`, it modifies only the index
+entries.
+
+See also http://marc.info/?l=git&m=116563135620359 and
+http://marc.info/?l=git&m=119150393620273 for further
+information.
+
Documentation
-------------
-Documentation by Pierre Habouzit.
+Documentation by Pierre Habouzit and the git-list <git@vger.kernel.org>.
GIT
---
<p>This tutorial explains how to use the "core" git programs to set up and\r
work with a git repository.</p>\r
<p>If you just need to use git as a revision control system you may prefer\r
-to start with <a href="gittutorial.html">gittutorial(7)</a>[a tutorial introduction to git] or\r
-<a href="user-manual.html">the git user manual</a>.</p>\r
+to start with "A Tutorial Introduction to GIT" (<a href="gittutorial.html">gittutorial(7)</a>) or\r
+<a href="user-manual.html">the GIT User Manual</a>.</p>\r
<p>However, an understanding of these low-level tools can be helpful if\r
you want to understand git's internals.</p>\r
<p>The core git is often called "plumbing", with the prettier user\r
<div class="content">\r
<pre><tt>$ mkdir git-tutorial\r
$ cd git-tutorial\r
-$ git-init</tt></pre>\r
+$ git init</tt></pre>\r
</div></div>\r
<p>to which git will reply</p>\r
<div class="listingblock">\r
<td class="icon">\r
<div class="title">Note</div>\r
</td>\r
-<td class="content">An advanced user may want to take a look at the\r
-<a href="gitrepository-layout.html">gitrepository-layout(5)</a>[repository layout] document\r
+<td class="content">An advanced user may want to take a look at <a href="gitrepository-layout.html">gitrepository-layout(5)</a>\r
after finishing this tutorial.</td>\r
</tr></table>\r
</div>\r
<p>So to populate the index with the two files you just created, you can do</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-update-index --add hello example</tt></pre>\r
+<pre><tt>$ git update-index --add hello example</tt></pre>\r
</div></div>\r
<p>and you have now told git to track those two files.</p>\r
<p>In fact, as you did that, if you now look into your object directory,\r
you'll have to use the object name, not the filename of the object:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-cat-file -t 557db03de997c86a4a028e1ebd3a1ceb225be238</tt></pre>\r
+<pre><tt>$ git cat-file -t 557db03de997c86a4a028e1ebd3a1ceb225be238</tt></pre>\r
</div></div>\r
<p>where the <tt>-t</tt> tells <tt>git-cat-file</tt> to tell you what the "type" of the\r
object is. git will tell you that you have a "blob" object (i.e., just a\r
regular file), and you can see the contents with</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-cat-file "blob" 557db03</tt></pre>\r
+<pre><tt>$ git cat-file "blob" 557db03</tt></pre>\r
</div></div>\r
<p>which will print out "Hello World". The object <tt>557db03</tt> is nothing\r
more than the contents of your file <tt>hello</tt>.</p>\r
<tt>git-diff-files</tt> command:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-diff-files</tt></pre>\r
+<pre><tt>$ git diff-files</tt></pre>\r
</div></div>\r
<p>Oops. That wasn't very readable. It just spit out its own internal\r
version of a <tt>diff</tt>, but that internal version really just tells you\r
that it has noticed that "hello" has been modified, and that the old object\r
contents it had have been replaced with something else.</p>\r
-<p>To make it readable, we can tell git-diff-files to output the\r
+<p>To make it readable, we can tell <tt>git-diff-files</tt> to output the\r
differences as a patch, using the <tt>-p</tt> flag:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-diff-files -p\r
+<pre><tt>$ git diff-files -p\r
diff --git a/hello b/hello\r
index 557db03..263414f 100644\r
--- a/hello\r
<p>In other words, <tt>git-diff-files</tt> always shows us the difference between\r
what is recorded in the index, and what is currently in the working\r
tree. That's very useful.</p>\r
-<p>A common shorthand for <tt>git-diff-files -p</tt> is to just write <tt>git\r
+<p>A common shorthand for <tt>git diff-files -p</tt> is to just write <tt>git\r
diff</tt>, which will do the same thing.</p>\r
<div class="listingblock">\r
<div class="content">\r
object as a <em>commit</em> object together with an explanation of what the\r
tree was all about, along with information of how we came to that state.</p>\r
<p>Creating a tree object is trivial, and is done with <tt>git-write-tree</tt>.\r
-There are no options or other input: git-write-tree will take the\r
+There are no options or other input: <tt>git write-tree</tt> will take the\r
current index state, and write an object that describes that whole\r
index. In other words, we're now tying together all the different\r
filenames with their contents (and their permissions), and we're\r
creating the equivalent of a git "directory" object:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-write-tree</tt></pre>\r
+<pre><tt>$ git write-tree</tt></pre>\r
</div></div>\r
<p>and this will just output the name of the resulting tree, in this case\r
(if you have done exactly as I've described) it should be</p>\r
<pre><tt>8988da15d077d4829fc51d8544c097def6644dbb</tt></pre>\r
</div></div>\r
<p>which is another incomprehensible object name. Again, if you want to,\r
-you can use <tt>git-cat-file -t 8988d...</tt> to see that this time the object\r
+you can use <tt>git cat-file -t 8988d...</tt> to see that this time the object\r
is not a "blob" object, but a "tree" object (you can also use\r
-<tt>git-cat-file</tt> to actually output the raw object contents, but you'll see\r
+<tt>git cat-file</tt> to actually output the raw object contents, but you'll see\r
mainly a binary mess, so that's less interesting).</p>\r
<p>However — normally you'd never use <tt>git-write-tree</tt> on its own, because\r
normally you always commit a tree into a commit object using the\r
all with a sequence of simple shell commands:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ tree=$(git-write-tree)\r
-$ commit=$(echo 'Initial commit' | git-commit-tree $tree)\r
-$ git-update-ref HEAD $commit</tt></pre>\r
+<pre><tt>$ tree=$(git write-tree)\r
+$ commit=$(echo 'Initial commit' | git commit-tree $tree)\r
+$ git update-ref HEAD $commit</tt></pre>\r
</div></div>\r
<p>In this case this creates a totally new commit that is not related to\r
anything else. Normally you do this only <strong>once</strong> for a project ever, and\r
that on purpose, to show the difference between the index state, and the\r
state in the working tree, and how they don't have to match, even\r
when we commit things.</p>\r
-<p>As before, if we do <tt>git-diff-files -p</tt> in our git-tutorial project,\r
+<p>As before, if we do <tt>git diff-files -p</tt> in our git-tutorial project,\r
we'll still see the same difference we saw last time: the index file\r
hasn't changed by the act of committing anything. However, now that we\r
have committed something, we can also learn to use a new command:\r
<p>But now we can do</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-diff-index -p HEAD</tt></pre>\r
+<pre><tt>$ git diff-index -p HEAD</tt></pre>\r
</div></div>\r
<p>(where <tt>-p</tt> has the same meaning as it did in <tt>git-diff-files</tt>), and it\r
will show us the same difference, but for a totally different reason.\r
working tree, but when given the <tt>--cached</tt> flag, it is told to\r
instead compare against just the index cache contents, and ignore the\r
current working tree state entirely. Since we just wrote the index\r
-file to HEAD, doing <tt>git-diff-index --cached -p HEAD</tt> should thus return\r
+file to HEAD, doing <tt>git diff-index --cached -p HEAD</tt> should thus return\r
an empty set of differences, and that's exactly what it does.</p>\r
<div class="admonitionblock">\r
<table><tr>\r
update the index cache:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-update-index hello</tt></pre>\r
+<pre><tt>$ git update-index hello</tt></pre>\r
</div></div>\r
<p>(note how we didn't need the <tt>--add</tt> flag this time, since git knew\r
about the file already).</p>\r
<p>Note what happens to the different <tt>git-diff-*</tt> versions here. After\r
-we've updated <tt>hello</tt> in the index, <tt>git-diff-files -p</tt> now shows no\r
-differences, but <tt>git-diff-index -p HEAD</tt> still *does* show that the\r
+we've updated <tt>hello</tt> in the index, <tt>git diff-files -p</tt> now shows no\r
+differences, but <tt>git diff-index -p HEAD</tt> still *does* show that the\r
current state is different from the state we committed. In fact, now\r
<tt>git-diff-index</tt> shows the same difference whether we use the <tt>--cached</tt>\r
flag or not, since now the index is coherent with the working tree.</p>\r
the same diff that we've already seen several times, we can now do</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-diff-tree -p HEAD</tt></pre>\r
+<pre><tt>$ git diff-tree -p HEAD</tt></pre>\r
</div></div>\r
<p>(again, <tt>-p</tt> means to show the difference as a human-readable patch),\r
and it will show what the last commit (in <tt>HEAD</tt>) actually changed.</p>\r
powerful)</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-whatchanged -p</tt></pre>\r
+<pre><tt>$ git whatchanged -p</tt></pre>\r
</div></div>\r
<p>and you will see exactly what has changed in the repository over its\r
short history.</p>\r
So after you do a <tt>cp -a</tt> to create a new copy, you'll want to do</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-update-index --refresh</tt></pre>\r
+<pre><tt>$ git update-index --refresh</tt></pre>\r
</div></div>\r
<p>in the new repository to make sure that the index file is up-to-date.</p>\r
</li>\r
so usually you'll precede the <tt>git-update-index</tt> with a</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-read-tree --reset HEAD\r
-$ git-update-index --refresh</tt></pre>\r
+<pre><tt>$ git read-tree --reset HEAD\r
+$ git update-index --refresh</tt></pre>\r
</div></div>\r
<p>which will force a total index re-build from the tree pointed to by <tt>HEAD</tt>.\r
It resets the index contents to <tt>HEAD</tt>, and then the <tt>git-update-index</tt>\r
makes sure to match up all index entries with the checked-out files.\r
If the original repository had uncommitted changes in its\r
-working tree, <tt>git-update-index --refresh</tt> notices them and\r
+working tree, <tt>git update-index --refresh</tt> notices them and\r
tells you they need to be updated.</p>\r
<p>The above can also be written as simply</p>\r
<div class="listingblock">\r
with the <tt>git xyz</tt> interfaces. You can learn things by just looking\r
at what the various git scripts do. For example, <tt>git reset</tt> used to be\r
the above two lines implemented in <tt>git-reset</tt>, but some things like\r
-<tt>git status</tt> and <tt>git commit</tt> are slightly more complex scripts around\r
+<tt>git-status</tt> and <tt>git-commit</tt> are slightly more complex scripts around\r
the basic git commands.</p>\r
<p>Many (most?) public remote repositories will not contain any of\r
the checked out files or even an index file, and will <strong>only</strong> contain the\r
<p>followed by</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-read-tree HEAD</tt></pre>\r
+<pre><tt>$ git read-tree HEAD</tt></pre>\r
</div></div>\r
<p>to populate the index. However, now you have populated the index, and\r
you have all the git internal files, but you will notice that you don't\r
those, you'd check them out with</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-checkout-index -u -a</tt></pre>\r
+<pre><tt>$ git checkout-index -u -a</tt></pre>\r
</div></div>\r
<p>where the <tt>-u</tt> flag means that you want the checkout to keep the index\r
up-to-date (so that you don't have to refresh it afterward), and the\r
<tt>-a</tt> flag means "check out all files" (if you have a stale copy or an\r
older version of a checked out tree you may also need to add the <tt>-f</tt>\r
-flag first, to tell git-checkout-index to <strong>force</strong> overwriting of any old\r
+flag first, to tell <tt>git-checkout-index</tt> to <strong>force</strong> overwriting of any old\r
files).</p>\r
<p>Again, this can all be simplified with</p>\r
<div class="listingblock">\r
$ git commit -m "Some work." -i hello</tt></pre>\r
</div></div>\r
<p>Here, we just added another line to <tt>hello</tt>, and we used a shorthand for\r
-doing both <tt>git-update-index hello</tt> and <tt>git commit</tt> by just giving the\r
+doing both <tt>git update-index hello</tt> and <tt>git commit</tt> by just giving the\r
filename directly to <tt>git commit</tt>, with an <tt>-i</tt> flag (it tells\r
git to <em>include</em> that file in addition to what you have done to\r
the index file so far when making the commit). The <tt>-m</tt> flag is to give the\r
</div></div>\r
<p>which will very loudly warn you that you're now committing a merge\r
(which is correct, so never mind), and you can write a small merge\r
-message about your adventures in git-merge-land.</p>\r
+message about your adventures in <tt>git-merge</tt>-land.</p>\r
<p>After you're done, start up <tt>gitk --all</tt> to see graphically what the\r
history looks like. Notice that <tt>mybranch</tt> still exists, and you can\r
switch to it, and continue to work with it if you want to. The\r
environment, is <tt>git show-branch</tt>.</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-show-branch --topo-order --more=1 master mybranch\r
+<pre><tt>$ git show-branch --topo-order --more=1 master mybranch\r
* [master] Merge work in mybranch\r
! [mybranch] Some work.\r
--\r
before the commit log message is a short name you can use to\r
name the commit. In the above example, <em>master</em> and <em>mybranch</em>\r
are branch heads. <em>master^</em> is the first parent of <em>master</em>\r
-branch head. Please see <em>git-rev-parse</em> documentation if you\r
+branch head. Please see <a href="git-rev-parse.html">git-rev-parse(1)</a> if you want to\r
see more complex cases.</p>\r
<div class="admonitionblock">\r
<table><tr>\r
<td class="icon">\r
<div class="title">Note</div>\r
</td>\r
-<td class="content">Without the <em>--more=1</em> option, <em>git-show-branch</em> would not output the\r
+<td class="content">Without the <em>--more=1</em> option, <tt>git-show-branch</tt> would not output the\r
<em>[master^]</em> commit, as <em>[mybranch]</em> commit is a common ancestor of\r
-both <em>master</em> and <em>mybranch</em> tips. Please see <em>git-show-branch</em>\r
-documentation for details.</td>\r
+both <em>master</em> and <em>mybranch</em> tips. Please see <a href="git-show-branch.html">git-show-branch(1)</a>\r
+for details.</td>\r
</tr></table>\r
</div>\r
<div class="admonitionblock">\r
<div class="title">Note</div>\r
</td>\r
<td class="content">If there were more commits on the <em>master</em> branch after the merge, the\r
-merge commit itself would not be shown by <em>git-show-branch</em> by\r
+merge commit itself would not be shown by <tt>git-show-branch</tt> by\r
default. You would need to provide <em>--sparse</em> option to make the\r
merge commit visible in this case.</td>\r
</tr></table>\r
<p>Now, let's pretend you are the one who did all the work in\r
<tt>mybranch</tt>, and the fruit of your hard work has finally been merged\r
to the <tt>master</tt> branch. Let's go back to <tt>mybranch</tt>, and run\r
-<tt>git merge</tt> to get the "upstream changes" back to your branch.</p>\r
+<tt>git-merge</tt> to get the "upstream changes" back to your branch.</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git checkout mybranch\r
The command it uses is <tt>git-merge-base</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ mb=$(git-merge-base HEAD mybranch)</tt></pre>\r
+<pre><tt>$ mb=$(git merge-base HEAD mybranch)</tt></pre>\r
</div></div>\r
<p>The command writes the commit object name of the common ancestor\r
to the standard output, so we captured its output to a variable,\r
tell it by:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-name-rev $mb\r
+<pre><tt>$ git name-rev $mb\r
my-first-tag</tt></pre>\r
</div></div>\r
<p>After finding out a common ancestor commit, the second step is\r
this:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-read-tree -m -u $mb HEAD mybranch</tt></pre>\r
+<pre><tt>$ git read-tree -m -u $mb HEAD mybranch</tt></pre>\r
</div></div>\r
<p>This is the same <tt>git-read-tree</tt> command we have already seen,\r
but it takes three trees, unlike previous examples. This reads\r
inspect the index file with this command:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-ls-files --stage\r
+<pre><tt>$ git ls-files --stage\r
100644 7f8b141b65fdcee47321e399a2598a235a032422 0 example\r
100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello\r
100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello\r
<p>To look at only non-zero stages, use <tt>--unmerged</tt> flag:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-ls-files --unmerged\r
+<pre><tt>$ git ls-files --unmerged\r
100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello\r
100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello\r
100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello</tt></pre>\r
<tt>git-merge-index</tt> command:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-merge-index git-merge-one-file hello\r
+<pre><tt>$ git merge-index git-merge-one-file hello\r
Auto-merging hello.\r
merge: warning: conflicts during merge\r
ERROR: Merge conflict in hello.\r
--stage</tt> again at this point:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-ls-files --stage\r
+<pre><tt>$ git ls-files --stage\r
100644 7f8b141b65fdcee47321e399a2598a235a032422 0 example\r
100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello\r
100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello\r
100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello</tt></pre>\r
</div></div>\r
<p>This is the state of the index file and the working file after\r
-<tt>git merge</tt> returns control back to you, leaving the conflicting\r
+<tt>git-merge</tt> returns control back to you, leaving the conflicting\r
merge for you to resolve. Notice that the path <tt>hello</tt> is still\r
-unmerged, and what you see with <tt>git diff</tt> at this point is\r
+unmerged, and what you see with <tt>git-diff</tt> at this point is\r
differences since stage 2 (i.e. your version).</p>\r
</div>\r
<h2>Publishing your work</h2>\r
<td class="icon">\r
<div class="title">Note</div>\r
</td>\r
-<td class="content"><tt>git push</tt> uses a pair of programs,\r
+<td class="content"><tt>git-push</tt> uses a pair of programs,\r
<tt>git-send-pack</tt> on your local machine, and <tt>git-receive-pack</tt>\r
on the remote machine. The communication between the two over\r
the network internally uses an SSH connection.</td>\r
<tt>.git</tt>, we do things slightly differently:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ GIT_DIR=my-git.git git-init</tt></pre>\r
+<pre><tt>$ GIT_DIR=my-git.git git init</tt></pre>\r
</div></div>\r
<p>Make sure this directory is available for others you want your\r
changes to be pulled by via the transport of your choice. Also\r
<td class="content">If you plan to publish this repository to be accessed over http,\r
you should do <tt>chmod +x my-git.git/hooks/post-update</tt> at this\r
point. This makes sure that every time you push into this\r
-repository, <tt>git-update-server-info</tt> is run.</td>\r
+repository, <tt>git update-server-info</tt> is run.</td>\r
</tr></table>\r
</div>\r
<p>Your "public repository" is now ready to accept your changes.\r
</li>\r
<li>\r
<p>\r
-<tt>git repack</tt> the public repository. This establishes a big\r
+<tt>git-repack</tt> the public repository. This establishes a big\r
pack that contains the initial set of objects as the\r
- baseline, and possibly <tt>git prune</tt> if the transport\r
+ baseline, and possibly <tt>git-prune</tt> if the transport\r
used for pulling from your repository supports packed\r
repositories.\r
</p>\r
</li>\r
<li>\r
<p>\r
-Every once in a while, "git repack" the public repository.\r
+Every once in a while, "git-repack" the public repository.\r
Go back to step 5. and continue working.\r
</p>\r
</li>\r
<ol>\r
<li>\r
<p>\r
-Prepare your work repository, by <tt>git clone</tt> the public\r
+Prepare your work repository, by <tt>git-clone</tt> the public\r
repository of the "project lead". The URL used for the\r
initial cloning is stored in the remote.origin.url\r
configuration variable.\r
<li>\r
<p>\r
Push into the public repository from your primary\r
- repository. Run <tt>git repack</tt>, and possibly <tt>git prune</tt> if the\r
+ repository. Run <tt>git-repack</tt>, and possibly <tt>git-prune</tt> if the\r
transport used for pulling from your repository supports\r
packed repositories.\r
</p>\r
</li>\r
<li>\r
<p>\r
-Every once in a while, <tt>git repack</tt> the public repository.\r
+Every once in a while, <tt>git-repack</tt> the public repository.\r
Go back to step 5. and continue working.\r
</p>\r
</li>\r
<ol>\r
<li>\r
<p>\r
-Prepare your work repository, by <tt>git clone</tt> the public\r
+Prepare your work repository, by <tt>git-clone</tt> the public\r
repository of the "project lead" (or a "subsystem\r
maintainer", if you work on a subsystem). The URL used for\r
the initial cloning is stored in the remote.origin.url\r
suggested in the previous section may be new to you. You do not\r
have to worry. git supports "shared public repository" style of\r
cooperation you are probably more familiar with as well.</p>\r
-<p>See <a href="gitcvs-migration.html">gitcvs-migration(7)</a>[git for CVS users] for the details.</p>\r
+<p>See <a href="gitcvs-migration.html">gitcvs-migration(7)</a> for the details.</p>\r
</div>\r
<h2>Bundling your work together</h2>\r
<div class="sectionbody">\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:31 UTC\r
+Last updated 02-Jul-2008 03:02:12 UTC\r
</div>\r
</div>\r
</body>\r
work with a git repository.
If you just need to use git as a revision control system you may prefer
-to start with linkgit:gittutorial[7][a tutorial introduction to git] or
-link:user-manual.html[the git user manual].
+to start with "A Tutorial Introduction to GIT" (linkgit:gittutorial[7]) or
+link:user-manual.html[the GIT User Manual].
However, an understanding of these low-level tools can be helpful if
you want to understand git's internals.
------------------------------------------------
$ mkdir git-tutorial
$ cd git-tutorial
-$ git-init
+$ git init
------------------------------------------------
to which git will reply
populating your tree.
[NOTE]
-An advanced user may want to take a look at the
-linkgit:gitrepository-layout[5][repository layout] document
+An advanced user may want to take a look at linkgit:gitrepository-layout[5]
after finishing this tutorial.
You have now created your first git repository. Of course, since it's
So to populate the index with the two files you just created, you can do
------------------------------------------------
-$ git-update-index --add hello example
+$ git update-index --add hello example
------------------------------------------------
and you have now told git to track those two files.
you'll have to use the object name, not the filename of the object:
----------------
-$ git-cat-file -t 557db03de997c86a4a028e1ebd3a1ceb225be238
+$ git cat-file -t 557db03de997c86a4a028e1ebd3a1ceb225be238
----------------
where the `-t` tells `git-cat-file` to tell you what the "type" of the
regular file), and you can see the contents with
----------------
-$ git-cat-file "blob" 557db03
+$ git cat-file "blob" 557db03
----------------
which will print out "Hello World". The object `557db03` is nothing
`git-diff-files` command:
------------
-$ git-diff-files
+$ git diff-files
------------
Oops. That wasn't very readable. It just spit out its own internal
that it has noticed that "hello" has been modified, and that the old object
contents it had have been replaced with something else.
-To make it readable, we can tell git-diff-files to output the
+To make it readable, we can tell `git-diff-files` to output the
differences as a patch, using the `-p` flag:
------------
-$ git-diff-files -p
+$ git diff-files -p
diff --git a/hello b/hello
index 557db03..263414f 100644
--- a/hello
what is recorded in the index, and what is currently in the working
tree. That's very useful.
-A common shorthand for `git-diff-files -p` is to just write `git
+A common shorthand for `git diff-files -p` is to just write `git
diff`, which will do the same thing.
------------
tree was all about, along with information of how we came to that state.
Creating a tree object is trivial, and is done with `git-write-tree`.
-There are no options or other input: git-write-tree will take the
+There are no options or other input: `git write-tree` will take the
current index state, and write an object that describes that whole
index. In other words, we're now tying together all the different
filenames with their contents (and their permissions), and we're
creating the equivalent of a git "directory" object:
------------------------------------------------
-$ git-write-tree
+$ git write-tree
------------------------------------------------
and this will just output the name of the resulting tree, in this case
----------------
which is another incomprehensible object name. Again, if you want to,
-you can use `git-cat-file -t 8988d\...` to see that this time the object
+you can use `git cat-file -t 8988d\...` to see that this time the object
is not a "blob" object, but a "tree" object (you can also use
-`git-cat-file` to actually output the raw object contents, but you'll see
+`git cat-file` to actually output the raw object contents, but you'll see
mainly a binary mess, so that's less interesting).
However -- normally you'd never use `git-write-tree` on its own, because
all with a sequence of simple shell commands:
------------------------------------------------
-$ tree=$(git-write-tree)
-$ commit=$(echo 'Initial commit' | git-commit-tree $tree)
-$ git-update-ref HEAD $commit
+$ tree=$(git write-tree)
+$ commit=$(echo 'Initial commit' | git commit-tree $tree)
+$ git update-ref HEAD $commit
------------------------------------------------
In this case this creates a totally new commit that is not related to
state in the working tree, and how they don't have to match, even
when we commit things.
-As before, if we do `git-diff-files -p` in our git-tutorial project,
+As before, if we do `git diff-files -p` in our git-tutorial project,
we'll still see the same difference we saw last time: the index file
hasn't changed by the act of committing anything. However, now that we
have committed something, we can also learn to use a new command:
But now we can do
----------------
-$ git-diff-index -p HEAD
+$ git diff-index -p HEAD
----------------
(where `-p` has the same meaning as it did in `git-diff-files`), and it
working tree, but when given the `\--cached` flag, it is told to
instead compare against just the index cache contents, and ignore the
current working tree state entirely. Since we just wrote the index
-file to HEAD, doing `git-diff-index \--cached -p HEAD` should thus return
+file to HEAD, doing `git diff-index \--cached -p HEAD` should thus return
an empty set of differences, and that's exactly what it does.
[NOTE]
update the index cache:
------------------------------------------------
-$ git-update-index hello
+$ git update-index hello
------------------------------------------------
(note how we didn't need the `\--add` flag this time, since git knew
about the file already).
Note what happens to the different `git-diff-\*` versions here. After
-we've updated `hello` in the index, `git-diff-files -p` now shows no
-differences, but `git-diff-index -p HEAD` still *does* show that the
+we've updated `hello` in the index, `git diff-files -p` now shows no
+differences, but `git diff-index -p HEAD` still *does* show that the
current state is different from the state we committed. In fact, now
`git-diff-index` shows the same difference whether we use the `--cached`
flag or not, since now the index is coherent with the working tree.
the same diff that we've already seen several times, we can now do
----------------
-$ git-diff-tree -p HEAD
+$ git diff-tree -p HEAD
----------------
(again, `-p` means to show the difference as a human-readable patch),
powerful)
----------------
-$ git-whatchanged -p
+$ git whatchanged -p
----------------
and you will see exactly what has changed in the repository over its
So after you do a `cp -a` to create a new copy, you'll want to do
+
----------------
-$ git-update-index --refresh
+$ git update-index --refresh
----------------
+
in the new repository to make sure that the index file is up-to-date.
so usually you'll precede the `git-update-index` with a
----------------
-$ git-read-tree --reset HEAD
-$ git-update-index --refresh
+$ git read-tree --reset HEAD
+$ git update-index --refresh
----------------
which will force a total index re-build from the tree pointed to by `HEAD`.
It resets the index contents to `HEAD`, and then the `git-update-index`
makes sure to match up all index entries with the checked-out files.
If the original repository had uncommitted changes in its
-working tree, `git-update-index --refresh` notices them and
+working tree, `git update-index --refresh` notices them and
tells you they need to be updated.
The above can also be written as simply
with the `git xyz` interfaces. You can learn things by just looking
at what the various git scripts do. For example, `git reset` used to be
the above two lines implemented in `git-reset`, but some things like
-`git status` and `git commit` are slightly more complex scripts around
+`git-status` and `git-commit` are slightly more complex scripts around
the basic git commands.
Many (most?) public remote repositories will not contain any of
followed by
----------------
-$ git-read-tree HEAD
+$ git read-tree HEAD
----------------
to populate the index. However, now you have populated the index, and
those, you'd check them out with
----------------
-$ git-checkout-index -u -a
+$ git checkout-index -u -a
----------------
where the `-u` flag means that you want the checkout to keep the index
up-to-date (so that you don't have to refresh it afterward), and the
`-a` flag means "check out all files" (if you have a stale copy or an
older version of a checked out tree you may also need to add the `-f`
-flag first, to tell git-checkout-index to *force* overwriting of any old
+flag first, to tell `git-checkout-index` to *force* overwriting of any old
files).
Again, this can all be simplified with
------------------------------------------------
Here, we just added another line to `hello`, and we used a shorthand for
-doing both `git-update-index hello` and `git commit` by just giving the
+doing both `git update-index hello` and `git commit` by just giving the
filename directly to `git commit`, with an `-i` flag (it tells
git to 'include' that file in addition to what you have done to
the index file so far when making the commit). The `-m` flag is to give the
which will very loudly warn you that you're now committing a merge
(which is correct, so never mind), and you can write a small merge
-message about your adventures in git-merge-land.
+message about your adventures in `git-merge`-land.
After you're done, start up `gitk \--all` to see graphically what the
history looks like. Notice that `mybranch` still exists, and you can
environment, is `git show-branch`.
------------------------------------------------
-$ git-show-branch --topo-order --more=1 master mybranch
+$ git show-branch --topo-order --more=1 master mybranch
* [master] Merge work in mybranch
! [mybranch] Some work.
--
before the commit log message is a short name you can use to
name the commit. In the above example, 'master' and 'mybranch'
are branch heads. 'master^' is the first parent of 'master'
-branch head. Please see 'git-rev-parse' documentation if you
+branch head. Please see linkgit:git-rev-parse[1] if you want to
see more complex cases.
[NOTE]
-Without the '--more=1' option, 'git-show-branch' would not output the
+Without the '--more=1' option, `git-show-branch` would not output the
'[master^]' commit, as '[mybranch]' commit is a common ancestor of
-both 'master' and 'mybranch' tips. Please see 'git-show-branch'
-documentation for details.
+both 'master' and 'mybranch' tips. Please see linkgit:git-show-branch[1]
+for details.
[NOTE]
If there were more commits on the 'master' branch after the merge, the
-merge commit itself would not be shown by 'git-show-branch' by
+merge commit itself would not be shown by `git-show-branch` by
default. You would need to provide '--sparse' option to make the
merge commit visible in this case.
Now, let's pretend you are the one who did all the work in
`mybranch`, and the fruit of your hard work has finally been merged
to the `master` branch. Let's go back to `mybranch`, and run
-`git merge` to get the "upstream changes" back to your branch.
+`git-merge` to get the "upstream changes" back to your branch.
------------
$ git checkout mybranch
The command it uses is `git-merge-base`:
------------
-$ mb=$(git-merge-base HEAD mybranch)
+$ mb=$(git merge-base HEAD mybranch)
------------
The command writes the commit object name of the common ancestor
tell it by:
------------
-$ git-name-rev $mb
+$ git name-rev $mb
my-first-tag
------------
this:
------------
-$ git-read-tree -m -u $mb HEAD mybranch
+$ git read-tree -m -u $mb HEAD mybranch
------------
This is the same `git-read-tree` command we have already seen,
inspect the index file with this command:
------------
-$ git-ls-files --stage
+$ git ls-files --stage
100644 7f8b141b65fdcee47321e399a2598a235a032422 0 example
100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello
100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello
To look at only non-zero stages, use `\--unmerged` flag:
------------
-$ git-ls-files --unmerged
+$ git ls-files --unmerged
100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello
100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello
100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello
`git-merge-index` command:
------------
-$ git-merge-index git-merge-one-file hello
+$ git merge-index git-merge-one-file hello
Auto-merging hello.
merge: warning: conflicts during merge
ERROR: Merge conflict in hello.
--stage` again at this point:
------------
-$ git-ls-files --stage
+$ git ls-files --stage
100644 7f8b141b65fdcee47321e399a2598a235a032422 0 example
100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello
100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello
------------
This is the state of the index file and the working file after
-`git merge` returns control back to you, leaving the conflicting
+`git-merge` returns control back to you, leaving the conflicting
merge for you to resolve. Notice that the path `hello` is still
-unmerged, and what you see with `git diff` at this point is
+unmerged, and what you see with `git-diff` at this point is
differences since stage 2 (i.e. your version).
done only once.
[NOTE]
-`git push` uses a pair of programs,
+`git-push` uses a pair of programs,
`git-send-pack` on your local machine, and `git-receive-pack`
on the remote machine. The communication between the two over
the network internally uses an SSH connection.
`.git`, we do things slightly differently:
------------
-$ GIT_DIR=my-git.git git-init
+$ GIT_DIR=my-git.git git init
------------
Make sure this directory is available for others you want your
If you plan to publish this repository to be accessed over http,
you should do `chmod +x my-git.git/hooks/post-update` at this
point. This makes sure that every time you push into this
-repository, `git-update-server-info` is run.
+repository, `git update-server-info` is run.
Your "public repository" is now ready to accept your changes.
Come back to the machine you have your private repository. From
3. Push into the public repository from your primary
repository.
-4. `git repack` the public repository. This establishes a big
+4. `git-repack` the public repository. This establishes a big
pack that contains the initial set of objects as the
- baseline, and possibly `git prune` if the transport
+ baseline, and possibly `git-prune` if the transport
used for pulling from your repository supports packed
repositories.
6. Push your changes to the public repository, and announce it
to the public.
-7. Every once in a while, "git repack" the public repository.
+7. Every once in a while, "git-repack" the public repository.
Go back to step 5. and continue working.
A recommended work cycle for a "subsystem maintainer" who works
on that project and has an own "public repository" goes like this:
-1. Prepare your work repository, by `git clone` the public
+1. Prepare your work repository, by `git-clone` the public
repository of the "project lead". The URL used for the
initial cloning is stored in the remote.origin.url
configuration variable.
point at the repository you are borrowing from.
4. Push into the public repository from your primary
- repository. Run `git repack`, and possibly `git prune` if the
+ repository. Run `git-repack`, and possibly `git-prune` if the
transport used for pulling from your repository supports
packed repositories.
"project lead" and possibly your "sub-subsystem
maintainers" to pull from it.
-7. Every once in a while, `git repack` the public repository.
+7. Every once in a while, `git-repack` the public repository.
Go back to step 5. and continue working.
not have a "public" repository is somewhat different. It goes
like this:
-1. Prepare your work repository, by `git clone` the public
+1. Prepare your work repository, by `git-clone` the public
repository of the "project lead" (or a "subsystem
maintainer", if you work on a subsystem). The URL used for
the initial cloning is stored in the remote.origin.url
have to worry. git supports "shared public repository" style of
cooperation you are probably more familiar with as well.
-See linkgit:gitcvs-migration[7][git for CVS users] for the details.
+See linkgit:gitcvs-migration[7] for the details.
Bundling your work together
---------------------------
important than any other. However, you can emulate the CVS model by\r
designating a single shared repository which people can synchronize with;\r
this document explains how to do that.</p>\r
-<p>Some basic familiarity with git is required. This\r
-<a href="gittutorial.html">gittutorial(7)</a>[tutorial introduction to git] and the\r
-<a href="gitglossary.html">gitglossary(7)</a>[git glossary] should be sufficient.</p>\r
+<p>Some basic familiarity with git is required. Having gone through\r
+<a href="gittutorial.html">gittutorial(7)</a> and\r
+<a href="gitglossary.html">gitglossary(7)</a> should be sufficient.</p>\r
</div>\r
<h2>Developing against a shared repository</h2>\r
<div class="sectionbody">\r
</td>\r
<td class="content">\r
<p>The <tt>pull</tt> command knows where to get updates from because of certain\r
-configuration variables that were set by the first <tt>git clone</tt>\r
+configuration variables that were set by the first <tt>git-clone</tt>\r
command; see <tt>git config -l</tt> and the <a href="git-config.html">git-config(1)</a> man\r
page for details.</p>\r
</td>\r
</tr></table>\r
</div>\r
<p>You can update the shared repository with your changes by first committing\r
-your changes, and then using the <a href="git-push.html">git-push(1)</a> command:</p>\r
+your changes, and then using the <tt>git-push</tt> command:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git push origin master</tt></pre>\r
</div></div>\r
<p>to "push" those commits to the shared repository. If someone else has\r
-updated the repository more recently, <tt>git push</tt>, like <tt>cvs commit</tt>, will\r
+updated the repository more recently, <tt>git-push</tt>, like <tt>cvs commit</tt>, will\r
complain, in which case you must pull any changes before attempting the\r
push again.</p>\r
-<p>In the <tt>git push</tt> command above we specify the name of the remote branch\r
-to update (<tt>master</tt>). If we leave that out, <tt>git push</tt> tries to update\r
+<p>In the <tt>git-push</tt> command above we specify the name of the remote branch\r
+to update (<tt>master</tt>). If we leave that out, <tt>git-push</tt> tries to update\r
any branches in the remote repository that have the same name as a branch\r
in the local repository. So the last <tt>push</tt> can be done with either of:</p>\r
<div class="listingblock">\r
<h2>Setting Up a Shared Repository</h2>\r
<div class="sectionbody">\r
<p>We assume you have already created a git repository for your project,\r
-possibly created from scratch or from a tarball (see the\r
-<a href="gittutorial.html">gittutorial(7)</a>[tutorial]), or imported from an already existing CVS\r
+possibly created from scratch or from a tarball (see\r
+<a href="gittutorial.html">gittutorial(7)</a>), or imported from an already existing CVS\r
repository (see the next section).</p>\r
<p>Assume your existing repo is at /home/alice/myproject. Create a new "bare"\r
repository (a repository without a working tree) and fetch your project into\r
<p>First, install version 2.1 or higher of cvsps from\r
<a href="http://www.cobite.com/cvsps/">http://www.cobite.com/cvsps/</a> and make\r
sure it is in your path. Then cd to a checked out CVS working directory\r
-of the project you are interested in and run <a href="git-cvsimport.html">git-cvsimport(1)</a>:</p>\r
+of the project you are interested in and run <tt>git-cvsimport</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git cvsimport -C <destination> <module></tt></pre>\r
<div class="sectionbody">\r
<p>Git allows you to specify scripts called "hooks" to be run at certain\r
points. You can use these, for example, to send all commits to the shared\r
-repository to a mailing list. See <a href="githooks.html">githooks(5)</a>[Hooks used by git].</p>\r
+repository to a mailing list. See <a href="githooks.html">githooks(5)</a>.</p>\r
<p>You can enforce finer grained permissions using update hooks. See\r
<a href="howto/update-hook-example.txt">Controlling access to branches using\r
update hooks</a>.</p>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:31 UTC\r
+Last updated 02-Jul-2008 03:02:12 UTC\r
</div>\r
</div>\r
</body>\r
designating a single shared repository which people can synchronize with;
this document explains how to do that.
-Some basic familiarity with git is required. This
-linkgit:gittutorial[7][tutorial introduction to git] and the
-linkgit:gitglossary[7][git glossary] should be sufficient.
+Some basic familiarity with git is required. Having gone through
+linkgit:gittutorial[7] and
+linkgit:gitglossary[7] should be sufficient.
Developing against a shared repository
--------------------------------------
[NOTE]
================================
The `pull` command knows where to get updates from because of certain
-configuration variables that were set by the first `git clone`
+configuration variables that were set by the first `git-clone`
command; see `git config -l` and the linkgit:git-config[1] man
page for details.
================================
You can update the shared repository with your changes by first committing
-your changes, and then using the linkgit:git-push[1] command:
+your changes, and then using the `git-push` command:
------------------------------------------------
$ git push origin master
------------------------------------------------
to "push" those commits to the shared repository. If someone else has
-updated the repository more recently, `git push`, like `cvs commit`, will
+updated the repository more recently, `git-push`, like `cvs commit`, will
complain, in which case you must pull any changes before attempting the
push again.
-In the `git push` command above we specify the name of the remote branch
-to update (`master`). If we leave that out, `git push` tries to update
+In the `git-push` command above we specify the name of the remote branch
+to update (`master`). If we leave that out, `git-push` tries to update
any branches in the remote repository that have the same name as a branch
in the local repository. So the last `push` can be done with either of:
------------------------------
We assume you have already created a git repository for your project,
-possibly created from scratch or from a tarball (see the
-linkgit:gittutorial[7][tutorial]), or imported from an already existing CVS
+possibly created from scratch or from a tarball (see
+linkgit:gittutorial[7]), or imported from an already existing CVS
repository (see the next section).
Assume your existing repo is at /home/alice/myproject. Create a new "bare"
First, install version 2.1 or higher of cvsps from
link:http://www.cobite.com/cvsps/[http://www.cobite.com/cvsps/] and make
sure it is in your path. Then cd to a checked out CVS working directory
-of the project you are interested in and run linkgit:git-cvsimport[1]:
+of the project you are interested in and run `git-cvsimport`:
-------------------------------------------
$ git cvsimport -C <destination> <module>
Git allows you to specify scripts called "hooks" to be run at certain
points. You can use these, for example, to send all commits to the shared
-repository to a mailing list. See linkgit:githooks[5][Hooks used by git].
+repository to a mailing list. See linkgit:githooks[5].
You can enforce finer grained permissions using update hooks. See
link:howto/update-hook-example.txt[Controlling access to branches using
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>The diff commands git-diff-index, git-diff-files, and git-diff-tree\r
+<p>The diff commands <tt>git-diff-index</tt>, <tt>git-diff-files</tt>, and <tt>git-diff-tree</tt>\r
can be told to manipulate differences they find in\r
-unconventional ways before showing diff(1) output. The manipulation\r
+unconventional ways before showing <tt>diff</tt> output. The manipulation\r
is collectively called "diffcore transformation". This short note\r
describes what they are and how to use them to produce diff outputs\r
that are easier to understand than the conventional kind.</p>\r
</div>\r
<h2>The chain of operation</h2>\r
<div class="sectionbody">\r
-<p>The git-diff-* family works by first comparing two sets of\r
+<p>The <tt>git-diff-*</tt> family works by first comparing two sets of\r
files:</p>\r
<ul>\r
<li>\r
<p>\r
-git-diff-index compares contents of a "tree" object and the\r
+<tt>git-diff-index</tt> compares contents of a "tree" object and the\r
working directory (when <em>--cached</em> flag is not used) or a\r
"tree" object and the index file (when <em>--cached</em> flag is\r
used);\r
</li>\r
<li>\r
<p>\r
-git-diff-files compares contents of the index file and the\r
+<tt>git-diff-files</tt> compares contents of the index file and the\r
working directory;\r
</p>\r
</li>\r
<li>\r
<p>\r
-git-diff-tree compares contents of two "tree" objects;\r
+<tt>git-diff-tree</tt> compares contents of two "tree" objects;\r
</p>\r
</li>\r
</ul>\r
</p>\r
</li>\r
</ul>\r
-<p>These are applied in sequence. The set of filepairs git-diff-*\r
+<p>These are applied in sequence. The set of filepairs <tt>git-diff-*</tt>\r
commands find are used as the input to diffcore-pathspec, and\r
the output from diffcore-pathspec is used as the input to the\r
next transformation. The final result is then passed to the\r
output routine and generates either diff-raw format (see Output\r
-format sections of the manual for git-diff-* commands) or\r
+format sections of the manual for <tt>git-diff-*</tt> commands) or\r
diff-patch format.</p>\r
</div>\r
<h2>diffcore-pathspec: For Ignoring Files Outside Our Consideration</h2>\r
<div class="sectionbody">\r
<p>The first transformation in the chain is diffcore-pathspec, and\r
is controlled by giving the pathname parameters to the\r
-git-diff-* commands on the command line. The pathspec is used\r
+<tt>git-diff-*</tt> commands on the command line. The pathspec is used\r
to limit the world diff operates in. It removes the filepairs\r
outside the specified set of pathnames. E.g. If the input set\r
of filepairs included:</p>\r
<div class="content">\r
<pre><tt>:100644 100644 bcd1234... 0123456... M junkfile</tt></pre>\r
</div></div>\r
-<p>but the command invocation was "git-diff-files myfile", then the\r
+<p>but the command invocation was <tt>git diff-files myfile</tt>, then the\r
junkfile entry would be removed from the list because only "myfile"\r
is under consideration.</p>\r
-<p>Implementation note. For performance reasons, git-diff-tree\r
+<p>Implementation note. For performance reasons, <tt>git-diff-tree</tt>\r
uses the pathname parameters on the command line to cull set of\r
filepairs it feeds the diffcore mechanism itself, and does not\r
use diffcore-pathspec, but the end result is the same.</p>\r
<h2>diffcore-break: For Splitting Up "Complete Rewrites"</h2>\r
<div class="sectionbody">\r
<p>The second transformation in the chain is diffcore-break, and is\r
-controlled by the -B option to the git-diff-* commands. This is\r
+controlled by the -B option to the <tt>git-diff-*</tt> commands. This is\r
used to detect a filepair that represents "complete rewrite" and\r
break such filepair into two filepairs that represent delete and\r
create. E.g. If the input contained this filepair:</p>\r
<div class="sectionbody">\r
<p>This transformation is used to detect renames and copies, and is\r
controlled by the -M option (to detect renames) and the -C option\r
-(to detect copies as well) to the git-diff-* commands. If the\r
+(to detect copies as well) to the <tt>git-diff-*</tt> commands. If the\r
input contained these filepairs:</p>\r
<div class="listingblock">\r
<div class="content">\r
number after the "-M" or "-C" option (e.g. "-M8" to tell it to use\r
8/10 = 80%).</p>\r
<p>Note. When the "-C" option is used with <tt>--find-copies-harder</tt>\r
-option, git-diff-* commands feed unmodified filepairs to\r
+option, <tt>git-diff-*</tt> commands feed unmodified filepairs to\r
diffcore mechanism as well as modified ones. This lets the copy\r
detector consider unmodified files as copy source candidates at\r
the expense of making it slower. Without <tt>--find-copies-harder</tt>,\r
-git-diff-* commands can detect copies only if the file that was\r
+<tt>git-diff-*</tt> commands can detect copies only if the file that was\r
copied happened to have been modified in the same changeset.</p>\r
</div>\r
<h2>diffcore-merge-broken: For Putting "Complete Rewrites" Back Together</h2>\r
<div class="sectionbody">\r
<p>This transformation is used to find filepairs that represent\r
changes that touch a specified string, and is controlled by the\r
--S option and the <tt>--pickaxe-all</tt> option to the git-diff-*\r
+-S option and the <tt>--pickaxe-all</tt> option to the <tt>git-diff-*</tt>\r
commands.</p>\r
<p>When diffcore-pickaxe is in use, it checks if there are\r
filepairs whose "original" side has the specified string and\r
<div class="sectionbody">\r
<p>This is used to reorder the filepairs according to the user's\r
(or project's) taste, and is controlled by the -O option to the\r
-git-diff-* commands.</p>\r
+<tt>git-diff-*</tt> commands.</p>\r
<p>This takes a text file each of whose lines is a shell glob\r
pattern. Filepairs that match a glob pattern on an earlier line\r
in the file are output before ones that match a later line, and\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:34 UTC\r
+Last updated 02-Jul-2008 03:02:13 UTC\r
</div>\r
</div>\r
</body>\r
DESCRIPTION
-----------
-The diff commands git-diff-index, git-diff-files, and git-diff-tree
+The diff commands `git-diff-index`, `git-diff-files`, and `git-diff-tree`
can be told to manipulate differences they find in
-unconventional ways before showing diff(1) output. The manipulation
+unconventional ways before showing `diff` output. The manipulation
is collectively called "diffcore transformation". This short note
describes what they are and how to use them to produce diff outputs
that are easier to understand than the conventional kind.
The chain of operation
----------------------
-The git-diff-* family works by first comparing two sets of
+The `git-diff-{asterisk}` family works by first comparing two sets of
files:
- - git-diff-index compares contents of a "tree" object and the
+ - `git-diff-index` compares contents of a "tree" object and the
working directory (when '\--cached' flag is not used) or a
"tree" object and the index file (when '\--cached' flag is
used);
- - git-diff-files compares contents of the index file and the
+ - `git-diff-files` compares contents of the index file and the
working directory;
- - git-diff-tree compares contents of two "tree" objects;
+ - `git-diff-tree` compares contents of two "tree" objects;
In all of these cases, the commands themselves compare
corresponding paths in the two sets of files. The result of
- diffcore-pickaxe
- diffcore-order
-These are applied in sequence. The set of filepairs git-diff-\*
+These are applied in sequence. The set of filepairs `git-diff-{asterisk}`
commands find are used as the input to diffcore-pathspec, and
the output from diffcore-pathspec is used as the input to the
next transformation. The final result is then passed to the
output routine and generates either diff-raw format (see Output
-format sections of the manual for git-diff-\* commands) or
+format sections of the manual for `git-diff-{asterisk}` commands) or
diff-patch format.
The first transformation in the chain is diffcore-pathspec, and
is controlled by giving the pathname parameters to the
-git-diff-* commands on the command line. The pathspec is used
+`git-diff-{asterisk}` commands on the command line. The pathspec is used
to limit the world diff operates in. It removes the filepairs
outside the specified set of pathnames. E.g. If the input set
of filepairs included:
:100644 100644 bcd1234... 0123456... M junkfile
------------------------------------------------
-but the command invocation was "git-diff-files myfile", then the
+but the command invocation was `git diff-files myfile`, then the
junkfile entry would be removed from the list because only "myfile"
is under consideration.
-Implementation note. For performance reasons, git-diff-tree
+Implementation note. For performance reasons, `git-diff-tree`
uses the pathname parameters on the command line to cull set of
filepairs it feeds the diffcore mechanism itself, and does not
use diffcore-pathspec, but the end result is the same.
----------------------------------------------------
The second transformation in the chain is diffcore-break, and is
-controlled by the -B option to the git-diff-* commands. This is
+controlled by the -B option to the `git-diff-{asterisk}` commands. This is
used to detect a filepair that represents "complete rewrite" and
break such filepair into two filepairs that represent delete and
create. E.g. If the input contained this filepair:
This transformation is used to detect renames and copies, and is
controlled by the -M option (to detect renames) and the -C option
-(to detect copies as well) to the git-diff-* commands. If the
+(to detect copies as well) to the `git-diff-{asterisk}` commands. If the
input contained these filepairs:
------------------------------------------------
8/10 = 80%).
Note. When the "-C" option is used with `\--find-copies-harder`
-option, git-diff-\* commands feed unmodified filepairs to
+option, `git-diff-{asterisk}` commands feed unmodified filepairs to
diffcore mechanism as well as modified ones. This lets the copy
detector consider unmodified files as copy source candidates at
the expense of making it slower. Without `\--find-copies-harder`,
-git-diff-\* commands can detect copies only if the file that was
+`git-diff-{asterisk}` commands can detect copies only if the file that was
copied happened to have been modified in the same changeset.
This transformation is used to find filepairs that represent
changes that touch a specified string, and is controlled by the
--S option and the `\--pickaxe-all` option to the git-diff-*
+-S option and the `\--pickaxe-all` option to the `git-diff-{asterisk}`
commands.
When diffcore-pickaxe is in use, it checks if there are
This is used to reorder the filepairs according to the user's
(or project's) taste, and is controlled by the -O option to the
-git-diff-* commands.
+`git-diff-{asterisk}` commands.
This takes a text file each of whose lines is a shell glob
pattern. Filepairs that match a glob pattern on an earlier line
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:32 UTC\r
+Last updated 02-Jul-2008 03:02:12 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<h2>post-merge</h2>\r
<div class="sectionbody">\r
-<p>This hook is invoked by <tt>git-merge</tt>, which happens when a <tt>git pull</tt>\r
+<p>This hook is invoked by <tt>git-merge</tt>, which happens when a <tt>git-pull</tt>\r
is done on a local repository. The hook takes a single parameter, a status\r
flag specifying whether or not the merge being done was a squash merge.\r
This hook cannot affect the outcome of <tt>git-merge</tt> and is not executed,\r
<h2><a id="pre-receive"></a>pre-receive</h2>\r
<div class="sectionbody">\r
<p>This hook is invoked by <tt>git-receive-pack</tt> on the remote repository,\r
-which happens when a <tt>git push</tt> is done on a local repository.\r
+which happens when a <tt>git-push</tt> is done on a local repository.\r
Just before starting to update refs on the remote repository, the\r
pre-receive hook is invoked. Its exit status determines the success\r
or failure of the update.</p>\r
<h2><a id="update"></a>update</h2>\r
<div class="sectionbody">\r
<p>This hook is invoked by <tt>git-receive-pack</tt> on the remote repository,\r
-which happens when a <tt>git push</tt> is done on a local repository.\r
+which happens when a <tt>git-push</tt> is done on a local repository.\r
Just before updating the ref on the remote repository, the update hook\r
is invoked. Its exit status determines the success or failure of\r
the ref update.</p>\r
<h2><a id="post-receive"></a>post-receive</h2>\r
<div class="sectionbody">\r
<p>This hook is invoked by <tt>git-receive-pack</tt> on the remote repository,\r
-which happens when a <tt>git push</tt> is done on a local repository.\r
+which happens when a <tt>git-push</tt> is done on a local repository.\r
It executes on the remote repository once after all the refs have\r
been updated.</p>\r
<p>This hook executes once for the receive operation. It takes no\r
<h2><a id="post-update"></a>post-update</h2>\r
<div class="sectionbody">\r
<p>This hook is invoked by <tt>git-receive-pack</tt> on the remote repository,\r
-which happens when a <tt>git push</tt> is done on a local repository.\r
+which happens when a <tt>git-push</tt> is done on a local repository.\r
It executes on the remote repository once after all the refs have\r
been updated.</p>\r
<p>It takes a variable number of parameters, each of which is the\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 25-Jun-2008 08:07:17 UTC\r
+Last updated 02-Jul-2008 03:02:10 UTC\r
</div>\r
</div>\r
</body>\r
post-merge
-----------
-This hook is invoked by `git-merge`, which happens when a `git pull`
+This hook is invoked by `git-merge`, which happens when a `git-pull`
is done on a local repository. The hook takes a single parameter, a status
flag specifying whether or not the merge being done was a squash merge.
This hook cannot affect the outcome of `git-merge` and is not executed,
-----------
This hook is invoked by `git-receive-pack` on the remote repository,
-which happens when a `git push` is done on a local repository.
+which happens when a `git-push` is done on a local repository.
Just before starting to update refs on the remote repository, the
pre-receive hook is invoked. Its exit status determines the success
or failure of the update.
------
This hook is invoked by `git-receive-pack` on the remote repository,
-which happens when a `git push` is done on a local repository.
+which happens when a `git-push` is done on a local repository.
Just before updating the ref on the remote repository, the update hook
is invoked. Its exit status determines the success or failure of
the ref update.
------------
This hook is invoked by `git-receive-pack` on the remote repository,
-which happens when a `git push` is done on a local repository.
+which happens when a `git-push` is done on a local repository.
It executes on the remote repository once after all the refs have
been updated.
-----------
This hook is invoked by `git-receive-pack` on the remote repository,
-which happens when a `git push` is done on a local repository.
+which happens when a `git-push` is done on a local repository.
It executes on the remote repository once after all the refs have
been updated.
the user's editor of choice) generally go into a file specified by\r
<tt>core.excludesfile</tt> in the user's <tt>~/.gitconfig</tt>.</p>\r
<p>The underlying git plumbing tools, such as\r
-<a href="git-ls-files.html">git-ls-files(1)</a> and <a href="git-read-tree.html">git-read-tree(1)</a>, read\r
+<tt>git-ls-files</tt> and <tt>git-read-tree</tt>, read\r
<tt>gitignore</tt> patterns specified by command-line options, or from\r
files specified by command-line options. Higher-level git\r
-tools, such as <a href="git-status.html">git-status(1)</a> and <a href="git-add.html">git-add(1)</a>,\r
+tools, such as <tt>git-status</tt> and <tt>git-add</tt>,\r
use patterns from the sources specified above.</p>\r
<p>Patterns have the following format:</p>\r
<ul>\r
<p>An example:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt> $ git-status\r
+<pre><tt> $ git status\r
[...]\r
# Untracked files:\r
[...]\r
*.html\r
# except foo.html which is maintained by hand\r
!foo.html\r
- $ git-status\r
+ $ git status\r
[...]\r
# Untracked files:\r
[...]\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:26 UTC\r
+Last updated 02-Jul-2008 03:02:10 UTC\r
</div>\r
</div>\r
</body>\r
`core.excludesfile` in the user's `~/.gitconfig`.
The underlying git plumbing tools, such as
-linkgit:git-ls-files[1] and linkgit:git-read-tree[1], read
+`git-ls-files` and `git-read-tree`, read
`gitignore` patterns specified by command-line options, or from
files specified by command-line options. Higher-level git
-tools, such as linkgit:git-status[1] and linkgit:git-add[1],
+tools, such as `git-status` and `git-add`,
use patterns from the sources specified above.
Patterns have the following format:
An example:
--------------------------------------------------------------
- $ git-status
+ $ git status
[...]
# Untracked files:
[...]
*.html
# except foo.html which is maintained by hand
!foo.html
- $ git-status
+ $ git status
[...]
# Untracked files:
[...]
<h2>OPTIONS</h2>\r
<div class="sectionbody">\r
<p>To control which revisions to shown, the command takes options applicable to\r
-the <a href="git-rev-list.html">git-rev-list(1)</a> command. This manual page describes only the most\r
+the <tt>git-rev-list</tt> command (see <a href="git-rev-list.html">git-rev-list(1)</a>).\r
+This manual page describes only the most\r
frequently used options.</p>\r
<dl>\r
<dt>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 22:47:04 UTC\r
+Last updated 02-Jul-2008 03:02:08 UTC\r
</div>\r
</div>\r
</body>\r
OPTIONS
-------
To control which revisions to shown, the command takes options applicable to
-the linkgit:git-rev-list[1] command. This manual page describes only the most
+the `git-rev-list` command (see linkgit:git-rev-list[1]).
+This manual page describes only the most
frequently used options.
-n <number>::
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:27 UTC\r
+Last updated 02-Jul-2008 03:02:10 UTC\r
</div>\r
</div>\r
</body>\r
are available in this object store. Whenever a pack is\r
added or removed, <tt>git update-server-info</tt> should be run\r
to keep this file up-to-date if the repository is\r
- published for dumb transports. <tt>git repack</tt> does this\r
+ published for dumb transports. <tt>git-repack</tt> does this\r
by default.\r
</p>\r
</dd>\r
<dd>\r
<p>\r
References are stored in subdirectories of this\r
- directory. The <tt>git prune</tt> command knows to keep\r
+ directory. The <tt>git-prune</tt> command knows to keep\r
objects reachable from refs found in this directory and\r
its subdirectories.\r
</p>\r
<dd>\r
<p>\r
A slightly deprecated way to store shorthands to be used\r
- to specify URL to <tt>git fetch</tt>, <tt>git pull</tt> and <tt>git push</tt>\r
+ to specify URL to <tt>git-fetch</tt>, <tt>git-pull</tt> and <tt>git-push</tt>\r
commands is to store a file in <tt>branches/<name></tt> and\r
give <em>name</em> to these commands in place of <em>repository</em>\r
argument.\r
<p>\r
Hooks are customization scripts used by various git\r
commands. A handful of sample hooks are installed when\r
- <tt>git init</tt> is run, but all of them are disabled by\r
+ <tt>git-init</tt> is run, but all of them are disabled by\r
default. To enable, they need to be made executable.\r
- Read <a href="githooks.html">githooks(5)</a>[hooks] for more details about\r
+ Read <a href="githooks.html">githooks(5)</a> for more details about\r
each hook.\r
</p>\r
</dd>\r
This file helps dumb transports discover what refs are\r
available in this repository. If the repository is\r
published for dumb transports, this file should be\r
- regenerated by <tt>git update-server-info</tt> every time a tag\r
+ regenerated by <tt>git-update-server-info</tt> every time a tag\r
or branch is created or modified. This is normally done\r
from the <tt>hooks/update</tt> hook, which is run by the\r
- <tt>git-receive-pack</tt> command when you <tt>git push</tt> into the\r
+ <tt>git-receive-pack</tt> command when you <tt>git-push</tt> into the\r
repository.\r
</p>\r
</dd>\r
<p>\r
This file, by convention among Porcelains, stores the\r
exclude pattern list. <tt>.gitignore</tt> is the per-directory\r
- ignore file. <tt>git status</tt>, <tt>git add</tt>, <tt>git rm</tt> and <tt>git\r
- clean</tt> look at it but the core git commands do not look\r
+ ignore file. <tt>git-status</tt>, <tt>git-add</tt>, <tt>git-rm</tt> and\r
+ <tt>git-clean</tt> look at it but the core git commands do not look\r
at it. See also: <a href="gitignore.html">gitignore(5)</a>.\r
</p>\r
</dd>\r
<dd>\r
<p>\r
Stores shorthands to be used to give URL and default\r
- refnames to interact with remote repository to <tt>git\r
- fetch</tt>, <tt>git pull</tt> and <tt>git push</tt> commands.\r
+ refnames to interact with remote repository to\r
+ <tt>git-fetch</tt>, <tt>git-pull</tt> and <tt>git-push</tt> commands.\r
</p>\r
</dd>\r
<dt>\r
<dd>\r
<p>\r
Records of changes made to refs are stored in this\r
- directory. See the documentation on git-update-ref\r
+ directory. See <a href="git-update-ref.html">git-update-ref(1)</a>\r
for more information.\r
</p>\r
</dd>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:28 UTC\r
+Last updated 02-Jul-2008 03:02:10 UTC\r
</div>\r
</div>\r
</body>\r
are available in this object store. Whenever a pack is
added or removed, `git update-server-info` should be run
to keep this file up-to-date if the repository is
- published for dumb transports. `git repack` does this
+ published for dumb transports. `git-repack` does this
by default.
objects/info/alternates::
refs::
References are stored in subdirectories of this
- directory. The `git prune` command knows to keep
+ directory. The `git-prune` command knows to keep
objects reachable from refs found in this directory and
its subdirectories.
branches::
A slightly deprecated way to store shorthands to be used
- to specify URL to `git fetch`, `git pull` and `git push`
+ to specify URL to `git-fetch`, `git-pull` and `git-push`
commands is to store a file in `branches/<name>` and
give 'name' to these commands in place of 'repository'
argument.
hooks::
Hooks are customization scripts used by various git
commands. A handful of sample hooks are installed when
- `git init` is run, but all of them are disabled by
+ `git-init` is run, but all of them are disabled by
default. To enable, they need to be made executable.
- Read linkgit:githooks[5][hooks] for more details about
+ Read linkgit:githooks[5] for more details about
each hook.
index::
This file helps dumb transports discover what refs are
available in this repository. If the repository is
published for dumb transports, this file should be
- regenerated by `git update-server-info` every time a tag
+ regenerated by `git-update-server-info` every time a tag
or branch is created or modified. This is normally done
from the `hooks/update` hook, which is run by the
- `git-receive-pack` command when you `git push` into the
+ `git-receive-pack` command when you `git-push` into the
repository.
info/grafts::
info/exclude::
This file, by convention among Porcelains, stores the
exclude pattern list. `.gitignore` is the per-directory
- ignore file. `git status`, `git add`, `git rm` and `git
- clean` look at it but the core git commands do not look
+ ignore file. `git-status`, `git-add`, `git-rm` and
+ `git-clean` look at it but the core git commands do not look
at it. See also: linkgit:gitignore[5].
remotes::
Stores shorthands to be used to give URL and default
- refnames to interact with remote repository to `git
- fetch`, `git pull` and `git push` commands.
+ refnames to interact with remote repository to
+ `git-fetch`, `git-pull` and `git-push` commands.
logs::
Records of changes made to refs are stored in this
- directory. See the documentation on git-update-ref
+ directory. See linkgit:git-update-ref[1]
for more information.
logs/refs/heads/`name`::
</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>You should work through <a href="gittutorial.html">gittutorial(7)</a>[A tutorial introduction to\r
-git] before reading this tutorial.</p>\r
+<p>You should work through <a href="gittutorial.html">gittutorial(7)</a> before reading this tutorial.</p>\r
<p>The goal of this tutorial is to introduce two fundamental pieces of\r
git's architecture--the object database and the index file--and to\r
provide the reader with everything necessary to understand the rest\r
following the example above generates a different SHA1 hash than\r
the one shown above because the commit object records the time when\r
it was created and the name of the person performing the commit.</p>\r
-<p>We can ask git about this particular object with the cat-file\r
+<p>We can ask git about this particular object with the <tt>cat-file</tt>\r
command. Don't copy the 40 hex digits from this example but use those\r
from your own version. Note that you can shorten it to only a few\r
characters to save yourself typing all 40 hex digits:</p>\r
</div>\r
<h2>The index file</h2>\r
<div class="sectionbody">\r
-<p>The primary tool we've been using to create commits is "git commit\r
--a", which creates a commit including every change you've made to\r
+<p>The primary tool we've been using to create commits is <tt>git-commit\r
+-a</tt>, which creates a commit including every change you've made to\r
your working tree. But what if you want to commit changes only to\r
certain files? Or only certain changes to certain files?</p>\r
<p>If we look at the way commits are created under the cover, we'll see\r
hello world!\r
+hello world, again</tt></pre>\r
</div></div>\r
-<p>So "git diff" is comparing against something other than the head.\r
+<p>So <tt>git-diff</tt> is comparing against something other than the head.\r
The thing that it's comparing against is actually the index file,\r
which is stored in .git/index in a binary format, but whose contents\r
we can examine with ls-files:</p>\r
hello world!\r
hello world, again</tt></pre>\r
</div></div>\r
-<p>So what our "git add" did was store a new blob and then put\r
+<p>So what our <tt>git-add</tt> did was store a new blob and then put\r
a reference to it in the index file. If we modify the file again,\r
-we'll see that the new modifications are reflected in the "git diff"\r
+we'll see that the new modifications are reflected in the <tt>git-diff</tt>\r
output:</p>\r
<div class="listingblock">\r
<div class="content">\r
hello world, again\r
+again?</tt></pre>\r
</div></div>\r
-<p>With the right arguments, git diff can also show us the difference\r
+<p>With the right arguments, <tt>git-diff</tt> can also show us the difference\r
between the working directory and the last commit, or between the\r
index and the last commit:</p>\r
<div class="listingblock">\r
hello world!\r
+hello world, again</tt></pre>\r
</div></div>\r
-<p>At any time, we can create a new commit using "git commit" (without\r
-the -a option), and verify that the state committed only includes the\r
+<p>At any time, we can create a new commit using <tt>git-commit</tt> (without\r
+the "-a" option), and verify that the state committed only includes the\r
changes stored in the index file, not the additional change that is\r
still only in our working tree:</p>\r
<div class="listingblock">\r
hello world, again\r
+again?</tt></pre>\r
</div></div>\r
-<p>So by default "git commit" uses the index to create the commit, not\r
-the working tree; the -a option to commit tells it to first update\r
+<p>So by default <tt>git-commit</tt> uses the index to create the commit, not\r
+the working tree; the "-a" option to commit tells it to first update\r
the index with all changes in the working tree.</p>\r
-<p>Finally, it's worth looking at the effect of "git add" on the index\r
+<p>Finally, it's worth looking at the effect of <tt>git-add</tt> on the index\r
file:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ echo "goodbye, world" >closing.txt\r
$ git add closing.txt</tt></pre>\r
</div></div>\r
-<p>The effect of the "git add" was to add one entry to the index file:</p>\r
+<p>The effect of the <tt>git-add</tt> was to add one entry to the index file:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git ls-files --stage\r
it is marked "changed but not updated". At this point, running "git\r
commit" would create a commit that added closing.txt (with its new\r
contents), but that didn't modify file.txt.</p>\r
-<p>Also, note that a bare "git diff" shows the changes to file.txt, but\r
+<p>Also, note that a bare <tt>git diff</tt> shows the changes to file.txt, but\r
not the addition of closing.txt, because the version of closing.txt\r
in the index file is identical to the one in the working directory.</p>\r
<p>In addition to being the staging area for new commits, the index file\r
is also populated from the object database when checking out a\r
branch, and is used to hold the trees involved in a merge operation.\r
-See the <a href="gitcore-tutorial.html">gitcore-tutorial(7)</a>[core tutorial] and the relevant man\r
+See <a href="gitcore-tutorial.html">gitcore-tutorial(7)</a> and the relevant man\r
pages for details.</p>\r
</div>\r
<h2>What next?</h2>\r
<p>At this point you should know everything necessary to read the man\r
pages for any of the git commands; one good place to start would be\r
with the commands mentioned in <a href="everyday.html">Everyday git</a>. You\r
-should be able to find any unknown jargon in the\r
-<a href="gitglossary.html">gitglossary(7)</a>[Glossary].</p>\r
+should be able to find any unknown jargon in <a href="gitglossary.html">gitglossary(7)</a>.</p>\r
<p>The <a href="user-manual.html">Git User's Manual</a> provides a more\r
comprehensive introduction to git.</p>\r
-<p>The <a href="gitcvs-migration.html">gitcvs-migration(7)</a>[CVS migration] document explains how to\r
+<p><a href="gitcvs-migration.html">gitcvs-migration(7)</a> explains how to\r
import a CVS repository into git, and shows how to use git in a\r
CVS-like way.</p>\r
<p>For some interesting examples of git use, see the\r
<a href="howto-index.html">howtos</a>.</p>\r
-<p>For git developers, the <a href="gitcore-tutorial.html">gitcore-tutorial(7)</a>[Core tutorial] goes\r
+<p>For git developers, <a href="gitcore-tutorial.html">gitcore-tutorial(7)</a> goes\r
into detail on the lower-level git mechanisms involved in, for\r
example, creating a new commit.</p>\r
</div>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 27-Jun-2008 08:26:24 UTC\r
+Last updated 02-Jul-2008 03:02:11 UTC\r
</div>\r
</div>\r
</body>\r
DESCRIPTION
-----------
-You should work through linkgit:gittutorial[7][A tutorial introduction to
-git] before reading this tutorial.
+You should work through linkgit:gittutorial[7] before reading this tutorial.
The goal of this tutorial is to introduce two fundamental pieces of
git's architecture--the object database and the index file--and to
the one shown above because the commit object records the time when
it was created and the name of the person performing the commit.
-We can ask git about this particular object with the cat-file
+We can ask git about this particular object with the `cat-file`
command. Don't copy the 40 hex digits from this example but use those
from your own version. Note that you can shorten it to only a few
characters to save yourself typing all 40 hex digits:
The index file
--------------
-The primary tool we've been using to create commits is "git commit
--a", which creates a commit including every change you've made to
+The primary tool we've been using to create commits is `git-commit
+-a`, which creates a commit including every change you've made to
your working tree. But what if you want to commit changes only to
certain files? Or only certain changes to certain files?
+hello world, again
------------------------------------------------
-So "git diff" is comparing against something other than the head.
+So `git-diff` is comparing against something other than the head.
The thing that it's comparing against is actually the index file,
which is stored in .git/index in a binary format, but whose contents
we can examine with ls-files:
hello world, again
------------------------------------------------
-So what our "git add" did was store a new blob and then put
+So what our `git-add` did was store a new blob and then put
a reference to it in the index file. If we modify the file again,
-we'll see that the new modifications are reflected in the "git diff"
+we'll see that the new modifications are reflected in the `git-diff`
output:
------------------------------------------------
+again?
------------------------------------------------
-With the right arguments, git diff can also show us the difference
+With the right arguments, `git-diff` can also show us the difference
between the working directory and the last commit, or between the
index and the last commit:
+hello world, again
------------------------------------------------
-At any time, we can create a new commit using "git commit" (without
-the -a option), and verify that the state committed only includes the
+At any time, we can create a new commit using `git-commit` (without
+the "-a" option), and verify that the state committed only includes the
changes stored in the index file, not the additional change that is
still only in our working tree:
+again?
------------------------------------------------
-So by default "git commit" uses the index to create the commit, not
-the working tree; the -a option to commit tells it to first update
+So by default `git-commit` uses the index to create the commit, not
+the working tree; the "-a" option to commit tells it to first update
the index with all changes in the working tree.
-Finally, it's worth looking at the effect of "git add" on the index
+Finally, it's worth looking at the effect of `git-add` on the index
file:
------------------------------------------------
$ git add closing.txt
------------------------------------------------
-The effect of the "git add" was to add one entry to the index file:
+The effect of the `git-add` was to add one entry to the index file:
------------------------------------------------
$ git ls-files --stage
commit" would create a commit that added closing.txt (with its new
contents), but that didn't modify file.txt.
-Also, note that a bare "git diff" shows the changes to file.txt, but
+Also, note that a bare `git diff` shows the changes to file.txt, but
not the addition of closing.txt, because the version of closing.txt
in the index file is identical to the one in the working directory.
In addition to being the staging area for new commits, the index file
is also populated from the object database when checking out a
branch, and is used to hold the trees involved in a merge operation.
-See the linkgit:gitcore-tutorial[7][core tutorial] and the relevant man
+See linkgit:gitcore-tutorial[7] and the relevant man
pages for details.
What next?
At this point you should know everything necessary to read the man
pages for any of the git commands; one good place to start would be
with the commands mentioned in link:everyday.html[Everyday git]. You
-should be able to find any unknown jargon in the
-linkgit:gitglossary[7][Glossary].
+should be able to find any unknown jargon in linkgit:gitglossary[7].
The link:user-manual.html[Git User's Manual] provides a more
comprehensive introduction to git.
-The linkgit:gitcvs-migration[7][CVS migration] document explains how to
+linkgit:gitcvs-migration[7] explains how to
import a CVS repository into git, and shows how to use git in a
CVS-like way.
For some interesting examples of git use, see the
link:howto-index.html[howtos].
-For git developers, the linkgit:gitcore-tutorial[7][Core tutorial] goes
+For git developers, linkgit:gitcore-tutorial[7] goes
into detail on the lower-level git mechanisms involved in, for
example, creating a new commit.
<p>If you are instead primarily interested in using git to fetch a project,\r
for example, to test the latest version, you may prefer to start with\r
the first two chapters of <a href="user-manual.html">The Git User's Manual</a>.</p>\r
-<p>First, note that you can get documentation for a command such as "git\r
-diff" with:</p>\r
+<p>First, note that you can get documentation for a command such as\r
+<tt>git log --graph</tt> with:</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ man git-diff</tt></pre>\r
+<pre><tt>$ man git-log</tt></pre>\r
</div></div>\r
<p>It is a good idea to introduce yourself to git with your name and\r
public email address before doing any operation. The easiest\r
<p>You've now initialized the working directory--you may notice a new\r
directory created, named ".git".</p>\r
<p>Next, tell git to take a snapshot of the contents of all files under the\r
-current directory (note the <em>.</em>), with <a href="git-add.html">git-add(1)</a>:</p>\r
+current directory (note the <em>.</em>), with <tt>git-add</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git add .</tt></pre>\r
</div></div>\r
<p>This snapshot is now stored in a temporary staging area which git calls\r
the "index". You can permanently store the contents of the index in the\r
-repository with <a href="git-commit.html">git-commit(1)</a>:</p>\r
+repository with <tt>git-commit</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git commit</tt></pre>\r
<pre><tt>$ git add file1 file2 file3</tt></pre>\r
</div></div>\r
<p>You are now ready to commit. You can see what is about to be committed\r
-using <a href="git-diff.html">git-diff(1)</a> with the --cached option:</p>\r
+using <tt>git-diff</tt> with the --cached option:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git diff --cached</tt></pre>\r
</div></div>\r
-<p>(Without --cached, <a href="git-diff.html">git-diff(1)</a> will show you any changes that\r
+<p>(Without --cached, <tt>git-diff</tt> will show you any changes that\r
you've made but not yet added to the index.) You can also get a brief\r
-summary of the situation with <a href="git-status.html">git-status(1)</a>:</p>\r
+summary of the situation with <tt>git-status</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git status\r
</div></div>\r
<p>This will again prompt you for a message describing the change, and then\r
record a new version of the project.</p>\r
-<p>Alternatively, instead of running <tt>git add</tt> beforehand, you can use</p>\r
+<p>Alternatively, instead of running <tt>git-add</tt> beforehand, you can use</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git commit -a</tt></pre>\r
</div>\r
<h2>Git tracks content not files</h2>\r
<div class="sectionbody">\r
-<p>Many revision control systems provide an "add" command that tells the\r
-system to start tracking changes to a new file. Git's "add" command\r
-does something simpler and more powerful: <tt>git add</tt> is used both for new\r
+<p>Many revision control systems provide an <tt>add</tt> command that tells the\r
+system to start tracking changes to a new file. Git's <tt>add</tt> command\r
+does something simpler and more powerful: <tt>git-add</tt> is used both for new\r
and newly modified files, and in both cases it takes a snapshot of the\r
given files and stages that content in the index, ready for inclusion in\r
the next commit.</p>\r
<pre><tt>$ git remote add bob /home/bob/myrepo</tt></pre>\r
</div></div>\r
<p>With this, Alice can perform the first operation alone using the\r
-"git fetch" command without merging them with her own branch,\r
+<tt>git-fetch</tt> command without merging them with her own branch,\r
using:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git fetch bob</tt></pre>\r
</div></div>\r
<p>Unlike the longhand form, when Alice fetches from Bob using a\r
-remote repository shorthand set up with <tt>git remote</tt>, what was\r
+remote repository shorthand set up with <tt>git-remote</tt>, what was\r
fetched is stored in a remote tracking branch, in this case\r
<tt>bob/master</tt>. So after this:</p>\r
<div class="listingblock">\r
<pre><tt>$ git config --get remote.origin.url\r
/home/alice/project</tt></pre>\r
</div></div>\r
-<p>(The complete configuration created by git-clone is visible using\r
-
"git config -l", and the <a href="git-config.html">git-config(1)</a> man page
\r+<p>(The complete configuration created by <tt>git-clone</tt> is visible using\r
+
<tt>git config -l</tt>, and the <a href="git-config.html">git-config(1)</a> man page
\r explains the meaning of each option.)</p>\r
<p>Git also keeps a pristine copy of Alice's master branch under the\r
name "origin/master":</p>\r
see <a href="git-pull.html">git-pull(1)</a> for details.</p>\r
<p>Git can also be used in a CVS-like mode, with a central repository\r
that various users push changes to; see <a href="git-push.html">git-push(1)</a> and\r
-<a href="gitcvs-migration.html">gitcvs-migration(7)</a>[git for CVS users].</p>\r
+<a href="gitcvs-migration.html">gitcvs-migration(7)</a>.</p>\r
</div>\r
<h2>Exploring history</h2>\r
<div class="sectionbody">\r
<p>Git history is represented as a series of interrelated commits. We\r
-have already seen that the git log command can list those commits.\r
+have already seen that the <tt>git-log</tt> command can list those commits.\r
Note that first line of each git log entry also gives a name for the\r
commit:</p>\r
<div class="listingblock">\r
\r
merge-base: Clarify the comments on post processing.</tt></pre>\r
</div></div>\r
-<p>We can give this name to git show to see the details about this\r
+<p>We can give this name to <tt>git-show</tt> to see the details about this\r
commit.</p>\r
<div class="listingblock">\r
<div class="content">\r
<p>You can also give commits names of your own; after running</p>\r
<div class="listingblock">\r
<div class="content">\r
-<pre><tt>$ git-tag v2.5 1b2e1d63ff</tt></pre>\r
+<pre><tt>$ git tag v2.5 1b2e1d63ff</tt></pre>\r
</div></div>\r
<p>you can refer to 1b2e1d63ff by the name "v2.5". If you intend to\r
share this name with other people (for example, to identify a release\r
<p>Be careful with that last command: in addition to losing any changes\r
in the working directory, it will also remove all later commits from\r
this branch. If this branch is the only branch containing those\r
-commits, they will be lost. Also, don't use "git reset" on a\r
+commits, they will be lost. Also, don't use <tt>git-reset</tt> on a\r
publicly-visible branch that other developers pull from, as it will\r
force needless merges on other developers to clean up the history.\r
-If you need to undo changes that you have pushed, use <a href="git-revert.html">git-revert(1)</a>\r
+If you need to undo changes that you have pushed, use <tt>git-revert</tt>\r
instead.</p>\r
-<p>The git grep command can search for strings in any version of your\r
+<p>The <tt>git-grep</tt> command can search for strings in any version of your\r
project, so</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git grep "hello" v2.5</tt></pre>\r
</div></div>\r
<p>searches for all occurrences of "hello" in v2.5.</p>\r
-<p>If you leave out the commit name, git grep will search any of the\r
+<p>If you leave out the commit name, <tt>git-grep</tt> will search any of the\r
files it manages in your current directory. So</p>\r
<div class="listingblock">\r
<div class="content">\r
</div></div>\r
<p>is a quick way to search just the files that are tracked by git.</p>\r
<p>Many git commands also take sets of commits, which can be specified\r
-in a number of ways. Here are some examples with git log:</p>\r
+in a number of ways. Here are some examples with <tt>git-log</tt>:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git log v2.5..v2.6 # commits between v2.5 and v2.6\r
$ git log v2.5.. Makefile # commits since v2.5 which modify\r
# Makefile</tt></pre>\r
</div></div>\r
-<p>You can also give git log a "range" of commits where the first is not\r
+<p>You can also give <tt>git-log</tt> a "range" of commits where the first is not\r
necessarily an ancestor of the second; for example, if the tips of\r
the branches "stable-release" and "master" diverged from a common\r
commit some time ago, then</p>\r
</div></div>\r
<p>will show the list of commits made on the stable branch but not\r
the experimental branch.</p>\r
-<p>The "git log" command has a weakness: it must present commits in a\r
+<p>The <tt>git-log</tt> command has a weakness: it must present commits in a\r
list. When the history has lines of development that diverged and\r
-then merged back together, the order in which "git log" presents\r
+then merged back together, the order in which <tt>git-log</tt> presents\r
those commits is meaningless.</p>\r
<p>Most projects with multiple contributors (such as the linux kernel,\r
-or git itself) have frequent merges, and gitk does a better job of\r
+or git itself) have frequent merges, and <tt>gitk</tt> does a better job of\r
visualizing their history. For example,</p>\r
<div class="listingblock">\r
<div class="content">\r
<div class="content">\r
<pre><tt>$ git diff v2.5:Makefile HEAD:Makefile.in</tt></pre>\r
</div></div>\r
-<p>You can also use "git show" to see any such file:</p>\r
+<p>You can also use <tt>git-show</tt> to see any such file:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git show v2.5:Makefile</tt></pre>\r
</p>\r
</li>\r
</ul>\r
-<p><a href="gittutorial-2.html">gittutorial-2(7)</a>[Part two of this tutorial] explains the object\r
+<p>Part two of this tutorial explains the object\r
database, the index file, and a few other odds and ends that you'll\r
-need to make the most of git.</p>\r
+need to make the most of git. You can find it at <a href="gittutorial-2.html">gittutorial-2(7)</a>.</p>\r
<p>If you don't want to continue with that right away, a few other\r
digressions that may be interesting at this point are:</p>\r
<ul>\r
</li>\r
<li>\r
<p>\r
-<a href="gitcvs-migration.html">gitcvs-migration(7)</a>[git for CVS users].\r
+<a href="gitcvs-migration.html">gitcvs-migration(7)</a>: Git for CVS users.\r
</p>\r
</li>\r
</ul>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 13-Jun-2008 10:02:46 UTC\r
+Last updated 02-Jul-2008 03:02:11 UTC\r
</div>\r
</div>\r
</body>\r
for example, to test the latest version, you may prefer to start with
the first two chapters of link:user-manual.html[The Git User's Manual].
-First, note that you can get documentation for a command such as "git
-diff" with:
+First, note that you can get documentation for a command such as
+`git log --graph` with:
------------------------------------------------
-$ man git-diff
+$ man git-log
------------------------------------------------
It is a good idea to introduce yourself to git with your name and
directory created, named ".git".
Next, tell git to take a snapshot of the contents of all files under the
-current directory (note the '.'), with linkgit:git-add[1]:
+current directory (note the '.'), with `git-add`:
------------------------------------------------
$ git add .
This snapshot is now stored in a temporary staging area which git calls
the "index". You can permanently store the contents of the index in the
-repository with linkgit:git-commit[1]:
+repository with `git-commit`:
------------------------------------------------
$ git commit
------------------------------------------------
You are now ready to commit. You can see what is about to be committed
-using linkgit:git-diff[1] with the --cached option:
+using `git-diff` with the --cached option:
------------------------------------------------
$ git diff --cached
------------------------------------------------
-(Without --cached, linkgit:git-diff[1] will show you any changes that
+(Without --cached, `git-diff` will show you any changes that
you've made but not yet added to the index.) You can also get a brief
-summary of the situation with linkgit:git-status[1]:
+summary of the situation with `git-status`:
------------------------------------------------
$ git status
This will again prompt you for a message describing the change, and then
record a new version of the project.
-Alternatively, instead of running `git add` beforehand, you can use
+Alternatively, instead of running `git-add` beforehand, you can use
------------------------------------------------
$ git commit -a
Git tracks content not files
----------------------------
-Many revision control systems provide an "add" command that tells the
-system to start tracking changes to a new file. Git's "add" command
-does something simpler and more powerful: `git add` is used both for new
+Many revision control systems provide an `add` command that tells the
+system to start tracking changes to a new file. Git's `add` command
+does something simpler and more powerful: `git-add` is used both for new
and newly modified files, and in both cases it takes a snapshot of the
given files and stages that content in the index, ready for inclusion in
the next commit.
------------------------------------------------
With this, Alice can perform the first operation alone using the
-"git fetch" command without merging them with her own branch,
+`git-fetch` command without merging them with her own branch,
using:
-------------------------------------
-------------------------------------
Unlike the longhand form, when Alice fetches from Bob using a
-remote repository shorthand set up with `git remote`, what was
+remote repository shorthand set up with `git-remote`, what was
fetched is stored in a remote tracking branch, in this case
`bob/master`. So after this:
/home/alice/project
-------------------------------------
-(The complete configuration created by git-clone is visible using
-"git config -l", and the linkgit:git-config[1] man page
+(The complete configuration created by `git-clone` is visible using
+`git config -l`, and the linkgit:git-config[1] man page
explains the meaning of each option.)
Git also keeps a pristine copy of Alice's master branch under the
Git can also be used in a CVS-like mode, with a central repository
that various users push changes to; see linkgit:git-push[1] and
-linkgit:gitcvs-migration[7][git for CVS users].
+linkgit:gitcvs-migration[7].
Exploring history
-----------------
Git history is represented as a series of interrelated commits. We
-have already seen that the git log command can list those commits.
+have already seen that the `git-log` command can list those commits.
Note that first line of each git log entry also gives a name for the
commit:
merge-base: Clarify the comments on post processing.
-------------------------------------
-We can give this name to git show to see the details about this
+We can give this name to `git-show` to see the details about this
commit.
-------------------------------------
You can also give commits names of your own; after running
-------------------------------------
-$ git-tag v2.5 1b2e1d63ff
+$ git tag v2.5 1b2e1d63ff
-------------------------------------
you can refer to 1b2e1d63ff by the name "v2.5". If you intend to
Be careful with that last command: in addition to losing any changes
in the working directory, it will also remove all later commits from
this branch. If this branch is the only branch containing those
-commits, they will be lost. Also, don't use "git reset" on a
+commits, they will be lost. Also, don't use `git-reset` on a
publicly-visible branch that other developers pull from, as it will
force needless merges on other developers to clean up the history.
-If you need to undo changes that you have pushed, use linkgit:git-revert[1]
+If you need to undo changes that you have pushed, use `git-revert`
instead.
-The git grep command can search for strings in any version of your
+The `git-grep` command can search for strings in any version of your
project, so
-------------------------------------
searches for all occurrences of "hello" in v2.5.
-If you leave out the commit name, git grep will search any of the
+If you leave out the commit name, `git-grep` will search any of the
files it manages in your current directory. So
-------------------------------------
is a quick way to search just the files that are tracked by git.
Many git commands also take sets of commits, which can be specified
-in a number of ways. Here are some examples with git log:
+in a number of ways. Here are some examples with `git-log`:
-------------------------------------
$ git log v2.5..v2.6 # commits between v2.5 and v2.6
# Makefile
-------------------------------------
-You can also give git log a "range" of commits where the first is not
+You can also give `git-log` a "range" of commits where the first is not
necessarily an ancestor of the second; for example, if the tips of
the branches "stable-release" and "master" diverged from a common
commit some time ago, then
will show the list of commits made on the stable branch but not
the experimental branch.
-The "git log" command has a weakness: it must present commits in a
+The `git-log` command has a weakness: it must present commits in a
list. When the history has lines of development that diverged and
-then merged back together, the order in which "git log" presents
+then merged back together, the order in which `git-log` presents
those commits is meaningless.
Most projects with multiple contributors (such as the linux kernel,
-or git itself) have frequent merges, and gitk does a better job of
+or git itself) have frequent merges, and `gitk` does a better job of
visualizing their history. For example,
-------------------------------------
$ git diff v2.5:Makefile HEAD:Makefile.in
-------------------------------------
-You can also use "git show" to see any such file:
+You can also use `git-show` to see any such file:
-------------------------------------
$ git show v2.5:Makefile
used to create commits, check out working directories, and
hold the various trees involved in a merge.
-linkgit:gittutorial-2[7][Part two of this tutorial] explains the object
+Part two of this tutorial explains the object
database, the index file, and a few other odds and ends that you'll
-need to make the most of git.
+need to make the most of git. You can find it at linkgit:gittutorial-2[7].
If you don't want to continue with that right away, a few other
digressions that may be interesting at this point are:
* link:everyday.html[Everyday GIT with 20 Commands Or So]
- * linkgit:gitcvs-migration[7][git for CVS users].
+ * linkgit:gitcvs-migration[7]: Git for CVS users.
SEE ALSO
--------
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 26-Jun-2008 06:33:16 UTC\r
+Last updated 02-Jul-2008 03:02:14 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:36 UTC\r
+Last updated 02-Jul-2008 03:02:15 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:36 UTC\r
+Last updated 02-Jul-2008 03:02:15 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:37 UTC\r
+Last updated 02-Jul-2008 03:02:16 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 23-Jun-2008 07:13:38 UTC\r
+Last updated 02-Jul-2008 03:02:16 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:38 UTC\r
+Last updated 02-Jul-2008 03:02:17 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:39 UTC\r
+Last updated 02-Jul-2008 03:02:17 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:40 UTC\r
+Last updated 02-Jul-2008 03:02:17 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:40 UTC\r
+Last updated 02-Jul-2008 03:02:18 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:41 UTC\r
+Last updated 02-Jul-2008 03:02:18 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:42 UTC\r
+Last updated 02-Jul-2008 03:02:18 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:42 UTC\r
+Last updated 02-Jul-2008 03:02:19 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:43 UTC\r
+Last updated 02-Jul-2008 03:02:19 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:53 UTC\r
+Last updated 02-Jul-2008 03:02:23 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:43 UTC\r
+Last updated 02-Jul-2008 03:02:19 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:44 UTC\r
+Last updated 02-Jul-2008 03:02:20 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 23-Jun-2008 07:13:38 UTC\r
+Last updated 02-Jul-2008 03:02:20 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 18-Jun-2008 03:17:08 UTC\r
+Last updated 02-Jul-2008 03:02:21 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:46 UTC\r
+Last updated 02-Jul-2008 03:02:21 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:47 UTC\r
+Last updated 02-Jul-2008 03:02:21 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:47 UTC\r
+Last updated 02-Jul-2008 03:02:22 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 18-Jun-2008 03:17:08 UTC\r
+Last updated 02-Jul-2008 03:02:22 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:48 UTC\r
+Last updated 02-Jul-2008 03:02:22 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:48 UTC\r
+Last updated 02-Jul-2008 03:02:22 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:49 UTC\r
+Last updated 02-Jul-2008 03:02:22 UTC\r
</div>\r
</div>\r
</body>\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 08-Jun-2008 01:34:49 UTC\r
+Last updated 02-Jul-2008 03:02:23 UTC\r
</div>\r
</div>\r
</body>\r
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Git User's Manual (for version 1.5.3 or newer)</title><link rel="stylesheet" href="docbook-xsl.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.69.1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="book" lang="en"><div class="titlepage"><div><div><h1 class="title"><a name="id189136"></a>Git User's Manual (for version 1.5.3 or newer)</h1></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="preface"><a href="#id264725">Preface</a></span></dt><dt><span class="chapter"><a href="#repositories-and-branches">1. Repositories and Branches</a></span></dt><dd><dl><dt><span class="section"><a href="#how-to-get-a-git-repository">How to get a git repository</a></span></dt><dt><span class="section"><a href="#how-to-check-out">How to check out a different version of a project</a></span></dt><dt><span class="section"><a href="#understanding-commits">Understanding History: Commits</a></span></dt><dd><dl><dt><span class="section"><a href="#understanding-reachability">Understanding history: commits, parents, and reachability</a></span></dt><dt><span class="section"><a href="#history-diagrams">Understanding history: History diagrams</a></span></dt><dt><span class="section"><a href="#what-is-a-branch">Understanding history: What is a branch?</a></span></dt></dl></dd><dt><span class="section"><a href="#manipulating-branches">Manipulating branches</a></span></dt><dt><span class="section"><a href="#detached-head">Examining an old version without creating a new branch</a></span></dt><dt><span class="section"><a href="#examining-remote-branches">Examining branches from a remote repository</a></span></dt><dt><span class="section"><a href="#how-git-stores-references">Naming branches, tags, and other references</a></span></dt><dt><span class="section"><a href="#Updating-a-repository-with-git-fetch">Updating a repository with git
fetch</a></span></dt><dt><span class="section"><a href="#fetching-branches">Fetching branches from other repositories</a></span></dt></dl></dd><dt><span class="chapter"><a href="#exploring-git-history">2. Exploring git history</a></span></dt><dd><dl><dt><span class="section"><a href="#using-bisect">How to use bisect to find a regression</a></span></dt><dt><span class="section"><a href="#naming-commits">Naming commits</a></span></dt><dt><span class="section"><a href="#creating-tags">Creating tags</a></span></dt><dt><span class="section"><a href="#browsing-revisions">Browsing revisions</a></span></dt><dt><span class="section"><a href="#generating-diffs">Generating diffs</a></span></dt><dt><span class="section"><a href="#viewing-old-file-versions">Viewing old file versions</a></span></dt><dt><span class="section"><a href="#history-examples">Examples</a></span></dt><dd><dl><dt><span class="section"><a href="#counting-commits-on-a-branch">Counting the number of commits on a branch</a></span></dt><dt><span class="section"><a href="#checking-for-equal-branches">Check whether two branches point at the same history</a></span></dt><dt><span class="section"><a href="#finding-tagged-descendants">Find first tagged version including a given fix</a></span></dt><dt><span class="section"><a href="#showing-commits-unique-to-a-branch">Showing commits unique to a given branch</a></span></dt><dt><span class="section"><a href="#making-a-release">Creating a changelog and tarball for a software release</a></span></dt><dt><span class="section"><a href="#Finding-comments-with-given-content">Finding commits referencing a file with given content</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#Developing-with-git">3. Developing with git</a></span></dt><dd><dl><dt><span class="section"><a href="#telling-git-your-name">Telling git your name</a></span></dt><dt><span class="section"><a href="#creating-a-new-repository">Creating a new repository</a></span></dt><dt><span class="section"><a href="#how-to-make-a-commit">How to make a commit</a></span></dt><dt><span class="section"><a href="#creating-good-commit-messages">Creating good commit messages</a></span></dt><dt><span class="section"><a href="#ignoring-files">Ignoring files</a></span></dt><dt><span class="section"><a href="#how-to-merge">How to merge</a></span></dt><dt><span class="section"><a href="#resolving-a-merge">Resolving a merge</a></span></dt><dd><dl><dt><span class="section"><a href="#conflict-resolution">Getting conflict-resolution help during a merge</a></span></dt></dl></dd><dt><span class="section"><a href="#undoing-a-merge">Undoing a merge</a></span></dt><dt><span class="section"><a href="#fast-forwards">Fast-forward merges</a></span></dt><dt><span class="section"><a href="#fixing-mistakes">Fixing mistakes</a></span></dt><dd><dl><dt><span class="section"><a href="#reverting-a-commit">Fixing a mistake with a new commit</a></span></dt><dt><span class="section"><a href="#fixing-a-mistake-by-rewriting-history">Fixing a mistake by rewriting history</a></span></dt><dt><span class="section"><a href="#checkout-of-path">Checking out an old version of a file</a></span></dt><dt><span class="section"><a href="#interrupted-work">Temporarily setting aside work in progress</a></span></dt></dl></dd><dt><span class="section"><a href="#ensuring-good-performance">Ensuring good performance</a></span></dt><dt><span class="section"><a href="#ensuring-reliability">Ensuring reliability</a></span></dt><dd><dl><dt><span class="section"><a href="#checking-for-corruption">Checking the repository for corruption</a></span></dt><dt><span class="section"><a href="#recovering-lost-changes">Recovering lost changes</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#sharing-development">4. Sharing development with others</a></span></dt><dd><dl><dt><span class="section"><a href="#getting-updates-with-git-pull">Getting updates with git pull</a></span></dt><dt><span class="section"><a href="#submitting-patches">Submitting patches to a project</a></span></dt><dt><span class="section"><a href="#importing-patches">Importing patches to a project</a></span></dt><dt><span class="section"><a href="#public-repositories">Public git repositories</a></span></dt><dd><dl><dt><span class="section"><a href="#setting-up-a-public-repository">Setting up a public repository</a></span></dt><dt><span class="section"><a href="#exporting-via-git">Exporting a git repository via the git protocol</a></span></dt><dt><span class="section"><a href="#exporting-via-http">Exporting a git repository via http</a></span></dt><dt><span class="section"><a href="#pushing-changes-to-a-public-repository">Pushing changes to a public repository</a></span></dt><dt><span class="section"><a href="#forcing-push">What to do when a push fails</a></span></dt><dt><span class="section"><a href="#setting-up-a-shared-repository">Setting up a shared repository</a></span></dt><dt><span class="section"><a href="#setting-up-gitweb">Allowing web browsing of a repository</a></span></dt></dl></dd><dt><span class="section"><a href="#sharing-development-examples">Examples</a></span></dt><dd><dl><dt><span class="section"><a href="#maintaining-topic-branches">Maintaining topic branches for a Linux subsystem maintainer</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#cleaning-up-history">5. Rewriting history and maintaining patch series</a></span></dt><dd><dl><dt><span class="section"><a href="#patch-series">Creating the perfect patch series</a></span></dt><dt><span class="section"><a href="#using-git-rebase">Keeping a patch series up to date using git-rebase</a></span></dt><dt><span class="section"><a href="#rewriting-one-commit">Rewriting a single commit</a></span></dt><dt><span class="section"><a href="#reordering-patch-series">Reordering or selecting from a patch series</a></span></dt><dt><span class="section"><a href="#patch-series-tools">Other tools</a></span></dt><dt><span class="section"><a href="#problems-with-rewriting-history">Problems with rewriting history</a></span></dt><dt><span class="section"><a href="#bisect-merges">Why bisecting merge commits can be harder than bisecting linear history</a></span></dt></dl></dd><dt><span class="chapter"><a href="#advanced-branch-management">6. Advanced branch management</a></span></dt><dd><dl><dt><span class="section"><a href="#fetching-individual-branches">Fetching individual branches</a></span></dt><dt><span class="section"><a href="#fetch-fast-forwards">git fetch and fast-forwards</a></span></dt><dt><span class="section"><a href="#forcing-fetch">Forcing git fetch to do non-fast-forward updates</a></span></dt><dt><span class="section"><a href="#remote-branch-configuration">Configuring remote branches</a></span></dt></dl></dd><dt><span class="chapter"><a href="#git-concepts">7. Git concepts</a></span></dt><dd><dl><dt><span class="section"><a href="#the-object-database">The Object Database</a></span></dt><dd><dl><dt><span class="section"><a href="#commit-object">Commit Object</a></span></dt><dt><span class="section"><a href="#tree-object">Tree Object</a></span></dt><dt><span class="section"><a href="#blob-object">Blob Object</a></span></dt><dt><span class="section"><a href="#trust">Trust</a></span></dt><dt><span class="section"><a href="#tag-object">Tag Object</a></span></dt><dt><span class="section"><a href="#pack-files">How git stores objects efficiently: pack files</a></span></dt><dt><span class="section"><a href="#dangling-objects">Dangling objects</a></span></dt><dt><span class="section"><a href="#recovering-from-repository-corruption">Recovering from repository corruption</a></span></dt></dl></dd><dt><span class="section"><a href="#the-index">The index</a></span></dt></dl></dd><dt><span class="chapter"><a href="#submodules">8. Submodules</a></span></dt><dd><dl><dt><span class="section"><a href="#id280264">Pitfalls with submodules</a></span></dt></dl></dd><dt><span class="chapter"><a href="#low-level-operations">9. Low-level git operations</a></span></dt><dd><dl><dt><span class="section"><a href="#object-manipulation">Object access and manipulation</a></span></dt><dt><span class="section"><a href="#the-workflow">The Workflow</a></span></dt><dd><dl><dt><span class="section"><a href="#working-directory-to-index">working directory -> index</a></span></dt><dt><span class="section"><a href="#index-to-object-database">index -> object database</a></span></dt><dt><span class="section"><a href="#object-database-to-index">object database -> index</a></span></dt><dt><span class="section"><a href="#index-to-working-directory">index -> working directory</a></span></dt><dt><span class="section"><a href="#tying-it-all-together">Tying it all together</a></span></dt></dl></dd><dt><span class="section"><a href="#examining-the-data">Examining the data</a></span></dt><dt><span class="section"><a href="#merging-multiple-trees">Merging multiple trees</a></span></dt><dt><span class="section"><a href="#merging-multiple-trees-2">Merging multiple trees, continued</a></span></dt></dl></dd><dt><span class="chapter"><a href="#hacking-git">10. Hacking git</a></span></dt><dd><dl><dt><span class="section"><a href="#object-details">Object storage format</a></span></dt><dt><span class="section"><a href="#birdview-on-the-source-code">A birds-eye view of Git's source code</a></span></dt></dl></dd><dt><span class="chapter"><a href="#glossary">11. GIT Glossary</a></span></dt><dt><span class="appendix"><a href="#git-quick-start">A. Git Quick Reference</a></span></dt><dd><dl><dt><span class="section"><a href="#quick-creating-a-new-repository">Creating a new repository</a></span></dt><dt><span class="section"><a href="#managing-branches">Managing branches</a></span></dt><dt><span class="section"><a href="#exploring-history">Exploring history</a></span></dt><dt><span class="section"><a href="#making-changes">Making changes</a></span></dt><dt><span class="section"><a href="#merging">Merging</a></span></dt><dt><span class="section"><a href="#sharing-your-changes">Sharing your changes</a></span></dt><dt><span class="section"><a href="#repository-maintenance">Repository maintenance</a></span></dt></dl></dd><dt><span class="appendix"><a href="#todo">B. Notes and todo list for this manual</a></span></dt></dl></div><div class="preface" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="id264725"></a>Preface</h2></div></div></div><p>Git is a fast distributed revision control system.</p><p>This manual is designed to be readable by someone with basic UNIX
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Git User's Manual (for version 1.5.3 or newer)</title><link rel="stylesheet" href="docbook-xsl.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.69.1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="book" lang="en"><div class="titlepage"><div><div><h1 class="title"><a name="id189136"></a>Git User's Manual (for version 1.5.3 or newer)</h1></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="preface"><a href="#id264725">Preface</a></span></dt><dt><span class="chapter"><a href="#repositories-and-branches">1. Repositories and Branches</a></span></dt><dd><dl><dt><span class="section"><a href="#how-to-get-a-git-repository">How to get a git repository</a></span></dt><dt><span class="section"><a href="#how-to-check-out">How to check out a different version of a project</a></span></dt><dt><span class="section"><a href="#understanding-commits">Understanding History: Commits</a></span></dt><dd><dl><dt><span class="section"><a href="#understanding-reachability">Understanding history: commits, parents, and reachability</a></span></dt><dt><span class="section"><a href="#history-diagrams">Understanding history: History diagrams</a></span></dt><dt><span class="section"><a href="#what-is-a-branch">Understanding history: What is a branch?</a></span></dt></dl></dd><dt><span class="section"><a href="#manipulating-branches">Manipulating branches</a></span></dt><dt><span class="section"><a href="#detached-head">Examining an old version without creating a new branch</a></span></dt><dt><span class="section"><a href="#examining-remote-branches">Examining branches from a remote repository</a></span></dt><dt><span class="section"><a href="#how-git-stores-references">Naming branches, tags, and other references</a></span></dt><dt><span class="section"><a href="#Updating-a-repository-with-git-fetch">Updating a repository with git
-fetch</a></span></dt><dt><span class="section"><a href="#fetching-branches">Fetching branches from other repositories</a></span></dt></dl></dd><dt><span class="chapter"><a href="#exploring-git-history">2. Exploring git history</a></span></dt><dd><dl><dt><span class="section"><a href="#using-bisect">How to use bisect to find a regression</a></span></dt><dt><span class="section"><a href="#naming-commits">Naming commits</a></span></dt><dt><span class="section"><a href="#creating-tags">Creating tags</a></span></dt><dt><span class="section"><a href="#browsing-revisions">Browsing revisions</a></span></dt><dt><span class="section"><a href="#generating-diffs">Generating diffs</a></span></dt><dt><span class="section"><a href="#viewing-old-file-versions">Viewing old file versions</a></span></dt><dt><span class="section"><a href="#history-examples">Examples</a></span></dt><dd><dl><dt><span class="section"><a href="#counting-commits-on-a-branch">Counting the number of commits on a branch</a></span></dt><dt><span class="section"><a href="#checking-for-equal-branches">Check whether two branches point at the same history</a></span></dt><dt><span class="section"><a href="#finding-tagged-descendants">Find first tagged version including a given fix</a></span></dt><dt><span class="section"><a href="#showing-commits-unique-to-a-branch">Showing commits unique to a given branch</a></span></dt><dt><span class="section"><a href="#making-a-release">Creating a changelog and tarball for a software release</a></span></dt><dt><span class="section"><a href="#Finding-comments-with-given-content">Finding commits referencing a file with given content</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#Developing-with-git">3. Developing with git</a></span></dt><dd><dl><dt><span class="section"><a href="#telling-git-your-name">Telling git your name</a></span></dt><dt><span class="section"><a href="#creating-a-new-repository">Creating a new repository</a></span></dt><dt><span class="section"><a href="#how-to-make-a-commit">How to make a commit</a></span></dt><dt><span class="section"><a href="#creating-good-commit-messages">Creating good commit messages</a></span></dt><dt><span class="section"><a href="#ignoring-files">Ignoring files</a></span></dt><dt><span class="section"><a href="#how-to-merge">How to merge</a></span></dt><dt><span class="section"><a href="#resolving-a-merge">Resolving a merge</a></span></dt><dd><dl><dt><span class="section"><a href="#conflict-resolution">Getting conflict-resolution help during a merge</a></span></dt></dl></dd><dt><span class="section"><a href="#undoing-a-merge">Undoing a merge</a></span></dt><dt><span class="section"><a href="#fast-forwards">Fast-forward merges</a></span></dt><dt><span class="section"><a href="#fixing-mistakes">Fixing mistakes</a></span></dt><dd><dl><dt><span class="section"><a href="#reverting-a-commit">Fixing a mistake with a new commit</a></span></dt><dt><span class="section"><a href="#fixing-a-mistake-by-rewriting-history">Fixing a mistake by rewriting history</a></span></dt><dt><span class="section"><a href="#checkout-of-path">Checking out an old version of a file</a></span></dt><dt><span class="section"><a href="#interrupted-work">Temporarily setting aside work in progress</a></span></dt></dl></dd><dt><span class="section"><a href="#ensuring-good-performance">Ensuring good performance</a></span></dt><dt><span class="section"><a href="#ensuring-reliability">Ensuring reliability</a></span></dt><dd><dl><dt><span class="section"><a href="#checking-for-corruption">Checking the repository for corruption</a></span></dt><dt><span class="section"><a href="#recovering-lost-changes">Recovering lost changes</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#sharing-development">4. Sharing development with others</a></span></dt><dd><dl><dt><span class="section"><a href="#getting-updates-with-git-pull">Getting updates with git-pull</a></span></dt><dt><span class="section"><a href="#submitting-patches">Submitting patches to a project</a></span></dt><dt><span class="section"><a href="#importing-patches">Importing patches to a project</a></span></dt><dt><span class="section"><a href="#public-repositories">Public git repositories</a></span></dt><dd><dl><dt><span class="section"><a href="#setting-up-a-public-repository">Setting up a public repository</a></span></dt><dt><span class="section"><a href="#exporting-via-git">Exporting a git repository via the git protocol</a></span></dt><dt><span class="section"><a href="#exporting-via-http">Exporting a git repository via http</a></span></dt><dt><span class="section"><a href="#pushing-changes-to-a-public-repository">Pushing changes to a public repository</a></span></dt><dt><span class="section"><a href="#forcing-push">What to do when a push fails</a></span></dt><dt><span class="section"><a href="#setting-up-a-shared-repository">Setting up a shared repository</a></span></dt><dt><span class="section"><a href="#setting-up-gitweb">Allowing web browsing of a repository</a></span></dt></dl></dd><dt><span class="section"><a href="#sharing-development-examples">Examples</a></span></dt><dd><dl><dt><span class="section"><a href="#maintaining-topic-branches">Maintaining topic branches for a Linux subsystem maintainer</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#cleaning-up-history">5. Rewriting history and maintaining patch series</a></span></dt><dd><dl><dt><span class="section"><a href="#patch-series">Creating the perfect patch series</a></span></dt><dt><span class="section"><a href="#using-git-rebase">Keeping a patch series up to date using git-rebase</a></span></dt><dt><span class="section"><a href="#rewriting-one-commit">Rewriting a single commit</a></span></dt><dt><span class="section"><a href="#reordering-patch-series">Reordering or selecting from a patch series</a></span></dt><dt><span class="section"><a href="#patch-series-tools">Other tools</a></span></dt><dt><span class="section"><a href="#problems-with-rewriting-history">Problems with rewriting history</a></span></dt><dt><span class="section"><a href="#bisect-merges">Why bisecting merge commits can be harder than bisecting linear history</a></span></dt></dl></dd><dt><span class="chapter"><a href="#advanced-branch-management">6. Advanced branch management</a></span></dt><dd><dl><dt><span class="section"><a href="#fetching-individual-branches">Fetching individual branches</a></span></dt><dt><span class="section"><a href="#fetch-fast-forwards">git fetch and fast-forwards</a></span></dt><dt><span class="section"><a href="#forcing-fetch">Forcing git-fetch to do non-fast-forward updates</a></span></dt><dt><span class="section"><a href="#remote-branch-configuration">Configuring remote branches</a></span></dt></dl></dd><dt><span class="chapter"><a href="#git-concepts">7. Git concepts</a></span></dt><dd><dl><dt><span class="section"><a href="#the-object-database">The Object Database</a></span></dt><dd><dl><dt><span class="section"><a href="#commit-object">Commit Object</a></span></dt><dt><span class="section"><a href="#tree-object">Tree Object</a></span></dt><dt><span class="section"><a href="#blob-object">Blob Object</a></span></dt><dt><span class="section"><a href="#trust">Trust</a></span></dt><dt><span class="section"><a href="#tag-object">Tag Object</a></span></dt><dt><span class="section"><a href="#pack-files">How git stores objects efficiently: pack files</a></span></dt><dt><span class="section"><a href="#dangling-objects">Dangling objects</a></span></dt><dt><span class="section"><a href="#recovering-from-repository-corruption">Recovering from repository corruption</a></span></dt></dl></dd><dt><span class="section"><a href="#the-index">The index</a></span></dt></dl></dd><dt><span class="chapter"><a href="#submodules">8. Submodules</a></span></dt><dd><dl><dt><span class="section"><a href="#id280263">Pitfalls with submodules</a></span></dt></dl></dd><dt><span class="chapter"><a href="#low-level-operations">9. Low-level git operations</a></span></dt><dd><dl><dt><span class="section"><a href="#object-manipulation">Object access and manipulation</a></span></dt><dt><span class="section"><a href="#the-workflow">The Workflow</a></span></dt><dd><dl><dt><span class="section"><a href="#working-directory-to-index">working directory -> index</a></span></dt><dt><span class="section"><a href="#index-to-object-database">index -> object database</a></span></dt><dt><span class="section"><a href="#object-database-to-index">object database -> index</a></span></dt><dt><span class="section"><a href="#index-to-working-directory">index -> working directory</a></span></dt><dt><span class="section"><a href="#tying-it-all-together">Tying it all together</a></span></dt></dl></dd><dt><span class="section"><a href="#examining-the-data">Examining the data</a></span></dt><dt><span class="section"><a href="#merging-multiple-trees">Merging multiple trees</a></span></dt><dt><span class="section"><a href="#merging-multiple-trees-2">Merging multiple trees, continued</a></span></dt></dl></dd><dt><span class="chapter"><a href="#hacking-git">10. Hacking git</a></span></dt><dd><dl><dt><span class="section"><a href="#object-details">Object storage format</a></span></dt><dt><span class="section"><a href="#birdview-on-the-source-code">A birds-eye view of Git's source code</a></span></dt></dl></dd><dt><span class="chapter"><a href="#glossary">11. GIT Glossary</a></span></dt><dt><span class="appendix"><a href="#git-quick-start">A. Git Quick Reference</a></span></dt><dd><dl><dt><span class="section"><a href="#quick-creating-a-new-repository">Creating a new repository</a></span></dt><dt><span class="section"><a href="#managing-branches">Managing branches</a></span></dt><dt><span class="section"><a href="#exploring-history">Exploring history</a></span></dt><dt><span class="section"><a href="#making-changes">Making changes</a></span></dt><dt><span class="section"><a href="#merging">Merging</a></span></dt><dt><span class="section"><a href="#sharing-your-changes">Sharing your changes</a></span></dt><dt><span class="section"><a href="#repository-maintenance">Repository maintenance</a></span></dt></dl></dd><dt><span class="appendix"><a href="#todo">B. Notes and todo list for this manual</a></span></dt></dl></div><div class="preface" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="id264725"></a>Preface</h2></div></div></div><p>Git is a fast distributed revision control system.</p><p>This manual is designed to be readable by someone with basic UNIX
command-line skills, but no previous knowledge of git.</p><p><a href="#repositories-and-branches" title="Chapter 1. Repositories and Branches">Chapter 1, <i>Repositories and Branches</i></a> and <a href="#exploring-git-history" title="Chapter 2. Exploring git history">Chapter 2, <i>Exploring git history</i></a> explain how
to fetch and study a project using git—read these chapters to learn how
to build and test a particular version of a software project, search for
regressions, and so on.</p><p>People needing to do actual development will also want to read
<a href="#Developing-with-git" title="Chapter 3. Developing with git">Chapter 3, <i>Developing with git</i></a> and <a href="#sharing-development" title="Chapter 4. Sharing development with others">Chapter 4, <i>Sharing development with others</i></a>.</p><p>Further chapters cover more specialized topics.</p><p>Comprehensive reference documentation is available through the man
-pages. For a command such as "git clone", just use</p><div class="literallayout"><p>$ man git-clone</p></div><p>See also <a href="#git-quick-start" title="Appendix A. Git Quick Reference">Appendix A, <i>Git Quick Reference</i></a> for a brief overview of git commands,
+pages. For a command such as "git clone
<repo>", just use</p><div class="literallayout"><p>$ man git-clone</p></div><p>See also <a href="#git-quick-start" title="Appendix A. Git Quick Reference">Appendix A, <i>Git Quick Reference</i></a> for a brief overview of git commands,
without any explanation.</p><p>Finally, see <a href="#todo" title="Appendix B. Notes and todo list for this manual">Appendix B, <i>Notes and todo list for this manual</i></a> for ways that you can help make this manual more
-complete.</p></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="repositories-and-branches"></a>Chapter 1. Repositories and Branches</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#how-to-get-a-git-repository">How to get a git repository</a></span></dt><dt><span class="section"><a href="#how-to-check-out">How to check out a different version of a project</a></span></dt><dt><span class="section"><a href="#understanding-commits">Understanding History: Commits</a></span></dt><dd><dl><dt><span class="section"><a href="#understanding-reachability">Understanding history: commits, parents, and reachability</a></span></dt><dt><span class="section"><a href="#history-diagrams">Understanding history: History diagrams</a></span></dt><dt><span class="section"><a href="#what-is-a-branch">Understanding history: What is a branch?</a></span></dt></dl></dd><dt><span class="section"><a href="#manipulating-branches">Manipulating branches</a></span></dt><dt><span class="section"><a href="#detached-head">Examining an old version without creating a new branch</a></span></dt><dt><span class="section"><a href="#examining-remote-branches">Examining branches from a remote repository</a></span></dt><dt><span class="section"><a href="#how-git-stores-references">Naming branches, tags, and other references</a></span></dt><dt><span class="section"><a href="#Updating-a-repository-with-git-fetch">Updating a repository with git
fetch</a></span></dt><dt><span class="section"><a href="#fetching-branches">Fetching branches from other repositories</a></span></dt></dl></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="how-to-get-a-git-repository"></a>How to get a git repository</h2></div></div></div><p>It will be useful to have a git repository to experiment with as you
+complete.</p></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="repositories-and-branches"></a>Chapter 1. Repositories and Branches</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#how-to-get-a-git-repository">How to get a git repository</a></span></dt><dt><span class="section"><a href="#how-to-check-out">How to check out a different version of a project</a></span></dt><dt><span class="section"><a href="#understanding-commits">Understanding History: Commits</a></span></dt><dd><dl><dt><span class="section"><a href="#understanding-reachability">Understanding history: commits, parents, and reachability</a></span></dt><dt><span class="section"><a href="#history-diagrams">Understanding history: History diagrams</a></span></dt><dt><span class="section"><a href="#what-is-a-branch">Understanding history: What is a branch?</a></span></dt></dl></dd><dt><span class="section"><a href="#manipulating-branches">Manipulating branches</a></span></dt><dt><span class="section"><a href="#detached-head">Examining an old version without creating a new branch</a></span></dt><dt><span class="section"><a href="#examining-remote-branches">Examining branches from a remote repository</a></span></dt><dt><span class="section"><a href="#how-git-stores-references">Naming branches, tags, and other references</a></span></dt><dt><span class="section"><a href="#Updating-a-repository-with-git-fetch">Updating a repository with git
-fetch</a></span></dt><dt><span class="section"><a href="#fetching-branches">Fetching branches from other repositories</a></span></dt></dl></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="how-to-get-a-git-repository"></a>How to get a git repository</h2></div></div></div><p>It will be useful to have a git repository to experiment with as you
read this manual.</p><p>The best way to get one is by using the <a href="git-clone.html" target="_top">git-clone(1)</a> command to
download a copy of an existing repository. If you don't already have a
project in mind, here are some interesting examples:</p><div class="literallayout"><p> # git itself (approx. 10MB download):<br>
<br>
if (mkdir(".git", 0755) < 0) {</p></div><p>As you can see, a commit shows who made the latest change, what they
did, and why.</p><p>Every commit has a 40-hexdigit id, sometimes called the "object name" or the
-"SHA1 id", shown on the first line of the "git show" output. You can usually
+"SHA1 id", shown on the first line of the "git-show" output. You can usually
refer to a commit by a shorter name, such as a tag or a branch name, but this
longer name can also be useful. Most importantly, it is a globally unique
name for this commit: so if you tell somebody else the object name (for
is usually a shortcut for the HEAD branch in the repository "origin".</p><p>For the complete list of paths which git checks for references, and
the order it uses to decide which to choose when there are multiple
references with the same shorthand name, see the "SPECIFYING
-REVISIONS" section of <a href="git-rev-parse.html" target="_top">git-rev-parse(1)</a>.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="Updating-a-repository-with-git-fetch"></a>Updating a repository with git
fetch</h2></div></div></div><p>Eventually the developer cloned from will do additional work in her
+REVISIONS" section of <a href="git-rev-parse.html" target="_top">git-rev-parse(1)</a>.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="Updating-a-repository-with-git-fetch"></a>Updating a repository with git
-fetch</h2></div></div></div><p>Eventually the developer cloned from will do additional work in her
repository, creating new commits and advancing the branches to point
at the new commits.</p><p>The command "git fetch", with no arguments, will update all of the
remote-tracking branches to the latest version found in her
$ git fetch linux-nfs<br>
* refs/remotes/linux-nfs/master: storing branch 'master' ...<br>
commit: bf81b46</p></div><p>New remote-tracking branches will be stored under the shorthand name
-that you gave "git
remote add", in this case linux-nfs:</p><div class="literallayout"><p>$ git branch -r<br>
+that you gave "git
-remote add", in this case linux-nfs:</p><div class="literallayout"><p>$ git branch -r<br>
linux-nfs/master<br>
origin/master</p></div><p>If you run "git fetch <remote>" later, the tracking branches for the
named <remote> will be updated.</p><p>If you examine the file .git/config, you will see that git has added
that of the HEAD. The command "git diff —cached", which shows
the difference between the HEAD and the index, should therefore
produce no output at that point.</p><p>Modifying the index is easy:</p><p>To update the index with the new contents of a modified file, use</p><div class="literallayout"><p>$ git add path/to/file</p></div><p>To add the contents of a new file to the index, use</p><div class="literallayout"><p>$ git add path/to/file</p></div><p>To remove a file from the index and from the working tree,</p><div class="literallayout"><p>$ git rm path/to/file</p></div><p>After each step you can verify that</p><div class="literallayout"><p>$ git diff --cached</p></div><p>always shows the difference between the HEAD and the index file—this
-is what you'd commit if you created the commit now—and that</p><div class="literallayout"><p>$ git diff</p></div><p>shows the difference between the working tree and the index file.</p><p>Note that "git add" always adds just the current contents of a file
+is what you'd commit if you created the commit now—and that</p><div class="literallayout"><p>$ git diff</p></div><p>shows the difference between the working tree and the index file.</p><p>Note that "git-add" always adds just the current contents of a file
to the index; further changes to the same file will be ignored unless
you run git-add on the file again.</p><p>When you're ready, just run</p><div class="literallayout"><p>$ git commit</p></div><p>and git will prompt you for a commit message and then create the new
commit. Check to make sure it looks like what you expected with</p><div class="literallayout"><p>$ git show</p></div><p>As a special shortcut,</p><div class="literallayout"><p>$ git commit -a</p></div><p>will update the index with any files that you've modified or removed
body.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="ignoring-files"></a>Ignoring files</h2></div></div></div><p>A project will often generate files that you do <span class="emphasis"><em>not</em></span> want to track with git.
This typically includes files generated by a build process or temporary
backup files made by your editor. Of course, <span class="emphasis"><em>not</em></span> tracking files with git
-is just a matter of <span class="emphasis"><em>not</em></span> calling "<code class="literal">git add</code>" on them. But it quickly becomes
+is just a matter of <span class="emphasis"><em>not</em></span> calling "<code class="literal">git-add</code>" on them. But it quickly becomes
annoying to have these untracked files lying around; e.g. they make
"<code class="literal">git add .</code>" and "<code class="literal">git commit -a</code>" practically useless, and they keep
showing up in the output of "<code class="literal">git status</code>".</p><p>You can tell git to ignore certain files by creating a file called .gitignore
this is an advanced topic to be left for
<a href="#cleaning-up-history" title="Chapter 5. Rewriting history and maintaining patch series">another chapter</a>.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="checkout-of-path"></a>Checking out an old version of a file</h3></div></div></div><p>In the process of undoing a previous bad change, you may find it
useful to check out an older version of a particular file using
-<a href="git-checkout.html" target="_top">git-checkout(1)</a>. We've used git checkout before to switch
+<a href="git-checkout.html" target="_top">git-checkout(1)</a>. We've used git-checkout before to switch
branches, but it has quite different behavior if it is given a path
name: the command</p><div class="literallayout"><p>$ git checkout HEAD^ path/to/file</p></div><p>replaces path/to/file by the contents it had in the commit HEAD^, and
also updates the index to match. It does not change branches.</p><p>If you just want to look at an old version of the file, without
"tip of the line" as being dangling, but there might be a whole deep
and complex commit history that was dropped.)</p><p>If you decide you want the history back, you can always create a new
reference pointing to it, for example, a new branch:</p><div class="literallayout"><p>$ git branch recovered-branch 7281251ddd</p></div><p>Other types of dangling objects (blobs and trees) are also possible, and
-dangling objects can arise in other situations.</p></div></div></div></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="sharing-development"></a>Chapter 4. Sharing development with others</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#getting-updates-with-git-pull">Getting updates with git
pull</a></span></dt><dt><span class="section"><a href="#submitting-patches">Submitting patches to a project</a></span></dt><dt><span class="section"><a href="#importing-patches">Importing patches to a project</a></span></dt><dt><span class="section"><a href="#public-repositories">Public git repositories</a></span></dt><dd><dl><dt><span class="section"><a href="#setting-up-a-public-repository">Setting up a public repository</a></span></dt><dt><span class="section"><a href="#exporting-via-git">Exporting a git repository via the git protocol</a></span></dt><dt><span class="section"><a href="#exporting-via-http">Exporting a git repository via http</a></span></dt><dt><span class="section"><a href="#pushing-changes-to-a-public-repository">Pushing changes to a public repository</a></span></dt><dt><span class="section"><a href="#forcing-push">What to do when a push fails</a></span></dt><dt><span class="section"><a href="#setting-up-a-shared-repository">Setting up a shared repository</a></span></dt><dt><span class="section"><a href="#setting-up-gitweb">Allowing web browsing of a repository</a></span></dt></dl></dd><dt><span class="section"><a href="#sharing-development-examples">Examples</a></span></dt><dd><dl><dt><span class="section"><a href="#maintaining-topic-branches">Maintaining topic branches for a Linux subsystem maintainer</a></span></dt></dl></dd></dl></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="getting-updates-with-git-pull"></a>Getting updates with git pull</h2></div></div></div><p>After you clone a repository and make a few changes of your own, you
+dangling objects can arise in other situations.</p></div></div></div></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="sharing-development"></a>Chapter 4. Sharing development with others</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#getting-updates-with-git-pull">Getting updates with git
-pull</a></span></dt><dt><span class="section"><a href="#submitting-patches">Submitting patches to a project</a></span></dt><dt><span class="section"><a href="#importing-patches">Importing patches to a project</a></span></dt><dt><span class="section"><a href="#public-repositories">Public git repositories</a></span></dt><dd><dl><dt><span class="section"><a href="#setting-up-a-public-repository">Setting up a public repository</a></span></dt><dt><span class="section"><a href="#exporting-via-git">Exporting a git repository via the git protocol</a></span></dt><dt><span class="section"><a href="#exporting-via-http">Exporting a git repository via http</a></span></dt><dt><span class="section"><a href="#pushing-changes-to-a-public-repository">Pushing changes to a public repository</a></span></dt><dt><span class="section"><a href="#forcing-push">What to do when a push fails</a></span></dt><dt><span class="section"><a href="#setting-up-a-shared-repository">Setting up a shared repository</a></span></dt><dt><span class="section"><a href="#setting-up-gitweb">Allowing web browsing of a repository</a></span></dt></dl></dd><dt><span class="section"><a href="#sharing-development-examples">Examples</a></span></dt><dd><dl><dt><span class="section"><a href="#maintaining-topic-branches">Maintaining topic branches for a Linux subsystem maintainer</a></span></dt></dl></dd></dl></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="getting-updates-with-git-pull"></a>Getting updates with git-pull</h2></div></div></div><p>After you clone a repository and make a few changes of your own, you
may wish to check the original repository for updates and merge them
-into your own work.</p><p>We have already seen <a href="#Updating-a-repository-with-git-fetch" title="Updating a repository with git
fetch">how to keep remote tracking branches up to date</a> with <a href="git-fetch.html" target="_top">git-fetch(1)</a>,
+into your own work.</p><p>We have already seen <a href="#Updating-a-repository-with-git-fetch" title="Updating a repository with git
-fetch">how to keep remote tracking branches up to date</a> with <a href="git-fetch.html" target="_top">git-fetch(1)</a>,
and how to merge two branches. So you can merge in changes from the
original repository's master branch with:</p><div class="literallayout"><p>$ git fetch<br>
$ git merge origin/master</p></div><p>However, the <a href="git-pull.html" target="_top">git-pull(1)</a> command provides a way to do this in
the original mailbox, with authorship and commit log message each
taken from the message containing each patch.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="public-repositories"></a>Public git repositories</h2></div></div></div><p>Another way to submit changes to a project is to tell the maintainer
of that project to pull the changes from your repository using
-<a href="git-pull.html" target="_top">git-pull(1)</a>. In the section "<a href="#getting-updates-with-git-pull" title="Getting updates with git pull">Getting updates with git pull</a>" we described this as a way to get
+<a href="git-pull.html" target="_top">git-pull(1)</a>. In the section "<a href="#getting-updates-with-git-pull" title="Getting updates with git-pull">Getting updates with git-pull</a>" we described this as a way to get
updates from the "main" repository, but it works just as well in the
other direction.</p><p>If you and the maintainer both have accounts on the same machine, then
you can just pull changes from each other's repositories directly;
$ cd proj.git<br>
$ git --bare update-server-info<br>
$ chmod a+x hooks/post-update</p></div><p>(For an explanation of the last two lines, see
-<a href="git-update-server-info.html" target="_top">git-update-server-info(1)</a>, and the documentation
-<a href="githooks.html" target="_top">githooks(5)</a>[Hooks used by git].)</p><p>Advertise the URL of proj.git. Anybody else should then be able to
+<a href="git-update-server-info.html" target="_top">git-update-server-info(1)</a> and <a href="githooks.html" target="_top">githooks(5)</a>.)</p><p>Advertise the URL of proj.git. Anybody else should then be able to
clone or pull from that URL, for example with a command line like:</p><div class="literallayout"><p>$ git clone http://yourserver.com/~you/proj.git</p></div><p>(See also
<a href="howto/setup-git-server-over-http.txt" target="_top">setup-git-server-over-http</a>
for a slightly more sophisticated setup using WebDAV which also
solution is to retry the push after first updating your work by either a
pull or a fetch followed by a rebase; see the
<a href="#setting-up-a-shared-repository" title="Setting up a shared repository">next section</a> and
-<a href="gitcvs-migration.html" target="_top">gitcvs-migration(7)</a>
[git for CVS users] for more.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="setting-up-a-shared-repository"></a>Setting up a shared repository</h3></div></div></div><p>Another way to collaborate is by using a model similar to that
+<a href="gitcvs-migration.html" target="_top">gitcvs-migration(7)</a> for more.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="setting-up-a-shared-repository"></a>Setting up a shared repository</h3></div></div></div><p>Another way to collaborate is by using a model similar to that
commonly used in CVS, where several developers with special rights
all push to and pull from a single shared repository. See
-<a href="gitcvs-migration.html" target="_top">gitcvs-migration(7)</a>[git for CVS users] for instructions on how to
+<a href="gitcvs-migration.html" target="_top">gitcvs-migration(7)</a> for instructions on how to
set this up.</p><p>However, while there is nothing wrong with git's support for shared
repositories, this mode of operation is not generally recommended,
simply because the mode of collaboration that git supports—by
and understanding why Y* was broken would probably be easier.</p><p>Partly for this reason, many experienced git users, even when
working on an otherwise merge-heavy project, keep the history
linear by rebasing against the latest upstream version before
-publishing.</p></div></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="advanced-branch-management"></a>Chapter 6. Advanced branch management</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#fetching-individual-branches">Fetching individual branches</a></span></dt><dt><span class="section"><a href="#fetch-fast-forwards">git fetch and fast-forwards</a></span></dt><dt><span class="section"><a href="#forcing-fetch">Forcing git
fetch to do non-fast-forward updates</a></span></dt><dt><span class="section"><a href="#remote-branch-configuration">Configuring remote branches</a></span></dt></dl></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="fetching-individual-branches"></a>Fetching individual branches</h2></div></div></div><p>Instead of using <a href="git-remote.html" target="_top">git-remote(1)</a>, you can also choose just
+publishing.</p></div></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="advanced-branch-management"></a>Chapter 6. Advanced branch management</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#fetching-individual-branches">Fetching individual branches</a></span></dt><dt><span class="section"><a href="#fetch-fast-forwards">git fetch and fast-forwards</a></span></dt><dt><span class="section"><a href="#forcing-fetch">Forcing git
-fetch to do non-fast-forward updates</a></span></dt><dt><span class="section"><a href="#remote-branch-configuration">Configuring remote branches</a></span></dt></dl></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="fetching-individual-branches"></a>Fetching individual branches</h2></div></div></div><p>Instead of using <a href="git-remote.html" target="_top">git-remote(1)</a>, you can also choose just
to update one branch at a time, and to store it locally under an
arbitrary name:</p><div class="literallayout"><p>$ git fetch origin todo:my-todo-work</p></div><p>The first argument, "origin", just tells git to fetch from the
repository you originally cloned from. The second argument tells git
described in the following section. However, note that in the
situation above this may mean losing the commits labeled "a" and "b",
unless you've already created a reference of your own pointing to
-them.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="forcing-fetch"></a>Forcing git
fetch to do non-fast-forward updates</h2></div></div></div><p>If git fetch fails because the new head of a branch is not a
+them.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="forcing-fetch"></a>Forcing git
-fetch to do non-fast-forward updates</h2></div></div></div><p>If git fetch fails because the new head of a branch is not a
descendant of the old head, you may force the update with:</p><div class="literallayout"><p>$ git fetch git://example.com/proj.git +master:refs/remotes/example/master</p></div><p>Note the addition of the "+" sign. Alternatively, you can use the "-f"
flag to force updates of all the fetched branches, as in:</p><div class="literallayout"><p>$ git fetch -f origin</p></div><p>Be aware that commits that the old version of example/master pointed at
may be lost, as we saw in the previous section.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="remote-branch-configuration"></a>Configuring remote branches</h2></div></div></div><p>We saw above that "origin" is just a shortcut to refer to the
after</p><div class="literallayout"><p>$ git config remote.example.url git://example.com/proj.git</p></div><p>then the following two commands will do the same thing:</p><div class="literallayout"><p>$ git fetch git://example.com/proj.git master:refs/remotes/example/master<br>
$ git fetch example master:refs/remotes/example/master</p></div><p>Even better, if you add one more option:</p><div class="literallayout"><p>$ git config remote.example.fetch master:refs/remotes/example/master</p></div><p>then the following commands will all do the same thing:</p><div class="literallayout"><p>$ git fetch git://example.com/proj.git master:refs/remotes/example/master<br>
$ git fetch example master:refs/remotes/example/master<br>
-$ git fetch example</p></div><p>You can also add a "+" to force the update each time:</p><div class="literallayout"><p>$ git config remote.example.fetch +master:ref/remotes/example/master</p></div><p>Don't do this unless you're sure you won't mind "git fetch" possibly
+$ git fetch example</p></div><p>You can also add a "+" to force the update each time:</p><div class="literallayout"><p>$ git config remote.example.fetch +master:ref/remotes/example/master</p></div><p>Don't do this unless you're sure you won't mind "git-fetch" possibly
throwing away commits on mybranch.</p><p>Also note that all of the above configuration can be performed by
directly editing the file .git/config instead of using
<a href="git-config.html" target="_top">git-config(1)</a>.</p><p>See <a href="git-config.html" target="_top">git-config(1)</a> for more details on the configuration
in case you corrupt things even more in the process.</p><p>We'll assume that the problem is a single missing or corrupted blob,
which is sometimes a solvable problem. (Recovering missing trees and
especially commits is <span class="strong"><strong>much</strong></span> harder).</p><p>Before starting, verify that there is corruption, and figure out where
-it is with <a href="git-fsck.html" target="_top">git-fsck(1)</a>; this may be time-consuming.</p><p>Assume the output looks like this:</p><div class="literallayout"><p>$ git-fsck --full<br>
+it is with <a href="git-fsck.html" target="_top">git-fsck(1)</a>; this may be time-consuming.</p><p>Assume the output looks like this:</p><div class="literallayout"><p>$ git fsck --full<br>
broken link from tree 2d9263c6d23595e7cb2a21e5ebbb53655278dff8<br>
to blob 4b9458b3786228369c63936db65827de3cc06200<br>
missing blob 4b9458b3786228369c63936db65827de3cc06200</p></div><p>(Typically there will be some "dangling object" messages too, but they
number, and will take on values other than 0 for files with merge
conflicts.</p></li></ol></div><p>The index is thus a sort of temporary staging area, which is filled with
a tree which you are in the process of working on.</p><p>If you blow the index away entirely, you generally haven't lost any
-information as long as you have the name of the tree that it described.</p></div></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="submodules"></a>Chapter 8. Submodules</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#id28026
4">Pitfalls with submodules</a></span></dt></dl></div><p>Large projects are often composed of smaller, self-contained modules. For
+information as long as you have the name of the tree that it described.</p></div></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="submodules"></a>Chapter 8. Submodules</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#id28026
3">Pitfalls with submodules</a></span></dt></dl></div><p>Large projects are often composed of smaller, self-contained modules. For
example, an embedded Linux distribution's source tree would include every
piece of software in the distribution with some local modifications; a movie
player might need to build against a specific, known-working version of a
$ for i in a b c d<br>
do<br>
git submodule add ~/git/$i<br>
-done</p></div><div class="note" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">Note</h3><p>Do not use local URLs here if you plan to publish your superproject!</p></div><p>See what files <code class="literal">git
submodule</code> created:</p><div class="literallayout"><p>$ ls -a<br>
-. .. .git .gitmodules a b c d</p></div><p>The <code class="literal">git
submodule add</code> command does a couple of things:</p><div class="itemizedlist"><ul type="disc"><li>
+done</p></div><div class="note" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">Note</h3><p>Do not use local URLs here if you plan to publish your superproject!</p></div><p>See what files <code class="literal">git
-submodule</code> created:</p><div class="literallayout"><p>$ ls -a<br>
+. .. .git .gitmodules a b c d</p></div><p>The <code class="literal">git
-submodule add</code> command does a couple of things:</p><div class="itemizedlist"><ul type="disc"><li>
It clones the submodule under the current directory and by default checks out
the master branch.
</li><li>
-d96249ff5d57de5de093e6baff9e0aafa5276a74 d</p></div><div class="note" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">Note</h3><p>The commit object names shown above would be different for you, but they
should match the HEAD commit object names of your repositories. You can check
it by running <code class="literal">git ls-remote ../a</code>.</p></div><p>Pulling down the submodules is a two-step process. First run <code class="literal">git submodule
-init</code> to add the submodule repository URLs to <code class="literal">.git/config</code>:</p><div class="literallayout"><p>$ git submodule init</p></div><p>Now use <code class="literal">git submodule update</code> to clone the repositories and check out the
+init</code> to add the submodule repository URLs to <code class="literal">.git/config</code>:</p><div class="literallayout"><p>$ git submodule init</p></div><p>Now use <code class="literal">git-submodule update</code> to clone the repositories and check out the
commits specified in the superproject:</p><div class="literallayout"><p>$ git submodule update<br>
$ cd a<br>
$ ls -a<br>
-. .. .git a.txt</p></div><p>One major difference between <code class="literal">git submodule update</code> and <code class="literal">git submodule add</code> is
-that <code class="literal">git submodule update</code> checks out a specific commit, rather than the tip
+. .. .git a.txt</p></div><p>One major difference between <code class="literal">git-submodule update</code> and <code class="literal">git-submodule add</code> is
+that <code class="literal">git-submodule update</code> checks out a specific commit, rather than the tip
of a branch. It's like checking out a tag: the head is detached, so you're not
working on a branch.</p><div class="literallayout"><p>$ git branch<br>
* (no branch)<br>
$ git add a<br>
$ git commit -m "Updated submodule a."<br>
$ git push</p></div><p>You have to run <code class="literal">git submodule update</code> after <code class="literal">git pull</code> if you want to update
-submodules, too.</p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id28026
4"></a>Pitfalls with submodules</h2></div></div></div><p>Always publish the submodule change before publishing the change to the
+submodules, too.</p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id28026
3"></a>Pitfalls with submodules</h2></div></div></div><p>Always publish the submodule change before publishing the change to the
superproject that references it. If you forget to publish the submodule change,
others won't be able to clone the repository:</p><div class="literallayout"><p>$ cd ~/git/super/a<br>
$ echo i added another line to this file >> a.txt<br>
other direction:</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="object-database-to-index"></a>object database -> index</h3></div></div></div><p>You read a "tree" file from the object database, and use that to
populate (and overwrite—don't do this if your index contains any
unsaved state that you might want to restore later!) your current
-index. Normal operation is just</p><div class="literallayout"><p>$ git
-read-tree <sha1 of tree></p></div><p>and your index file will now be equivalent to the tree that you saved
+index. Normal operation is just</p><div class="literallayout"><p>$ git
read-tree <sha1 of tree></p></div><p>and your index file will now be equivalent to the tree that you saved
earlier. However, that is only your <span class="emphasis"><em>index</em></span> file: your working
directory contents have not been modified.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="index-to-working-directory"></a>index -> working directory</h3></div></div></div><p>You update your working directory from the index by "checking out"
files. This is not a very common operation, since normally you'd just
working directory (i.e. <code class="literal">git-update-index</code>).</p><p>However, if you decide to jump to a new version, or check out somebody
else's version, or just restore a previous tree, you'd populate your
index file with read-tree, and then you need to check out the result
-with</p><div class="literallayout"><p>$ git
-checkout-index filename</p></div><p>or, if you want to check out all of the index, use <code class="literal">-a</code>.</p><p>NOTE! git-checkout-index normally refuses to overwrite old files, so
+with</p><div class="literallayout"><p>$ git
checkout-index filename</p></div><p>or, if you want to check out all of the index, use <code class="literal">-a</code>.</p><p>NOTE! git-checkout-index normally refuses to overwrite old files, so
if you have an old version of the tree already checked out, you will
need to use the "-f" flag (<span class="emphasis"><em>before</em></span> the "-a" flag or the filename) to
<span class="emphasis"><em>force</em></span> the checkout.</p><p>Finally, there are a few odds and ends which are not purely moving
previous states represented by other commits.</p><p>In other words, while a "tree" represents a particular directory state
of a working directory, a "commit" represents that state in "time",
and explains how we got there.</p><p>You create a commit object by giving it the tree that describes the
-state at the time of the commit, and a list of parents:</p><div class="literallayout"><p>$ git
-commit-tree <tree> -p <parent> [-p <parent2> ..]</p></div><p>and then giving the reason for the commit on stdin (either through
+state at the time of the commit, and a list of parents:</p><div class="literallayout"><p>$ git
commit-tree <tree> -p <parent> [-p <parent2> ..]</p></div><p>and then giving the reason for the commit on stdin (either through
redirection from a pipe or file, or by just typing it at the tty).</p><p>git-commit-tree will return the name of the object that represents
that commit, and you should save it away for later use. Normally,
you'd commit a new <code class="literal">HEAD</code> state, and while git doesn't care where you
</p></div></div></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="examining-the-data"></a>Examining the data</h2></div></div></div><p>You can examine the data represented in the object database and the
index with various helper tools. For every object, you can use
<a href="git-cat-file.html" target="_top">git-cat-file(1)</a> to examine details about the
-object:</p><div class="literallayout"><p>$ git
-cat-file -t <objectname></p></div><p>shows the type of the object, and once you have the type (which is
-usually implicit in where you find the object), you can use</p><div class="literallayout"><p>$ git
-cat-file blob|tree|commit|tag <objectname></p></div><p>to show its contents. NOTE! Trees have binary content, and as a result
+object:</p><div class="literallayout"><p>$ git
cat-file -t <objectname></p></div><p>shows the type of the object, and once you have the type (which is
+usually implicit in where you find the object), you can use</p><div class="literallayout"><p>$ git
cat-file blob|tree|commit|tag <objectname></p></div><p>to show its contents. NOTE! Trees have binary content, and as a result
there is a special helper for showing that content, called
<code class="literal">git-ls-tree</code>, which turns the binary content into a more easily
readable form.</p><p>It's especially instructive to look at "commit" objects, since those
tend to be small and fairly self-explanatory. In particular, if you
follow the convention of having the top commit name in <code class="literal">.git/HEAD</code>,
-you can do</p><div class="literallayout"><p>$ git
-cat-file commit HEAD</p></div><p>to see what the top commit was.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="merging-multiple-trees"></a>Merging multiple trees</h2></div></div></div><p>Git helps you do a three-way merge, which you can expand to n-way by
+you can do</p><div class="literallayout"><p>$ git
cat-file commit HEAD</p></div><p>to see what the top commit was.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="merging-multiple-trees"></a>Merging multiple trees</h2></div></div></div><p>Git helps you do a three-way merge, which you can expand to n-way by
repeating the merge procedure arbitrary times until you finally
"commit" the state. The normal situation is that you'd only do one
three-way merge (two parents), and commit it, but if you like to, you
that you want to merge, use those to find the closest common parent (a
third "commit" object), and then use those commit objects to find the
state of the directory ("tree" object) at these points.</p><p>To get the "base" for the merge, you first look up the common parent
-of two commits with</p><div class="literallayout"><p>$ git
-merge-base <commit1> <commit2></p></div><p>which will return you the commit they are both based on. You should
+of two commits with</p><div class="literallayout"><p>$ git
merge-base <commit1> <commit2></p></div><p>which will return you the commit they are both based on. You should
now look up the "tree" objects of those commits, which you can easily
-do with (for example)</p><div class="literallayout"><p>$ git
-cat-file commit <commitname> | head -1</p></div><p>since the tree object information is always the first line in a commit
+do with (for example)</p><div class="literallayout"><p>$ git
cat-file commit <commitname> | head -1</p></div><p>since the tree object information is always the first line in a commit
object.</p><p>Once you know the three trees you are going to merge (the one "original"
tree, aka the common tree, and the two "result" trees, aka the branches
you want to merge), you do a "merge" read into the index. This will
complain if it has to throw away your old index contents, so you should
make sure that you've committed those—in fact you would normally
always do a merge against your last commit (which should thus match what
-you have in your current index anyway).</p><p>To do the merge, do</p><div class="literallayout"><p>$ git
-read-tree -m -u <origtree> <yourtree> <targettree></p></div><p>which will do all trivial merge operations for you directly in the
+you have in your current index anyway).</p><p>To do the merge, do</p><div class="literallayout"><p>$ git
read-tree -m -u <origtree> <yourtree> <targettree></p></div><p>which will do all trivial merge operations for you directly in the
index file, and you can just write the result out with
<code class="literal">git-write-tree</code>.</p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="merging-multiple-trees-2"></a>Merging multiple trees, continued</h2></div></div></div><p>Sadly, many merges aren't trivial. If there are files that have
been added, moved or removed, or if both branches have modified the
same file, you will be left with an index tree that contains "merge
entries" in it. Such an index tree can <span class="emphasis"><em>NOT</em></span> be written out to a tree
object, and you will have to resolve any such merge clashes using
-other tools before you can write out the result.</p><p>You can examine such index state with <code class="literal">git-ls-files —unmerged</code>
-command. An example:</p><div class="literallayout"><p>$ git-read-tree -m $orig HEAD $target<br>
-$ git-ls-files --unmerged<br>
+other tools before you can write out the result.</p><p>You can examine such index state with <code class="literal">git ls-files —unmerged</code>
+command. An example:</p><div class="literallayout"><p>$ git read-tree -m $orig HEAD $target<br>
+$ git ls-files --unmerged<br>
100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello.c<br>
100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello.c<br>
-100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello.c</p></div><p>Each line of the <code class="literal">git-ls-files —unmerged</code> output begins with
+100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello.c</p></div><p>Each line of the <code class="literal">git ls-files —unmerged</code> output begins with
the blob mode bits, blob SHA1, <span class="emphasis"><em>stage number</em></span>, and the
filename. The <span class="emphasis"><em>stage number</em></span> is git's way to say which tree it
came from: stage 1 corresponds to <code class="literal">$orig</code> tree, stage 2 <code class="literal">HEAD</code>
<code class="literal">$orig</code> to <code class="literal">HEAD</code> and <code class="literal">$orig</code> to <code class="literal">$target</code> in a different way.
You could resolve this by running your favorite 3-way merge
program, e.g. <code class="literal">diff3</code>, <code class="literal">merge</code>, or git's own merge-file, on
-the blob objects from these three stages yourself, like this:</p><div class="literallayout"><p>$ git-cat-file blob 263414f... >hello.c~1<br>
-$ git-cat-file blob 06fa6a2... >hello.c~2<br>
-$ git-cat-file blob cc44c73... >hello.c~3<br>
+the blob objects from these three stages yourself, like this:</p><div class="literallayout"><p>$ git cat-file blob 263414f... >hello.c~1<br>
+$ git cat-file blob 06fa6a2... >hello.c~2<br>
+$ git cat-file blob cc44c73... >hello.c~3<br>
$ git merge-file hello.c~2 hello.c~1 hello.c~3</p></div><p>This would leave the merge result in <code class="literal">hello.c~2</code> file, along
with conflict markers if there are conflicts. After verifying
the merge result makes sense, you can tell git what the final
merge result for this file is by:</p><div class="literallayout"><p>$ mv -f hello.c~2 hello.c<br>
-$ git
-update-index hello.c</p></div><p>When a path is in unmerged state, running <code class="literal">git-update-index</code> for
+$ git
update-index hello.c</p></div><p>When a path is in unmerged state, running <code class="literal">git-update-index</code> for
that path tells git to mark the path resolved.</p><p>The above is the description of a git merge at the lowest level,
to help you understand what conceptually happens under the hood.
In practice, nobody, not even git itself, uses three <code class="literal">git-cat-file</code>
for this. There is <code class="literal">git-merge-index</code> program that extracts the
-stages to temporary files and calls a "merge" script on it:</p><div class="literallayout"><p>$ git
-merge-index git-merge-one-file hello.c</p></div><p>and that is what higher level <code class="literal">git merge -s resolve</code> is implemented with.</p></div></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="hacking-git"></a>Chapter 10. Hacking git</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#object-details">Object storage format</a></span></dt><dt><span class="section"><a href="#birdview-on-the-source-code">A birds-eye view of Git's source code</a></span></dt></dl></div><p>This chapter covers internal details of the git implementation which
+stages to temporary files and calls a "merge" script on it:</p><div class="literallayout"><p>$ git
merge-index git-merge-one-file hello.c</p></div><p>and that is what higher level <code class="literal">git-merge -s resolve</code> is implemented with.</p></div></div><div class="chapter" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="hacking-git"></a>Chapter 10. Hacking git</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#object-details">Object storage format</a></span></dt><dt><span class="section"><a href="#birdview-on-the-source-code">A birds-eye view of Git's source code</a></span></dt></dl></div><p>This chapter covers internal details of the git implementation which
probably only git developers need to understand.</p><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="object-details"></a>Object storage format</h2></div></div></div><p>All objects have a statically determined "type" which identifies the
format of the object (i.e. how it is used, and how it can refer to other
objects). There are currently four different object types: "blob",
<code class="literal">prepare_revision_walk()</code> for initialization, and then you can get the
commits one by one with the function <code class="literal">get_revision()</code>.</p><p>If you are interested in more details of the revision walking process,
just have a look at the first implementation of <code class="literal">cmd_log()</code>; call
-<code class="literal">git-show v1.3.0~155^2~4</code> and scroll down to that function (note that you
+<code class="literal">git show v1.3.0~155^2~4</code> and scroll down to that function (note that you
no longer need to call <code class="literal">setup_pager()</code> directly).</p><p>Nowadays, <code class="literal">git log</code> is a builtin, which means that it is _contained_ in the
command <code class="literal">git</code>. The source side of a builtin is</p><div class="itemizedlist"><ul type="disc"><li>
a function called <code class="literal">cmd_<bla></code>, typically defined in <code class="literal">builtin-<bla>.c</code>,
works, find the source code for it (something like <code class="literal">git grep
read_object_with | grep ":[a-z]"</code> in the git repository), and read
the source.</p><p>To find out how the result can be used, just read on in <code class="literal">cmd_cat_file()</code>:</p><div class="literallayout"><p> write_or_die(1, buf, size);</p></div><p>Sometimes, you do not know where to look for a feature. In many such cases,
-it helps to search through the output of <code class="literal">git log</code>, and then <code class="literal">git show</code> the
-corresponding commit.</p><p>Example: If you know that there was some test case for <code class="literal">git bundle</code>, but
+it helps to search through the output of <code class="literal">git log</code>, and then <code class="literal">git-show</code> the
+corresponding commit.</p><p>Example: If you know that there was some test case for <code class="literal">git-bundle</code>, but
do not remember where it was (yes, you _could_ <code class="literal">git grep bundle t/</code>, but that
does not illustrate the point!):</p><div class="literallayout"><p>$ git log --no-merges t/</p></div><p>In the pager (<code class="literal">less</code>), just search for "bundle", go a few lines back,
and see that it is in commit 18449ab0… Now just copy this object name,
Further chapters cover more specialized topics.
Comprehensive reference documentation is available through the man
-pages. For a command such as "git clone", just use
+pages. For a command such as "git clone <repo>", just use
------------------------------------------------
$ man git-clone
did, and why.
Every commit has a 40-hexdigit id, sometimes called the "object name" or the
-"SHA1 id", shown on the first line of the "git show" output. You can usually
+"SHA1 id", shown on the first line of the "git-show" output. You can usually
refer to a commit by a shorter name, such as a tag or a branch name, but this
longer name can also be useful. Most importantly, it is a globally unique
name for this commit: so if you tell somebody else the object name (for
REVISIONS" section of linkgit:git-rev-parse[1].
[[Updating-a-repository-with-git-fetch]]
-Updating a repository with git fetch
+Updating a repository with git-fetch
------------------------------------
Eventually the developer cloned from will do additional work in her
-------------------------------------------------
New remote-tracking branches will be stored under the shorthand name
-that you gave "git remote add", in this case linux-nfs:
+that you gave "git-remote add", in this case linux-nfs:
-------------------------------------------------
$ git branch -r
shows the difference between the working tree and the index file.
-Note that "git add" always adds just the current contents of a file
+Note that "git-add" always adds just the current contents of a file
to the index; further changes to the same file will be ignored unless
you run git-add on the file again.
A project will often generate files that you do 'not' want to track with git.
This typically includes files generated by a build process or temporary
backup files made by your editor. Of course, 'not' tracking files with git
-is just a matter of 'not' calling "`git add`" on them. But it quickly becomes
+is just a matter of 'not' calling "`git-add`" on them. But it quickly becomes
annoying to have these untracked files lying around; e.g. they make
"`git add .`" and "`git commit -a`" practically useless, and they keep
showing up in the output of "`git status`".
In the process of undoing a previous bad change, you may find it
useful to check out an older version of a particular file using
-linkgit:git-checkout[1]. We've used git checkout before to switch
+linkgit:git-checkout[1]. We've used git-checkout before to switch
branches, but it has quite different behavior if it is given a path
name: the command
===============================
[[getting-updates-with-git-pull]]
-Getting updates with git pull
+Getting updates with git-pull
-----------------------------
After you clone a repository and make a few changes of your own, you
Another way to submit changes to a project is to tell the maintainer
of that project to pull the changes from your repository using
linkgit:git-pull[1]. In the section "<<getting-updates-with-git-pull,
-Getting updates with git pull>>" we described this as a way to get
+Getting updates with git-pull>>" we described this as a way to get
updates from the "main" repository, but it works just as well in the
other direction.
-------------------------------------------------
(For an explanation of the last two lines, see
-linkgit:git-update-server-info[1], and the documentation
-linkgit:githooks[5][Hooks used by git].)
+linkgit:git-update-server-info[1] and linkgit:githooks[5].)
Advertise the URL of proj.git. Anybody else should then be able to
clone or pull from that URL, for example with a command line like:
solution is to retry the push after first updating your work by either a
pull or a fetch followed by a rebase; see the
<<setting-up-a-shared-repository,next section>> and
-linkgit:gitcvs-migration[7][git for CVS users] for more.
+linkgit:gitcvs-migration[7] for more.
[[setting-up-a-shared-repository]]
Setting up a shared repository
Another way to collaborate is by using a model similar to that
commonly used in CVS, where several developers with special rights
all push to and pull from a single shared repository. See
-linkgit:gitcvs-migration[7][git for CVS users] for instructions on how to
+linkgit:gitcvs-migration[7] for instructions on how to
set this up.
However, while there is nothing wrong with git's support for shared
them.
[[forcing-fetch]]
-Forcing git fetch to do non-fast-forward updates
+Forcing git-fetch to do non-fast-forward updates
------------------------------------------------
If git fetch fails because the new head of a branch is not a
$ git config remote.example.fetch +master:ref/remotes/example/master
-------------------------------------------------
-Don't do this unless you're sure you won't mind "git fetch" possibly
+Don't do this unless you're sure you won't mind "git-fetch" possibly
throwing away commits on mybranch.
Also note that all of the above configuration can be performed by
Assume the output looks like this:
------------------------------------------------
-$ git-fsck --full
+$ git fsck --full
broken link from tree 2d9263c6d23595e7cb2a21e5ebbb53655278dff8
to blob 4b9458b3786228369c63936db65827de3cc06200
missing blob 4b9458b3786228369c63936db65827de3cc06200
NOTE: Do not use local URLs here if you plan to publish your superproject!
-See what files `git submodule` created:
+See what files `git-submodule` created:
-------------------------------------------------
$ ls -a
. .. .git .gitmodules a b c d
-------------------------------------------------
-The `git submodule add` command does a couple of things:
+The `git-submodule add` command does a couple of things:
- It clones the submodule under the current directory and by default checks out
the master branch.
$ git submodule init
-------------------------------------------------
-Now use `git submodule update` to clone the repositories and check out the
+Now use `git-submodule update` to clone the repositories and check out the
commits specified in the superproject:
-------------------------------------------------
. .. .git a.txt
-------------------------------------------------
-One major difference between `git submodule update` and `git submodule add` is
-that `git submodule update` checks out a specific commit, rather than the tip
+One major difference between `git-submodule update` and `git-submodule add` is
+that `git-submodule update` checks out a specific commit, rather than the tip
of a branch. It's like checking out a tag: the head is detached, so you're not
working on a branch.
index. Normal operation is just
-------------------------------------------------
-$ git-read-tree <sha1 of tree>
+$ git read-tree <sha1 of tree>
-------------------------------------------------
and your index file will now be equivalent to the tree that you saved
with
-------------------------------------------------
-$ git-checkout-index filename
+$ git checkout-index filename
-------------------------------------------------
or, if you want to check out all of the index, use `-a`.
state at the time of the commit, and a list of parents:
-------------------------------------------------
-$ git
-commit-tree <tree> -p <parent> [-p <parent2> ..]
+$ git
commit-tree <tree> -p <parent> [-p <parent2> ..]
-------------------------------------------------
and then giving the reason for the commit on stdin (either through
object:
-------------------------------------------------
-$ git-cat-file -t <objectname>
+$ git cat-file -t <objectname>
-------------------------------------------------
shows the type of the object, and once you have the type (which is
usually implicit in where you find the object), you can use
-------------------------------------------------
-$ git-cat-file blob|tree|commit|tag <objectname>
+$ git cat-file blob|tree|commit|tag <objectname>
-------------------------------------------------
to show its contents. NOTE! Trees have binary content, and as a result
you can do
-------------------------------------------------
-$ git-cat-file commit HEAD
+$ git cat-file commit HEAD
-------------------------------------------------
to see what the top commit was.
of two commits with
-------------------------------------------------
-$ git-merge-base <commit1> <commit2>
+$ git merge-base <commit1> <commit2>
-------------------------------------------------
which will return you the commit they are both based on. You should
do with (for example)
-------------------------------------------------
-$ git-cat-file commit <commitname> | head -1
+$ git cat-file commit <commitname> | head -1
-------------------------------------------------
since the tree object information is always the first line in a commit
To do the merge, do
-------------------------------------------------
-$ git-read-tree -m -u <origtree> <yourtree> <targettree>
+$ git read-tree -m -u <origtree> <yourtree> <targettree>
-------------------------------------------------
which will do all trivial merge operations for you directly in the
object, and you will have to resolve any such merge clashes using
other tools before you can write out the result.
-You can examine such index state with `git-ls-files --unmerged`
+You can examine such index state with `git ls-files --unmerged`
command. An example:
------------------------------------------------
-$ git-read-tree -m $orig HEAD $target
-$ git-ls-files --unmerged
+$ git read-tree -m $orig HEAD $target
+$ git ls-files --unmerged
100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello.c
100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello.c
100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello.c
------------------------------------------------
-Each line of the `git-ls-files --unmerged` output begins with
+Each line of the `git ls-files --unmerged` output begins with
the blob mode bits, blob SHA1, 'stage number', and the
filename. The 'stage number' is git's way to say which tree it
came from: stage 1 corresponds to `$orig` tree, stage 2 `HEAD`
the blob objects from these three stages yourself, like this:
------------------------------------------------
-$ git-cat-file blob 263414f... >hello.c~1
-$ git-cat-file blob 06fa6a2... >hello.c~2
-$ git-cat-file blob cc44c73... >hello.c~3
+$ git cat-file blob 263414f... >hello.c~1
+$ git cat-file blob 06fa6a2... >hello.c~2
+$ git cat-file blob cc44c73... >hello.c~3
$ git merge-file hello.c~2 hello.c~1 hello.c~3
------------------------------------------------
-------------------------------------------------
$ mv -f hello.c~2 hello.c
-$ git-update-index hello.c
+$ git update-index hello.c
-------------------------------------------------
When a path is in unmerged state, running `git-update-index` for
stages to temporary files and calls a "merge" script on it:
-------------------------------------------------
-$ git-merge-index git-merge-one-file hello.c
+$ git merge-index git-merge-one-file hello.c
-------------------------------------------------
-and that is what higher level `git merge -s resolve` is implemented with.
+and that is what higher level `git-merge -s resolve` is implemented with.
[[hacking-git]]
Hacking git
If you are interested in more details of the revision walking process,
just have a look at the first implementation of `cmd_log()`; call
-`git-show v1.3.0{tilde}155^2{tilde}4` and scroll down to that function (note that you
+`git show v1.3.0{tilde}155^2{tilde}4` and scroll down to that function (note that you
no longer need to call `setup_pager()` directly).
Nowadays, `git log` is a builtin, which means that it is _contained_ in the
-----------------------------------
Sometimes, you do not know where to look for a feature. In many such cases,
-it helps to search through the output of `git log`, and then `git show` the
+it helps to search through the output of `git log`, and then `git-show` the
corresponding commit.
-Example: If you know that there was some test case for `git bundle`, but
+Example: If you know that there was some test case for `git-bundle`, but
do not remember where it was (yes, you _could_ `git grep bundle t/`, but that
does not illustrate the point!):
projects / git.git / commitdiff