Git Pull — Half-Finished Code Deployed from Staged Changes

# io.thecodeforge — Understanding Git Pull

# ─────────────────────────────────────────────────────────────
# SCENARIO: You're on the 'main' branch of a team project.
# A colleague just pushed a bug fix to the remote repo.
# You need to get their changes before starting your next task.
# ─────────────────────────────────────────────────────────────

# Step 1: Check your current status before touching anything.
# Always do this. Know what state you're in before you pull.
git status
# Expected: 'nothing to commit, working tree clean'
# If you see modified files here — STOP. Stash or commit first.

# Step 2: See what branch you're on and where it sits vs. remote.
git log --oneline --decorate -5
# Shows the last 5 commits with branch pointers.
# Look for: HEAD -> main (your local) vs. origin/main (remote).
# If origin/main is ahead, you're behind — pull is needed.

# Step 3: Run fetch first to SEE what's coming, safely.
# This downloads remote changes but touches NOTHING in your working tree.
git fetch origin

# Step 4: Check what just arrived from the remote without merging yet.
# This shows commits on origin/main that aren't on your local main.
git log main..origin/main --oneline
# Output shows each incoming commit on its own line.
# If this is empty, you're already up to date.

# Step 5: Now merge the fetched changes into your local branch.
# This is the step that actually updates your files.
git merge origin/main

# ─── OR ────────────────────────────────────────────────────────
# Do both steps at once with git pull (only when working tree is clean).
git pull origin main
# Equivalent to: git fetch origin && git merge origin/main
# The 'origin' is the remote name. 'main' is the branch. Both are explicit here.
# Relying on defaults is fine locally but be explicit in scripts.

# io.thecodeforge — Safe Pull Workflow

# ─────────────────────────────────────────────────────────────
# SCENARIO: Mid-morning on the checkout-service team.
# You've been editing OrderValidator.java for 45 minutes.
# Your team lead just Slacked: "pushed the tax fix, pull when ready."
# Your working tree is NOT clean. Here's the safe workflow.
# ─────────────────────────────────────────────────────────────

# Step 1: Always check status first. Non-negotiable.
git status
# You see: 'modified: src/orders/OrderValidator.java'
# Do NOT pull yet.

# Step 2: Stash your in-progress changes.
# git stash is a stack — it saves your current diff and reverts the file.
# The message makes it identifiable when you have multiple stashes.
git stash push -m "WIP: adding discount threshold logic to OrderValidator"
# Output: Saved working directory and index state On main: WIP: adding...

# Step 3: Confirm working tree is now clean before pulling.
git status
# Output: 'nothing to commit, working tree clean' — safe to pull.

# Step 4: Pull the remote changes cleanly.
git pull origin main
# Output: Updating 9b1c233..e4f9021 — fast-forward or merge commit.

# Step 5: Re-apply your stashed work on top of the fresh code.
git stash pop
# Output: On branch main — your changes are restored on top of the new base.

# Step 6: Check if your work and the pulled changes conflict.
git status
# If OrderValidator.java shows 'both modified', you have a conflict to fix.
# If it shows 'modified' with no conflict markers — you're clean.

# io.thecodeforge — Pull Rebase vs Merge

# ─────────────────────────────────────────────────────────────
# SCENARIO: You're working on the checkout-service feature branch.
# You've made 2 local commits (not pushed yet).
# The remote main has 3 new commits since you branched.
# Goal: get remote changes without polluting history with merge commits.
# ─────────────────────────────────────────────────────────────

# ── WITHOUT --rebase (default merge behaviour) ──────────────────
# Your history before pull:
# A - B - C (origin/main)
#          \
#           D - E (your local commits, not pushed yet)
#
# After: git pull origin main
# A - B - C --------- M (merge commit — clutters history)
#          \         /
#           D - E --/

# ── WITH --rebase ───────────────────────────────────────────────
# Your history before pull:
# A - B - C (origin/main)
#          \
#           D - E (your local commits)
#
# After: git pull --rebase origin main
# A - B - C - D' - E' (linear — D and E replayed on top of C)
# D' and E' are new SHAs but same changes — history reads cleanly.

# ─────────────────────────────────────────────────────────────
# Running it:
# ─────────────────────────────────────────────────────────────

# Check current state before pulling
git log --oneline -5
# Shows your 2 local commits on top

# Pull with rebase — safe because your commits are not yet on remote
git pull --rebase origin main

# If a rebase conflict occurs during the replay of your commits,
# Git pauses and shows you the conflict.
# Fix the file, stage it, then continue the rebase:
git add src/payments/CheckoutOrchestrator.java
git rebase --continue
# Do NOT run git commit here — rebase --continue does the commit for you.

