Git: Comprehensive Guide

Table of Contents

• Configuration
• Aliases and Shortcuts
• Merge Conflicts
• Merge Strategies
• Repository Management
• Best Practices
• Common Commands Reference

Configuration

Global Configuration Setup

git config --global user.name "CJ Steiner"
git config --global user.email "csrhinoserver@gmail.com"
git config --global core.editor vi
git config --global core.pager "less -FRXS"
git config --global color.ui true
git config --global svc.rmdir true
git config --global merge.tool vimdiff
git config --global merge.summary true
git config --global push.default simple
git config --global format.pretty fuller
git config --global pull.rebase true

Aliases and Shortcuts

Navigation Aliases

alias ..='cd ../'
alias ...='cd ../../'
alias ....='cd ../../../'

Git Aliases

alias gd='git diff'
alias gds='git diff --staged'
alias gs='git status'
alias ga='git add'
alias gr='git restore'
alias grs='git restore --staged'
alias gc='git commit'
alias gcm='git commit -m'
alias gca='git commit --amend --no-edit --date=now'
alias gb='git branch'
alias gbdates="git for-each-ref --sort=committerdate refs/heads/ --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(contents-subject) - %(authorname) (%(color:green)%(committerdate:short)%(color:reset))'"
alias gbresethard='git reset --hard @{u}'

Merge Conflicts

Understanding Merge Conflicts

A merge conflict occurs when Git cannot automatically resolve differences between two commits. This happens when:

• Both branches modify the same lines in a file
• One branch deletes a file that another branch modifies
• Two branches add different files with the same name

Common Conflict Scenarios

Code Changes in Same Location

# Branch A modifies line 10-15
# Branch B modifies line 10-15
# Result: Conflict when merging
git merge feature-branch
# Conflict in README.md

File Deletion vs Modification

# Branch A: deletes config.json
# Branch B: modifies config.json
# Result: Delete/modify conflict

Understanding Conflict Markers

When a conflict occurs, Git marks the conflicting sections:

<<<<<<< HEAD
This is the version from the current branch (HEAD)
=======
This is the version from the branch being merged
>>>>>>> feature-branch

Sections marked:

• <<<<<<< HEAD — Current branch version
• ======= — Separator
• >>>>>>> branch-name — Incoming branch version

Resolving Conflicts Manually

Step 1: Identify Conflicted Files

git status
# Shows "Unmerged paths" with conflicted files

Step 2: Edit Conflicted Files

Open conflicted files and manually decide which changes to keep. Remove conflict markers and edit the code.

# Example: resolving in config.json
<<<<<<< HEAD
{
  "environment": "production"
}
=======
{
  "environment": "staging"
}
>>>>>>> update-config

# Resolved version:
{
  "environment": "production-staging"
}

Step 3: Mark as Resolved

git add <resolved-file>

Step 4: Complete the Merge

git commit -m "Resolve merge conflict in config.json"
# Or if already staged:
git merge --continue

Using Merge Tools

Configure a Merge Tool

# Use vimdiff
git config --global merge.tool vimdiff

# Use VSCode
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'

# Use meld (visual tool)
git config --global merge.tool meld

Launch Merge Tool

git mergetool

The tool opens each conflicted file for visual resolution. After resolving:

git add .
git commit

Merge Strategies

Recursive (Default)

git merge feature-branch

Works best for most scenarios. Takes multiple common ancestors into account.

Ours Strategy

Always prefer current branch changes:

git merge -s ours feature-branch

Use with caution — discards changes from the merged branch.

Theirs Strategy

Take changes from the branch being merged (requires creating a temporary commit):

git merge -X theirs feature-branch

Resolve Strategy

Simpler algorithm, useful for 2-way merges:

git merge -s resolve feature-branch

Conflict Resolution Preferences

Prefer current branch’s changes:

git merge -X ours feature-branch

Prefer incoming branch’s changes:

git merge -X theirs feature-branch

Undoing a Merge

If Not Yet Committed

Abort the merge entirely:

git merge --abort

After Merging (Undo Last Commit)

# Reset to before merge
git reset --hard HEAD~1

Creating a Revert Commit

For merged commits already pushed to shared branches:

git revert -m 1 <merge-commit-hash>

The -m 1 flag specifies merging with mainline.

Working with Rebases

Conflicts can also occur during rebasing. The process is similar:

git rebase main
# Conflicts occur
# ... resolve conflicts ...
git add <resolved-files>
git rebase --continue
# Or abort:
git rebase --abort

Repository Management

Create a Git Bundle

Create a portable repository snapshot:

git bundle create repo.bundle --all
git clone repo.bundle /tmp/repo/

Sync Local with Upstream

git fetch upstream
# if no upstream git remote add upstream <url>
git merge upstream/master
git push origin master

Alternative using rebase:

git fetch upstream
git rebase upstream/master
git push origin master

Fix Broken Git Repository

git gc
git remote prune origin
git fetch --prune # clean up refs

Best Practices

Keep Commits Small and Focused

Smaller, focused commits reduce conflict surface area.

# Good: Specific commit
git commit -m "Fix authentication bug in login handler"

# Avoid: Large commit touching many areas
git commit -m "Various fixes and updates"

Sync Frequently with Main Branch

git fetch origin
git rebase origin/master
# or
git merge origin/master

Communicate with Team

• Discuss major changes before starting work
• Review related PRs before starting similar work
• Notify team when working on shared files

Use Feature Branches Strategically

Keep feature branches short-lived (days, not weeks).

# Create focused feature branch
git checkout -b fix/auth-bug
# ... make changes ...
# Merge quickly to avoid divergence
git push origin fix/auth-bug
# Create PR and merge

Organize Code to Minimize Conflicts

• Separate concerns into different files
• Avoid modifying shared utility files unnecessarily
• Use configuration files for shared settings

Common Commands Reference

Command	Purpose
git status	Show working tree status
git diff	View differences
git diff --staged	View staged changes
git add <file>	Stage changes
git commit -m "msg"	Create commit
git push	Push to remote
git pull	Fetch and merge
git fetch	Download remote changes
git merge <branch>	Merge branch
git rebase <branch>	Rebase current branch
git branch	List branches
git checkout -b <branch>	Create and switch branch
git log	View commit history
git reset --hard HEAD~1	Undo last commit
git checkout --ours <file>	Take current branch version in conflict
git checkout --theirs <file>	Take incoming branch version in conflict
git mergetool	Open visual merge tool
git merge --abort	Cancel merge in progress
git revert -m 1 <hash>	Revert merge commit
git bundle create	Create repository bundle
git gc	Garbage collection
git remote prune origin	Clean up stale remote refs