Введение в Git: от установки до основных команд

Git – git documentation

GIT_MERGE_VERBOSITY

A number controlling the amount of output shown by
the recursive merge strategy. Overrides merge.verbosity.
See git-merge[1]

This environment variable overrides $PAGER. If it is set
to an empty string or to the value “cat”, Git will not launch
a pager. See also the core.pager option in
git-config[1].

GIT_PROGRESS_DELAY

A number controlling how many seconds to delay before showing
optional progress indicators. Defaults to 2.

GIT_EDITOR

This environment variable overrides $EDITOR and $VISUAL.
It is used by several Git commands when, on interactive mode,
an editor is to be launched. See also git-var[1]
and the core.editor option in git-config[1].

GIT_SEQUENCE_EDITOR

This environment variable overrides the configured Git editor
when editing the todo list of an interactive rebase. See also
git-rebase[1] and the sequence.editor option in
git-config[1].

GIT_SSH
GIT_SSH_COMMAND

If either of these environment variables is set then git fetch
and git push will use the specified command instead of ssh
when they need to connect to a remote system.
The command-line parameters passed to the configured command are
determined by the ssh variant. See ssh.variant option in
git-config[1] for details.

$GIT_SSH_COMMAND takes precedence over $GIT_SSH, and is interpreted
by the shell, which allows additional arguments to be included.
$GIT_SSH on the other hand must be just the path to a program
(which can be a wrapper shell script, if additional arguments are
needed).

Usually it is easier to configure any desired options through your
personal .ssh/config file. Please consult your ssh documentation
for further details.

GIT_SSH_VARIANT

If this environment variable is set, it overrides Git’s autodetection
whether GIT_SSH/GIT_SSH_COMMAND/core.sshCommand refer to OpenSSH,
plink or tortoiseplink. This variable overrides the config setting
ssh.variant that serves the same purpose.

GIT_ASKPASS

If this environment variable is set, then Git commands which need to
acquire passwords or passphrases (e.g. for HTTP or IMAP authentication)
will call this program with a suitable prompt as command-line argument
and read the password from its STDOUT. See also the core.askPass
option in git-config[1].

GIT_TERMINAL_PROMPT

If this environment variable is set to , git will not prompt
on the terminal (e.g., when asking for HTTP authentication).

GIT_CONFIG_GLOBAL
GIT_CONFIG_SYSTEM

Take the configuration from the given files instead from global or
system-level configuration files. If GIT_CONFIG_SYSTEM is set, the
system config file defined at build time (usually /etc/gitconfig)
will not be read. Likewise, if GIT_CONFIG_GLOBAL is set, neither
$HOME/.gitconfig nor $XDG_CONFIG_HOME/git/config will be read. Can
be set to /dev/null to skip reading configuration files of the
respective level.

GIT_CONFIG_NOSYSTEM

Whether to skip reading settings from the system-wide
$(prefix)/etc/gitconfig file. This environment variable can
be used along with $HOME and $XDG_CONFIG_HOME to create a
predictable environment for a picky script, or you can set it
temporarily to avoid using a buggy /etc/gitconfig file while
waiting for someone with sufficient permissions to fix it.

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 check-attr and git check-ignore will
force a flush of the output stream after each 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
not set, Git will choose buffered or record-oriented flushing
based on whether stdout appears to be redirected to a file or not.

GIT_TRACE

Enables general trace messages, e.g. alias expansion, built-in
command execution and external command execution.

If this variable is set to “1”, “2” or “true” (comparison
is case insensitive), trace messages will be printed to
stderr.

If the variable is set to an integer value greater than 2
and lower than 10 (strictly) then Git will interpret this
value as an open file descriptor and will try to write the
trace messages into this file descriptor.

Alternatively, if the variable is set to an absolute path
(starting with a / character), Git will interpret this
as a file path and will try to append the trace messages
to it.

Unsetting the variable, or setting it to empty, “0” or
“false” (case insensitive) disables trace messages.

GIT_TRACE_FSMONITOR

Enables trace messages for the filesystem monitor extension.
See GIT_TRACE for available trace output options.

GIT_TRACE_PACK_ACCESS

Enables trace messages for all accesses to any packs. For each
access, the pack file name and an offset in the pack is
recorded. This may be helpful for troubleshooting some
pack-related performance problems.
See GIT_TRACE for available trace output options.

GIT_TRACE_PACKET

Enables trace messages for all packets coming in or out of a
given program. This can help with debugging object negotiation
or other protocol issues. Tracing is turned off at a packet
starting with “PACK” (but see GIT_TRACE_PACKFILE below).
See GIT_TRACE for available trace output options.

GIT_TRACE_PACKFILE

Enables tracing of packfiles sent or received by a
given program. Unlike other trace output, this trace is
verbatim: no headers, and no quoting of binary data. You almost
certainly want to direct into a file (e.g.,
GIT_TRACE_PACKFILE=/tmp/my.pack) rather than displaying it on
the terminal or mixing it with other trace output.

Note that this is currently only implemented for the client side
of clones and fetches.

GIT_TRACE_PERFORMANCE

Enables performance related trace messages, e.g. total execution
time of each Git command.
See GIT_TRACE for available trace output options.

GIT_TRACE_REFS

Enables trace messages for operations on the ref database.
See GIT_TRACE for available trace output options.

GIT_TRACE_SETUP

Enables trace messages printing the .git, working tree and current
working directory after Git has completed its setup phase.
See GIT_TRACE for available trace output options.

GIT_TRACE_SHALLOW

Enables trace messages that can help debugging fetching /
cloning of shallow repositories.
See GIT_TRACE for available trace output options.

GIT_TRACE_CURL

Enables a curl full trace dump of all incoming and outgoing data,
including descriptive information, of the git transport protocol.
This is similar to doing curl --trace-ascii on the command line.
See GIT_TRACE for available trace output options.

GIT_TRACE_CURL_NO_DATA

When a curl trace is enabled (see GIT_TRACE_CURL above), do not dump
data (that is, only dump info lines and headers).

GIT_TRACE2

Enables more detailed trace messages from the “trace2” library.
Output from GIT_TRACE2 is a simple text-based format for human
readability.

If this variable is set to “1”, “2” or “true” (comparison
is case insensitive), trace messages will be printed to
stderr.

If the variable is set to an integer value greater than 2
and lower than 10 (strictly) then Git will interpret this
value as an open file descriptor and will try to write the
trace messages into this file descriptor.

Alternatively, if the variable is set to an absolute path
(starting with a / character), Git will interpret this
as a file path and will try to append the trace messages
to it. If the path already exists and is a directory, the
trace messages will be written to files (one per process)
in that directory, named according to the last component
of the SID and an optional counter (to avoid filename
collisions).

In addition, if the variable is set to
af_unix:[<socket_type>:]<absolute-pathname>, Git will try
to open the path as a Unix Domain Socket. The socket type
can be either stream or dgram.

Unsetting the variable, or setting it to empty, “0” or
“false” (case insensitive) disables trace messages.

See Trace2 documentation
for full details.

GIT_TRACE2_EVENT

This setting writes a JSON-based format that is suited for machine
interpretation.
See GIT_TRACE2 for available trace output options and
Trace2 documentation for full details.

GIT_TRACE2_PERF

In addition to the text-based messages available in GIT_TRACE2, this
setting writes a column-based format for understanding nesting
regions.
See GIT_TRACE2 for available trace output options and
Trace2 documentation for full details.

GIT_TRACE_REDACT

By default, when tracing is activated, Git redacts the values of
cookies, the “Authorization:” header, the “Proxy-Authorization:”
header and packfile URIs. Set this variable to to prevent this
redaction.

GIT_LITERAL_PATHSPECS

Setting this variable to 1 will cause Git to treat all
pathspecs literally, rather than as glob patterns. For example,
running GIT_LITERAL_PATHSPECS=1 git log -- '*.c' will search
for commits that touch the path *.c, not any paths that the
glob *.c matches. You might want this if you are feeding
literal paths to Git (e.g., paths previously given to you by
git ls-tree, --raw diff output, etc).

GIT_GLOB_PATHSPECS

Setting this variable to 1 will cause Git to treat all
pathspecs as glob patterns (aka “glob” magic).

GIT_NOGLOB_PATHSPECS

Setting this variable to 1 will cause Git to treat all
pathspecs as literal (aka “literal” magic).

GIT_ICASE_PATHSPECS

Setting this variable to 1 will cause Git to treat all
pathspecs as case-insensitive.

GIT_REFLOG_ACTION

When a ref is updated, reflog entries are created to keep
track of the reason why the ref was updated (which is
typically the name of the high-level command that updated
the ref), in addition to the old and new values of the ref.
A scripted Porcelain command can use set_reflog_action
helper function in git-sh-setup to set its name to this
variable when it is invoked as the top level command by the
end user, to be recorded in the body of the reflog.

GIT_REF_PARANOIA

If set to , ignore broken or badly named refs when iterating
over lists of refs. Normally Git will try to include any such
refs, which may cause some operations to fail. This is usually
preferable, as potentially destructive operations (e.g.,
git-prune[1]) are better off aborting rather than
ignoring broken refs (and thus considering the history they
point to as not worth saving). The default value is 1 (i.e.,
be paranoid about detecting and aborting all operations). You
should not normally need to set this to , but it may be
useful when trying to salvage data from a corrupted repository.

GIT_ALLOW_PROTOCOL

