Hands-on lab — Day 30: Git Fundamentals: Repositories, Staging, and Commits

#!/usr/bin/env bash
# Day 030 lab — completed reference implementation.
#
# Demonstrates Git's core model end to end in a THROWAWAY repository:
#   working directory -> (git add) -> staging area -> (git commit) -> repository
#
# It creates a temporary repo under this lab directory, gives it a LOCAL
# identity (never touching your global git config), walks the full
# init -> status -> add -> commit -> edit -> diff -> add -> commit ->
# .gitignore -> log flow, then deletes the temporary repo on exit.
#
# No network, no sudo, no changes outside the temp directory it creates.
set -euo pipefail

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
work="$(mktemp -d "${lab_dir}/.gitdemo.XXXXXX")"

# Always clean up the throwaway repo, however the script exits.
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT

# Run every git command with a LOCAL identity for this repo only. We pass the
# identity via -c on each call so nothing is written to your ~/.gitconfig.
git_local() {
  git -C "${work}" \
    -c user.name="Day 30 Learner" \
    -c user.email="learner@example.invalid" \
    -c init.defaultBranch=main \
    -c commit.gpgsign=false \
    "$@"
}

rule() { printf '\n----- %s -----\n' "$1"; }

rule "1. git init — create an empty repository"
git_local init -q
echo "Created a repository. The .git directory now exists:"
ls -d "${work}/.git" | sed "s#${work}/#./#"

rule "2. git status — a brand-new file is UNTRACKED"
printf 'notes for day 30\n' > "${work}/notes.txt"
git_local status --short
echo "(?? means Git sees the file but is not tracking it yet)"

rule "3. git add — move notes.txt into the STAGING AREA"
git_local add notes.txt
git_local status --short
echo "(A in the left column means the file is staged, ready to commit)"

rule "4. git commit — record the staged snapshot in the repository"
git_local commit -q -m "Add notes.txt with initial notes"
first_hash="$(git_local rev-parse --short HEAD)"
echo "First commit created: ${first_hash}"

rule "5. Edit the file, then git diff — see the UNSTAGED change"
printf 'a second line, added later\n' >> "${work}/notes.txt"
git_local status --short
echo "(the M means notes.txt is modified in the working directory but not staged)"
echo "Working directory vs last commit:"
git_local --no-pager diff

rule "6. git add + git commit — record the second snapshot"
git_local add notes.txt
git_local commit -q -m "Append a second line to notes.txt"
second_hash="$(git_local rev-parse --short HEAD)"
echo "Second commit created: ${second_hash}"

rule "7. .gitignore — keep an ignored file UNTRACKED"
printf 'secret.key\n' > "${work}/.gitignore"
printf 'PRETEND-API-KEY-do-not-commit\n' > "${work}/secret.key"
git_local add .gitignore
git_local commit -q -m "Add .gitignore to exclude secret.key"
echo "status --short (secret.key must NOT appear; .gitignore is now committed):"
git_local status --short
echo "(empty status above = clean tree; secret.key is ignored, not staged)"
echo "Proof Git is deliberately ignoring it:"
git_local check-ignore -v secret.key | sed "s#${work}/#./#"

rule "8. git log --oneline — read the history (newest first)"
git_local log --oneline

rule "Summary"
echo "First commit  (short hash): ${first_hash}"
echo "Second commit (short hash): ${second_hash}"
echo "HEAD points at: $(git_local rev-parse --short HEAD) (the latest commit on branch main)"
echo "Commits in history: $(git_local rev-list --count HEAD)"
echo "Ignored and never committed: secret.key"
echo
echo "Done. The throwaway repository at ${work} will now be deleted."

lesson_id: D030
day: 30
kind: command-line-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-030-git-fundamentals-repositories-staging-and-commits
run_commands:
  - bash examples/git_basics.sh
  - bash starter/git_basics.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'rm -rf .gitdemo.* .gittest.*  # only needed if a run was interrupted; scripts self-clean'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), Git 2.50.1, bash tests/run_tests.sh → 12 checks, 0 failure(s)'

# Dependencies — Day 030 lab

**One tool: Git.** This lab needs nothing else beyond a POSIX shell.

- `git` (any 2.x version; the reference run used 2.50.1). Check with
  `git --version`.
- `bash` ≥ 3.2 and the standard utilities `mktemp`, `printf`, `sed`, `grep`,
  `ls`, `rm` — all preinstalled on macOS and every mainstream Linux
  distribution.

## Installing Git

- **macOS:** `git` ships with the Xcode Command Line Tools. If `git --version`
  prompts to install them, accept — or install Git via Homebrew
  (`brew install git`).