# If the conflict is too messy and you want to abort:
git rebase --abort
# This resets everything as if you never ran the rebase.

# ─────────────────────────────────────────────────────────────
# Make rebase the default for ALL future pulls (recommended):
# ─────────────────────────────────────────────────────────────
git config --global pull.rebase true
# Now every 'git pull' behaves like 'git pull --rebase' automatically.

# io/thecodeforge — Pull Autostash

# ─────────────────────────────────────────────────────────────
# SCENARIO: You have uncommitted changes across 3 files.
# Your teammate pushes an urgent hotfix to main.
# You need to pull before you forget, but you don't want to
# interrupt your flow with manual stash commands.
# ─────────────────────────────────────────────────────────────

# Without --autostash: three commands
git stash push -m "WIP: cart service refactor"
git pull --rebase origin main
git stash pop

# With --autostash: one command
git pull --rebase --autostash origin main
# Git: 'Created autostash: refs/autostash'
# Git: pulls and rebases
# Git: 'Applied autostash'
# Your dirty files are back exactly where you left them.

# ─────────────────────────────────────────────────────────────
# CONFIGURE autostash as default (do this once, globally)
# ─────────────────────────────────────────────────────────────
git config --global rebase.autoStash true
# Now git pull --rebase automatically includes --autostash.
# You never need to type --autostash again.

# Verify
git config --global rebase.autoStash
# Output: true

# io.thecodeforge — Fast-Forward vs Three-Way Merge

# ─────────────────────────────────────────────────────────────
# FAST-FORWARD: Your branch has no local commits.
# Remote is simply ahead. Git moves your pointer forward.
# ─────────────────────────────────────────────────────────────

# Before: your main is at commit B, remote main is at commit E
#   A - B (your main, HEAD)
#        \
#         C - D - E (origin/main)

git pull origin main
# Output: Updating b2a3c1f..e4f9021
#         Fast-forward
# After: your main pointer moved to E. No merge commit created.

# ─────────────────────────────────────────────────────────────
# THREE-WAY MERGE: Both branches have new commits.
# Git creates a merge commit with two parents.
# ─────────────────────────────────────────────────────────────

# Before: you committed F and G locally. Remote added C, D, E.
#   A - B - C - D - E (origin/main)
#          \
#           F - G (your local main, HEAD)

git pull origin main
# Output: Merge made by the 'ort' strategy.
# After: merge commit M created with two parents (E and G).

# ─────────────────────────────────────────────────────────────
# --ff-only: Force fast-forward, fail if diverged.
# Use this in CI scripts or automated deploys.
# ─────────────────────────────────────────────────────────────

git pull --ff-only origin main
# If fast-forward is possible: succeeds silently.
# If branches have diverged: fatal: Not possible to fast-forward, aborting.

# ─────────────────────────────────────────────────────────────
# --no-ff: Force merge commit even when fast-forward is possible.
# Use this when merging feature branches.
# ─────────────────────────────────────────────────────────────

git checkout main
git pull --no-ff feature/discount-engine
# Creates a merge commit even if a fast-forward was possible.

# io/thecodeforge — Git Stash Deep Dive

# ─────────────────────────────────────────────────────────────
# BASIC STASH OPERATIONS
# ─────────────────────────────────────────────────────────────

# Save current work with a descriptive message
git stash push -m "WIP: discount threshold validation for orders over 500"

# See all stashes with their messages
git stash list
# stash@{0}: On main: WIP: discount threshold validation
# stash@{1}: On main: WIP: refactoring CartService for multi-currency
# stash@{2}: On main: WIP: adding logging to PaymentProcessor

# See what is IN a stash without applying it
git stash show -p stash@{1}

# Apply the most recent stash and KEEP it on the stack
git stash apply

# Apply the most recent stash and REMOVE it from the stack
git stash pop

# Apply a specific stash (by index)
git stash apply stash@{1}

# Remove a specific stash without applying it
git stash drop stash@{1}

# Clear ALL stashes (nuclear — no confirmation)
git stash clear

# io/thecodeforge — Fork Sync Workflow

# ─────────────────────────────────────────────────────────────
# SCENARIO: You've forked github.com/acme-corp/checkout-service
# to github.com/your-username/checkout-service.
# ─────────────────────────────────────────────────────────────

# Step 1: Add the original repo as 'upstream' (only needed once)
git remote add upstream https://github.com/acme-corp/checkout-service.git

