Hands-on lab — Day 35: Git Workflows for Real Projects

#!/usr/bin/env bash
# Day 035 lab — completed reference implementation: a real git workflow.
#
# Simulates GitHub Flow entirely on your own machine, with no network and no
# account. It creates a throwaway working repository and a local bare "origin"
# in a temporary directory, sets a LOCAL git identity (never touching your
# global config), then:
#   1. commits an initial .gitignore  (chore:)
#   2. branches off main               (feat/notes-search)
#   3. makes two atomic commits        (feat: , fix:)
#   4. merges back with --no-ff        (like merging a pull request)
#   5. tags an annotated release       (git tag -a v1.0.0)
# It also demonstrates that an ignored file stays out of git, and contrasts an
# atomic commit sequence with a sloppy one. The temp directory is removed on
# exit, so the demo leaves nothing behind.
set -euo pipefail

# --- Create an isolated workspace and clean it up on exit -------------------
work_root="$(mktemp -d "${TMPDIR:-/tmp}/day035-demo.XXXXXX")"
cleanup() { rm -rf "${work_root}"; }
trap cleanup EXIT

origin="${work_root}/origin.git"   # local bare repo standing in for a remote
repo="${work_root}/notes"          # our working clone

# --- A local bare repo acts as "origin" (no network involved) ---------------
git init --quiet --bare -b main "${origin}"
git clone --quiet "${origin}" "${repo}" 2>/dev/null
cd "${repo}"

# LOCAL identity only: these writes stay inside ${repo}/.git/config and never
# alter your machine's global git identity.
git config user.name  "Workflow Demo"
git config user.email "demo@example.invalid"

echo "=== 1. Initial commit with a .gitignore ==="
printf '%s\n' 'node_modules/' '*.log' '.env' > .gitignore
printf '%s\n' '# Course Notes' '' 'Notes for the 365 Days of AI course.' > README.md
git add .gitignore README.md
git commit --quiet -m "chore: initialize notes repository with .gitignore"

# Prove .gitignore works: a matching file must NOT appear in git status.
echo 'SECRET_KEY=do-not-commit-me' > .env
if git status --porcelain | grep -q '\.env'; then
  echo "  UNEXPECTED: .env showed up in git status" >&2
else
  echo "  .env is present on disk but correctly ignored by git (not tracked)"
fi

echo
echo "=== 2. Create a short-lived feature branch (GitHub Flow) ==="
git switch --quiet -c feat/notes-search
echo "  on branch: $(git branch --show-current)"

echo
echo "=== 3. Two atomic commits with Conventional Commit messages ==="
printf '%s\n' 'def search(notes, query):' '    return [n for n in notes if query.lower() in n.lower()]' > search.py
git add search.py
git commit --quiet -m "feat: add case-insensitive note search"

printf '%s\n' 'def search(notes, query):' '    if not query:' '        return []' '    return [n for n in notes if query.lower() in n.lower()]' > search.py
git add search.py
git commit --quiet -m "fix: handle empty query without crashing"

echo
echo "=== 4. Merge back to main with --no-ff (like merging a pull request) ==="
git switch --quiet main
git merge --no-ff --quiet -m "Merge branch 'feat/notes-search'" feat/notes-search
echo "  merged; main now has a merge commit recording the reviewed branch"

echo
echo "=== 5. Tag an annotated release and push everything to origin ==="
git tag -a v1.0.0 -m "First release: note search"
git push --quiet origin main
git push --quiet origin v1.0.0

echo
echo "=== Atomic vs sloppy commit (illustration on a scratch branch) ==="
git switch --quiet -c demo/atomic-vs-sloppy
# Atomic: two separate logical changes -> two commits you can revert or bisect.
echo 'MAX_RESULTS = 50' > config.py
git add config.py
git commit --quiet -m "feat: add MAX_RESULTS setting"
printf '%s\n' 'def tidy(s):' '    return s.strip()' > utils.py
git add utils.py
git commit --quiet -m "refactor: add tidy() helper"
echo "  Atomic history on this branch:"
git log --oneline -2 | sed 's/^/    /'
git switch --quiet main
git branch -D demo/atomic-vs-sloppy >/dev/null 2>&1
echo "  (A sloppy alternative would cram both changes into one 'stuff' commit,"
echo "   which you could not revert or bisect independently.)"

echo
echo "=== Tags ==="
git tag
echo "=== History (main) ==="
git log --oneline --decorate --graph
echo "=== Workflow demo complete ==="

lesson_id: D035
day: 35
kind: shell-scripting
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-035-git-workflows-for-real-projects
run_commands:
  - bash examples/workflow_demo.sh
  - bash starter/workflow_demo.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - '# nothing to clean up: scripts work only in a mktemp dir removed on exit'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), git 2.50.x, bash tests/run_tests.sh → 8 checks, 0 failure(s)'