- **Debian/Ubuntu:** `sudo apt install git`
- **Fedora/RHEL:** `sudo dnf install git`
- **Windows:** install Git for Windows, or run this lab inside WSL and follow
  the Linux path.

There is deliberately no `requirements.txt`/`package.json` here: the lab is
pure Git and shell. It makes **no network connections** and needs **no API
key**. It never writes to your global Git configuration — every command runs
with a local identity scoped to a throwaway repository the script deletes on
exit.

#!/usr/bin/env bash
# Day 030 lab — YOUR working file.
#
# Goal: drive Git's core model by hand in a THROWAWAY repository and watch a
# file move through the three areas:
#   working directory -> (git add) -> staging area -> (git commit) -> repository
#
# The scaffolding below sets up a temporary repo with a LOCAL identity (so
# nothing touches your global git config) and cleans it up on exit. Your job
# is the five numbered exercises: replace each `FILL_ME` line with the exact
# git command named in the comment above it. The finished reference is in
# examples/git_basics.sh — try it yourself first.
#
# Run it with:  bash starter/git_basics.sh
set -euo pipefail

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
work="$(mktemp -d "${lab_dir}/.gitdemo.XXXXXX")"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT

# Every git command runs with a LOCAL identity for THIS repo only.
git_local() {
  git -C "${work}" \
    -c user.name="Day 30 Learner" \
    -c user.email="learner@example.invalid" \
    -c init.defaultBranch=main \
    -c commit.gpgsign=false \
    "$@"
}

# --- Exercise 1: initialise an empty repository ---------------------------
# Replace FILL_ME with:  git_local init -q
echo "Exercise 1: git init"
FILL_ME
[ -d "${work}/.git" ] && echo "  .git created" || { echo "  ERROR: no .git dir"; exit 1; }

# Create a file in the working directory (given).
printf 'notes for day 30\n' > "${work}/notes.txt"

# --- Exercise 2: stage notes.txt (move it to the staging area) ------------
# Replace FILL_ME with:  git_local add notes.txt
echo "Exercise 2: git add notes.txt"
FILL_ME
echo "  status after add:"; git_local status --short | sed 's/^/    /'

# --- Exercise 3: commit the staged snapshot -------------------------------
# Replace FILL_ME with:  git_local commit -q -m "Add notes.txt with initial notes"
echo "Exercise 3: git commit"
FILL_ME
echo "  first commit: $(git_local rev-parse --short HEAD)"

# Edit the file so there is an unstaged change to see (given).
printf 'a second line, added later\n' >> "${work}/notes.txt"

# --- Exercise 4: show the unstaged change with a diff ---------------------
# Replace FILL_ME with:  git_local --no-pager diff
echo "Exercise 4: git diff (working directory vs last commit)"
FILL_ME

# Stage and commit the second snapshot (given, so you finish with 2 commits).
git_local add notes.txt
git_local commit -q -m "Append a second line to notes.txt"
echo "  second commit: $(git_local rev-parse --short HEAD)"

# Add a .gitignore and an ignored file (given).
printf 'secret.key\n' > "${work}/.gitignore"
printf 'PRETEND-API-KEY-do-not-commit\n' > "${work}/secret.key"
git_local add .gitignore
git_local commit -q -m "Add .gitignore to exclude secret.key"

# --- Exercise 5: print the one-line history -------------------------------
# Replace FILL_ME with:  git_local log --oneline
echo "Exercise 5: git log --oneline"
FILL_ME

echo
echo "If you see 3 commits above and secret.key never appeared in a status, you did it."

# Git worksheet — Day 030

Fill this in from a real run of `examples/git_basics.sh` (or your finished
`starter/git_basics.sh`). Watch the output scroll past and record what you
actually saw — the point is to connect each command to the state it produced.

## 1. The state of `notes.txt` at each stage

For each moment, write what `git status --short` showed (or would have shown)
for `notes.txt`, and say which of the three areas held the current version.

| Moment | `git status --short` code | Which area holds the newest content |
| --- | --- | --- |
| Right after creating the file, before `git add` | `______` | working directory only |
| After `git add notes.txt`, before commit | `______` | ______ |
| Right after the first `git commit` | (clean / no entry) | ______ |
| After appending a second line, before staging | `______` | ______ |
| After staging and the second `git commit` | (clean / no entry) | ______ |

Reminder of the codes: `??` = untracked, `A ` = staged new file,
` M` = modified but not staged, `M ` = modified and staged.

## 2. Your two commit hashes (short form)

Copy the short hashes the script printed (yours will differ from anyone
else's — that is expected; a hash is computed from the snapshot's content,
author, time, message, and parent).

- First commit  ("Add notes.txt with initial notes"): `_______`
- Second commit ("Append a second line to notes.txt"): `_______`
- Which commit does `HEAD` point at after the run? `_______`

