Hands-on lab — Day 36: Choosing and Configuring a Code Editor

#!/usr/bin/env bash
# Day 036 lab — completed reference implementation.
#
# Builds a small sample project with deliberately messy files, writes an
# .editorconfig with the standard formatting rules, then checks every file
# against those rules using grep/awk and reports the violations. This is a
# real, editor-agnostic config check: no editor and no network are needed.
#
# The sample project lives in a temporary directory that is deleted on exit,
# so this script writes nothing permanent to your machine.
set -euo pipefail

# --- 1. Create an isolated sample project (cleaned up on exit) ------------
project_dir="$(mktemp -d "${TMPDIR:-/tmp}/editorconfig-demo.XXXXXX")"
cleanup() {
  echo "Cleaning up temporary project."
  rm -rf "${project_dir}"
}
trap cleanup EXIT

echo "=== EditorConfig demo ==="
echo "Created sample project in: ${project_dir}"

# A clean file: two-space indentation, no trailing whitespace, ends in a newline.
printf 'def greet(name):\n  return "Hi " + name\n' >"${project_dir}/clean.py"

# A file indented with a TAB instead of spaces (breaks indent_style = space).
printf 'def greet(name):\n\treturn "Hi " + name\n' >"${project_dir}/tabs.py"

# A file with trailing whitespace on two lines (breaks trim_trailing_whitespace).
printf 'x = 1  \ny = 2 \n' >"${project_dir}/trailing.py"

# A file with NO final newline (breaks insert_final_newline).
printf 'z = 3' >"${project_dir}/no_newline.py"

# --- 2. Write the .editorconfig the whole team would share ----------------
cat >"${project_dir}/.editorconfig" <<'EOF'
root = true

[*]
indent_style = space
indent_size = 2
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
charset = utf-8
EOF
echo "Wrote .editorconfig with 6 rules."
echo