# Dependencies — Day 035 lab

**Just git and a POSIX shell.** This lab has no installable dependencies:

- `git` (2.23 or newer — for the `git switch` command; any git from the last
  few years works). Check with `git --version`.
- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution).
- Standard OS utilities used by the scripts: `mktemp`, `printf`, `grep`, `awk`,
  `sed` — all part of the base system.

There is no `requirements.txt` or `package.json`, no account, and no API key.
Every git operation runs against a **local bare repository** created in a
temporary directory, so the lab needs **no network connection** at all.

If `git` is missing:

- **macOS:** `xcode-select --install` (installs the command-line tools), or
  install git from your package manager of choice.
- **Debian/Ubuntu:** `sudo apt install git`.
- **Fedora:** `sudo dnf install git`.

#!/usr/bin/env bash
# Day 035 lab — YOUR working file: run a real git workflow yourself.
#
# This starter builds the same isolated, network-free setup as the reference
# (a throwaway working repo plus a local bare "origin" in a temp directory,
# with a LOCAL git identity so your global config is never touched). Your job
# is to complete the five numbered exercises below, replacing each
#   : "__FILL_ME_IN__ exercise N ..."   # a harmless no-op placeholder line
# with the real git command named in its comment. Try it before peeking at
# examples/workflow_demo.sh.
#
# Run it with:   bash starter/workflow_demo.sh
# Check it with: bash tests/run_tests.sh
set -euo pipefail

# --- Isolated workspace, cleaned up on exit (already done for you) ----------
work_root="$(mktemp -d "${TMPDIR:-/tmp}/day035-starter.XXXXXX")"
cleanup() { rm -rf "${work_root}"; }
trap cleanup EXIT

origin="${work_root}/origin.git"
repo="${work_root}/notes"

git init --quiet --bare -b main "${origin}"
git clone --quiet "${origin}" "${repo}" 2>/dev/null
cd "${repo}"
git config user.name  "Workflow Learner"
git config user.email "learner@example.invalid"

echo "=== 1. Initial commit with a .gitignore ==="
printf '%s\n' 'node_modules/' '*.log' '.env' > .gitignore
printf '%s\n' '# Course Notes' '' 'Notes for the 365 Days of AI course.' > README.md
git add .gitignore README.md
# Exercise 1: make the initial commit with a chore: Conventional Commit message.
#   Use: git commit -m "chore: initialize notes repository with .gitignore"
: "__FILL_ME_IN__ exercise 1 — replace this line with the git commit command above"

echo
echo "=== 2. Create a short-lived feature branch (GitHub Flow) ==="
# Exercise 2: create AND switch to a feature branch named feat/notes-search.
#   Use: git switch -c feat/notes-search
: "__FILL_ME_IN__ exercise 2 — replace this line with the git switch command above"
echo "  on branch: $(git branch --show-current)"

echo
echo "=== 3. Two atomic commits with Conventional Commit messages ==="
printf '%s\n' 'def search(notes, query):' '    return [n for n in notes if query.lower() in n.lower()]' > search.py
git add search.py
# Exercise 3a: commit this as a feature.
#   Use: git commit -m "feat: add case-insensitive note search"
: "__FILL_ME_IN__ exercise 3a — replace this line with the feat: commit command above"
printf '%s\n' 'def search(notes, query):' '    if not query:' '        return []' '    return [n for n in notes if query.lower() in n.lower()]' > search.py
git add search.py
# Exercise 3b: commit the bug fix separately (this is what makes it atomic).
#   Use: git commit -m "fix: handle empty query without crashing"
: "__FILL_ME_IN__ exercise 3b — replace this line with the fix: commit command above"

echo
echo "=== 4. Merge back to main with --no-ff (like merging a pull request) ==="
git switch --quiet main
# Exercise 4: merge the feature branch WITHOUT fast-forward so a merge commit
# is recorded (the shape of a merged pull request).
#   Use: git merge --no-ff -m "Merge branch 'feat/notes-search'" feat/notes-search
: "__FILL_ME_IN__ exercise 4 — replace this line with the git merge --no-ff command above"

echo
echo "=== 5. Tag an annotated release ==="
# Exercise 5: create an ANNOTATED tag for the first release. Choose the semver
# deliberately and record your reasoning in starter/workflow-worksheet.md.
#   Use: git tag -a v1.0.0 -m "First release: note search"
: "__FILL_ME_IN__ exercise 5 — replace this line with the git tag -a command above"

echo
echo "=== Tags ==="
git tag
echo "=== History (main) ==="
git log --oneline --decorate --graph
echo "=== Workflow demo complete ==="

# Workflow worksheet — Day 035