If set to a colon-separated list of protocols, behave as if
protocol.allow is set to never, and each of the listed
protocols has protocol.<name>.allow set to always
(overriding any existing configuration). In other words, any
protocol not mentioned will be disallowed (i.e., this is a
whitelist, not a blacklist). See the description of
protocol.allow in git-config[1] for more details.

GIT_PROTOCOL_FROM_USER

Set to 0 to prevent protocols used by fetch/push/clone which are
configured to the user state. This is useful to restrict recursive
submodule initialization from an untrusted repository or for programs
which feed potentially-untrusted URLS to git commands. See
git-config[1] for more details.

GIT_PROTOCOL

For internal use only. Used in handshaking the wire protocol.
Contains a colon : separated list of keys with optional values
key[=value]. Presence of unknown keys and values must be
ignored.

Note that servers may need to be configured to allow this variable to
pass over some transports. It will be propagated automatically when
accessing local repositories (i.e., file:// or a filesystem path), as
well as over the git:// protocol. For git-over-http, it should work
automatically in most configurations, but see the discussion in
git-http-backend[1]. For git-over-ssh, the ssh server may need
to be configured to allow clients to pass this variable (e.g., by using
AcceptEnv GIT_PROTOCOL with OpenSSH).

This configuration is optional. If the variable is not propagated, then
clients will fall back to the original “v0” protocol (but may miss out
on some performance improvements or features). This variable currently
only affects clones and fetches; it is not yet used for pushes (but may
be in the future).

GIT_OPTIONAL_LOCKS

If set to , Git will complete any requested operation without
performing any optional sub-operations that require taking a lock.
For example, this will prevent git status from refreshing the
index as a side effect. This is useful for processes running in
the background which do not want to cause lock contention with
other operations on the repository. Defaults to 1.

GIT_REDIRECT_STDIN
GIT_REDIRECT_STDOUT
GIT_REDIRECT_STDERR

Windows-only: allow redirecting the standard input/output/error
handles to paths specified by the environment variables. This is
particularly useful in multi-threaded applications where the
canonical way to pass standard handles via CreateProcess() is
not an option because it would require the handles to be marked
inheritable (and consequently every spawned process would
inherit them, possibly blocking regular Git operations). The
primary intended use case is to use named pipes for communication
(e.g. \.pipemy-git-stdin-123).

Two special values are supported: off will simply close the
corresponding standard handle, and if GIT_REDIRECT_STDERR is
2>&1, standard error will be redirected to the same handle as
standard output.

GIT_PRINT_SHA1_ELLIPSIS (deprecated)

If set to yes, print an ellipsis following an
(abbreviated) SHA-1 value. This affects indications of
detached HEADs (git-checkout[1]) and the raw
diff output (git-diff[1]). Printing an
ellipsis in the cases mentioned is no longer considered
adequate and support for it is likely to be removed in the
foreseeable future (along with the variable).

Git – git-config documentation

advice.*

These variables control various optional help messages designed to
aid new users. All advice.* variables default to true, and you
can tell Git that you do not need help by setting these to false:

ambiguousFetchRefspec

Advice shown when fetch refspec for multiple remotes map to
the same remote-tracking branch namespace and causes branch
tracking set-up to fail.

fetchShowForcedUpdates

Advice shown when git-fetch[1] takes a long time
to calculate forced updates after ref updates, or to warn
that the check is disabled.

pushUpdateRejected

Set this variable to false if you want to disable
pushNonFFCurrent, pushNonFFMatching, pushAlreadyExists,
pushFetchFirst, pushNeedsForce, and pushRefNeedsUpdate
simultaneously.

pushNonFFCurrent

Advice shown when git-push[1] fails due to a
non-fast-forward update to the current branch.

pushNonFFMatching

Advice shown when you ran git-push[1] and pushed
matching refs explicitly (i.e. you used :, or
specified a refspec that isn’t your current branch) and
it resulted in a non-fast-forward error.

pushAlreadyExists

Shown when git-push[1] rejects an update that
does not qualify for fast-forwarding (e.g., a tag.)

pushFetchFirst

Shown when git-push[1] rejects an update that
tries to overwrite a remote ref that points at an
object we do not have.

pushNeedsForce

Shown when git-push[1] rejects an update that
tries to overwrite a remote ref that points at an
object that is not a commit-ish, or make the remote
ref point at an object that is not a commit-ish.

pushUnqualifiedRefname

Shown when git-push[1] gives up trying to
guess based on the source and destination refs what
remote ref namespace the source belongs in, but where
we can still suggest that the user push to either
refs/heads/* or refs/tags/* based on the type of the
source object.

pushRefNeedsUpdate

Shown when git-push[1] rejects a forced update of
a branch when its remote-tracking ref has updates that we
do not have locally.

skippedCherryPicks

Shown when git-rebase[1] skips a commit that has already
been cherry-picked onto the upstream branch.

statusAheadBehind

Shown when git-status[1] computes the ahead/behind
counts for a local ref compared to its remote tracking ref,
and that calculation takes longer than expected. Will not
appear if status.aheadBehind is false or the option
--no-ahead-behind is given.

statusHints

Show directions on how to proceed from the current
state in the output of git-status[1], in
the template shown when writing commit messages in
git-commit[1], and in the help message shown
by git-switch[1] or
git-checkout[1] when switching branch.

statusUoption

Advise to consider using the -u option to git-status[1]
when the command takes more than 2 seconds to enumerate untracked
files.

commitBeforeMerge

Advice shown when git-merge[1] refuses to
merge to avoid overwriting local changes.

resetNoRefresh

Advice to consider using the --no-refresh option to
git-reset[1] when the command takes more than 2 seconds
to refresh the index after reset.

resolveConflict

Advice shown by various commands when conflicts
prevent the operation from being performed.

sequencerInUse

Advice shown when a sequencer command is already in progress.

implicitIdentity

Advice on how to set your identity configuration when
your information is guessed from the system username and
domain name.

detachedHead

Advice shown when you used
git-switch[1] or git-checkout[1]
to move to the detach HEAD state, to instruct how to
create a local branch after the fact.

suggestDetachingHead

Advice shown when git-switch[1] refuses to detach HEAD
without the explicit --detach option.

checkoutAmbiguousRemoteBranchName

Advice shown when the argument to
git-checkout[1] and git-switch[1]
ambiguously resolves to a
remote tracking branch on more than one remote in
situations where an unambiguous argument would have
otherwise caused a remote-tracking branch to be
checked out. See the checkout.defaultRemote
configuration variable for how to set a given remote
to used by default in some situations where this
advice would be printed.

amWorkDir

Advice that shows the location of the patch file when
git-am[1] fails to apply it.

rmHints

In case of failure in the output of git-rm[1],
show directions on how to proceed from the current state.

addEmbeddedRepo

Advice on what to do when you’ve accidentally added one
git repo inside of another.

ignoredHook

Advice shown if a hook is ignored because the hook is not
set as executable.

waitingForEditor

Print a message to the terminal whenever Git is waiting for
editor input from the user.

nestedTag

Advice shown if a user attempts to recursively tag a tag object.

submoduleAlternateErrorStrategyDie

Advice shown when a submodule.alternateErrorStrategy option
configured to “die” causes a fatal error.

submodulesNotUpdated

Advice shown when a user runs a submodule command that fails
because git submodule update --init was not run.

addIgnoredFile

Advice shown if a user attempts to add an ignored file to
the index.

addEmptyPathspec

Advice shown if a user runs the add command without providing
the pathspec parameter.

updateSparsePath

Advice shown when either git-add[1] or git-rm[1]
is asked to update index entries outside the current sparse
checkout.

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.
git-clone[1] or 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 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 git-clone[1] or 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 to true, enable the built-in file system monitor
daemon for this working directory (git-fsmonitor–daemon[1]).

Like hook-based file system monitors, the built-in file system monitor
can speed up Git commands that need to refresh the Git index
(e.g. git status) in a working directory with many files. The
built-in monitor eliminates the need to install and maintain an
external third-party tool.

The built-in file system monitor is currently available only on a
limited set of supported platforms. Currently, this includes Windows
and MacOS.

This hook command is used to identify all files that may have changed
since the requested date/time. This information is used to speed up
git by avoiding unnecessary scanning of files that have not changed.

See the “fsmonitor-watchman” section of githooks[5].

Note that if you concurrently use multiple versions of Git, such
as one version on the command line and another version in an IDE
tool, that the definition of core.fsmonitor was extended to
allow boolean values in addition to hook pathnames. Git versions
2.35.1 and prior will not understand the boolean values and will
consider the “true” or “false” values as hook pathnames to be
invoked. Git versions 2.26 thru 2.35.1 default to hook protocol
V2 and will fall back to no fsmonitor (full scan). Git versions
prior to 2.26 default to hook protocol V1 and will silently
assume there were no changes to report (no scan), so status
commands may report incomplete results. For this reason, it is
best to upgrade all of your Git versions before using the built-in
file system monitor.

core.fsmonitorHookVersion

Sets the protocol version to be used when invoking the
“fsmonitor” hook.

There are currently versions 1 and 2. When this is not set,
version 2 will be tried first and if it fails then version 1
will be tried. Version 1 uses a timestamp as input to determine
which files have changes since that time but some monitors
like Watchman have race conditions when used with a timestamp.
Version 2 uses an opaque string so that the monitor can return
something that can be used to determine what files have changed
without race conditions.

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 git-update-index[1]. True by default.

core.splitIndex

If true, the split-index feature of the index will be used.
See 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 git-update-index[1]. keep by default, unless
feature.manyFiles is enabled which sets this setting to
true 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 302265 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 are marked as text (either by having the text
attribute set, or by having text=auto and Git auto-detecting
the contents as text).
Alternatives are lf, crlf and native, which uses the platform’s
native line ending. The default value is native. See
gitattributes[5] for more information on end-of-line
conversion. Note that this value is ignored if core.autocrlf
is set to true or input.

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.

Похожее:  VNC в Windows: настройка сервера и клиента -

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 gitattributes[5]).
The default value is SHIFT-JIS.

If false, symbolic links are checked out as small plain files that
contain the link text. git-update-index[1] and
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 git-clone[1] or 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
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 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
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 git-add[1] or git-merge[1].

This setting is automatically guessed by git-clone[1] or
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 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 per thread 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 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 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 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 git-var[1].

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).

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):

core.fsync

A comma-separated list of components of the repository that
should be hardened via the core.fsyncMethod when created or
modified. You can disable hardening of any component by
prefixing it with a . Items that are not hardened may be
lost in the event of an unclean system shutdown. Unless you
have special requirements, it is recommended that you leave
this option empty or pick one of committed, added,
or all.

When this configuration is encountered, the set of components starts with
the platform default value, disabled components are removed, and additional
components are added. none resets the state so that the platform default
is ignored.

The empty string resets the fsync configuration to the platform
default. The default on most platforms is equivalent to
core.fsync=committed,-loose-object, which has good performance,
but risks losing recent work in the event of an unclean system shutdown.

  • none clears the set of fsynced components.

  • loose-object hardens objects added to the repo in loose-object form.

  • pack hardens objects added to the repo in packfile form.

  • pack-metadata hardens packfile bitmaps and indexes.

  • commit-graph hardens the commit graph file.

  • index hardens the index when it is modified.

  • objects is an aggregate option that is equivalent to
    loose-object,pack.

  • reference hardens references modified in the repo.

  • derived-metadata is an aggregate option that is equivalent to
    pack-metadata,commit-graph.

  • committed is an aggregate option that is currently equivalent to
    objects. This mode sacrifices some performance to ensure that work
    that is committed to the repository with git commit or similar commands
    is hardened.

  • added is an aggregate option that is currently equivalent to
    committed,index. This mode sacrifices additional performance to
    ensure that the results of commands like git add and similar operations
    are hardened.

  • all is an aggregate option that syncs all individual components above.

core.fsyncMethod

A value indicating the strategy Git will use to harden repository data
using fsync and related primitives.

  • fsync uses the fsync() system call or platform equivalents.

  • writeout-only issues pagecache writeback requests, but depending on the
    filesystem and storage hardware, data added to the repository may not be
    durable in the event of a system crash. This is the default mode on macOS.

  • batch enables a mode that uses writeout-only flushes to stage multiple
    updates in the disk writeback cache and then does a single full fsync of
    a dummy file to trigger the disk cache flush at the end of the operation.

    Currently batch mode only applies to loose-object files. Other repository
    data is made durable as if fsync was specified. This mode is expected to
    be as safe as fsync on macOS for repos stored on HFS or APFS filesystems
    and on Windows for repos stored on NTFS or ReFS filesystems.

core.fsyncObjectFiles

This boolean will enable fsync() when writing object files.
This setting is deprecated. Use core.fsync instead.

This setting affects data added to the Git repository in loose-object
form. When set to true, Git will issue an fsync or similar system call
to flush caches so that loose-objects remain consistent in the face
of a unclean system shutdown.

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.unsetenvvars

Windows-only: comma-separated list of environment variables’
names that need to be unset before spawning any other process.
Defaults to PERL5LIB to account for the fact that Git for
Windows insists on using its own Perl interpreter.

core.restrictinheritedhandles

Windows-only: override whether spawned processes inherit only standard
file handles (stdin, stdout and stderr) or all handles. Can be
auto, true or false. Defaults to auto, which means true on
Windows 7 and later, and false on older Windows versions.

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 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 true. See
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 git[1] and
git-replace[1] for more information.

core.multiPackIndex

Use the multi-pack-index file to track multiple packfiles using a
single index. See git-multi-pack-index[1] for more
information. Defaults to true.

core.sparseCheckout

Enable “sparse checkout” feature. See git-sparse-checkout[1]
for more information.

core.sparseCheckoutCone

Enables the “cone mode” of the sparse checkout feature. When the
sparse-checkout file contains a limited set of patterns, this
mode provides significant performance advantages. The “non
cone mode” can be requested to allow specifying a more flexible
patterns by setting this variable to false. See
git-sparse-checkout[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.
If set to “no”, no abbreviation is made and the object names
are shown in their full length.
The minimum length is 4.

add.ignoreErrors
add.ignore-errors (deprecated)

Tells git add to continue adding files when some files cannot be
added due to indexing errors. Equivalent to the --ignore-errors
option of git-add[1]. add.ignore-errors is deprecated,
as it does not follow the usual naming convention for configuration
variables.

add.interactive.useBuiltin

Set to false to fall back to the original Perl implementation of
the interactive version of git-add[1] instead of the built-in
version. Is true by default.

alias.*

Command aliases for the git[1] command wrapper – e.g.
after defining alias.last = cat-file commit HEAD, the invocation
git last is equivalent to git cat-file commit HEAD. To avoid
confusion and troubles with script usage, aliases that
hide existing Git commands are ignored. Arguments are split by
spaces, the usual shell quoting and escaping is supported.
A quote pair or a backslash can be used to quote them.

Note that the first word of an alias does not necessarily have to be a
command. It can be a command-line option that will be passed into the
invocation of git. In particular, this is useful when used with -c
to pass in one-time configurations or -p to force pagination. For example,
loud-rebase = -c commit.verbose=true rebase can be defined such that
running git loud-rebase would be equivalent to
git -c commit.verbose=true rebase. Also, ps = -p status would be a
helpful alias since git ps would paginate the output of git status
where the original command does not.

If the alias expansion is prefixed with an exclamation point,
it will be treated as a shell command. For example, defining
alias.new = !gitk --all --not ORIG_HEAD, the invocation
git new is equivalent to running the shell command
gitk --all --not ORIG_HEAD. Note that shell commands will be
executed from the top-level directory of a repository, which may
not necessarily be the current directory.
GIT_PREFIX is set as returned by running git rev-parse --show-prefix
from the original current directory. See git-rev-parse[1].

am.keepcr

If true, git-am will call git-mailsplit for patches in mbox format
with parameter --keep-cr. In this case git-mailsplit will
not remove r from lines ending with rn. Can be overridden
by giving --no-keep-cr from the command line.
See git-am[1], git-mailsplit[1].

am.threeWay

By default, git am will fail if the patch does not apply cleanly. When
set to true, this setting tells git am to fall back on 3-way merge if
the patch records the identity of blobs it is supposed to apply to and
we have those blobs available locally (equivalent to giving the --3way
option from the command line). Defaults to false.
See git-am[1].

apply.ignoreWhitespace

When set to change, tells git apply to ignore changes in
whitespace, in the same way as the --ignore-space-change
option.
When set to one of: no, none, never, false tells git apply to
respect all whitespace differences.
See git-apply[1].

apply.whitespace

Tells git apply how to handle whitespaces, in the same way
as the --whitespace option. See git-apply[1].

blame.blankBoundary

Show blank commit object name for boundary commits in
git-blame[1]. This option defaults to false.

blame.coloring

This determines the coloring scheme to be applied to blame
output. It can be repeatedLines, highlightRecent,
or none which is the default.

blame.date

Specifies the format used to output dates in git-blame[1].
If unset the iso format is used. For supported values,
see the discussion of the --date option at git-log[1].

blame.showEmail

Show the author email instead of author name in git-blame[1].
This option defaults to false.

blame.showRoot

Do not treat root commits as boundaries in git-blame[1].
This option defaults to false.

blame.ignoreRevsFile

Ignore revisions listed in the file, one unabbreviated object name per
line, in git-blame[1]. Whitespace and comments beginning with
# are ignored. This option may be repeated multiple times. Empty
file names will reset the list of ignored revisions. This option will
be handled before the command line option --ignore-revs-file.

blame.markUnblamableLines

Mark lines that were changed by an ignored revision that we could not
attribute to another commit with a * in the output of
git-blame[1].

blame.markIgnoredLines

Mark lines that were changed by an ignored revision that we attributed to
another commit with a ? in the output of git-blame[1].

branch.autoSetupMerge

Tells git branch, git switch and git checkout to set up new branches
so that git-pull[1] will appropriately merge from the
starting point branch. Note that even if this option is not set,
this behavior can be chosen per-branch using the --track
and --no-track options. The valid settings are: false — no
automatic setup is done; true — automatic setup is done when the
starting point is a remote-tracking branch; always — automatic setup is done when the starting point is either a
local branch or remote-tracking branch; inherit — if the starting point
has a tracking configuration, it is copied to the new
branch; simple — automatic setup is done only when the starting point
is a remote-tracking branch and the new branch has the same name as the
remote branch. This option defaults to true.

Похожее:  1С:Рабочее место кассира
branch.autoSetupRebase

When a new branch is created with git branch, git switch or git checkout
that tracks another branch, this variable tells Git to set
up pull to rebase instead of merge (see “branch.<name>.rebase”).
When never, rebase is never automatically set to true.
When local, rebase is set to true for tracked branches of
other local branches.
When remote, rebase is set to true for tracked branches of
remote-tracking branches.
When always, rebase will be set to true for all tracking
branches.
See “branch.autoSetupMerge” for details on how to set up a
branch to track another branch.
This option defaults to never.

branch.sort

This variable controls the sort ordering of branches when displayed by
git-branch[1]. Without the “–sort=<value>” option provided, the
value of this variable will be used as the default.
See git-for-each-ref[1] field names for valid values.

branch.<name>.remote

When on branch <name>, it tells git fetch and git push
which remote to fetch from/push to. The remote to push to
may be overridden with remote.pushDefault (for all branches).
The remote to push to, for the current branch, may be further
overridden by branch.<name>.pushRemote. If no remote is
configured, or if you are not on any branch and there is more than
one remote defined in the repository, it defaults to origin for
fetching and remote.pushDefault for pushing.
Additionally, . (a period) is the current local repository
(a dot-repository), see branch.<name>.merge‘s final note below.

branch.<name>.pushRemote

When on branch <name>, it overrides branch.<name>.remote for
pushing. It also overrides remote.pushDefault for pushing
from branch <name>. When you pull from one place (e.g. your
upstream) and push to another place (e.g. your own publishing
repository), you would want to set remote.pushDefault to
specify the remote to push to for all branches, and use this
option to override it for a specific branch.

branch.<name>.merge

Defines, together with branch.<name>.remote, the upstream branch
for the given branch. It tells git fetch/git pull/git rebase which
branch to merge and can also affect git push (see push.default).
When in branch <name>, it tells git fetch the default
refspec to be marked for merging in FETCH_HEAD. The value is
handled like the remote part of a refspec, and must match a
ref which is fetched from the remote given by
“branch.<name>.remote”.
The merge information is used by git pull (which at first calls
git fetch) to lookup the default branch for merging. Without
this option, git pull defaults to merge the first refspec fetched.
Specify multiple values to get an octopus merge.
If you wish to setup git pull so that it merges into <name> from
another branch in the local repository, you can point
branch.<name>.merge to the desired branch, and use the relative path
setting . (a period) for branch.<name>.remote.

branch.<name>.mergeOptions

Sets default options for merging into branch <name>. The syntax and
supported options are the same as those of git-merge[1], but
option values containing whitespace characters are currently not
supported.

branch.<name>.rebase

When true, rebase the branch <name> on top of the fetched branch,
instead of merging the default branch from the default remote when
“git pull” is run. See “pull.rebase” for doing this in a non
branch-specific manner.

When merges (or just m), pass the --rebase-merges option to git rebase
so that the local merge commits are included in the rebase (see
git-rebase[1] for details).

When the value is interactive (or just i), the rebase is run in interactive
mode.

NOTE: this is a possibly dangerous operation; do not use
it unless you understand the implications (see git-rebase[1]
for details).

branch.<name>.description

Branch description, can be edited with
git branch --edit-description. Branch description is
automatically added in the format-patch cover letter or
request-pull summary.

browser.<tool>.cmd

Specify the command to invoke the specified browser. The
specified command is evaluated in shell with the URLs passed
as arguments. (See git-web–browse[1].)

browser.<tool>.path

Override the path for the given tool that may be used to
browse HTML help (see -w option in git-help[1]) or a
working repository in gitweb (see git-instaweb[1]).

checkout.defaultRemote

When you run git checkout <something>
or git switch <something> and only have one
remote, it may implicitly fall back on checking out and
tracking e.g. origin/<something>. This stops working as soon
as you have more than one remote with a <something>
reference. This setting allows for setting the name of a
preferred remote that should always win when it comes to
disambiguation. The typical use-case is to set this to
origin.

Currently this is used by git-switch[1] and
git-checkout[1] when git checkout <something>
or git switch <something>
will checkout the <something> branch on another remote,
and by git-worktree[1] when git worktree add refers to a
remote branch. This setting might be used for other checkout-like
commands or functionality in the future.

checkout.guess

Provides the default value for the --guess or --no-guess
option in git checkout and git switch. See
git-switch[1] and git-checkout[1].

checkout.workers

The number of parallel workers to use when updating the working tree.
The default is one, i.e. sequential execution. If set to a value less
than one, Git will use as many workers as the number of logical cores
available. This setting and checkout.thresholdForParallelism affect
all commands that perform checkout. E.g. checkout, clone, reset,
sparse-checkout, etc.

Note: parallel checkout usually delivers better performance for repositories
located on SSDs or over NFS. For repositories on spinning disks and/or machines
with a small number of cores, the default sequential checkout often performs
better. The size and compression level of a repository might also influence how
well the parallel version performs.

checkout.thresholdForParallelism

When running parallel checkout with a small number of files, the cost
of subprocess spawning and inter-process communication might outweigh
the parallelization gains. This setting allows to define the minimum
number of files for which parallel checkout should be attempted. The
default is 100.

clean.requireForce

A boolean to make git-clean do nothing unless given -f,
-i or -n. Defaults to true.

clone.defaultRemoteName

The name of the remote to create when cloning a repository. Defaults to
origin, and can be overridden by passing the --origin command-line
option to git-clone[1].

clone.rejectShallow

Reject to clone a repository if it is a shallow one, can be overridden by
passing option --reject-shallow in command line. See git-clone[1]

clone.filterSubmodules

If a partial clone filter is provided (see --filter in
git-rev-list[1]) and --recurse-submodules is used, also apply
the filter to submodules.

color.advice

A boolean to enable/disable color in hints (e.g. when a push
failed, see advice.* for a list). May be set to always,
false (or never) or auto (or true), in which case colors
are used only when the error output goes to a terminal. If
unset, then the value of color.ui is used (auto by default).

color.advice.hint

Use customized color for hints.

color.blame.highlightRecent

Specify the line annotation color for git blame --color-by-age
depending upon the age of the line.

This setting should be set to a comma-separated list of color and
date settings, starting and ending with a color, the dates should be
set from oldest to newest. The metadata will be colored with the
specified colors if the line was introduced before the given
timestamp, overwriting older timestamped colors.

Instead of an absolute timestamp relative timestamps work as well,
e.g. 2.weeks.ago is valid to address anything older than 2 weeks.

It defaults to blue,12 month ago,white,1 month ago,red, which
colors everything older than one year blue, recent changes between
one month and one year old are kept white, and lines introduced
within the last month are colored red.

color.blame.repeatedLines

Use the specified color to colorize line annotations for
git blame --color-lines, if they come from the same commit as the
preceding line. Defaults to cyan.

color.branch

A boolean to enable/disable color in the output of
git-branch[1]. May be set to always,
false (or never) or auto (or true), in which case colors are used
only when the output is to a terminal. If unset, then the
value of color.ui is used (auto by default).

color.branch.<slot>

Use customized color for branch coloration. <slot> is one of
current (the current branch), local (a local branch),
remote (a remote-tracking branch in refs/remotes/),
upstream (upstream tracking branch), plain (other
refs).

color.diff

Whether to use ANSI escape sequences to add color to patches.
If this is set to always, git-diff[1],
git-log[1], and git-show[1] will use color
for all patches. If it is set to true or auto, those
commands will only use color when output is to the terminal.
If unset, then the value of color.ui is used (auto by
default).

This does not affect git-format-patch[1] or the
git-diff-* plumbing commands. Can be overridden on the
command line with the --color[=<when>] option.

color.diff.<slot>

Use customized color for diff colorization. <slot> specifies
which part of the patch to use the specified color, and is one
of context (context text – plain is a historical synonym),
meta (metainformation), frag
(hunk header), func (function in hunk header), old (removed lines),
new (added lines), commit (commit headers), whitespace
(highlighting whitespace errors), oldMoved (deleted lines),
newMoved (added lines), oldMovedDimmed, oldMovedAlternative,
oldMovedAlternativeDimmed, newMovedDimmed, newMovedAlternativenewMovedAlternativeDimmed (See the <mode>
setting of –color-moved in git-diff[1] for details),
contextDimmed, oldDimmed, newDimmed, contextBold,
oldBold, and newBold (see git-range-diff[1] for details).

color.decorate.<slot>

Use customized color for git log –decorate output. <slot> is one
of branch, remoteBranch, tag, stash or HEAD for local
branches, remote-tracking branches, tags, stash and HEAD, respectively
and grafted for grafted commits.

color.grep

When set to always, always highlight matches. When false (or
never), never. When set to true or auto, use color only
when the output is written to the terminal. If unset, then the
value of color.ui is used (auto by default).

color.grep.<slot>

Use customized color for grep colorization. <slot> specifies which
part of the line to use the specified color, and is one of

color.interactive

When set to always, always use colors for interactive prompts
and displays (such as those used by “git-add –interactive” and
“git-clean –interactive”). When false (or never), never.
When set to true or auto, use colors only when the output is
to the terminal. If unset, then the value of color.ui is
used (auto by default).

color.interactive.<slot>

Use customized color for git add –interactive and git clean
–interactive
output. <slot> may be prompt, header, help
or error, for four distinct types of normal output from
interactive commands.

A boolean to specify whether auto color modes should colorize
output going to the pager. Defaults to true; set this to false
if your pager does not understand ANSI color codes.

color.push

A boolean to enable/disable color in push errors. May be set to
always, false (or never) or auto (or true), in which
case colors are used only when the error output goes to a terminal.
If unset, then the value of color.ui is used (auto by default).

color.push.error

Use customized color for push errors.

color.remote

If set, keywords at the start of the line are highlighted. The
keywords are “error”, “warning”, “hint” and “success”, and are
matched case-insensitively. May be set to always, false (or
never) or auto (or true). If unset, then the value of
color.ui is used (auto by default).

color.remote.<slot>

Use customized color for each remote keyword. <slot> may be
hint, warning, success or error which match the
corresponding keyword.

color.showBranch

A boolean to enable/disable color in the output of
git-show-branch[1]. May be set to always,
false (or never) or auto (or true), in which case colors are used
only when the output is to a terminal. If unset, then the
value of color.ui is used (auto by default).

color.status

A boolean to enable/disable color in the output of
git-status[1]. May be set to always,
false (or never) or auto (or true), in which case colors are used
only when the output is to a terminal. If unset, then the
value of color.ui is used (auto by default).

color.status.<slot>

Use customized color for status colorization. <slot> is
one of header (the header text of the status message),
added or updated (files which are added but not committed),
changed (files which are changed but not added in the index),
untracked (files which are not tracked by Git),
branch (the current branch),
nobranch (the color the no branch warning is shown in, defaulting
to red),
localBranch or remoteBranch (the local and remote branch names,
respectively, when branch and tracking information is displayed in the
status short-format), or
unmerged (files which have unmerged changes).

color.transport

A boolean to enable/disable color when pushes are rejected. May be
set to always, false (or never) or auto (or true), in which
case colors are used only when the error output goes to a terminal.
If unset, then the value of color.ui is used (auto by default).

color.transport.rejected

Use customized color when a push was rejected.

color.ui

This variable determines the default value for variables such
as color.diff and color.grep that control the use of color
per command family. Its scope will expand as more commands learn
configuration to set a default for the --color option. Set it
to false or never if you prefer Git commands not to use
color unless enabled explicitly with some other configuration
or the --color option. Set it to always if you want all
output not intended for machine consumption to use color, to
true or auto (this is the default since Git 1.8.4) if you
want such output to use color when written to the terminal.

column.ui

Specify whether supported commands should output in columns.
This variable consists of a list of tokens separated by spaces
or commas:

These options control when the feature should be enabled
(defaults to never):

These options control layout (defaults to column). Setting any
of these implies always if none of always, never, or auto are
specified.

Finally, these options can be combined with a layout option (defaults
to nodense):

column.branch

Specify whether to output branch listing in git branch in columns.
See column.ui for details.

column.clean

Specify the layout when list items in git clean -i, which always
shows files and directories in columns. See column.ui for details.

column.status

Specify whether to output untracked files in git status in columns.
See column.ui for details.

column.tag

Specify whether to output tag listing in git tag in columns.
See column.ui for details.

commit.cleanup

This setting overrides the default of the --cleanup option in
git commit. See git-commit[1] for details. Changing the
default can be useful when you always want to keep lines that begin
with comment character # in your log message, in which case you
would do git config commit.cleanup whitespace (note that you will
have to remove the help lines that begin with # in the commit log
template yourself, if you do this).

commit.gpgSign

A boolean to specify whether all commits should be GPG signed.
Use of this option when doing operations such as rebase can
result in a large number of commits being signed. It may be
convenient to use an agent to avoid typing your GPG passphrase
several times.

commit.status

A boolean to enable/disable inclusion of status information in the
commit message template when using an editor to prepare the commit
message. Defaults to true.

commit.template

Specify the pathname of a file to use as the template for
new commit messages.

commit.verbose

A boolean or int to specify the level of verbose with git commit.
See git-commit[1].

commitGraph.generationVersion

Specifies the type of generation number version to use when writing
or reading the commit-graph file. If version 1 is specified, then
the corrected commit dates will not be written or read. Defaults to
2.

commitGraph.maxNewFilters

Specifies the default value for the --max-new-filters option of git
commit-graph write
(c.f., git-commit-graph[1]).

commitGraph.readChangedPaths

If true, then git will use the changed-path Bloom filters in the
commit-graph file (if it exists, and they are present). Defaults to
true. See git-commit-graph[1] for more information.

credential.helper

Specify an external helper to be called when a username or
password credential is needed; the helper may consult external
storage to avoid prompting the user for the credentials. This is
normally the name of a credential helper with possible
arguments, but may also be an absolute path with arguments or, if
preceded by !, shell commands.

Note that multiple helpers may be defined. See gitcredentials[7]
for details and examples.

credential.useHttpPath

When acquiring credentials, consider the “path” component of an http
or https URL to be important. Defaults to false. See
gitcredentials[7] for more information.

credential.username

If no username is set for a network authentication, use this username
by default. See credential.<context>.* below, and
gitcredentials[7].

credential.<url>.*

Any of the credential.* options above can be applied selectively to
some credentials. For example “credential.https://example.com.username”
would set the default username only for https connections to
example.com. See gitcredentials[7] for details on how URLs are
matched.

credentialCache.ignoreSIGHUP

Tell git-credential-cache—​daemon to ignore SIGHUP, instead of quitting.

credentialStore.lockTimeoutMS

The length of time, in milliseconds, for git-credential-store to retry
when trying to lock the credentials file. Value 0 means not to retry at
all; -1 means to try indefinitely. Default is 1000 (i.e., retry for
1s).

completion.commands

This is only used by git-completion.bash to add or remove
commands from the list of completed commands. Normally only
porcelain commands and a few select others are completed. You
can add more commands, separated by space, in this
variable. Prefixing the command with will remove it from
the existing list.

diff.autoRefreshIndex

When using git diff to compare with work tree
files, do not consider stat-only change as changed.
Instead, silently run git update-index --refresh to
update the cached stat information for paths whose
contents in the work tree match the contents in the
index. This option defaults to true. Note that this
affects only git diff Porcelain, and not lower level
diff commands such as git diff-files.

diff.dirstat

A comma separated list of --dirstat parameters specifying the
default behavior of the --dirstat option to git-diff[1]
and friends. The defaults can be overridden on the command line
(using --dirstat=<param1,param2,...>). The fallback defaults
(when not changed by diff.dirstat) are changes,noncumulative,3.
The following parameters are available:

Example: The following will count changed files, while ignoring
directories with less than 10% of the total amount of changed files,
and accumulating child directory counts in the parent directories:
files,10,cumulative.

diff.statGraphWidth

Limit the width of the graph part in –stat output. If set, applies
to all commands generating –stat output except format-patch.

diff.context

Generate diffs with <n> lines of context instead of the default
of 3. This value is overridden by the -U option.

diff.interHunkContext

Show the context between diff hunks, up to the specified number
of lines, thereby fusing the hunks that are close to each other.
This value serves as the default for the --inter-hunk-context
command line option.

diff.external

If this config variable is set, diff generation is not
performed using the internal diff machinery, but using the
given command. Can be overridden with the ‘GIT_EXTERNAL_DIFF’
environment variable. The command is called with parameters
as described under “git Diffs” in git[1]. Note: if
you want to use an external diff program only on a subset of
your files, you might want to use gitattributes[5] instead.

diff.ignoreSubmodules

Sets the default value of –ignore-submodules. Note that this
affects only git diff Porcelain, and not lower level diff
commands such as git diff-files. git checkout
and git switch also honor
this setting when reporting uncommitted changes. Setting it to
all disables the submodule summary normally shown by git commit
and git status when status.submoduleSummary is set unless it is
overridden by using the –ignore-submodules command-line option.
The git submodule commands are not affected by this setting.
By default this is set to untracked so that any untracked
submodules are ignored.

diff.mnemonicPrefix

If set, git diff uses a prefix pair that is different from the
standard “a/” and “b/” depending on what is being compared. When
this configuration is in effect, reverse diff output also swaps
the order of the prefixes:

diff.noprefix

If set, git diff does not show any source or destination prefix.

diff.relative

If set to true, git diff does not show changes outside of the directory
and show pathnames relative to the current directory.

diff.orderFile

File indicating how to order files within a diff.
See the -O option to git-diff[1] for details.
If diff.orderFile is a relative pathname, it is treated as
relative to the top of the working tree.

diff.renameLimit

The number of files to consider in the exhaustive portion of
copy/rename detection; equivalent to the git diff option
-l. If not set, the default value is currently 1000. This
setting has no effect if rename detection is turned off.

diff.renames

Whether and how Git detects renames. If set to “false”,
rename detection is disabled. If set to “true”, basic rename
detection is enabled. If set to “copies” or “copy”, Git will
detect copies, as well. Defaults to true. Note that this
affects only git diff Porcelain like git-diff[1] and
git-log[1], and not lower level commands such as
git-diff-files[1].

diff.suppressBlankEmpty

A boolean to inhibit the standard behavior of printing a space
before each empty output line. Defaults to false.

diff.submodule

Specify the format in which differences in submodules are
shown. The “short” format just shows the names of the commits
at the beginning and end of the range. The “log” format lists
the commits in the range like git-submodule[1]summary
does. The “diff” format shows an inline diff of the changed
contents of the submodule. Defaults to “short”.

diff.wordRegex

A POSIX Extended Regular Expression used to determine what is a “word”
when performing word-by-word difference calculations. Character
sequences that match the regular expression are “words”, all other
characters are ignorable whitespace.

diff.<driver>.command

The custom diff driver command. See gitattributes[5]
for details.

diff.<driver>.xfuncname

The regular expression that the diff driver should use to
recognize the hunk header. A built-in pattern may also be used.
See gitattributes[5] for details.

diff.<driver>.binary

Set this option to true to make the diff driver treat files as
binary. See gitattributes[5] for details.

diff.<driver>.textconv

The command that the diff driver should call to generate the
text-converted version of a file. The result of the
conversion is used to generate a human-readable diff. See
gitattributes[5] for details.

diff.<driver>.wordRegex

The regular expression that the diff driver should use to
split words in a line. See gitattributes[5] for
details.

diff.<driver>.cachetextconv

Set this option to true to make the diff driver cache the text
conversion outputs. See gitattributes[5] for details.

diff.tool

Controls which diff tool is used by git-difftool[1].
This variable overrides the value configured in merge.tool.
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.<tool>.cmd variable is defined.

diff.guitool

Controls which diff tool is used by 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.

  • araxis

  • bc

  • codecompare

  • deltawalker

  • diffmerge

  • diffuse

  • ecmerge

  • emerge

  • examdiff

  • guiffy

  • gvimdiff

  • kdiff3

  • kompare

  • meld

  • nvimdiff

  • opendiff

  • p4merge

  • smerge

  • tkdiff

  • vimdiff

  • winmerge

  • xxdiff

diff.indentHeuristic

Set this option to false to disable the default heuristics
that shift diff hunk boundaries to make patches easier to read.

diff.algorithm

Choose a diff algorithm. The variants are as follows:

diff.wsErrorHighlight

Highlight whitespace errors in the context, old or new
lines of the diff. Multiple values are separated by comma,
none resets previous values, default reset the list to
new and all is a shorthand for old,new,context. The
whitespace errors are colored with color.diff.whitespace.
The command line option --ws-error-highlight=<kind>
overrides this setting.

diff.colorMoved

If set to either a valid <mode> or a true value, moved lines
in a diff are colored differently, for details of valid modes
see –color-moved in git-diff[1]. If simply set to
true the default color mode will be used. When set to false,
moved lines are not colored.

diff.colorMovedWS

When moved lines are colored using e.g. the diff.colorMoved setting,
this option controls the <mode> how spaces are treated
for details of valid modes see –color-moved-ws in git-diff[1].

difftool.<tool>.path

Override the path for the given tool. This is useful in case
your tool is not in the PATH.

difftool.<tool>.cmd

Specify the command to invoke the specified diff tool.
The specified command is evaluated in shell with the following
variables available: LOCAL is set to the name of the temporary
file containing the contents of the diff pre-image and REMOTE
is set to the name of the temporary file containing the contents
of the diff post-image.

difftool.prompt

Prompt before each invocation of the diff tool.

extensions.objectFormat

Specify the hash algorithm to use. The acceptable values are sha1 and
sha256. If not specified, sha1 is assumed. It is an error to specify
this key unless core.repositoryFormatVersion is 1.

Note that this setting should only be set by git-init[1] or
git-clone[1]. Trying to change it after initialization will not
work and will produce hard-to-diagnose issues.

extensions.worktreeConfig

If enabled, then worktrees will load config settings from the
$GIT_DIR/config.worktree file in addition to the
$GIT_COMMON_DIR/config file. Note that $GIT_COMMON_DIR and
$GIT_DIR are the same for the main working tree, while other
working trees have $GIT_DIR equal to
$GIT_COMMON_DIR/worktrees/<id>/. The settings in the
config.worktree file will override settings from any other
config files.

Похожее:  SSH-Bastion. Замковые ворота вашей инфраструктуры — KAZARIN OnLine

When enabling extensions.worktreeConfig, you must be careful to move
certain values from the common config file to the main working tree’s
config.worktree file, if present:

fastimport.unpackLimit

If the number of objects imported by git-fast-import[1]
is below this limit, then the objects will be unpacked into
loose object files. However if the number of imported objects
equals or exceeds this limit then the pack will be stored as a
pack. Storing the pack from a fast-import can make the import
operation complete faster, especially on slow filesystems. If
not set, the value of transfer.unpackLimit is used instead.

feature.*

The config settings that start with feature. modify the defaults of
a group of other config settings. These groups are created by the Git
developer community as recommended defaults and are subject to change.
In particular, new config options may be added with different defaults.

feature.experimental

Enable config options that are new to Git, and are being considered for
future defaults. Config settings included here may be added or removed
with each release, including minor version updates. These settings may
have unintended interactions since they are so new. Please enable this
setting if you are interested in providing feedback on experimental
features. The new default values are:

  • fetch.negotiationAlgorithm=skipping may improve fetch negotiation times by
    skipping more commits at a time, reducing the number of round trips.

feature.manyFiles

Enable config options that optimize for repos with many files in the
working directory. With many files, commands such as git status and
git checkout may be slow and these new defaults improve performance:

  • index.version=4 enables path-prefix compression in the index.

  • core.untrackedCache=true enables the untracked cache. This setting assumes
    that mtime is working on your machine.

fetch.recurseSubmodules

This option controls whether git fetch (and the underlying fetch
in git pull) will recursively fetch into populated submodules.
This option can be set either to a boolean value or to on-demand.
Setting it to a boolean changes the behavior of fetch and pull to
recurse unconditionally into submodules when set to true or to not
recurse at all when set to false. When set to on-demand, fetch and
pull will only recurse into a populated submodule when its
superproject retrieves a commit that updates the submodule’s
reference.
Defaults to on-demand, or to the value of submodule.recurse if set.

fetch.fsckObjects

If it is set to true, git-fetch-pack will check all fetched
objects. See transfer.fsckObjects for what’s
checked. Defaults to false. If not set, the value of
transfer.fsckObjects is used instead.

fetch.fsck.<msg-id>

Acts like fsck.<msg-id>, but is used by
git-fetch-pack[1] instead of git-fsck[1]. See
the fsck.<msg-id> documentation for details.

fetch.fsck.skipList

Acts like fsck.skipList, but is used by
git-fetch-pack[1] instead of git-fsck[1]. See
the fsck.skipList documentation for details.

fetch.unpackLimit

If the number of objects fetched over the Git native
transfer is below this
limit, then the objects will be unpacked into loose object
files. However if the number of received objects equals or
exceeds this limit then the received pack will be stored as
a pack, after adding any missing delta bases. Storing the
pack from a push can make the push operation complete faster,
especially on slow filesystems. If not set, the value of
transfer.unpackLimit is used instead.

fetch.prune

If true, fetch will automatically behave as if the --prune
option was given on the command line. See also remote.<name>.prune
and the PRUNING section of git-fetch[1].

fetch.pruneTags

If true, fetch will automatically behave as if the
refs/tags/*:refs/tags/* refspec was provided when pruning,
if not set already. This allows for setting both this option
and fetch.prune to maintain a 1=1 mapping to upstream
refs. See also remote.<name>.pruneTags and the PRUNING
section of git-fetch[1].

fetch.output

Control how ref update status is printed. Valid values are
full and compact. Default value is full. See section
OUTPUT in git-fetch[1] for detail.

fetch.negotiationAlgorithm

Control how information about the commits in the local repository
is sent when negotiating the contents of the packfile to be sent by
the server. Set to “consecutive” to use an algorithm that walks
over consecutive commits checking each one. Set to “skipping” to
use an algorithm that skips commits in an effort to converge
faster, but may result in a larger-than-necessary packfile; or set
to “noop” to not send any information at all, which will almost
certainly result in a larger-than-necessary packfile, but will skip
the negotiation step. Set to “default” to override settings made
previously and use the default behaviour. The default is normally
“consecutive”, but if feature.experimental is true, then the
default is “skipping”. Unknown values will cause git fetch to
error out.

See also the --negotiate-only and --negotiation-tip options to
git-fetch[1].

fetch.showForcedUpdates

Set to false to enable --no-show-forced-updates in
git-fetch[1] and git-pull[1] commands.
Defaults to true.

fetch.parallel

Specifies the maximal number of fetch operations to be run in parallel
at a time (submodules, or remotes when the --multiple option of
git-fetch[1] is in effect).

A value of 0 will give some reasonable default. If unset, it defaults to 1.

For submodules, this setting can be overridden using the submodule.fetchJobs
config setting.

fetch.writeCommitGraph

Set to true to write a commit-graph after every git fetch command
that downloads a pack-file from a remote. Using the --split option,
most executions will create a very small commit-graph file on top of
the existing commit-graph file(s). Occasionally, these files will
merge and the write may take longer. Having an updated commit-graph
file helps performance of many Git commands, including git merge-base,
git push -f, and git log --graph. Defaults to false.

format.attach

Enable multipart/mixed attachments as the default for
format-patch. The value can also be a double quoted string
which will enable attachments as the default and set the
value as the boundary. See the –attach option in
git-format-patch[1].

format.from

Provides the default value for the --from option to format-patch.
Accepts a boolean value, or a name and email address. If false,
format-patch defaults to --no-from, using commit authors directly in
the “From:” field of patch mails. If true, format-patch defaults to
--from, using your committer identity in the “From:” field of patch
mails and including a “From:” field in the body of the patch mail if
different. If set to a non-boolean value, format-patch uses that
value instead of your committer identity. Defaults to false.

format.numbered

A boolean which can enable or disable sequence numbers in patch
subjects. It defaults to “auto” which enables it only if there
is more than one patch. It can be enabled or disabled for all
messages by setting it to “true” or “false”. See –numbered
option in git-format-patch[1].

Additional email headers to include in a patch to be submitted
by mail. See git-format-patch[1].

format.to
format.cc

Additional recipients to include in a patch to be submitted
by mail. See the –to and –cc options in
git-format-patch[1].

format.subjectPrefix

The default for format-patch is to output files with the [PATCH]
subject prefix. Use this variable to change that prefix.

format.coverFromDescription

The default mode for format-patch to determine which parts of
the cover letter will be populated using the branch’s
description. See the --cover-from-description option in
git-format-patch[1].

format.signature

The default for format-patch is to output a signature containing
the Git version number. Use this variable to change that default.
Set this variable to the empty string (“”) to suppress
signature generation.

format.signatureFile

Works just like format.signature except the contents of the
file specified by this variable will be used as the signature.

format.suffix

The default for format-patch is to output files with the suffix
.patch. Use this variable to change that suffix (make sure to
include the dot if you want it).

Encode email headers that have non-ASCII characters with
“Q-encoding” (described in RFC 2047) for email transmission.
Defaults to true.

format.pretty

The default pretty format for log/show/whatchanged command,
See git-log[1], git-show[1],
git-whatchanged[1].

format.thread

The default threading style for git format-patch. Can be
a boolean value, or shallow or deep. shallow threading
makes every mail a reply to the head of the series,
where the head is chosen from the cover letter, the
--in-reply-to, and the first patch mail, in this order.
deep threading makes every mail a reply to the previous one.
A true boolean value is the same as shallow, and a false
value disables threading.

format.signOff

A boolean value which lets you enable the -s/--signoff option of
format-patch by default. Note: Adding the Signed-off-by trailer to a
patch should be a conscious act and means that you certify you have
the rights to submit this work under the same open source license.
Please see the SubmittingPatches document for further discussion.

format.coverLetter

A boolean that controls whether to generate a cover-letter when
format-patch is invoked, but in addition can be set to “auto”, to
generate a cover-letter only when there’s more than one patch.
Default is false.

format.outputDirectory

Set a custom directory to store the resulting files instead of the
current working directory. All directory components will be created.

format.filenameMaxLength

The maximum length of the output filenames generated by the
format-patch command; defaults to 64. Can be overridden
by the --filename-max-length=<n> command line option.

format.useAutoBase

A boolean value which lets you enable the --base=auto option of
format-patch by default. Can also be set to “whenAble” to allow
enabling --base=auto if a suitable base is available, but to skip
adding base info otherwise without the format dying.

format.notes

Provides the default value for the --notes option to
format-patch. Accepts a boolean value, or a ref which specifies
where to get notes. If false, format-patch defaults to
--no-notes. If true, format-patch defaults to --notes. If
set to a non-boolean value, format-patch defaults to
--notes=<ref>, where ref is the non-boolean value. Defaults
to false.

If one wishes to use the ref ref/notes/true, please use that literal
instead.

This configuration can be specified multiple times in order to allow
multiple notes refs to be included. In that case, it will behave
similarly to multiple --[no-]notes[=] options passed in. That is, a
value of true will show the default notes, a value of <ref> will
also show notes from that notes ref and a value of false will negate
previous configurations and not show notes.

For example,

will only show notes from refs/notes/bar.

filter.<driver>.clean

The command which is used to convert the content of a worktree
file to a blob upon checkin. See gitattributes[5] for
details.

filter.<driver>.smudge

The command which is used to convert the content of a blob
object to a worktree file upon checkout. See
gitattributes[5] for details.

fsck.<msg-id>

During fsck git may find issues with legacy data which
wouldn’t be generated by current versions of git, and which
wouldn’t be sent over the wire if transfer.fsckObjects was
set. This feature is intended to support working with legacy
repositories containing such data.

Setting fsck.<msg-id> will be picked up by git-fsck[1], but
to accept pushes of such data set receive.fsck.<msg-id> instead, or
to clone or fetch it set fetch.fsck.<msg-id>.

The rest of the documentation discusses fsck.* for brevity, but the
same applies for the corresponding receive.fsck.* and
fetch.<msg-id>.*. variables.

Unlike variables like color.ui and core.editor the
receive.fsck.<msg-id> and fetch.fsck.<msg-id> variables will not
fall back on the fsck.<msg-id> configuration if they aren’t set. To
uniformly configure the same fsck settings in different circumstances
all three of them they must all set to the same values.

When fsck.<msg-id> is set, errors can be switched to warnings and
vice versa by configuring the fsck.<msg-id> setting where the
<msg-id> is the fsck message ID and the value is one of error,
warn or ignore. For convenience, fsck prefixes the error/warning
with the message ID, e.g. “missingEmail: invalid author/committer
line – missing email” means that setting fsck.missingEmail = ignore
will hide that issue.

In general, it is better to enumerate existing objects with problems
with fsck.skipList, instead of listing the kind of breakages these
problematic objects share to be ignored, as doing the latter will
allow new instances of the same breakages go unnoticed.

Setting an unknown fsck.<msg-id> value will cause fsck to die, but
doing the same for receive.fsck.<msg-id> and fetch.fsck.<msg-id>
will only cause git to warn.

fsck.skipList

The path to a list of object names (i.e. one unabbreviated SHA-1 per
line) that are known to be broken in a non-fatal way and should
be ignored. On versions of Git 2.20 and later comments (#), empty
lines, and any leading and trailing whitespace is ignored. Everything
but a SHA-1 per line will error out on older versions.

This feature is useful when an established project should be accepted
despite early commits containing errors that can be safely ignored
such as invalid committer email addresses. Note: corrupt objects
cannot be skipped with this setting.

Like fsck.<msg-id> this variable has corresponding
receive.fsck.skipList and fetch.fsck.skipList variants.

Unlike variables like color.ui and core.editor the
receive.fsck.skipList and fetch.fsck.skipList variables will not
fall back on the fsck.skipList configuration if they aren’t set. To
uniformly configure the same fsck settings in different circumstances
all three of them they must all set to the same values.

Older versions of Git (before 2.20) documented that the object names
list should be sorted. This was never a requirement, the object names
could appear in any order, but when reading the list we tracked whether
the list was sorted for the purposes of an internal binary search
implementation, which could save itself some work with an already sorted
list. Unless you had a humongous list there was no reason to go out of
your way to pre-sort the list. After Git version 2.20 a hash implementation
is used instead, so there’s now no reason to pre-sort the list.

gc.aggressiveDepth

The depth parameter used in the delta compression
algorithm used by git gc –aggressive. This defaults
to 50, which is the default for the --depth option when
--aggressive isn’t in use.

See the documentation for the --depth option in
git-repack[1] for more details.

gc.aggressiveWindow

The window size parameter used in the delta compression
algorithm used by git gc –aggressive. This defaults
to 250, which is a much more aggressive window size than
the default --window of 10.

See the documentation for the --window option in
git-repack[1] for more details.

gc.auto

When there are approximately more than this many loose
objects in the repository, git gc --auto will pack them.
Some Porcelain commands use this command to perform a
light-weight garbage collection from time to time. The
default value is 6700.

Setting this to 0 disables not only automatic packing based on the
number of loose objects, but any other heuristic git gc --auto will
otherwise use to determine if there’s work to do, such as
gc.autoPackLimit.

gc.autoPackLimit

When there are more than this many packs that are not
marked with *.keep file in the repository, git gc
--auto
consolidates them into one larger pack. The
default value is 50. Setting this to 0 disables it.
Setting gc.auto to 0 will also disable this.

See the gc.bigPackThreshold configuration variable below. When in
use, it’ll affect how the auto pack limit works.

gc.autoDetach

Make git gc --auto return immediately and run in background
if the system supports it. Default is true.

gc.bigPackThreshold

If non-zero, all packs larger than this limit are kept when
git gc is run. This is very similar to --keep-largest-pack
except that all packs that meet the threshold are kept, not
just the largest pack. Defaults to zero. Common unit suffixes of
k, m, or g are supported.

Note that if the number of kept packs is more than gc.autoPackLimit,
this configuration variable is ignored, all packs except the base pack
will be repacked. After this the number of packs should go below
gc.autoPackLimit and gc.bigPackThreshold should be respected again.

If the amount of memory estimated for git repack to run smoothly is
not available and gc.bigPackThreshold is not set, the largest pack
will also be excluded (this is the equivalent of running git gc with
--keep-largest-pack).

gc.writeCommitGraph

If true, then gc will rewrite the commit-graph file when
git-gc[1] is run. When using git gc --auto
the commit-graph will be updated if housekeeping is
required. Default is true. See git-commit-graph[1]
for details.

gc.logExpiry

If the file gc.log exists, then git gc --auto will print
its content and exit with status zero instead of running
unless that file is more than gc.logExpiry old. Default is
“1.day”. See gc.pruneExpire for more ways to specify its
value.

gc.packRefs

Running git pack-refs in a repository renders it
unclonable by Git versions prior to 1.5.1.2 over dumb
transports such as HTTP. This variable determines whether
git gc runs git pack-refs. This can be set to notbare
to enable it within all non-bare repos or it can be set to a
boolean value. The default is true.

gc.cruftPacks

Store unreachable objects in a cruft pack (see
git-repack[1]) instead of as loose objects. The default
is false.

gc.pruneExpire

When git gc is run, it will call prune –expire 2.weeks.ago
(and repack –cruft –cruft-expiration 2.weeks.ago if using
cruft packs via gc.cruftPacks or --cruft). Override the
grace period with this config variable. The value “now” may be
used to disable this grace period and always prune unreachable
objects immediately, or “never” may be used to suppress pruning.
This feature helps prevent corruption when git gc runs
concurrently with another process writing to the repository; see
the “NOTES” section of git-gc[1].

gc.worktreePruneExpire

When git gc is run, it calls
git worktree prune –expire 3.months.ago.
This config variable can be used to set a different grace
period. The value “now” may be used to disable the grace
period and prune $GIT_DIR/worktrees immediately, or “never”
may be used to suppress pruning.

gc.reflogExpire
gc.<pattern>.reflogExpire

git reflog expire removes reflog entries older than
this time; defaults to 90 days. The value “now” expires all
entries immediately, and “never” suppresses expiration
altogether. With “<pattern>” (e.g.
“refs/stash”) in the middle the setting applies only to
the refs that match the <pattern>.

gc.reflogExpireUnreachable
gc.<pattern>.reflogExpireUnreachable

git reflog expire removes reflog entries older than
this time and are not reachable from the current tip;
defaults to 30 days. The value “now” expires all entries
immediately, and “never” suppresses expiration altogether.
With “<pattern>” (e.g. “refs/stash”)
in the middle, the setting applies only to the refs that
match the <pattern>.

These types of entries are generally created as a result of using git
commit --amend
or git rebase and are the commits prior to the amend
or rebase occurring. Since these changes are not part of the current
project most users will want to expire them sooner, which is why the
default is more aggressive than gc.reflogExpire.

gc.rerereResolved

Records of conflicted merge you resolved earlier are
kept for this many days when git rerere gc is run.
You can also use more human-readable “1.month.ago”, etc.
The default is 60 days. See git-rerere[1].

gc.rerereUnresolved

Records of conflicted merge you have not resolved are
kept for this many days when git rerere gc is run.
You can also use more human-readable “1.month.ago”, etc.
The default is 15 days. See git-rerere[1].

gitcvs.commitMsgAnnotation

Append this string to each commit message. Set to empty string
to disable this feature. Defaults to “via git-CVS emulator”.

gitcvs.enabled

Whether the CVS server interface is enabled for this repository.
See git-cvsserver[1].

gitcvs.logFile

Path to a log file where the CVS server interface well…​ logs
various stuff. See git-cvsserver[1].

gitcvs.usecrlfattr

If true, the server will look up the end-of-line conversion
attributes for files to determine the -k modes to use. If
the attributes force Git to treat a file as text,
the -k mode will be left blank so CVS clients will
treat it as text. If they suppress text conversion, the file
will be set with -kb mode, which suppresses any newline munging
the client might otherwise do. If the attributes do not allow
the file type to be determined, then gitcvs.allBinary is
used. See gitattributes[5].

gitcvs.allBinary

This is used if gitcvs.usecrlfattr does not resolve
the correct -kb mode to use. If true, all
unresolved files are sent to the client in
mode -kb. This causes the client to treat them
as binary files, which suppresses any newline munging it
otherwise might do. Alternatively, if it is set to “guess”,
then the contents of the file are examined to decide if
it is binary, similar to core.autocrlf.

gitcvs.dbName

Database used by git-cvsserver to cache revision information
derived from the Git repository. The exact meaning depends on the
used database driver, for SQLite (which is the default driver) this
is a filename. Supports variable substitution (see
git-cvsserver[1] for details). May not contain semicolons (;).
Default: %Ggitcvs.%m.sqlite

gitcvs.dbDriver

Used Perl DBI driver. You can specify any available driver
for this here, but it might not work. git-cvsserver is tested
with DBD::SQLite, reported to work with DBD::Pg, and
reported not to work with DBD::mysql. Experimental feature.
May not contain double colons (:). Default: SQLite.
See git-cvsserver[1].

gitcvs.dbUser, gitcvs.dbPass

Database user and password. Only useful if setting gitcvs.dbDriver,
since SQLite has no concept of database users and/or passwords.
gitcvs.dbUser supports variable substitution (see
git-cvsserver[1] for details).

gitcvs.dbTableNamePrefix

Database table name prefix. Prepended to the names of any
database tables used, allowing a single database to be used
for several repositories. Supports variable substitution (see
git-cvsserver[1] for details). Any non-alphabetic
characters will be replaced with underscores.

Как настроить подключение к удаленному git репозиторию

На практике мне когда-то помогла эта статья – лучший пример из всего что я видел:
http://habrahabr.ru/sandbox/37865/

В ней полностью показаны клиентские программы для работы с push-ом и pull-ом. У меня лично Windows недолюбливал родной Git клиент, но всегда прекрасно работает с Tortoise (есть в статье).

В ней есть полное руководство по подключению. Не уверен правильная ли это аналогия, но вы можете поставить себе программу Composer и ей подобные, после чего можно через консоль Windows полностью клонировать себе репозиторий с Git-а.

Если же касается более специфичного подключения именно к Git, то эта страница будет полезной: http://webhamster.ru/site/page/index/articles/comp/171


Добавил, как попросили, кратко содержимое статьи:

Идем на официальную страницу Git http://vhod-v-lichnyj-kabinet.ru, кликаем на Download for Windows. В открывшемся окне кликаем на Full installer for official Git. Запускаем полученный exe-шник.

Я рекомендую выбрать “Run Git from the Windows Command Prompt”. Все остальные опции можно оставлять по-умолчанию. После установки Git нужно перегрузиться или завершить сеанс пользователя и снова войти, чтобы применились изменения в системной переменной PATH.

Далее нужно проверить, доступен ли Git для работы. В любом каталоге даем команду:

git --version

Если получаем информацию о версии, то Git установлен и работает. Если получаем информацию что программа git не найдена, разбираемся что сделали не так.

Настройка SSH-ключей в Windows

В операционной системе Windows генератор SSH-ключей включен в комплект поставки Git. Для генерации ключей необходимо запустить на выполнение файл C:Program FilesGitGit bash.vbs. Его можно запустить как обычный exe-шник. Откроется программа “Консоль git”. В ней надо дать команду:

ssh-keygen -t rsa -C "myemail@mail.ru"

Будьте внимательны, в этой консоли подглючивает копи-паст, проще ввести команду вручную. В качестве email указываем свой почтовый ящик. На запрос “Enter file in which to save the key” просто нажимаем Enter. При запросе пароля “Enter passphrase” и “Enter same passphrase again” просто нажимаем Enter. В процессе генерации ключей в консоли будет выдаваться примерно следующая информация:

Generating public/private rsa key pair.
Enter file in which to save the key (/c/Documents and Settings/username/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /c/Documents and Settings/username/.ssh/id_rsa.
Your public key has been saved in /c/Documents and Settings/username/.ssh/id_rsa.pub.
The key fingerprint is:
51:db:73:e9:31:9f:51:a6:7a:c5:3d:da:9c:35:8f:95 myemail@mail.ru

После выполнения этой программы, в каталоге C:Documents and Settingsusername.ssh будут лежать файлы id_rsa и id_rsa.pub, они нам пригодятся в дальнейшем.

Установка SSH-ключа в GitHub

Нас колько я помню, эта часть ответа несколько изменилась в современном дизайне GitHub-а, но интуитивно можо найти.

Сразу после регистрации необходимо прописать в системе GutHub свой публичный ключ шифрования (открытый SSH-ключ). Для добавления ключа, надо в правом верхнем углу нажать “Account Settings”.

В открывшемся окне нужно кликнуть на пункт меню “SSH Public Keys”, и нажать “Add Another Public Key”. Появится два поля – название ключа (Title) и содержимое ключа (Key).

В поле Title можно написать название компьютера, на котором сгенерирован публичный ключ. Можно писать по-русски.

В поле Key надо вставить содержимое файла id_rsa.pub. Помните, в каком каталоге они находятся? Переходим в этот каталог, открываем любым текстовым редактором файл id_rsa.pub (именно с расширением .pub, не перепутайте). Выделяем весь текст, копируем, и вставляем на странице GitHub в поле Key.

После добавления ключа, компьютер может соединяться с GitHub через программу git, и никаких ошибок не должно возникать.

Работа с репозитарием на GitHub через программу Git

Начиная с этого момента, пляски вокруг web-интерфейса GitHub можно считать законченными. Далее можно работать только используя программу git.

Вначале нужно сделать небольшую настройку программы git: указать локальной системе git имя пользователя и email. Это делается следующими командами, которые можно выполнить, находясь в любом каталоге:

git config --global user.name "YourFullName"
git config --global user.email myemail@mail.ru

где вместо YourFullName нужно написать свое имя, а вместо myemail@mail.ru – свой email. Эти значения используются для логина на GitHub. Поэтому на месте YourFullName нужно указать ваш логин на GitHub-е, а на месте myemail@mail.ru нужно указать email, который вы вводили при генерации ключей шифрования.

После этих настроек, можно заливать свои файлы в репозитарий. Переходим в каталог со своим проектом, и даем команды:

git init
git add .
git commit -a -m 'first commit'
git remote add origin git@github.com:username/reponame.git
git push -u origin master

После этих команд на сервере GitHub образуется копии файлов того каталога, в котором были выполнены данные команды. Далее можно уже делать коммиты, заливки на сервер GitHub изменений, считывания изменений с сервера. Но это уже совсем другая история.

1 Звезда2 Звезды3 Звезды4 Звезды5 Звезд (1 оценок, среднее: 5,00 из 5)
Загрузка...

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector