Hands-on lab — Day 9: Navigating the Filesystem: Paths, Files, and Permissions

#!/usr/bin/env bash
# Day 009 lab — completed reference implementation.
# Builds a small sample directory tree inside a temporary workspace created
# UNDER this lab directory, navigates it with pwd/cd/ls, creates and moves
# files, makes one file executable with chmod (showing the before/after
# `ls -l`), and then removes the whole temporary tree on exit via a trap.
#
# Nothing outside the temporary workspace is ever touched. Safe to re-run.
set -euo pipefail

# The lab directory is the parent of this script's directory (examples/..).
lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

# Create the temporary workspace INSIDE the lab directory, and register a
# trap so it is deleted whether the script succeeds, fails, or is interrupted.
workspace="$(mktemp -d "${lab_dir}/tmp.explore.XXXXXX")"
cleanup() { rm -rf "${workspace}"; }
trap cleanup EXIT

echo "=== Build and Explore a File Tree ==="
echo "Workspace: ${workspace}"
echo

# --- 1. Where are we, and build a small tree -------------------------------
cd "${workspace}"
echo "Working directory (pwd): $(pwd)"
mkdir -p project/data
echo "Created nested directories with: mkdir -p project/data"
echo

# --- 2. Create files and list the tree -------------------------------------
cd project
touch data/notes.txt report.md
echo "Created files: data/notes.txt and report.md"
echo "Contents of $(pwd) (ls):"
ls
echo
echo "Long listing including hidden entries (ls -la):"
ls -la
echo

# --- 3. Make a file executable and show the before/after -------------------
touch run.sh
chmod 644 run.sh          # normalize starting permissions for a stable demo
echo "Before chmod:"
ls -l run.sh
chmod 754 run.sh          # owner rwx, group r-x, other r-- => octal 754
echo "After chmod:"
ls -l run.sh
echo "The permission string changed to -rwxr-xr-- (octal 754): the execute bit is now set."
echo

# --- 4. Move a file and confirm its new location ---------------------------
mv report.md data/
echo "Moved report.md into data/ with: mv report.md data/"
echo "Current directory now contains (ls):"
ls
echo "data/ now contains (ls data):"
ls data
echo

echo "=== Done ==="
echo "The trap will now remove ${workspace}, leaving nothing behind."

lesson_id: D009
day: 9
kind: command-line-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-009-navigating-the-filesystem-paths-files-and
run_commands:
  - bash examples/explore_files.sh
  - bash starter/explore_files.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/explore_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 → 15 checks, 0 failure(s), exit 0; no tmp.explore.* left behind'

# Dependencies — Day 009 lab

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

- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution)
- Standard OS utilities: `mktemp`, `mkdir`, `touch`, `cp`, `mv`, `rm`, `ls`,
  `chmod`, `pwd`, and `find` — all part of the base system.

There is deliberately no `requirements.txt`/`package.json` here; the lab must
run on a factory-fresh machine. Windows users run the scripts inside WSL
(Windows Subsystem for Linux), which provides the same utilities.

#!/usr/bin/env bash
# Day 009 lab — build and explore a file tree (YOUR working file).
#
# The workspace machinery (a temporary directory created UNDER this lab
# directory, plus a trap that deletes it on exit) is already written for you
# and is SAFE: nothing outside the workspace is ever touched.
#
# Your task: complete the five numbered exercises below. Each one names the
# EXACT command to use in its comment. Replace the single placeholder line in
# each exercise (the one that echoes a marker) with that command. The completed
# reference version is in examples/explore_files.sh — try it yourself first,
# then compare.
#
# Note: this starter uses `set -u` (not the stricter `set -euo pipefail` of the
# reference) so that it still runs to completion while exercises are only partly
# filled in. Once every placeholder is replaced, it behaves exactly like the
# reference.
set -u

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

echo "=== Build and Explore a File Tree ==="
echo "Workspace: ${workspace}"
echo

cd "${workspace}"

# --- Exercise 1: print the working directory -------------------------------
# Replace the next line with the command:  pwd
echo -n "Working directory (pwd): "
echo "REPLACE-ME-1"
echo

# --- Exercise 2: build a nested directory tree -----------------------------
# Replace the next line with the command:  mkdir -p project/data
echo "REPLACE-ME-2"
echo "Created nested directories with: mkdir -p project/data"
echo

cd project

# --- Exercise 3: create two empty files ------------------------------------
# Replace the next line with the command:  touch data/notes.txt report.md
echo "REPLACE-ME-3"
echo "Contents of $(pwd) (ls):"
ls
echo
echo "Long listing including hidden entries (ls -la):"
ls -la
echo

# --- Exercise 4: make a file executable ------------------------------------
touch run.sh
chmod 644 run.sh          # normalize starting permissions (given)
echo "Before chmod:"
ls -l run.sh
# Replace the next line with the command:  chmod 754 run.sh
echo "REPLACE-ME-4"
echo "After chmod:"
ls -l run.sh
echo

# --- Exercise 5: move a file into the data directory -----------------------
# Replace the next line with the command:  mv report.md data/
echo "REPLACE-ME-5"
echo "Moved report.md into data/ with: mv report.md data/"
echo "Current directory now contains (ls):"
ls
echo "data/ now contains (ls data):"
ls data
echo

