Hands-on lab — Day 38: Regular Expressions

#!/usr/bin/env bash
# Day 038 lab — worked regex drills with grep -E and sed -E.
#
# This is the completed REFERENCE script. It runs entirely offline against the
# committed sample file examples/samples/data.txt and demonstrates the four
# everyday regex jobs: extract, count, extract-with-groups, and reformat.
# Read each pattern's explanation, run the script, then rebuild it yourself in
# starter/regex_drills.sh.
#
# We use grep -E (extended regex) and sed -E throughout, and POSIX character
# classes like [0-9] and [[:alnum:]] rather than the PCRE shorthands \d and \w,
# because the POSIX forms behave the same in BSD grep/sed (macOS) and GNU
# grep/sed (Linux). See troubleshooting.md for the dialect differences.
set -euo pipefail

# Resolve the sample file relative to this script, so the drills run from any
# working directory.
script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
sample="${script_dir}/samples/data.txt"

echo "=== Drill 1: extract every email address ==="
# Pattern, piece by piece:
#   [[:alnum:]._%+-]+   one or more letters/digits/dot/underscore/percent/plus/hyphen  (the local part)
#   @                   a literal @ sign
#   [[:alnum:].-]+      one or more letters/digits/dot/hyphen                           (the domain name)
#   \.                  a LITERAL dot (escaped — an unescaped . matches any character)
#   [[:alpha:]]{2,}     two or more letters                                            (the top-level domain)
# -o prints only the matched text, not the whole line.
grep -E -o '[[:alnum:]._%+-]+@[[:alnum:].-]+\.[[:alpha:]]{2,}' "${sample}"
echo

echo "=== Drill 2: count lines that contain a YYYY-MM-DD date ==="
# [0-9]{4}-[0-9]{2}-[0-9]{2}  four digits, hyphen, two digits, hyphen, two digits.
# -c counts MATCHING LINES rather than printing them. Note: this checks the
# SHAPE of a date, not whether the month and day are real calendar values.
grep -E -c '[0-9]{4}-[0-9]{2}-[0-9]{2}' "${sample}"
echo

echo "=== Drill 3: extract every IP-ish address ==="
# ([0-9]{1,3}\.){3}   a group of "1-3 digits then a literal dot", repeated 3 times
#   [0-9]{1,3}        a final 1-3 digit number
# This matches the SHAPE of an IPv4 address. It also matches impossible octets
# like 999.999.999.999 — good enough to extract from logs you trust, not to
# validate untrusted input.
grep -E -o '([0-9]{1,3}\.){3}[0-9]{1,3}' "${sample}"
echo

echo "=== Drill 4: reformat a date field with capture groups (sed backreferences) ==="
# Turn YYYY/MM/DD into YYYY-MM-DD.
#   ([0-9]{4})/([0-9]{2})/([0-9]{2})   capture year, month, day into groups 1, 2, 3
#   \1-\2-\3                           rebuild them joined by hyphens
# We use '#' as the sed delimiter instead of the usual '/' so the slashes in the
# date do not clash with sed's own syntax.
echo '2026/07/12' | sed -E 's#([0-9]{4})/([0-9]{2})/([0-9]{2})#\1-\2-\3#'
echo

echo "=== Done. Compare these results with the counts in the README. ==="

# Synthetic sample data for the Day 38 regex lab.
# Every name, address, phone number, and IP below is fictional and for practice only.
# Lines beginning with '#' are comments.
#
# --- Section 1: contacts ---
Ada Lovelace <ada.lovelace@example.com> joined 2026-01-15
Grace Hopper <grace.hopper@example.org> joined 2026-02-03
Alan Turing <alan.turing@example.net> joined 2026-03-21
Katherine Johnson, katherine.johnson@example.com, phone 555-0142
Edsger Dijkstra, edsger.dijkstra@example.org, phone (555) 867-5309
#
# --- Section 2: phone list (synthetic) ---
Support line: 555-0100
Fax (old): 555-0199
Mobile: 555-234-5678
#
# --- Section 3: access log (synthetic IPs and status codes) ---
192.168.1.44 - - [2026-07-12] "GET /health" 200
10.0.0.7 - - [2026-07-12] "POST /login" 401
172.16.5.9 - - [2026-07-12] "GET /report" 200
192.168.1.44 - - [2026-07-13] "GET /data.csv" 404
10.0.0.7 - - [2026-07-13] "GET /health" 500
#
# --- Section 4: mixed notes ---
Renewal due 2026-11-30 for account #4821 (pending)
No date on this line, just some plain text.
Contact backup: mission.control@example.net