Fill this in as you complete `starter/workflow_demo.sh` (or as you run the
commands by hand in your own throwaway repository). It is the record of the
GitHub Flow cycle you ran, and it feeds the Versioned Notes Repository project.

## 1. Branch

- **Feature branch name I created:** `______________________`
  (Convention used in this lab: `feat/notes-search`. A good branch name is
  short and says what the work is.)
- **Command I used to create and switch to it:**

  ```bash
  ______________________________________________
  ```

## 2. Atomic commits (Conventional Commits)

Record each commit message you wrote. At least one `feat:` and one `fix:`.

| # | Type | Full commit message |
| - | ---- | ------------------- |
| 1 | chore | `chore: initialize notes repository with .gitignore` |
| 2 | feat  | `______________________________________________` |
| 3 | fix   | `______________________________________________` |

Why is each of these commits *atomic*? (One sentence.)

> ______________________________________________________________

## 3. Merge (like merging a pull request)

- **Merge command I used:**

  ```bash
  ______________________________________________
  ```

- **Why `--no-ff`?** (One sentence — what does the merge commit record?)

  > ______________________________________________________________

## 4. Release tag

- **Tag command I used:**

  ```bash
  ______________________________________________
  ```

- **Annotated or lightweight? Why that choice?**

  > ______________________________________________________________

## 5. The semantic version I chose — and why

I chose the version **`v______`**.

Justify each part as if explaining it to a teammate who will depend on the
number (2–4 sentences):

- **MAJOR (___):** ______________________________________________
- **MINOR (___):** ______________________________________________
- **PATCH (___):** ______________________________________________

## 6. Reflection

If you added a backward-compatible feature next, what would the version become,
and why?

> ______________________________________________________________

#!/usr/bin/env bash
# Tests for the Day 035 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Runs the workflow scripts (each in its own throwaway, network-free repo) and
# verifies the resulting history: a feature branch was merged into main, an
# annotated v1.0.0 tag exists, and the commits follow the feat:/fix:
# Conventional Commits convention. Exits 0 on success, non-zero on any failure.
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
}

# A workflow script proves its behavior through the history it prints. We run
# it, capture output, and assert on the merge, the tag, and the commit types.
run_workflow_checks() {
  local script="$1" output
  echo "Testing ${script} ..."
  if ! output="$(bash "${script}" 2>&1)"; then
    check "script exits successfully" "no"
    echo "${output}" | sed 's/^/    /'
    return
  fi
  check "script exits successfully" "yes"

  echo "${output}" | grep -q "Merge branch 'feat/notes-search'" \
    && check "feature branch merged into main (merge commit present)" "yes" \
    || check "feature branch merged into main (merge commit present)" "no"

  echo "${output}" | grep -q "tag: v1.0.0" \
    && check "annotated v1.0.0 tag pinned in history" "yes" \
    || check "annotated v1.0.0 tag pinned in history" "no"

  echo "${output}" | awk '/^=== Tags ===/{f=1;next} /^===/{f=0} f' | grep -qx "v1.0.0" \
    && check "git tag lists v1.0.0" "yes" \
    || check "git tag lists v1.0.0" "no"

  echo "${output}" | grep -q "feat: add case-insensitive note search" \
    && check "has a Conventional Commit feat: message" "yes" \
    || check "has a Conventional Commit feat: message" "no"

  echo "${output}" | grep -q "fix: handle empty query without crashing" \
    && check "has a Conventional Commit fix: message" "yes" \
    || check "has a Conventional Commit fix: message" "no"
}

# 1) The reference implementation must satisfy every behavioral check.
run_workflow_checks "${lab_dir}/examples/workflow_demo.sh"

# 2) The starter: only run it once the learner has completed the exercises;
#    while placeholders remain it cannot build a valid repo, so we check
#    structure instead.
echo "Testing starter/workflow_demo.sh ..."
if grep -q '__FILL_ME_IN__' "${lab_dir}/starter/workflow_demo.sh"; then
  echo "  Note: starter still has unfilled exercises — checking structure only."
  count="$(grep -c 'Exercise [0-9]' "${lab_dir}/starter/workflow_demo.sh")"
  [ "${count}" -ge 5 ] \
    && check "starter names all five exercises" "yes" \
    || check "starter names all five exercises" "no"
else
  run_workflow_checks "${lab_dir}/starter/workflow_demo.sh"
fi

# 3) Hard rule: lab scripts stay fully local — no network URLs anywhere.
if grep -rEn 'https?://' "${lab_dir}/examples" "${lab_dir}/starter" "${lab_dir}/tests" >/dev/null 2>&1; then
  check "lab scripts contain no network URLs" "no"
else
  check "lab scripts contain no network URLs" "yes"
fi

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