Configuration, Ignore Rules, and Attributes

Git ignore rules apply only to untracked paths. Once a file has an entry in the index, Git keeps reporting and committing its changes whatever .gitignore says. Untrack it with git rm --cached, then commit that removal.

The file's line endings switched between LF and CRLF. Git compares whole lines, so an invisible carriage return at the end of every line makes every line differ and the whole file looks rewritten.

A .gitattributes file assigns per-path attributes that change how Git diffs, merges, filters and archives matching files. Patterns use .gitignore syntax; within one file the last matching line wins, and .git/info/attributes outranks committed files.

A leading slash anchors a Git ignore pattern to the directory holding the .gitignore instead of matching at any depth. A trailing slash restricts the match to directories. Double asterisk matches across directory separators, which a single asterisk never does.

In Git, .gitattributes is committed, so the rule travels with every clone and CI checkout and cannot be forgotten on a new machine. It also overrides per-machine config and allows per-path exceptions, which core.autocrlf cannot express.

In Git, core.autocrlf=true converts CRLF to LF on commit and back to CRLF on checkout; input converts to LF on commit but never converts on checkout; false, the default, stores and checks out the bytes unchanged.

In Git, set user.signingKey to your key, commit.gpgSign and tag.gpgSign to true, and gpg.format to ssh if you are signing with an SSH key rather than the default OpenPGP. Individual commands can still opt out with --no-gpg-sign.

It proves the holder of that key produced that exact commit object and it has not changed since. Git's author and committer fields come from local config and are unverified text, so the signature attests the signer, never the person named as author.

An alias is a config key under the alias section, so git config --global alias.st status makes git st work. A leading exclamation mark makes the value a shell command instead of Git subcommand arguments, run from the top of the working tree.

Run git config --list --show-origin, which prints the file path in front of every resolved key, and add --show-scope to label each as system, global, local, worktree or command. Filter to one key with git config --show-origin --get <key>.

The binary attribute is a built-in macro expanding to -diff -merge -text. Git then reports the file as differing rather than showing a textual diff, refuses to content-merge it, and applies no end-of-line conversion.

Run git check-ignore -v <path>. Git prints the source file, line number and pattern that excluded the path, and exits with status 1 when nothing matches it. Add --no-index to check a path that is already tracked.

Git never descends into an excluded directory, so no pattern inside it can re-include anything. Exclude the directory's contents with a pattern like assets/* instead of assets/, then negate the paths you want back.

In Git, use git log --show-signature for a range, git verify-commit or git verify-tag for a single object and a scriptable exit status, and the %G? pretty format placeholder for a compact per-commit status column.

Use a conditional include in your global config: an includeIf section with a gitdir condition pointing at ~/work/ pulls in a second config file whose user.email is the work address, so every repository under that directory gets the work identity automatically.

A clean filter transforms content on its way into the repository, when a file is staged; a smudge filter transforms it on the way out, at checkout. Both are named by a filter attribute and defined by commands in Git config.

Assign the built-in union merge driver in Git with a line such as CHANGELOG.md merge=union. Git then keeps lines from both sides instead of writing conflict markers, which suits append-only, order-insensitive text and nothing else.

Personal, cross-repository rules belong in the file named by core.excludesFile; personal rules for one clone belong in .git/info/exclude. The committed .gitignore should hold only what every contributor produces, such as build output.

Commit the .gitattributes rule, then run git add --renormalize . and commit the result. Git re-applies the new conversion to every tracked file, producing one commit that rewrites the stored line endings without changing any visible text.

Those operations create new commit objects rather than editing old ones, and a signature only validates the exact object it was made over. The new commit has different parents, committer or timestamp, so the old signature cannot carry over and must be replaced.

Start with signed release tags, then extend to commits on protected branches. Signing only pays off if verification runs somewhere that matters and a trust list of principals and keys is actively maintained, including rotation and revocation.

Git picks the first of GIT_EDITOR, the core.editor config value, VISUAL and EDITOR that is set, falling back to a built-in default. Set core.editor globally to change it, and check the result with git var GIT_EDITOR.

Ship a tracked config fragment in the repository and have each clone reference it once with git config include.path, provision personal defaults through dotfiles or a system file, and enforce anything that actually matters with server-side hooks rather than trusting client configuration.

Custom diff, merge and filter drivers are named in a committed file but defined in per-machine Git config, so behaviour silently differs by machine. When correctness depends on the driver, prefer built-in attributes or remove the artifact from the repository.