lesson_id: D038
day: 38
kind: conversion-exercises
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-038-regular-expressions
run_commands:
  - bash examples/regex_drills.sh
  - bash starter/regex_drills.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/regex_drills.sh starter/regex-worksheet.md  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon, BSD grep/sed), bash tests/run_tests.sh → 8 checks, 0 failure(s).'

# Dependencies — Day 038 lab

**None beyond a POSIX shell with `grep` and `sed`.** This lab has zero
installable dependencies:

- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution)
- `grep` with the `-E` (extended regex) option — preinstalled everywhere
- `sed` with the `-E` (extended regex) option — preinstalled on macOS (BSD sed)
  and Linux (GNU sed)

There is deliberately no `requirements.txt`/`package.json`: every tool used
ships with the operating system, nothing reaches the network, and no account or
API key is required. The lab only *reads* the committed sample file and prints
to your terminal.

If `grep -E` or `sed -E` is somehow missing (extremely minimal containers),
install `grep` and `sed` from your package manager (`apt install grep sed` on
Debian/Ubuntu). See `../troubleshooting.md` for BSD-vs-GNU differences.

#!/usr/bin/env bash
# Day 038 lab — YOUR regex drills.
#
# Four numbered exercises. Each has a pattern placeholder set to
# WRITE_YOUR_PATTERN_HERE. Replace each placeholder with a working extended
# regular expression, then run:  bash starter/regex_drills.sh
#
# Use grep -E and sed -E, and prefer POSIX classes ([0-9], [[:alpha:]]) over the
# PCRE shorthands \d and \w so your patterns work in both BSD (macOS) and GNU
# (Linux) tools. The completed reference is in examples/regex_drills.sh — try it
# yourself before peeking. Expected results are in the README's "Expected output".
set -uo pipefail

script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
sample="${script_dir}/../examples/samples/data.txt"

echo "=== Exercise 1: extract every phone-ish number ==="
# Phone numbers in the sample look like 555-0142, 555-0100, 867-5309, 234-5678.
# Write a pattern for "three digits, a hyphen, four digits" and pass it to
# grep -E -o. Expected: 5 matches.
EX1_PATTERN="WRITE_YOUR_PATTERN_HERE"   # hint: [0-9]{3}-[0-9]{4}
grep -E -o "${EX1_PATTERN}" "${sample}" || echo "(no matches yet — fill in EX1_PATTERN)"
echo

echo "=== Exercise 2: extract just the status codes from the log lines ==="
# The access-log lines end with a quoted request then a 3-digit status code,
# e.g.  "GET /health" 200 . Beware: several phone lines also end in digits, so
# a naive [0-9]{3}$ would match those too. First keep only log lines (they
# contain a quote followed by a space and three digits at end of line), then
# extract the trailing 3-digit code. Expected: 200 401 200 404 500.
EX2_SELECT="WRITE_YOUR_PATTERN_HERE"    # hint: " [0-9]{3}$   (selects log lines)
EX2_EXTRACT="WRITE_YOUR_PATTERN_HERE"   # hint: [0-9]{3}$     (pulls the code)
grep -E "${EX2_SELECT}" "${sample}" | grep -E -o "${EX2_EXTRACT}" || echo "(fill in EX2 patterns)"
echo

echo "=== Exercise 3: count how many lines are NOT comments ==="
# Comment lines begin with '#'. Use grep with -c (count) and -v (invert match)
# and an anchor to count every line that does NOT start with '#'. Expected: 16.
EX3_PATTERN="WRITE_YOUR_PATTERN_HERE"   # hint: ^#
grep -E -c -v "${EX3_PATTERN}" "${sample}" || echo "(fill in EX3_PATTERN)"
echo

echo "=== Exercise 4: reformat a day-first date with capture groups ==="
# Turn a day-first date like 12-07-2026 into ISO order 2026-07-12 by capturing
# the three fields and rebuilding them in a new order with backreferences.
# Fill in EX4_FIND (three capture groups) and EX4_REPLACE (\3-\2-\1).
EX4_FIND="WRITE_YOUR_PATTERN_HERE"      # hint: ([0-9]{2})-([0-9]{2})-([0-9]{4})
EX4_REPLACE="WRITE_YOUR_PATTERN_HERE"   # hint: \3-\2-\1
echo '12-07-2026' | sed -E "s#${EX4_FIND}#${EX4_REPLACE}#"
echo

echo "=== Done. Compare with the README's Expected output. ==="

# Regex worksheet — Day 038