# --- 3. Check each file against the rules using grep/awk ------------------
# The three checks below mirror three .editorconfig keys:
#   indent_style = space      -> no leading tabs
#   trim_trailing_whitespace  -> no trailing spaces/tabs
#   insert_final_newline      -> file ends with a newline
check_file() {
  local file="$1" name violations
  name="$(basename "${file}")"
  violations=""

  # indent_style = space: any line that begins with a tab is a violation.
  if awk 'index($0, "\t") == 1 { found = 1 } END { exit !found }' "${file}"; then
    violations="uses tabs (indent_style = space)"
  fi

  # trim_trailing_whitespace: count lines ending in a space or tab.
  local trailing
  trailing="$(awk '/[ \t]+$/ { c++ } END { print c + 0 }' "${file}")"
  if [ "${trailing}" -gt 0 ]; then
    if [ -n "${violations}" ]; then violations="${violations}; "; fi
    violations="${violations}trailing whitespace on ${trailing} line(s)"
  fi

  # insert_final_newline: if the last byte is not a newline, it is missing.
  if [ -n "$(tail -c 1 "${file}")" ]; then
    if [ -n "${violations}" ]; then violations="${violations}; "; fi
    violations="${violations}missing final newline"
  fi

  # Report, padded with dots so the columns line up.
  printf '  %s ' "${name}"
  local pad=$((20 - ${#name}))
  while [ "${pad}" -gt 0 ]; do printf '.'; pad=$((pad - 1)); done
  if [ -z "${violations}" ]; then
    printf ' OK\n'
    return 0
  else
    printf ' VIOLATION: %s\n' "${violations}"
    return 1
  fi
}

echo "Checking files against .editorconfig ..."
violation_count=0
clean_count=0
for file in "${project_dir}/clean.py" "${project_dir}/tabs.py" \
            "${project_dir}/trailing.py" "${project_dir}/no_newline.py"; do
  if check_file "${file}"; then
    clean_count=$((clean_count + 1))
  else
    violation_count=$((violation_count + 1))
  fi
done

echo
echo "${violation_count} file(s) with violations, ${clean_count} clean."

lesson_id: D036
day: 36
kind: configuration-activity
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-036-choosing-and-configuring-a-code-editor
run_commands:
  - bash examples/editorconfig_demo.sh
  - bash starter/editorconfig_demo.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - '# nothing to clean: the demo writes only to a temp dir it deletes on exit'
  - 'git checkout -- starter/editorconfig_demo.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 → 12 checks, 0 failure(s)'

# Dependencies — Day 036 lab

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

- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution).
- Standard POSIX utilities: `awk`, `grep`, `printf`, `tail`, `mktemp`,
  `basename`, `rm` — all part of the base system.
- **Any editor** to view and edit the files. The lab is where you put the
  editor you chose in the lesson to use, but no specific editor is required to
  run the scripts, and no extension or plugin is needed for the checker.

There is deliberately no `requirements.txt`/`package.json` here; the lab must
run on a factory-fresh machine. EditorConfig support in an editor (built in for
some, a free plugin for others) is optional and only needed for the extension
exercise that watches your editor enforce the rules live.

# Editor worksheet — Day 036

Fill this in as you choose and configure your editor. Keep it: a later lesson
on debuggers, linters, and formatters builds on the editor you set up today.

## 1. Which editor do you use?

- **Editor:** _(for example: Visual Studio Code)_
- **Why this one?** _(1–2 sentences: free/paid, platform, what pulled you to it)_
- **Cost:** _(free / free tier / paid — state which)_

## 2. Three settings you configured (and why)

For each, name the setting and the concrete reason it helps you.

| # | Setting (name or key) | Value you chose | Why it helps |
| - | --------------------- | --------------- | ------------ |
| 1 | _(e.g. editor.tabSize)_ | _(e.g. 2)_ | _(e.g. matches this course's .editorconfig)_ |
| 2 | | | |
| 3 | | | |

## 3. What does your .editorconfig enforce?

List the rules in the project's `.editorconfig` and what each one guarantees:

- `indent_style = ` _____ → _(tabs or spaces for indentation)_
- `indent_size = ` _____ → _(how many columns per indent level)_
- `end_of_line = ` _____ → _(line-ending style)_
- `insert_final_newline = ` _____ → _(every file ends with a newline)_
- `trim_trailing_whitespace = ` _____ → _(no stray spaces at line ends)_
- `charset = ` _____ → _(text encoding)_

## 4. Reflection

In two or three sentences, describe how using your editor's search and
multi-cursor (or find-and-replace) features to rename a variable felt,
compared with making the same edit in a plain text editor.

_(your answer here)_

#!/usr/bin/env bash
# Day 036 lab — YOUR working file.
#
# Complete the four numbered exercises below. Each one names the exact lines
# to write. The completed reference version is in
# examples/editorconfig_demo.sh — run that first to see the goal, then do
# these yourself. When you are finished, run:  bash tests/run_tests.sh
#
# The sample project is built in a temporary directory and deleted on exit,
# so nothing permanent is written to your machine.
set -euo pipefail

project_dir="$(mktemp -d "${TMPDIR:-/tmp}/editorconfig-starter.XXXXXX")"
cleanup() { rm -rf "${project_dir}"; }
trap cleanup EXIT

echo "=== EditorConfig starter ==="
echo "Sample project: ${project_dir}"

# A clean file (correct already) and three messy ones to check against rules.
printf 'def greet(name):\n  return "Hi " + name\n' >"${project_dir}/clean.py"
printf 'def greet(name):\n\treturn "Hi " + name\n'  >"${project_dir}/tabs.py"
printf 'x = 1  \ny = 2 \n'                          >"${project_dir}/trailing.py"
printf 'z = 3'                                      >"${project_dir}/no_newline.py"

# A reusable checker (already written for you) — it reports whether a file
# obeys indent_style = space, trim_trailing_whitespace, and insert_final_newline.
check_file() {
  local file="$1" name violations trailing pad
  name="$(basename "${file}")"
  violations=""
  if awk 'index($0, "\t") == 1 { found = 1 } END { exit !found }' "${file}"; then
    violations="uses tabs (indent_style = space)"
  fi
  trailing="$(awk '/[ \t]+$/ { c++ } END { print c + 0 }' "${file}")"
  if [ "${trailing}" -gt 0 ]; then
    [ -n "${violations}" ] && violations="${violations}; "
    violations="${violations}trailing whitespace on ${trailing} line(s)"
  fi
  if [ -n "$(tail -c 1 "${file}")" ]; then
    [ -n "${violations}" ] && violations="${violations}; "
    violations="${violations}missing final newline"
  fi
  printf '  %s ' "${name}"
  pad=$((20 - ${#name})); while [ "${pad}" -gt 0 ]; do printf '.'; pad=$((pad - 1)); done
  if [ -z "${violations}" ]; then printf ' OK\n'; return 0
  else printf ' VIOLATION: %s\n' "${violations}"; return 1; fi
}

# ---------------------------------------------------------------------------
# Exercise 1: WRITE AN .editorconfig RULE.
# Inside the [*] section below, replace the single placeholder line with the
# six standard rules, one per line:
#   indent_style = space
#   indent_size = 2
#   end_of_line = lf
#   insert_final_newline = true
#   trim_trailing_whitespace = true
#   charset = utf-8
cat >"${project_dir}/.editorconfig" <<'EOF'
root = true

[*]
FILL-IN-EX1
EOF
echo "Wrote .editorconfig."
echo

# ---------------------------------------------------------------------------
# Exercise 2: CHECK A FILE against the rules.
# Replace the placeholder below so it calls the checker on the trailing file:
#   check_file "${project_dir}/trailing.py"
echo "Checking trailing.py before the fix:"
FILL-IN-EX2 || true
echo

# ---------------------------------------------------------------------------
# Exercise 3: FIX A VIOLATION.
# Rewrite trailing.py without the trailing spaces. Replace the placeholder
# below with:
#   printf 'x = 1\ny = 2\n' >"${project_dir}/trailing.py"
FILL-IN-EX3
echo "Fixed trailing.py."
echo

# ---------------------------------------------------------------------------
# Exercise 4: VERIFY the fix.
# Check trailing.py again — it should now report OK. Replace the placeholder
# below with:
#   check_file "${project_dir}/trailing.py"
echo "Checking trailing.py after the fix:"
FILL-IN-EX4
echo
echo "Done. Compare your run with examples/editorconfig_demo.sh."

#!/usr/bin/env bash
# Tests for the Day 036 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the reference demo writes an .editorconfig with the required
# keys and that its checker detects the known trailing-whitespace and
# missing-final-newline violations (and the tab and clean cases too). If the
# learner has finished the starter, it is held to the same standard.
# No network, no privileges, writes nothing outside temp dirs.
set -u

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

# --- The .editorconfig the demo writes must contain the required keys -----
echo "Checking the demo defines all required .editorconfig keys ..."
for key in indent_style indent_size end_of_line insert_final_newline \
           trim_trailing_whitespace charset; do
  if grep -q "^${key} = " "${example}"; then
    check "demo writes '${key}' rule" "yes"
  else
    check "demo writes '${key}' rule" "no"
  fi
done

# --- The checker must detect the known violations -------------------------
run_checker_checks() {
  local script="$1" output
  echo "Running ${script##*/} and inspecting its report ..."
  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 -Eq 'Wrote .editorconfig' \
    && check "reports the .editorconfig was written" "yes" \
    || check "reports the .editorconfig was written" "no"
  echo "${output}" | grep -Eq 'trailing\.py .*VIOLATION: trailing whitespace on 2 line' \
    && check "detects the trailing-whitespace violation" "yes" \
    || check "detects the trailing-whitespace violation" "no"
  echo "${output}" | grep -Eq 'no_newline\.py .*VIOLATION: missing final newline' \
    && check "detects the missing-final-newline violation" "yes" \
    || check "detects the missing-final-newline violation" "no"
  echo "${output}" | grep -Eq 'tabs\.py .*VIOLATION: uses tabs' \
    && check "detects the tab-indentation violation" "yes" \
    || check "detects the tab-indentation violation" "no"
  echo "${output}" | grep -Eq 'clean\.py .*OK' \
    && check "passes the clean file" "yes" \
    || check "passes the clean file" "no"
}

run_checker_checks "${example}"

# The starter ships with FILL-IN placeholders; once the learner has replaced
# them all, run and inspect their version too.
if grep -q 'FILL-IN' "${starter}"; then
  echo "Note: starter still has FILL-IN exercises — skipping its run (structure only)."
else
  echo "Running the completed starter and inspecting its report ..."
  if out="$(bash "${starter}" 2>&1)"; then
    check "completed starter exits successfully" "yes"
    echo "${out}" | grep -Eq 'trailing\.py .*OK' \
      && check "starter's fix makes trailing.py clean" "yes" \
      || check "starter's fix makes trailing.py clean" "no"
  else
    check "completed starter exits successfully" "no"
    echo "${out}" | sed 's/^/    /'
  fi
fi

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