Merge branch 'nd/config-split'
authorJunio C Hamano <gitster@pobox.com>
Tue, 13 Nov 2018 13:37:16 +0000 (22:37 +0900)
committerJunio C Hamano <gitster@pobox.com>
Tue, 13 Nov 2018 13:37:16 +0000 (22:37 +0900)
Split the overly large Documentation/config.txt file into million
little pieces.  This potentially allows each individual piece
included into the manual page of the command it affects more easily.

* nd/config-split: (81 commits)
  config.txt: remove config/dummy.txt
  config.txt: move worktree.* to a separate file
  config.txt: move web.* to a separate file
  config.txt: move versionsort.* to a separate file
  config.txt: move user.* to a separate file
  config.txt: move url.* to a separate file
  config.txt: move uploadpack.* to a separate file
  config.txt: move uploadarchive.* to a separate file
  config.txt: move transfer.* to a separate file
  config.txt: move tag.* to a separate file
  config.txt: move submodule.* to a separate file
  config.txt: move stash.* to a separate file
  config.txt: move status.* to a separate file
  config.txt: move splitIndex.* to a separate file
  config.txt: move showBranch.* to a separate file
  config.txt: move sequencer.* to a separate file
  config.txt: move sendemail-config.txt to config/
  config.txt: move reset.* to a separate file
  config.txt: move rerere.* to a separate file
  config.txt: move repack.* to a separate file
  ...

1  2 
Documentation/config/core.txt
Documentation/config/diff.txt
Documentation/config/merge.txt
Documentation/git-rebase.txt
Makefile

