Hands-on lab — Day 14: Automating Tasks with Shell Scripts and cron

#!/usr/bin/env bash
# Day 014 lab — completed reference implementation.
#
# Organize a directory by sorting its files into subfolders named for their
# file extension. Designed to be SAFE to run unattended and on a schedule:
#   * --dry-run   previews every action and changes nothing
#   * logging     appends one timestamped line per real move to organize.log
#   * idempotent  a second run moves nothing, because sorted files now live
#                 in subfolders that the top-level scan does not descend into
#
# Usage:
#   organize_files.sh [--dry-run] <directory>
#
# This script only ever touches the directory you give it. It never edits
# your crontab or any system setting.
set -euo pipefail

usage() {
  echo "Usage: $(basename "$0") [--dry-run] <directory>"
  echo "  Sort files in <directory> into subfolders by extension."
  echo "  --dry-run   print what would happen without moving anything"
}

# --- parse arguments -------------------------------------------------------
dry_run=false
target=""
for arg in "$@"; do
  case "$arg" in
    --dry-run) dry_run=true ;;
    -h|--help) usage; exit 0 ;;
    -*) echo "error: unknown option: $arg" >&2; usage >&2; exit 2 ;;
    *)  target="$arg" ;;
  esac
done

if [ -z "$target" ]; then
  echo "error: no target directory given" >&2
  usage >&2
  exit 2
fi
if [ ! -d "$target" ]; then
  echo "error: not a directory: $target" >&2
  exit 2
fi

log="$target/organize.log"
prefix=""
$dry_run && prefix="[dry-run] "

# Track which extension folders we have already announced in a dry run,
# since dry-run never actually creates the directory.
announced=" "

