ㄴㅋㄹㅇ🌅

https://git-scm.com/book/en/v2

UPD 2021-01-29: I recently messed up local master branch at work. Not sure what happened but it was just not the same any more as remote one in GitHub. No matter what I did, some commits were kept applying to master thay should not have. Doing git plumbing is just a waste of time. Guess what, I deleted whole local repo and cloned again. And this is after I read whole book about Git. Guess that tells something about this complex monstrosity.

Basics

Git was made in 2005 by Linux community
Git is distributed, each client has fully copy
snapshots, not diffs
nearly all operations local
everything is checksummed, can’t loose data in transit or in file corruption
SHA-1 hash for checksums
everything is stored in git DB by hash
generally only adds data
three states files can be in: modified, staged, committed
git config --local to use .git/config
git config --list
git config --show-origin .... to show where config value is defined
git status -s for short status
.gitignore uses Glob patterns = simplified Regex
.gitignore use ! to negate pattern
.gitignore use /**/ to match nested directories
.gitignore official examples https://github.com/github/gitignore
git diff --staged for what has been staged
git rm --staged to keep file but remove staged changes
git log --pretty=oneline
git log --pretty=format:"%h - %an, %ar : %s"
git log --graph to also add graph
git log --since=2.weeks to select time
git log -S function_name known as “pickaxe” option, which shows commits that changed that string, useful for functions, args
git log -- path/to/file for changes to file or dir
git log --no-merges to hide merges, useful if there are a lot of them
git log --decorate to show where branch pointers are pointing
git commit --amend to update last commit. it pushes away old commit as if it did not exist with a new one. old one will not show up in history.
git checkout - <file> will reset file with version from latest commit
git restore --staged <file> to un-stage file
git restore <file> to discard last changes
git remote -v list remotes with URL
git remote add <name> <URL> to add remote
git fetch <name> to load all info from remote, it does not automatically merge
git remote show <name> to show details on remote
git tag list all tags
tags are annotated=”objects in git database, have message, can be signed and verified” or lightweight=”pointer to specific commit”
git tag -a v1.0 -m "my message" to create annotated tag
git show v1.0 to print details on tag
git push origin --tags to push all tags at once
git push origin --delete <tagname> to delete tag in remote
DETACHED HEAD means that if you make commit then it will not belong to any branch or have any parent, it will be reachable only by commit hash
[my note] it must be a good idea to make a tag for version. And only if there is some bugfixes for that version, then checkout that tag and make a release branch. good job!
git config --global alias.visual '!gitk' to invoke shell command from alias use !
git diff --check show whitespaces in diff

Branching

branch = pointer to a commit that moves with each new commit, it is literally a file with checksum of a commit where it points to, note each commit is identified by checksum
HEAD = special pointer to where you are right now
git switch <branch-name> to checkout to other branch, new “checkout”
git switch -c <branch-name> to create a new branch, new “checkout”
git merge <branch-name> merge other branch into current one, make a merge commit
git branch -vv list branches
git branch --merged list branches merged into current branch
git push origin --delete master rebel!
can not move remote pointers manually
origin is not special. just like master it can be renamed.
two ways to integrate changes between branches: merge and rebase
git rebase master makes an ancestor branch you rebase onto, getting diff of each commit introduced by current branch, and applying it to new branch, moving current branch to last new commit. rebasing makes clean history as if all changes happened sequentially. better not use them it makes collaboration harder for merges.

Server

can run on “local” protocol, git pull /home/john/project or git remote add local_proj /srv/git/project.git
NFS is often slower than SSH
smart HTTP runs on HTTPS
dumb HTTP serves files. easy to setup, just add post-update hook. Typically in read only mode.
SSH downside is you need SSH access even for read-only mode
git protocol is like SSH but with anonymous access. either public or private. if public everyone can write. fast. used in public repos.
git init --bare --shared to create server
restrict users shell access only to git for “git” user with sudo chsh git -s $(which git-shell)
restrict ssh port forwarding and other SSH things no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty in authorized_keys
for public access use git:// with git daemon --reuseaddr --base-path=/srv/git/ /srv/git/ use systemd for this
for smart HTTP need Apache HTTP server for CGI
git instaweb --http=webrick for simple http frontend
GitLab can be self-hosted, and is like Github

Distributed Workflows

