Git

• Or worktree
• The entire file including the files under the .git/, which means all its history and current state.

--depth DEPTH clone the number of recent commits specified.

• Show status.

• It shows commits reachable from HEAD, which means past commits.
• log [([^]<ref>)*] To control the scope, one can specify which commit to start logging.
  • <ref>=(HEAD|<hash>|<tag>|<branch>)(^N|~N)* where ^N means N=th parent when current commit is a merge of multiple commits, and =~N means N parents back.
• --graph: Show graph
• --oneline: One line per commit
• --decorate:

• Stage diffs so that it can be readily committed. Add path at the end
• -p --patch: Add /hunks/(blocks of changes) individually.

Use reset <file> or restore --staged <file> to undo.

• Move HEAD.

$ git checkout <hash|name>

            HEAD
             v
        <branchname>
             v
---O----O----O

======V======

  HEAD   <branchname>
   v         v
---O----O----O

• Switch branch.

• Add commit, move branch reference and HEAD.
• -a to add the changes of the tracked files before commiting.
• -C or -c=(edit the message) to use the existing commit object, probably there because of =git reset.
• --amend to replace the tip of the commit with a new one, effectively amending it.
  • --no-edit to keep the commit message.
• --fixup, --squash: Marks the commit that it is to be squashed when git rebase --autosquash

$ git commit

    <branchname> <- HEAD
        v
---O----O

======V======

        <branchname> <- HEAD
             v
---O----O----O

• Tag is a immovable identifier.

$ git tag <tagname>

        <branchname>
             v
---O----O----O
    ^
HEAD

======V======

        <branchname>
             v
---O----O----O
   ^
<tagname> <- HEAD

• Branch is a identifier that moves along as one commits.

$ git branch <branchname>

     <main>
        v
---O----O
   ^
  HEAD

======V======

     <main>
        v
---O----O
   ^
<branchname> <- HEAD

• Git does three-way merging which analyzes base, local, remote and produces best result.

$ git merge <feature>

    <main> <- HEAD
        v
---O----O
    \---O
        ^
    <feature>

======V======

          <main> <- HEAD
             v
---O----O----O
    \---O---/
        ^
    <feature>

• --squash
  • Change current working tree into the merged state, but not committed. Therefore, git commit is required.
  • This enables creating a single commit with single parent.

• Local branch is created when one checkout the remote branch, and the local branch has an upstream pointer that is connected to the remote branch.

$ git fetch <remote/origin/main>

      HEAD
        v
    <main> ~> <remote/origin/main>
        |_______/
        v
---O----O

======V======

      HEAD
        v
    <main> ~> <remote/origin/main>
        |         |
        v         v
---O----O----O----O

• Merge local and remote branch.

$ git pull <remote/origin/main>

      HEAD
        v
    <main> ~> <remote/origin/main>
        |         |
        v         v
---O----O----O----O

======V======

      HEAD
        v
    <main> ~> <remote/origin/main>
        \_________|
                  v
---O----O----O----O

• Checks if any divergence happened and if it did git refuses to push. To resolve this one needs to merge the remote branch.
• --force-with-lease: Only force push if the remote is the same as the local.

• Changes of working tree (the current state) from the HEAD, Or diff X Y for diff between X and Y.
• git diff <ref> [<ref>=HEAD] > <patchfile> stores the diff that can be applied by git apply <patchfile>.

• Uncommit or Unstage or hard reset.
• --soft: only moves the HEAD, --hard: moves the HEAD and reset the index and working tree.
• The current HEAD gets stored to ORIG_HEAD.

• Restore files to a specific state. Add path at the end. It does not affect the index unless --staged
• -s <tree> --source=<tree>: Specify commit, branch to restore from. Restore from index if unspecified.
• --staged: Unstage

• Commit the inverse of previous commits.

• Commit just one commit within other branch onto the current branch.

• Commit current branch on top of another branch.
• git rebase -i <ref>: Perform rebase on <ref>. This means the commits after <ref> will be available for rebasing.
  • fixup: append to the previous commit.
  • squash: append the previous commit to itself.
  • reword: change the commit message.
  • edit: perform git commit --amend on the commit.

It tracks every single move of HEAD pointer, even hard reset and branch deletion.

git reset --hard can reset to one of the reference point.

• Temporarily stores diffs in a separate area.
• Name of stash looks like stash@{n} which can be referenced by only the n. The latest stash is 0.
• git stash push
  • -k --keep-index: Stash only the changes.
  • -S --staged: Stash only the index.
• git stash pop: Apply the stash and drop it. They must match the index.
• git stash list, git stash drop <stash>

• Add notes to commits. It does not affect the commit at all.

• add <path> <commit-ish>: copy the entire repository into the <path> (except the per-worktree files, like HEAD, index, …) and link it to the current one. It is a linked worktree.

• If a git repository is inside a git repository, then the outer repository only tracks the HEAD of the inner repository.

• Track down a bug by bisecting the commits.

• Open a GUI in the browser

• Garbage collection for tidying up the git files.

• See who wrote certain code

• Remove unnecessary files.

• start

• user
  • name
  • email
• credential
  • helper: store and cache is provided by default.
• alias
  • Short string to be used as a subcommand.
• {{video https://youtu.be/aolI_Rz0ZqY?si=ZFHkS8qCT6Uh5GrA}}
• gpg
  • Sign your commit
• maintenance
  • Automatically maintain your repository

$XDG_CONFIG_HOME/git/ignore, $GIT_DIR/info/exclude, .gitignore are searched for the files to ignore.

Each line is a pattern for the files.

• ! prefix: negate the pattern
• / suffix: match directory only
• *, ?, ** wildcards
• # prefix: comment

• git cat-file to inspect objects
• Every object is hashed and stored in the same way within the .git/objects/ directory.
• They are referenced by their hash.
• Commit
  • Contains the reference to the root tree.
• Tree
  • Correspond to the directory in the file structure.
  • Contains the reference to trees and blobs within the directory.
• Blob
  • Correspond to a file.