count=0
for path in "$target"/*; do
  # Only consider regular files that sit directly in the target directory.
  [ -f "$path" ] || continue

  base="$(basename "$path")"

  # Skip our own log file so we never sort the log into a "log/" folder.
  [ "$base" = "organize.log" ] && continue

  # Skip dotfiles and anything without a clear extension (no dot in the name).
  case "$base" in
    .*) continue ;;      # hidden files like .gitkeep
    *.*) : ;;            # has an extension — proceed
    *) continue ;;       # no extension at all — leave it alone
  esac

  # Extension = text after the final dot, lowercased for tidy folder names.
  ext="$(printf '%s' "${base##*.}" | tr '[:upper:]' '[:lower:]')"
  dest="$target/$ext"

  # Announce (dry-run) or create (real) the destination folder once.
  if [ ! -d "$dest" ] && [[ "$announced" != *" $ext "* ]]; then
    if $dry_run; then
      echo "${prefix}would create directory: $dest"
    else
      mkdir -p "$dest"
    fi
    announced="$announced$ext "
  fi

  # Idempotency guard: only move if the file is not already in its folder.
  if [ "$(cd "$(dirname "$path")" && pwd)" = "$(cd "$dest" 2>/dev/null && pwd || echo "$dest")" ]; then
    continue
  fi

  count=$((count + 1))
  if $dry_run; then
    echo "${prefix}would move $base -> $ext/"
  else
    mv "$path" "$dest/"
    echo "moved $base -> $ext/"
    echo "$(date '+%F %T') moved $base -> $ext/" >> "$log"
  fi
done

if $dry_run; then
  echo "${prefix}complete: $count file(s) would be organized, 0 changes made"
else
  echo "complete: $count file(s) organized"
  echo "$(date '+%F %T') run complete: $count file(s) organized" >> "$log"
fi

# Scheduling the organizer with cron — read, understand, opt in later

This file shows how you *would* run `organize_files.sh` on a schedule. You do
**not** have to install any of these, and this lab never edits your crontab for
you. Read the examples to understand the syntax; if and when you want a real
scheduled job, you add it yourself, deliberately, with `crontab -e`.

## The shape of a crontab line

```text
┌── minute (0–59)
│ ┌── hour (0–23)
│ │ ┌── day of month (1–31)
│ │ │ ┌── month (1–12)
│ │ │ │ ┌── day of week (0–7, 0 and 7 = Sunday)
│ │ │ │ │
* * * * *   command to run
```

Always use **absolute paths** in a crontab line: cron runs with a bare
environment and an unpredictable working directory, so `~/Downloads` or a
relative script path may not resolve. Spell everything out.

## Ready-to-read examples

Organize your Downloads folder **every day at 8:00 p.m.**:

```text
0 20 * * * /usr/bin/env bash /Users/you/labs/.../examples/organize_files.sh "$HOME/Downloads"
```

Organize it **every Monday at 6:00 a.m.**:

```text
0 6 * * 1 /usr/bin/env bash /Users/you/labs/.../examples/organize_files.sh "$HOME/Downloads"
```

Organize it **every 15 minutes during weekday business hours** (a busy shared
folder):

```text
*/15 9-17 * * 1-5 /usr/bin/env bash /path/to/organize_files.sh "$HOME/Inbox"
```

Preview instead of acting — a **daily dry run** whose output you can inspect,
useful while you still don't fully trust a job:

```text
0 20 * * * /usr/bin/env bash /path/to/organize_files.sh --dry-run "$HOME/Downloads" >> "$HOME/organize-dryrun.log" 2>&1
```

The trailing `>> file 2>&1` sends both normal output and errors to a log file
you own, which is exactly how unattended jobs keep a record you can read the
next morning.

## How to add one yourself (only if you choose to)

```bash
crontab -l          # list your current jobs (may be empty — that is normal)
crontab -e          # open your crontab in an editor; add ONE line; save; quit
crontab -l          # confirm the line is there
```

To remove it later, run `crontab -e` again and delete the line. On macOS the
modern, recommended scheduler is `launchd` rather than cron; on Linux you may
prefer a `systemd` timer. The five-field idea above is the same in all of
them — learn it once, read them all.

## Safety reminder

Only ever schedule a script you have **read**, that supports **--dry-run**, and
that **logs** what it does. Run it by hand (and in dry-run) several times first.
A scheduled job runs faithfully, unattended, for as long as you leave it in the
table — make sure it is a job you trust that much.

lesson_id: D014
day: 14
kind: shell-scripting
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-014-automating-tasks-with-shell-scripts-and
run_commands:
  - bash examples/organize_files.sh --dry-run ~/organize-demo
  - bash examples/organize_files.sh ~/organize-demo
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'rm -rf ~/organize-demo  # remove the scratch folder you created for practice'
  - 'git checkout -- starter/organize_files.sh  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), bash tests/run_tests.sh → 18 checks, 0 failure(s)'

# Dependencies — Day 014 lab

**None beyond a POSIX shell.** This lab has zero installable dependencies:

- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution)
- Standard OS utilities only: `basename`, `dirname`, `mkdir`, `mv`, `tr`,
  `date`, `find` — all part of the base system.

There is deliberately no `requirements.txt` / `package.json` here: the lab runs
on a factory-fresh machine with nothing installed.

No scheduler is required or configured. The lab **reads about** cron, launchd,
systemd timers, and Task Scheduler but installs none of them and never edits
your crontab. If you later choose to schedule the script yourself, `crontab`
(part of cron) already ships with macOS and Linux — but that is optional and
outside the tested lab.

# Automation worksheet — Day 014

Fill this in as you work through the lesson and lab. It feeds directly into
the Week 2 project (a Personal Automation Script). Nothing here touches your
real crontab — you are writing and reading schedules on paper, not installing
them.

## Part 1 — Write two cron expressions

Using only the five-field definition (minute, hour, day-of-month, month,
day-of-week), write the crontab line for each schedule and explain every
field. The command to run in both cases is:

```text
/usr/bin/env bash /absolute/path/to/organize_files.sh "$HOME/Downloads"
```

### 1a. Every day at 8:00 p.m.

```text
Your cron expression:  ____  ____  ____  ____  ____   <command>
```

| Field | Your value | What it means |
| ----- | ---------- | ------------- |
| minute | | |
| hour | | |
| day of month | | |
| month | | |
| day of week | | |

### 1b. Every Monday at 6:00 a.m.

```text
Your cron expression:  ____  ____  ____  ____  ____   <command>
```

| Field | Your value | What it means |
| ----- | ---------- | ------------- |
| minute | | |
| hour | | |
| day of month | | |
| month | | |
| day of week | | |

## Part 2 — Predict the dry-run output

Suppose the target folder contains exactly these entries before you run the
script:

```text
budget.xlsx
photo1.JPG
photo2.jpg
readme
notes.txt
.gitkeep
organize.log
```

Predict the dry-run output **before running anything**. Answer these:

1. Which subfolders would the script create? (List the extension names.)
   Your answer: ______________________________________________

2. Which files would it report it "would move," and to which folder each?
   Your answer: ______________________________________________

3. Which entries would it skip entirely, and why?
   Your answer: ______________________________________________

4. How many files would the summary line report? ______

> Hints, from the script's rules: extensions are **lowercased** (so `photo1.JPG`
> sorts to `jpg/`, the same folder as `photo2.jpg`); files with **no dot** in
> the name are skipped; **dotfiles** (names starting with `.`) are skipped; and
> the script never sorts its own `organize.log`.

## Part 3 — Check your prediction

Create a scratch folder, recreate the listing above, and run the real script
in dry-run mode. Compare its output with your Part 2 answers.

```bash
mkdir -p ~/organize-demo && cd ~/organize-demo
touch budget.xlsx photo1.JPG photo2.jpg readme notes.txt .gitkeep organize.log
bash /path/to/lab/examples/organize_files.sh --dry-run ~/organize-demo
```

Note any difference between your prediction and the actual output here:

```text
Differences (if any): ______________________________________
```

#!/usr/bin/env bash
# Day 014 lab — YOUR working file.
#
# Build a safe file-organizing script step by step. The skeleton already
# parses arguments and loops over the directory's files; your job is to fill
# in the five numbered exercises below so the script sorts files by extension,
# supports a --dry-run preview, logs its moves, and is safe to run twice.
#
# The completed reference version is in examples/organize_files.sh — try to
# finish this yourself first, then compare.
#
# Usage:  organize_files.sh [--dry-run] <directory>
#
# This script must ONLY touch the directory you give it. It never edits your
# crontab or any system setting.
set -euo pipefail

usage() {
  echo "Usage: $(basename "$0") [--dry-run] <directory>"
}

# --- argument parsing (already done for you) -------------------------------
dry_run=false
target=""
for arg in "$@"; do
  case "$arg" in
    --dry-run) dry_run=true ;;
    -h|--help) usage; exit 0 ;;
    -*) echo "error: unknown option: $arg" >&2; usage >&2; exit 2 ;;
    *)  target="$arg" ;;
  esac
done

if [ -z "$target" ] || [ ! -d "$target" ]; then
  echo "error: give one existing directory to organize" >&2
  usage >&2
  exit 2
fi

log="$target/organize.log"
prefix=""
$dry_run && prefix="[dry-run] "
announced=" "
count=0

for path in "$target"/*; do
  [ -f "$path" ] || continue
  base="$(basename "$path")"
  [ "$base" = "organize.log" ] && continue

  # Exercise 1 (SKIP FILES WITH NO EXTENSION):
  #   Skip dotfiles (names starting with '.') and any file with no dot in its
  #   name, so files without a clear extension are left alone. Use a `case`:
  #     case "$base" in .*) continue ;; *.*) : ;; *) continue ;; esac
  case "$base" in
    .*) continue ;;
    *) : ;;            # <-- replace this line to also skip names with no dot
  esac

  # Exercise 2 (COMPUTE THE EXTENSION AND DESTINATION):
  #   Set `ext` to the text after the final dot, lowercased, and `dest` to a
  #   subfolder of "$target" named for that extension. Hints:
  #     ext="$(printf '%s' "${base##*.}" | tr '[:upper:]' '[:lower:]')"
  #     dest="$target/$ext"
  ext="unknown"
  dest="$target/$ext"

  # Exercise 3 (CREATE OR ANNOUNCE THE FOLDER):
  #   If the destination does not exist and has not been announced yet, then
  #   in dry-run mode print   "${prefix}would create directory: $dest"
  #   and in real mode run    mkdir -p "$dest"
  #   Record it:              announced="$announced$ext "
  if [ ! -d "$dest" ] && [[ "$announced" != *" $ext "* ]]; then
    : # <-- add the dry-run echo / real mkdir here, then record it in announced
    announced="$announced$ext "
  fi

  count=$((count + 1))

  # Exercise 4 (MOVE OR PREVIEW, WITH LOGGING):
  #   In dry-run mode print   "${prefix}would move $base -> $ext/"
  #   In real mode:           mv "$path" "$dest/"
  #                           echo "moved $base -> $ext/"
  #                           and append a timestamped line to "$log":
  #                           echo "$(date '+%F %T') moved $base -> $ext/" >> "$log"
  if $dry_run; then
    : # <-- print the "would move" line
  else
    : # <-- move the file, echo it, and append to the log
  fi
done

# Exercise 5 (PRINT THE SUMMARY):
#   In dry-run mode print:  "${prefix}complete: $count file(s) would be organized, 0 changes made"
#   In real mode print:     "complete: $count file(s) organized"
#   (and, in real mode, append the same summary to "$log")
if $dry_run; then
  echo "(exercise 5: print the dry-run summary here)"   # <-- replace this line
else
  echo "(exercise 5: print the real-run summary here)"  # <-- replace this line
fi

#!/usr/bin/env bash
# Tests for the Day 014 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies the completed reference organizer (examples/organize_files.sh):
#   * --dry-run previews actions and moves NOTHING
#   * a real run sorts files into subfolders named for their extension
#   * every real move is recorded in organize.log
#   * a second real run is idempotent (moves nothing)
#
# The tests operate ONLY inside a fresh temp directory created with mktemp and
# removed on exit. They never read, write, or touch cron, launchd, systemd, or
# anything outside that temp directory.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
script="${lab_dir}/examples/organize_files.sh"
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
}

# --- isolated sandbox ------------------------------------------------------
work="$(mktemp -d)"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT

sandbox="${work}/messy"
mkdir -p "${sandbox}"
# Known mixed files, including case and extension variety.
touch "${sandbox}/report.pdf" \
      "${sandbox}/notes.txt" \
      "${sandbox}/photo.JPG" \
      "${sandbox}/data.csv" \
      "${sandbox}/archive.zip"
before_listing="$(cd "${sandbox}" && ls | sort | tr '\n' ' ')"

echo "Testing dry-run mode (must change nothing) ..."
dry_out="$(bash "${script}" --dry-run "${sandbox}" 2>&1)"
check "dry-run exits successfully" "$([ $? -eq 0 ] && echo yes || echo no)"
echo "${dry_out}" | grep -q "would move report.pdf -> pdf/" && check "dry-run previews a move" "yes" || check "dry-run previews a move" "no"
echo "${dry_out}" | grep -q "0 changes made" && check "dry-run reports 0 changes made" "yes" || check "dry-run reports 0 changes made" "no"
after_dry="$(cd "${sandbox}" && ls | sort | tr '\n' ' ')"
[ "${before_listing}" = "${after_dry}" ] && check "dry-run left the folder untouched" "yes" || check "dry-run left the folder untouched" "no"
[ ! -e "${sandbox}/pdf" ] && check "dry-run created no subfolders" "yes" || check "dry-run created no subfolders" "no"
[ ! -e "${sandbox}/organize.log" ] && check "dry-run wrote no log" "yes" || check "dry-run wrote no log" "no"

echo "Testing real run (must sort files by extension) ..."
real_out="$(bash "${script}" "${sandbox}" 2>&1)"
check "real run exits successfully" "$([ $? -eq 0 ] && echo yes || echo no)"
[ -f "${sandbox}/pdf/report.pdf" ] && check "report.pdf landed in pdf/" "yes" || check "report.pdf landed in pdf/" "no"
[ -f "${sandbox}/txt/notes.txt" ] && check "notes.txt landed in txt/" "yes" || check "notes.txt landed in txt/" "no"
[ -f "${sandbox}/jpg/photo.JPG" ] && check "photo.JPG landed in jpg/ (extension lowercased)" "yes" || check "photo.JPG landed in jpg/ (extension lowercased)" "no"
[ -f "${sandbox}/csv/data.csv" ] && check "data.csv landed in csv/" "yes" || check "data.csv landed in csv/" "no"
[ -f "${sandbox}/zip/archive.zip" ] && check "archive.zip landed in zip/" "yes" || check "archive.zip landed in zip/" "no"
[ -z "$(find "${sandbox}" -maxdepth 1 -type f ! -name organize.log)" ] && check "no loose files remain at the top level" "yes" || check "no loose files remain at the top level" "no"

echo "Testing logging ..."
if [ -f "${sandbox}/organize.log" ]; then
  check "organize.log was created" "yes"
  logged="$(grep -c "moved .* -> " "${sandbox}/organize.log")"
  [ "${logged}" -ge 5 ] && check "log records at least 5 moves" "yes" || check "log records at least 5 moves" "no"
else
  check "organize.log was created" "no"
  check "log records at least 5 moves" "no"
fi

echo "Testing idempotency (second real run must move nothing) ..."
second_out="$(bash "${script}" "${sandbox}" 2>&1)"
check "second run exits successfully" "$([ $? -eq 0 ] && echo yes || echo no)"
echo "${second_out}" | grep -q "0 file(s) organized" && check "second run organizes 0 files" "yes" || check "second run organizes 0 files" "no"

echo "Confirming isolation ..."
[ -d "${work}" ] && check "all work stayed inside the temp sandbox" "yes" || check "all work stayed inside the temp sandbox" "no"

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