centralized remote
integration-manager = each dev has write access to their own repo… this is model for GitHub and GitLab
dictator-lieutenants = Linux kernel
git request-pull to make pull request via fork in GitHub style
git merge --squash makes one commit with changesets from all commits
git format-patch -M origin/master to make email version of commit, some teams use that
there is .gitconfig for IMAP for email commits
git apply <path-to-path.path> to apply patch sent say over email. for patches made with diff. legacy
git am to apply from format-patch. recommended.
git diff master...contrib show only work introduced since common ancestor
git cherry-pick <hash> to rebase single commit (apply patch from it with a new commit)
git rerere = “reuse recorded resolution” is a cache of resolutions of conflicts to reuse them and not bother user each time
git describe master to show human readable commit version
git archive master --prefix='project/' | gzip > $(git describe master).tar.gz

GitHub

GitHub can send email with changes that contains patch. You can apply patch like curl ..../1.patch | git am
Not even once “stacks” are mentioned.
Not even once “small pull requests” are mentioned.
git ls-remote https://github.com/nikolaydubina/go-featurprocessing to show list of pull requests with refs. But since PR are not in /head they are not pulled as normal branches.
can update .gitconfig to fetch all pull requests on fetch

Git Tools

git log --abbrev-commit short SHA
short shat unlikely to collide. in Linux repo there is 875,000 commits, no collision
git reflog
git log master..experiment what is in experiment starting from ancestor with master
git log master...experiment what is reachable by both commits but not both of them
git log --left-right master...experiment for nice format
git add -i for interactive mode
git stash for saving staged changes
git stash -u for stashing untracked files too
git stash -a for stashing ignored files too
git stash branch <name> to make a branch from stash instead of apply right away. useful if can not apply.
git rebase -i HEAD~3 change history of commits
git filter-branch -all --tree-filter 'rm -f passwords.txt' HEAD to remove secrets file from whole history
HEAD last commit
Index staging changes
working directory everything
git reset changes: 1) HEAD, branch to point to new hash; 2) index to pointed hash; 3) working directory to hash
git revert -m 1 HEAD create a new commit that undoes changes from old commit
branches can have completely different histories, meaning they have different repositories! used in subtrees.
git blame -C -L 69,82 Makefile to show how edited last lines from to in file. ^ means that it was unmodified since the beginning. -C shows which files it come from.
git bisect start git bisect bad git bisect good v1.0 to run bisect.
git bisect run test-error.sh if your script exists with 0 for good and non-0 for bad state. this will fully automate bisect. can be used with make tests for example.
git bundle create <bundlename> HEAD master to make archive to create whole branch, then git clone <bundlename> or git fetch <bundlename> master:other-master
git replace to make some commits pretend to be other commits, useful for history rewrites

Submodules

keep repository as subdirectory of another repository
git submodule add https://github.com/linux/linux
parent does not track changes in submodule
git clone --resource-submodules https://... for cloning with submodules
git pull + git submodule update --init --recursive to update all submodules
git submodule foreach 'shell here' to run any shell on each submodule

Credential Storage

by default not used
cache = in memory, in single process, no other process can read
store = disk
osxkeychain = keychain
git config --global credential.helper cache

Config

help.autocorrect=1 autocorrect
.gitattributes can set which program to run on each file format for diffs
“smudge” filter = between checkout (stage) and workdir
“clean” filter = between workdir and stage

Hooks

client side: pre-commit = code style, lint; post-commit = notifications, pre-rebase
server side: pre-receive; update; post-receive=notifications

Other

can work as client for other version control systems via adapters “bridges”

Internals

at core it is key-value data store. key is SHA-1
git hash-object
echo 'test content' | git hash-object -w --stdin to store
git cat-file -p <SHA-1>
git cat-file -p master^{tree} list files in commit
sometimes uses packfile to store deltas when storing on disk. uses git gc

Data Recovery

git reflog to list SHA-1 of commits
git log -g same
git branch recover-branch <hash>
git fsck --full to check integrity of git database, even if no reflog exists
git gc + git count-objects -v to see how much space using
git verify-pack -v .git/objects/pack/pack-29…69.idx | sort -k 3 -n | tail -3 to show larges objects in packs
git rev-list --objects --all | grep <object hash> will show path of object
git log --oneline --branches -- git.tgz list commits with object
git filter-branch --index-filter 'git rm --ignore-unmatch --cached git.tgz' -- <hash first commit with object>^.. to remove it from all commits
rm -Rf .git/refs/original and ` rm -Rf .git/logs/ and git gc`
git prune --expire now