Fill this in as you work through the lab. Write your patterns in the code spans
and record the counts you get. The sample file is
`../examples/samples/data.txt` (relative to this `starter/` directory).

## 1. Write the pattern for an email address

Write an extended-regex pattern that extracts every email address from the
sample with `grep -E -o`.

- My pattern: `______________________________________________`
- Command I ran: `grep -E -o '______' ../examples/samples/data.txt`
- Number of addresses it found: `____`

> One-sentence note on what your pattern does NOT guarantee (hint: think about
> what "a valid email address" really requires):
>
> _______________________________________________________________

## 2. Write the pattern for a YYYY-MM-DD date

Write a pattern that matches an ISO date such as `2026-07-12`.

- My pattern: `______________________________________________`
- One thing about dates this pattern does NOT verify: `__________________`

## 3. Count how many lines match a pattern of your choice

Pick any pattern (an IP address, a phone number, lines containing `@`, lines
that are comments, …) and use `grep -E -c` to count the matching lines.

- Pattern I chose: `______________________________________________`
- What it is meant to match (in words): `__________________________`
- Command: `grep -E -c '______' ../examples/samples/data.txt`
- Count returned: `____`

## 4. Reflection (2–3 sentences)

Which was harder to get right: describing the shape you wanted, or avoiding
matches you did not want? Give one example from this lab where a pattern was
"too loose" (matched something unintended) or "too tight" (missed something)
and how you fixed it.

_______________________________________________________________________

_______________________________________________________________________

#!/usr/bin/env bash
# Tests for the Day 038 regex lab. Run from anywhere:
#   bash tests/run_tests.sh
#
# Verifies that the reference drills extract the KNOWN correct counts from the
# committed synthetic sample, and that the example script runs clean. No
# network, no writes outside stdout. Exits 0 on success, non-zero on any
# failure, so it is safe for CI.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
sample="${lab_dir}/examples/samples/data.txt"
example="${lab_dir}/examples/regex_drills.sh"
failures=0
checks=0

check() {
  local label="$1" expected="$2" actual="$3"
  checks=$((checks + 1))
  if [ "${expected}" = "${actual}" ]; then
    echo "  ok: ${label} (${actual})"
  else
    echo "  FAIL: ${label} — expected '${expected}', got '${actual}'"
    failures=$((failures + 1))
  fi
}

echo "Checking the committed sample exists ..."
if [ ! -f "${sample}" ]; then
  echo "  FAIL: sample file not found at ${sample}"
  echo
  echo "1 checks, 1 failure(s)."
  exit 1
fi
echo "  ok: ${sample}"

echo "Checking known counts from the sample ..."

# Drill 1: email addresses (expected 6)
emails="$(grep -E -o '[[:alnum:]._%+-]+@[[:alnum:].-]+\.[[:alpha:]]{2,}' "${sample}" | grep -c .)"
check "email addresses extracted" "6" "${emails}"

# Drill 2: lines containing a YYYY-MM-DD date (expected 9)
dated="$(grep -E -c '[0-9]{4}-[0-9]{2}-[0-9]{2}' "${sample}")"
check "lines with a YYYY-MM-DD date" "9" "${dated}"

# Drill 3: IP-ish addresses (expected 5)
ips="$(grep -E -o '([0-9]{1,3}\.){3}[0-9]{1,3}' "${sample}" | grep -c .)"
check "IP-ish addresses extracted" "5" "${ips}"

# Status codes from log lines (expected 5): select log lines, then pull the code
codes="$(grep -E '" [0-9]{3}$' "${sample}" | grep -E -o '[0-9]{3}$' | grep -c .)"
check "status codes from log lines" "5" "${codes}"

# Non-comment lines (expected 16)
noncomment="$(grep -E -c -v '^#' "${sample}")"
check "non-comment lines" "16" "${noncomment}"

# Drill 4: sed reformat of a slash date to a hyphen date
reformatted="$(echo '2026/07/12' | sed -E 's#([0-9]{4})/([0-9]{2})/([0-9]{2})#\1-\2-\3#')"
check "sed backreference reformat" "2026-07-12" "${reformatted}"

echo "Checking the example drills script runs clean ..."
if out="$(bash "${example}" 2>&1)"; then
  check "examples/regex_drills.sh exits 0" "yes" "yes"
else
  check "examples/regex_drills.sh exits 0" "yes" "no"
  echo "${out}" | sed 's/^/    /'
fi
# The example output must contain the reformatted date it demonstrates.
if echo "${out}" | grep -q '2026-07-12'; then
  check "example output shows reformatted date" "yes" "yes"
else
  check "example output shows reformatted date" "yes" "no"
fi

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