echo "=== Done ==="
echo "The trap will now remove ${workspace}, leaving nothing behind."

# Filesystem worksheet — Day 009

Fill in every value from your own machine using the commands from the
lesson. Keep this file — Week 2's shell-scripting lessons build on these
skills.

## 1. Your home directory

Run `cd ~` then `pwd`.

| Question | Your answer | Command you used |
| -------- | ----------- | ---------------- |
| Absolute path of your home directory |            | `cd ~ ; pwd`     |

## 2. The same file, two ways

Create a file (for example, `~/day9/hello.txt` via `mkdir -p ~/day9 && touch ~/day9/hello.txt`).
Then write its location two ways and confirm both reach the same file.

| Question | Your answer |
| -------- | ----------- |
| Absolute path to the file (starts with `/`) |            |
| Relative path to the file from one directory above it |            |
| Command you ran to confirm both point at the same file (e.g. `ls -l <path>`) |            |

## 3. A permission you set

Make a file executable: `chmod 754 ~/day9/hello.txt` (or your own file), then
`ls -l` it.

| Question | Your answer |
| -------- | ----------- |
| Full permission string from `ls -l` (e.g. `-rwxr-xr--`) |            |
| Octal number for that string |            |
| Owner triad → octal (show the arithmetic, e.g. r+w+x = 4+2+1 = 7) |            |
| Group triad → octal (show the arithmetic) |            |
| Other triad → octal (show the arithmetic) |            |

## 4. In your own words

In two or three sentences, explain why the execute (`x`) bit is what
separates a plain data file from a runnable script.

_Your answer:_

#!/usr/bin/env bash
# Tests for the Day 009 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the reference script builds the sample tree, makes a file
# executable (before/after permission strings), prints the required lines,
# exits 0, and leaves NOTHING behind (its temporary workspace is removed).
# The starter is checked the same way once its exercises are completed.
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
}

count_workspaces() {
  # How many leftover temp workspaces exist directly under the lab directory.
  find "${lab_dir}" -maxdepth 1 -type d -name 'tmp.explore.*' 2>/dev/null | wc -l | tr -d ' '
}

run_script_checks() {
  local script="$1" strict="$2" output before after
  echo "Testing ${script} ..."

  before="$(count_workspaces)"
  if ! output="$(bash "${script}" 2>&1)"; then
    check "script exits successfully" "no"
    echo "${output}" | sed 's/^/    /'
    return
  fi
  check "script exits successfully" "yes"
  after="$(count_workspaces)"

  echo "${output}" | grep -q '^=== Build and Explore a File Tree ===$' \
    && check "prints the lab header" "yes" || check "prints the lab header" "no"
  echo "${output}" | grep -q '^=== Done ===$' \
    && check "prints the done footer" "yes" || check "prints the done footer" "no"

  # Leaves nothing behind: no new workspace directory remains.
  if [ "${after}" -le "${before}" ]; then
    check "removes its temporary workspace (leaves nothing behind)" "yes"
  else
    check "removes its temporary workspace (leaves nothing behind)" "no"
  fi

  if [ "${strict}" = "strict" ]; then
    # The sample tree was built: mkdir and a listing that includes data/.
    echo "${output}" | grep -q 'mkdir -p project/data' \
      && check "builds the nested directory tree" "yes" || check "builds the nested directory tree" "no"
    echo "${output}" | grep -Eq '(^| )data( |$)' \
      && check "sample tree lists the data directory" "yes" || check "sample tree lists the data directory" "no"

    # A file became executable: before shows no x for owner, after shows -rwx.
    echo "${output}" | grep -q '^Before chmod:$' \
      && check "shows the 'Before chmod:' listing" "yes" || check "shows the 'Before chmod:' listing" "no"
    echo "${output}" | grep -q '^After chmod:$' \
      && check "shows the 'After chmod:' listing" "yes" || check "shows the 'After chmod:' listing" "no"
    echo "${output}" | grep -q -- '-rw-r--r--.*run\.sh' \
      && check "before: run.sh is not executable (-rw-r--r--)" "yes" || check "before: run.sh is not executable (-rw-r--r--)" "no"
    echo "${output}" | grep -q -- '-rwxr-xr--.*run\.sh' \
      && check "after: run.sh is executable (-rwxr-xr--, octal 754)" "yes" || check "after: run.sh is executable (-rwxr-xr--, octal 754)" "no"

    # A file was moved into data/.
    echo "${output}" | grep -q 'Moved report.md into data/\|report.md into data' \
      && check "moves report.md into data/" "yes" || check "moves report.md into data/" "no"
  fi
}

run_script_checks "${lab_dir}/examples/explore_files.sh" strict

# The starter ships with REPLACE-ME placeholders on purpose; once the learner
# has replaced them all, hold their script to the same strict standard.
if grep -q 'REPLACE-ME' "${lab_dir}/starter/explore_files.sh"; then
  echo "Note: starter/explore_files.sh still has unfinished exercises — testing structure only."
  run_script_checks "${lab_dir}/starter/explore_files.sh" lenient
else
  run_script_checks "${lab_dir}/starter/explore_files.sh" strict
fi

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