# Step 2: Verify both remotes
git remote -v
# origin    https://github.com/your-username/checkout-service.git (fetch)
# upstream  https://github.com/acme-corp/checkout-service.git (fetch)

# Step 3: Fetch all branches from upstream
git fetch upstream

# Step 4: Switch to your local main and merge upstream/main
git checkout main
git merge upstream/main

# Step 5: Push the synced main to your fork
git push origin main

# ─────────────────────────────────────────────────────────────
# ALIAS FOR DAILY SYNC
# ─────────────────────────────────────────────────────────────
git config --global alias.syncfork '!git fetch upstream && git checkout main && git merge upstream/main && git push origin main'
# Now run: git syncfork

# io/thecodeforge — Upstream Tracking

# ─────────────────────────────────────────────────────────────
# See the upstream for all local branches
# ─────────────────────────────────────────────────────────────
git branch -vv
# * main        a3f92c1 [origin/main] Fix rounding bug
#   feature/pay e8d1b20 [origin/feature/pay: ahead 2, behind 1] Add Apple Pay
#   hotfix/tax  3c2fa01 Add tax override logic  <- no upstream

# ─────────────────────────────────────────────────────────────
# SET UPSTREAM on first push
# ─────────────────────────────────────────────────────────────
git checkout -b feature/apple-pay
git push -u origin feature/apple-pay
# The -u sets upstream. Now git pull and git push work without arguments.

# ─────────────────────────────────────────────────────────────
# SET UPSTREAM on existing branch
# ─────────────────────────────────────────────────────────────
git branch --set-upstream-to=origin/feature/apple-pay

# ─────────────────────────────────────────────────────────────
# REMOVE UPSTREAM
# ─────────────────────────────────────────────────────────────
git branch --unset-upstream
# Now git pull without arguments will fail.

# io/thecodeforge — Undo Pull

# ─────────────────────────────────────────────────────────────
# SCENARIO 1: Fast-forward pull — undo with ORIG_HEAD
# ─────────────────────────────────────────────────────────────
git reset --hard ORIG_HEAD
# Moves branch pointer back to pre-pull state.

# ─────────────────────────────────────────────────────────────
# SCENARIO 2: Three-way merge — undo the merge commit
# ─────────────────────────────────────────────────────────────

# Option A: reset (rewrites history — safe if not pushed)
git reset --hard HEAD~1

# Option B: revert (creates undo commit — safe even if pushed)
git revert -m 1 HEAD
# -m 1 means: revert to the first parent (your branch before the merge).

# ─────────────────────────────────────────────────────────────
# SCENARIO 3: Rebase pull — undo the rebase
# ─────────────────────────────────────────────────────────────

# If rebase is still in progress:
git rebase --abort

# If rebase completed:
git reset --hard ORIG_HEAD

# io/thecodeforge — CI/CD Pull Patterns

# ─────────────────────────────────────────────────────────────
# Pattern 1: Shallow clone for speed
# ─────────────────────────────────────────────────────────────
git clone --depth=1 --branch main https://github.com/acme-corp/checkout-service.git

# ─────────────────────────────────────────────────────────────
# Pattern 2: Fetch deeper history if needed
# ─────────────────────────────────────────────────────────────
git fetch --deepen=50

# ─────────────────────────────────────────────────────────────
# Pattern 3: Deterministic pull — fail if branch has diverged
# ─────────────────────────────────────────────────────────────
git pull --ff-only origin main

# ─────────────────────────────────────────────────────────────
# Pattern 4: Deploy only if pull was clean
# ─────────────────────────────────────────────────────────────
if git pull --ff-only origin main; then
    echo "Deploying $(git rev-parse --short HEAD)"
    ./deploy.sh
else
    echo "ABORT: branch has diverged. Manual intervention required."
    exit 1
fi

# io/thecodeforge — Detached HEAD and Pull

# ─────────────────────────────────────────────────────────────
# You checked out a tag — now in detached HEAD
# ─────────────────────────────────────────────────────────────
git checkout v2.1.0
# Output: You are in 'detached HEAD' state...

# ─────────────────────────────────────────────────────────────
# SAFE: Create a branch before working
# ─────────────────────────────────────────────────────────────
git checkout -b bugfix/v2.1.0-hotfix
# Now on a real branch. git pull works normally.

# ─────────────────────────────────────────────────────────────
# RECOVERY: Commits lost in detached HEAD
# ─────────────────────────────────────────────────────────────
git reflog
# Find the commit hash of your lost work
git checkout -b rescue/lost-work <commit-hash>
# Commits rescued onto a branch.