## 3. What `.gitignore` excluded

- The file name listed inside `.gitignore`: `______________`
- The file that stayed **untracked** because of it: `______________`
- Did that ignored file ever appear in `git status`? (yes / no): `______`
- One sentence in your own words on why keeping secrets out of a repository
  matters:

  `___________________________________________________________________`

## 4. One thing that surprised you

`_____________________________________________________________________`

#!/usr/bin/env bash
# Tests for the Day 030 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Builds a throwaway repository the same way the lab does (temp dir under the
# lab directory, LOCAL identity only, no network) and verifies the real
# behaviour of Git's core model: init works, staging works, commits accumulate,
# .gitignore actually excludes a file, and cleanup leaves nothing behind.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

# --- 0. The reference script runs cleanly and cleans up after itself -------
before_count="$(ls -1d "${lab_dir}"/.gitdemo.* 2>/dev/null | wc -l | tr -d ' ')"
if bash "${lab_dir}/examples/git_basics.sh" >/dev/null 2>&1; then
  check "examples/git_basics.sh exits successfully" "yes"
else
  check "examples/git_basics.sh exits successfully" "no"
fi
after_count="$(ls -1d "${lab_dir}"/.gitdemo.* 2>/dev/null | wc -l | tr -d ' ')"
if [ "${before_count}" = "${after_count}" ]; then
  check "reference script leaves no .gitdemo.* directory behind" "yes"
else
  check "reference script leaves no .gitdemo.* directory behind" "no"
fi

# --- Build our own throwaway repo to assert on Git's behaviour directly ----
work="$(mktemp -d "${lab_dir}/.gittest.XXXXXX")"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT

git_local() {
  git -C "${work}" \
    -c user.name="Test Runner" \
    -c user.email="test@example.invalid" \
    -c init.defaultBranch=main \
    -c commit.gpgsign=false \
    "$@"
}

# 1. init creates a repository
git_local init -q >/dev/null 2>&1
[ -d "${work}/.git" ] && check "git init creates a .git repository" "yes" \
  || check "git init creates a .git repository" "no"

# 2. a new file is untracked
printf 'hello\n' > "${work}/file.txt"
if git_local status --short | grep -q '^?? file.txt$'; then
  check "a new file shows as untracked (??)" "yes"
else
  check "a new file shows as untracked (??)" "no"
fi

# 3. staging moves it to the index
git_local add file.txt
if git_local status --short | grep -q '^A  file.txt$'; then
  check "git add stages the file (A in status)" "yes"
else
  check "git add stages the file (A in status)" "no"
fi

# 4. first commit lands
git_local commit -q -m "first commit" >/dev/null 2>&1
c1="$(git_local rev-list --count HEAD 2>/dev/null || echo 0)"
[ "${c1}" = "1" ] && check "first commit is recorded (1 commit)" "yes" \
  || check "first commit is recorded (1 commit)" "no"

# 5. edit + second commit -> 2 commits
printf 'world\n' >> "${work}/file.txt"
# the edit must be visible as an unstaged modification before we stage it
if git_local status --short | grep -q '^ M file.txt$'; then
  check "an edit shows as modified-but-unstaged ( M)" "yes"
else
  check "an edit shows as modified-but-unstaged ( M)" "no"
fi
git_local add file.txt
git_local commit -q -m "second commit" >/dev/null 2>&1
c2="$(git_local rev-list --count HEAD 2>/dev/null || echo 0)"
if [ "${c2}" -ge 2 ]; then
  check "history reaches 2+ commits" "yes"
else
  check "history reaches 2+ commits" "no"
fi

# 6. .gitignore actually excludes a file
printf 'ignored.log\n' > "${work}/.gitignore"
printf 'noise\n' > "${work}/ignored.log"
if git_local status --short | grep -q 'ignored.log'; then
  check ".gitignore keeps the ignored file out of status" "no"
else
  check ".gitignore keeps the ignored file out of status" "yes"
fi
if git_local check-ignore -q ignored.log; then
  check "git confirms the file is ignored (check-ignore)" "yes"
else
  check "git confirms the file is ignored (check-ignore)" "no"
fi

# 7. HEAD resolves to a real commit hash
if git_local rev-parse --short HEAD >/dev/null 2>&1; then
  check "HEAD points at a real commit" "yes"
else
  check "HEAD points at a real commit" "no"
fi

# 8. no network was used — assert the repo has no configured remote
if [ -z "$(git_local remote 2>/dev/null)" ]; then
  check "repository has no remote (fully local, no network)" "yes"
else
  check "repository has no remote (fully local, no network)" "no"
fi

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]