index 0000000,73430b6..30adc61
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,594 +1,594 @@@
 -      hex object id per line (i.e., the same as produce by `git for-each-ref
+ core.fileMode::
+       Tells Git if the executable bit of files in the working tree
+       is to be honored.
+ +
+ Some filesystems lose the executable bit when a file that is
+ marked as executable is checked out, or checks out a
+ non-executable file with executable bit on.
+ linkgit:git-clone[1] or linkgit:git-init[1] probe the filesystem
+ to see if it handles the executable bit correctly
+ and this variable is automatically set as necessary.
+ +
+ A repository, however, may be on a filesystem that handles
+ the filemode correctly, and this variable is set to 'true'
+ when created, but later may be made accessible from another
+ environment that loses the filemode (e.g. exporting ext4 via
+ CIFS mount, visiting a Cygwin created repository with
+ Git for Windows or Eclipse).
+ In such a case it may be necessary to set this variable to 'false'.
+ See linkgit:git-update-index[1].
+ +
+ The default is true (when core.filemode is not specified in the config file).
+ core.hideDotFiles::
+       (Windows-only) If true, mark newly-created directories and files whose
+       name starts with a dot as hidden.  If 'dotGitOnly', only the `.git/`
+       directory is hidden, but no other files starting with a dot.  The
+       default mode is 'dotGitOnly'.
+ core.ignoreCase::
+       Internal variable which enables various workarounds to enable
+       Git to work better on filesystems that are not case sensitive,
+       like APFS, HFS+, FAT, NTFS, etc. For example, if a directory listing
+       finds "makefile" when Git expects "Makefile", Git will assume
+       it is really the same file, and continue to remember it as
+       "Makefile".
+ +
+ The default is false, except linkgit:git-clone[1] or linkgit:git-init[1]
+ will probe and set core.ignoreCase true if appropriate when the repository
+ is created.
+ +
+ Git relies on the proper configuration of this variable for your operating
+ and file system. Modifying this value may result in unexpected behavior.
+ core.precomposeUnicode::
+       This option is only used by Mac OS implementation of Git.
+       When core.precomposeUnicode=true, Git reverts the unicode decomposition
+       of filenames done by Mac OS. This is useful when sharing a repository
+       between Mac OS and Linux or Windows.
+       (Git for Windows 1.7.10 or higher is needed, or Git under cygwin 1.7).
+       When false, file names are handled fully transparent by Git,
+       which is backward compatible with older versions of Git.
+ core.protectHFS::
+       If set to true, do not allow checkout of paths that would
+       be considered equivalent to `.git` on an HFS+ filesystem.
+       Defaults to `true` on Mac OS, and `false` elsewhere.
+ core.protectNTFS::
+       If set to true, do not allow checkout of paths that would
+       cause problems with the NTFS filesystem, e.g. conflict with
+       8.3 "short" names.
+       Defaults to `true` on Windows, and `false` elsewhere.
+ core.fsmonitor::
+       If set, the value of this variable is used as a command which
+       will identify all files that may have changed since the
+       requested date/time. This information is used to speed up git by
+       avoiding unnecessary processing of files that have not changed.
+       See the "fsmonitor-watchman" section of linkgit:githooks[5].
+ core.trustctime::
+       If false, the ctime differences between the index and the
+       working tree are ignored; useful when the inode change time
+       is regularly modified by something outside Git (file system
+       crawlers and some backup systems).
+       See linkgit:git-update-index[1]. True by default.
+ core.splitIndex::
+       If true, the split-index feature of the index will be used.
+       See linkgit:git-update-index[1]. False by default.
+ core.untrackedCache::
+       Determines what to do about the untracked cache feature of the
+       index. It will be kept, if this variable is unset or set to
+       `keep`. It will automatically be added if set to `true`. And
+       it will automatically be removed, if set to `false`. Before
+       setting it to `true`, you should check that mtime is working
+       properly on your system.
+       See linkgit:git-update-index[1]. `keep` by default.
+ core.checkStat::
+       When missing or is set to `default`, many fields in the stat
+       structure are checked to detect if a file has been modified
+       since Git looked at it.  When this configuration variable is
+       set to `minimal`, sub-second part of mtime and ctime, the
+       uid and gid of the owner of the file, the inode number (and
+       the device number, if Git was compiled to use it), are
+       excluded from the check among these fields, leaving only the
+       whole-second part of mtime (and ctime, if `core.trustCtime`
+       is set) and the filesize to be checked.
+ +
+ There are implementations of Git that do not leave usable values in
+ some fields (e.g. JGit); by excluding these fields from the
+ comparison, the `minimal` mode may help interoperability when the
+ same repository is used by these other systems at the same time.
+ core.quotePath::
+       Commands that output paths (e.g. 'ls-files', 'diff'), will
+       quote "unusual" characters in the pathname by enclosing the
+       pathname in double-quotes and escaping those characters with
+       backslashes in the same way C escapes control characters (e.g.
+       `\t` for TAB, `\n` for LF, `\\` for backslash) or bytes with
+       values larger than 0x80 (e.g. octal `\302\265` for "micro" in
+       UTF-8).  If this variable is set to false, bytes higher than
+       0x80 are not considered "unusual" any more. Double-quotes,
+       backslash and control characters are always escaped regardless
+       of the setting of this variable.  A simple space character is
+       not considered "unusual".  Many commands can output pathnames
+       completely verbatim using the `-z` option. The default value
+       is true.
+ core.eol::
+       Sets the line ending type to use in the working directory for
+       files that have the `text` property set when core.autocrlf is false.
+       Alternatives are 'lf', 'crlf' and 'native', which uses the platform's
+       native line ending.  The default value is `native`.  See
+       linkgit:gitattributes[5] for more information on end-of-line
+       conversion.
+ core.safecrlf::
+       If true, makes Git check if converting `CRLF` is reversible when
+       end-of-line conversion is active.  Git will verify if a command
+       modifies a file in the work tree either directly or indirectly.
+       For example, committing a file followed by checking out the
+       same file should yield the original file in the work tree.  If
+       this is not the case for the current setting of
+       `core.autocrlf`, Git will reject the file.  The variable can
+       be set to "warn", in which case Git will only warn about an
+       irreversible conversion but continue the operation.
+ +
+ CRLF conversion bears a slight chance of corrupting data.
+ When it is enabled, Git will convert CRLF to LF during commit and LF to
+ CRLF during checkout.  A file that contains a mixture of LF and
+ CRLF before the commit cannot be recreated by Git.  For text
+ files this is the right thing to do: it corrects line endings
+ such that we have only LF line endings in the repository.
+ But for binary files that are accidentally classified as text the
+ conversion can corrupt data.
+ +
+ If you recognize such corruption early you can easily fix it by
+ setting the conversion type explicitly in .gitattributes.  Right
+ after committing you still have the original file in your work
+ tree and this file is not yet corrupted.  You can explicitly tell
+ Git that this file is binary and Git will handle the file
+ appropriately.
+ +
+ Unfortunately, the desired effect of cleaning up text files with
+ mixed line endings and the undesired effect of corrupting binary
+ files cannot be distinguished.  In both cases CRLFs are removed
+ in an irreversible way.  For text files this is the right thing
+ to do because CRLFs are line endings, while for binary files
+ converting CRLFs corrupts data.
+ +
+ Note, this safety check does not mean that a checkout will generate a
+ file identical to the original file for a different setting of
+ `core.eol` and `core.autocrlf`, but only for the current one.  For
+ example, a text file with `LF` would be accepted with `core.eol=lf`
+ and could later be checked out with `core.eol=crlf`, in which case the
+ resulting file would contain `CRLF`, although the original file
+ contained `LF`.  However, in both work trees the line endings would be
+ consistent, that is either all `LF` or all `CRLF`, but never mixed.  A
+ file with mixed line endings would be reported by the `core.safecrlf`
+ mechanism.
+ core.autocrlf::
+       Setting this variable to "true" is the same as setting
+       the `text` attribute to "auto" on all files and core.eol to "crlf".
+       Set to true if you want to have `CRLF` line endings in your
+       working directory and the repository has LF line endings.
+       This variable can be set to 'input',
+       in which case no output conversion is performed.
+ core.checkRoundtripEncoding::
+       A comma and/or whitespace separated list of encodings that Git
+       performs UTF-8 round trip checks on if they are used in an
+       `working-tree-encoding` attribute (see linkgit:gitattributes[5]).
+       The default value is `SHIFT-JIS`.
+ core.symlinks::
+       If false, symbolic links are checked out as small plain files that
+       contain the link text. linkgit:git-update-index[1] and
+       linkgit:git-add[1] will not change the recorded type to regular
+       file. Useful on filesystems like FAT that do not support
+       symbolic links.
+ +
+ The default is true, except linkgit:git-clone[1] or linkgit:git-init[1]
+ will probe and set core.symlinks false if appropriate when the repository
+ is created.
+ core.gitProxy::
+       A "proxy command" to execute (as 'command host port') instead
+       of establishing direct connection to the remote server when
+       using the Git protocol for fetching. If the variable value is
+       in the "COMMAND for DOMAIN" format, the command is applied only
+       on hostnames ending with the specified domain string. This variable
+       may be set multiple times and is matched in the given order;
+       the first match wins.
+ +
+ Can be overridden by the `GIT_PROXY_COMMAND` environment variable
+ (which always applies universally, without the special "for"
+ handling).
+ +
+ The special string `none` can be used as the proxy command to
+ specify that no proxy be used for a given domain pattern.
+ This is useful for excluding servers inside a firewall from
+ proxy use, while defaulting to a common proxy for external domains.
+ core.sshCommand::
+       If this variable is set, `git fetch` and `git push` will
+       use the specified command instead of `ssh` when they need to
+       connect to a remote system. The command is in the same form as
+       the `GIT_SSH_COMMAND` environment variable and is overridden
+       when the environment variable is set.
+ core.ignoreStat::
+       If true, Git will avoid using lstat() calls to detect if files have
+       changed by setting the "assume-unchanged" bit for those tracked files
+       which it has updated identically in both the index and working tree.
+ +
+ When files are modified outside of Git, the user will need to stage
+ the modified files explicitly (e.g. see 'Examples' section in
+ linkgit:git-update-index[1]).
+ Git will not normally detect changes to those files.
+ +
+ This is useful on systems where lstat() calls are very slow, such as
+ CIFS/Microsoft Windows.
+ +
+ False by default.
+ core.preferSymlinkRefs::
+       Instead of the default "symref" format for HEAD
+       and other symbolic reference files, use symbolic links.
+       This is sometimes needed to work with old scripts that
+       expect HEAD to be a symbolic link.
+ core.alternateRefsCommand::
+       When advertising tips of available history from an alternate, use the shell to
+       execute the specified command instead of linkgit:git-for-each-ref[1]. The
+       first argument is the absolute path of the alternate. Output must contain one
++      hex object id per line (i.e., the same as produced by `git for-each-ref
+       --format='%(objectname)'`).
+ +
+ Note that you cannot generally put `git for-each-ref` directly into the config
+ value, as it does not take a repository path as an argument (but you can wrap
+ the command above in a shell script).
+ core.alternateRefsPrefixes::
+       When listing references from an alternate, list only references that begin
+       with the given prefix. Prefixes match as if they were given as arguments to
+       linkgit:git-for-each-ref[1]. To list multiple prefixes, separate them with
+       whitespace. If `core.alternateRefsCommand` is set, setting
+       `core.alternateRefsPrefixes` has no effect.
+ core.bare::
+       If true this repository is assumed to be 'bare' and has no
+       working directory associated with it.  If this is the case a
+       number of commands that require a working directory will be
+       disabled, such as linkgit:git-add[1] or linkgit:git-merge[1].
+ +
+ This setting is automatically guessed by linkgit:git-clone[1] or
+ linkgit:git-init[1] when the repository was created.  By default a
+ repository that ends in "/.git" is assumed to be not bare (bare =
+ false), while all other repositories are assumed to be bare (bare
+ = true).
+ core.worktree::
+       Set the path to the root of the working tree.
+       If `GIT_COMMON_DIR` environment variable is set, core.worktree
+       is ignored and not used for determining the root of working tree.
+       This can be overridden by the `GIT_WORK_TREE` environment
+       variable and the `--work-tree` command-line option.
+       The value can be an absolute path or relative to the path to
+       the .git directory, which is either specified by --git-dir
+       or GIT_DIR, or automatically discovered.
+       If --git-dir or GIT_DIR is specified but none of
+       --work-tree, GIT_WORK_TREE and core.worktree is specified,
+       the current working directory is regarded as the top level
+       of your working tree.
+ +
+ Note that this variable is honored even when set in a configuration
+ file in a ".git" subdirectory of a directory and its value differs
+ from the latter directory (e.g. "/path/to/.git/config" has
+ core.worktree set to "/different/path"), which is most likely a
+ misconfiguration.  Running Git commands in the "/path/to" directory will
+ still use "/different/path" as the root of the work tree and can cause
+ confusion unless you know what you are doing (e.g. you are creating a
+ read-only snapshot of the same index to a location different from the
+ repository's usual working tree).
+ core.logAllRefUpdates::
+       Enable the reflog. Updates to a ref <ref> is logged to the file
+       "`$GIT_DIR/logs/<ref>`", by appending the new and old
+       SHA-1, the date/time and the reason of the update, but
+       only when the file exists.  If this configuration
+       variable is set to `true`, missing "`$GIT_DIR/logs/<ref>`"
+       file is automatically created for branch heads (i.e. under
+       `refs/heads/`), remote refs (i.e. under `refs/remotes/`),
+       note refs (i.e. under `refs/notes/`), and the symbolic ref `HEAD`.
+       If it is set to `always`, then a missing reflog is automatically
+       created for any ref under `refs/`.
+ +
+ This information can be used to determine what commit
+ was the tip of a branch "2 days ago".
+ +
+ This value is true by default in a repository that has
+ a working directory associated with it, and false by
+ default in a bare repository.
+ core.repositoryFormatVersion::
+       Internal variable identifying the repository format and layout
+       version.
+ core.sharedRepository::
+       When 'group' (or 'true'), the repository is made shareable between
+       several users in a group (making sure all the files and objects are
+       group-writable). When 'all' (or 'world' or 'everybody'), the
+       repository will be readable by all users, additionally to being
+       group-shareable. When 'umask' (or 'false'), Git will use permissions
+       reported by umask(2). When '0xxx', where '0xxx' is an octal number,
+       files in the repository will have this mode value. '0xxx' will override
+       user's umask value (whereas the other options will only override
+       requested parts of the user's umask value). Examples: '0660' will make
+       the repo read/write-able for the owner and group, but inaccessible to
+       others (equivalent to 'group' unless umask is e.g. '0022'). '0640' is a
+       repository that is group-readable but not group-writable.
+       See linkgit:git-init[1]. False by default.
+ core.warnAmbiguousRefs::
+       If true, Git will warn you if the ref name you passed it is ambiguous
+       and might match multiple refs in the repository. True by default.
+ core.compression::
+       An integer -1..9, indicating a default compression level.
+       -1 is the zlib default. 0 means no compression,
+       and 1..9 are various speed/size tradeoffs, 9 being slowest.
+       If set, this provides a default to other compression variables,
+       such as `core.looseCompression` and `pack.compression`.
+ core.looseCompression::
+       An integer -1..9, indicating the compression level for objects that
+       are not in a pack file. -1 is the zlib default. 0 means no
+       compression, and 1..9 are various speed/size tradeoffs, 9 being
+       slowest.  If not set,  defaults to core.compression.  If that is
+       not set,  defaults to 1 (best speed).
+ core.packedGitWindowSize::
+       Number of bytes of a pack file to map into memory in a
+       single mapping operation.  Larger window sizes may allow
+       your system to process a smaller number of large pack files
+       more quickly.  Smaller window sizes will negatively affect
+       performance due to increased calls to the operating system's
+       memory manager, but may improve performance when accessing
+       a large number of large pack files.
+ +
+ Default is 1 MiB if NO_MMAP was set at compile time, otherwise 32
+ MiB on 32 bit platforms and 1 GiB on 64 bit platforms.  This should
+ be reasonable for all users/operating systems.  You probably do
+ not need to adjust this value.
+ +
+ Common unit suffixes of 'k', 'm', or 'g' are supported.
+ core.packedGitLimit::
+       Maximum number of bytes to map simultaneously into memory
+       from pack files.  If Git needs to access more than this many
+       bytes at once to complete an operation it will unmap existing
+       regions to reclaim virtual address space within the process.
+ +
+ Default is 256 MiB on 32 bit platforms and 32 TiB (effectively
+ unlimited) on 64 bit platforms.
+ This should be reasonable for all users/operating systems, except on
+ the largest projects.  You probably do not need to adjust this value.
+ +
+ Common unit suffixes of 'k', 'm', or 'g' are supported.
+ core.deltaBaseCacheLimit::
+       Maximum number of bytes to reserve for caching base objects
+       that may be referenced by multiple deltified objects.  By storing the
+       entire decompressed base objects in a cache Git is able
+       to avoid unpacking and decompressing frequently used base
+       objects multiple times.
+ +
+ Default is 96 MiB on all platforms.  This should be reasonable
+ for all users/operating systems, except on the largest projects.
+ You probably do not need to adjust this value.
+ +
+ Common unit suffixes of 'k', 'm', or 'g' are supported.
+ core.bigFileThreshold::
+       Files larger than this size are stored deflated, without
+       attempting delta compression.  Storing large files without
+       delta compression avoids excessive memory usage, at the
+       slight expense of increased disk usage. Additionally files
+       larger than this size are always treated as binary.
+ +
+ Default is 512 MiB on all platforms.  This should be reasonable
+ for most projects as source code and other text files can still
+ be delta compressed, but larger binary media files won't be.
+ +
+ Common unit suffixes of 'k', 'm', or 'g' are supported.
+ core.excludesFile::
+       Specifies the pathname to the file that contains patterns to
+       describe paths that are not meant to be tracked, in addition
+       to '.gitignore' (per-directory) and '.git/info/exclude'.
+       Defaults to `$XDG_CONFIG_HOME/git/ignore`.
+       If `$XDG_CONFIG_HOME` is either not set or empty, `$HOME/.config/git/ignore`
+       is used instead. See linkgit:gitignore[5].
+ core.askPass::
+       Some commands (e.g. svn and http interfaces) that interactively
+       ask for a password can be told to use an external program given
+       via the value of this variable. Can be overridden by the `GIT_ASKPASS`
+       environment variable. If not set, fall back to the value of the
+       `SSH_ASKPASS` environment variable or, failing that, a simple password
+       prompt. The external program shall be given a suitable prompt as
+       command-line argument and write the password on its STDOUT.
+ core.attributesFile::
+       In addition to '.gitattributes' (per-directory) and
+       '.git/info/attributes', Git looks into this file for attributes
+       (see linkgit:gitattributes[5]). Path expansions are made the same
+       way as for `core.excludesFile`. Its default value is
+       `$XDG_CONFIG_HOME/git/attributes`. If `$XDG_CONFIG_HOME` is either not
+       set or empty, `$HOME/.config/git/attributes` is used instead.
+ core.hooksPath::
+       By default Git will look for your hooks in the
+       '$GIT_DIR/hooks' directory. Set this to different path,
+       e.g. '/etc/git/hooks', and Git will try to find your hooks in
+       that directory, e.g. '/etc/git/hooks/pre-receive' instead of
+       in '$GIT_DIR/hooks/pre-receive'.
+ +
+ The path can be either absolute or relative. A relative path is
+ taken as relative to the directory where the hooks are run (see
+ the "DESCRIPTION" section of linkgit:githooks[5]).
+ +
+ This configuration variable is useful in cases where you'd like to
+ centrally configure your Git hooks instead of configuring them on a
+ per-repository basis, or as a more flexible and centralized
+ alternative to having an `init.templateDir` where you've changed
+ default hooks.
+ core.editor::
+       Commands such as `commit` and `tag` that let you edit
+       messages by launching an editor use the value of this
+       variable when it is set, and the environment variable
+       `GIT_EDITOR` is not set.  See linkgit:git-var[1].
+ core.commentChar::
+       Commands such as `commit` and `tag` that let you edit
+       messages consider a line that begins with this character
+       commented, and removes them after the editor returns
+       (default '#').
+ +
+ If set to "auto", `git-commit` would select a character that is not
+ the beginning character of any line in existing commit messages.
+ core.filesRefLockTimeout::
+       The length of time, in milliseconds, to retry when trying to
+       lock an individual reference. Value 0 means not to retry at
+       all; -1 means to try indefinitely. Default is 100 (i.e.,
+       retry for 100ms).
+ core.packedRefsTimeout::
+       The length of time, in milliseconds, to retry when trying to
+       lock the `packed-refs` file. Value 0 means not to retry at
+       all; -1 means to try indefinitely. Default is 1000 (i.e.,
+       retry for 1 second).
+ core.pager::
+       Text viewer for use by Git commands (e.g., 'less').  The value
+       is meant to be interpreted by the shell.  The order of preference
+       is the `$GIT_PAGER` environment variable, then `core.pager`
+       configuration, then `$PAGER`, and then the default chosen at
+       compile time (usually 'less').
+ +
+ When the `LESS` environment variable is unset, Git sets it to `FRX`
+ (if `LESS` environment variable is set, Git does not change it at
+ all).  If you want to selectively override Git's default setting
+ for `LESS`, you can set `core.pager` to e.g. `less -S`.  This will
+ be passed to the shell by Git, which will translate the final
+ command to `LESS=FRX less -S`. The environment does not set the
+ `S` option but the command line does, instructing less to truncate
+ long lines. Similarly, setting `core.pager` to `less -+F` will
+ deactivate the `F` option specified by the environment from the
+ command-line, deactivating the "quit if one screen" behavior of
+ `less`.  One can specifically activate some flags for particular
+ commands: for example, setting `pager.blame` to `less -S` enables
+ line truncation only for `git blame`.
+ +
+ Likewise, when the `LV` environment variable is unset, Git sets it
+ to `-c`.  You can override this setting by exporting `LV` with
+ another value or setting `core.pager` to `lv +c`.
+ core.whitespace::
+       A comma separated list of common whitespace problems to
+       notice.  'git diff' will use `color.diff.whitespace` to
+       highlight them, and 'git apply --whitespace=error' will
+       consider them as errors.  You can prefix `-` to disable
+       any of them (e.g. `-trailing-space`):
+ +
+ * `blank-at-eol` treats trailing whitespaces at the end of the line
+   as an error (enabled by default).
+ * `space-before-tab` treats a space character that appears immediately
+   before a tab character in the initial indent part of the line as an
+   error (enabled by default).
+ * `indent-with-non-tab` treats a line that is indented with space
+   characters instead of the equivalent tabs as an error (not enabled by
+   default).
+ * `tab-in-indent` treats a tab character in the initial indent part of
+   the line as an error (not enabled by default).
+ * `blank-at-eof` treats blank lines added at the end of file as an error
+   (enabled by default).
+ * `trailing-space` is a short-hand to cover both `blank-at-eol` and
+   `blank-at-eof`.
+ * `cr-at-eol` treats a carriage-return at the end of line as
+   part of the line terminator, i.e. with it, `trailing-space`
+   does not trigger if the character before such a carriage-return
+   is not a whitespace (not enabled by default).
+ * `tabwidth=<n>` tells how many character positions a tab occupies; this
+   is relevant for `indent-with-non-tab` and when Git fixes `tab-in-indent`
+   errors. The default tab width is 8. Allowed values are 1 to 63.
+ core.fsyncObjectFiles::
+       This boolean will enable 'fsync()' when writing object files.
+ +
+ This is a total waste of time and effort on a filesystem that orders
+ data writes properly, but can be useful for filesystems that do not use
+ journalling (traditional UNIX filesystems) or that only journal metadata
+ and not file contents (OS X's HFS+, or Linux ext3 with "data=writeback").
+ core.preloadIndex::
+       Enable parallel index preload for operations like 'git diff'
+ +
+ This can speed up operations like 'git diff' and 'git status' especially
+ on filesystems like NFS that have weak caching semantics and thus
+ relatively high IO latencies.  When enabled, Git will do the
+ index comparison to the filesystem data in parallel, allowing
+ overlapping IO's.  Defaults to true.
+ core.createObject::
+       You can set this to 'link', in which case a hardlink followed by
+       a delete of the source are used to make sure that object creation
+       will not overwrite existing objects.
+ +
+ On some file system/operating system combinations, this is unreliable.
+ Set this config setting to 'rename' there; However, This will remove the
+ check that makes sure that existing object files will not get overwritten.
+ core.notesRef::
+       When showing commit messages, also show notes which are stored in
+       the given ref.  The ref must be fully qualified.  If the given
+       ref does not exist, it is not an error but means that no
+       notes should be printed.
+ +
+ This setting defaults to "refs/notes/commits", and it can be overridden by
+ the `GIT_NOTES_REF` environment variable.  See linkgit:git-notes[1].
+ core.commitGraph::
+       If true, then git will read the commit-graph file (if it exists)
+       to parse the graph structure of commits. Defaults to false. See
+       linkgit:git-commit-graph[1] for more information.
+ core.useReplaceRefs::
+       If set to `false`, behave as if the `--no-replace-objects`
+       option was given on the command line. See linkgit:git[1] and
+       linkgit:git-replace[1] for more information.
+ core.multiPackIndex::
+       Use the multi-pack-index file to track multiple packfiles using a
+       single index. See link:technical/multi-pack-index.html[the
+       multi-pack-index design document].
+ core.sparseCheckout::
+       Enable "sparse checkout" feature. See section "Sparse checkout" in
+       linkgit:git-read-tree[1] for more information.
+ core.abbrev::
+       Set the length object names are abbreviated to.  If
+       unspecified or set to "auto", an appropriate value is
+       computed based on the approximate number of packed objects
+       in your repository, which hopefully is enough for
+       abbreviated object names to stay unique for some time.
+       The minimum length is 4.
@@@ -177,15 -177,7 +177,15 @@@ diff.tool:
        Any other value is treated as a custom diff tool and requires
        that a corresponding difftool.<tool>.cmd variable is defined.
  
- include::mergetools-diff.txt[]
 +diff.guitool::
 +      Controls which diff tool is used by linkgit:git-difftool[1] when
 +      the -g/--gui flag is specified. This variable overrides the value
 +      configured in `merge.guitool`. The list below shows the valid
 +      built-in values. Any other value is treated as a custom diff tool
 +      and requires that a corresponding difftool.<guitool>.cmd variable
 +      is defined.
 +
+ include::../mergetools-diff.txt[]
  
  diff.indentHeuristic::
        Set this option to `true` to enable experimental heuristics
@@@ -63,13 -63,7 +63,13 @@@ merge.tool:
        Any other value is treated as a custom merge tool and requires
        that a corresponding mergetool.<tool>.cmd variable is defined.
  
- include::mergetools-merge.txt[]
 +merge.guitool::
 +      Controls which merge tool is used by linkgit:git-mergetool[1] when the
 +      -g/--gui flag is specified. The list below shows the valid built-in values.
 +      Any other value is treated as a custom merge tool and requires that a
 +      corresponding mergetool.<guitool>.cmd variable is defined.
 +
+ include::../mergetools-merge.txt[]
  
  merge.verbosity::
        Controls the amount of output shown by the recursive merge
Simple merge
diff --cc Makefile
Simple merge