Add a settings screen so nothing needs a text editor

All eighteen options are now reachable from the menu as a cursor list: arrows
select, Space or Right cycles a value, q goes back, changes are written
immediately. A numbered menu would have run out of digits.

Three real bugs surfaced while building it, each found by testing against an
actual pty rather than a pipe:

- Labels went through printf as format strings, so the percent sign in
  "Minimum battery level (%)" was an invalid conversion. cau_msg_in now only
  treats a message as a format string when arguments were actually passed -
  otherwise any literal % a translator writes is a trap.

- Mixing bash's line-mode read into a single-key interface left the following
  read -sn1 receiving nothing at all, reproducibly, so the screen froze after
  editing the package list. Replaced with a small line editor built on the same
  single-character reader.

- Backspace was being swallowed: in canonical mode DEL is the ERASE character
  and the line discipline consumes it, and bash returns to canonical mode
  between each read -sn1. The interface now holds non-canonical mode for its
  whole lifetime and hands the terminal back only around actions that print or
  prompt, with a trap restoring it on Ctrl-C.

Translations and config reads are memoized; the screen redraws every label on
every keypress and a fork per lookup was the reason the redraw was slow enough
to matter.

src/lib/common.sh

@@ -75,13 +75,34 @@ cau_msg() {
 	cau_msg_in "$(cau_ui_locale)" "$@"
 }
 
+# Translations are memoized. Every gettext lookup is a fork, and the settings
+# screen redraws forty-odd labels per keypress; without this the redraw takes
+# long enough that a keystroke arriving during it is lost when the terminal
+# switches back to single-character mode.
+declare -A CAU_MSG_CACHE=()
+
 # cau_msg_in <locale> <msgid> [printf args...]
 cau_msg_in() {
-	local locale="$1" msgid="$2" translated
+	local locale="$1" msgid="$2" translated cachekey
 	shift 2
 
-	translated="$(LC_ALL="$locale" LANGUAGE="${locale%%.*}" gettext -- "$msgid" 2>/dev/null)"
-	[[ -n $translated ]] || translated="$msgid"
+	cachekey="${locale}"$'\x1f'"${msgid}"
+	if [[ -n ${CAU_MSG_CACHE[$cachekey]+set} ]]; then
+		translated="${CAU_MSG_CACHE[$cachekey]}"
+	else
+		translated="$(LC_ALL="$locale" LANGUAGE="${locale%%.*}" gettext -- "$msgid" 2>/dev/null)"
+		[[ -n $translated ]] || translated="$msgid"
+		CAU_MSG_CACHE[$cachekey]="$translated"
+	fi
+
+	# With no arguments the message is plain text, not a format string. Feeding
+	# it to printf anyway turns any literal percent sign in it - "Battery (%)",
+	# "100 % done" - into an invalid conversion, and that is a trap every
+	# translator would eventually walk into.
+	if (( $# == 0 )); then
+		printf '%s' "$translated"
+		return
+	fi
 
 	# shellcheck disable=SC2059  # the format string is the translated message
 	printf -- "$translated" "$@"

src/lib/config.sh

@@ -6,14 +6,33 @@
 # root-run daemon, and sourcing it would turn a stray line into arbitrary code
 # execution. The format is one "Key=Value" per line, '#' starts a comment.
 
+# The file is cached and parsed in-process rather than shelled out to sed on
+# every lookup. The settings screen reads every key on every redraw, and a fork
+# per key made the redraw slow enough to swallow keystrokes.
+CAU_CONFIG_CACHE=''
+CAU_CONFIG_CACHED=0
+
+_cau_config_slurp() {
+	(( CAU_CONFIG_CACHED )) && return 0
+	CAU_CONFIG_CACHE=''
+	[[ -r $CAU_CONFIG ]] && CAU_CONFIG_CACHE="$(< "$CAU_CONFIG")"
+	CAU_CONFIG_CACHED=1
+	return 0
+}
+
 # cau_config_get <Key> [default]
 cau_config_get() {
-	local key="$1" default="${2:-}" val
+	local key="$1" default="${2:-}" val='' line
 
 	[[ -r $CAU_CONFIG ]] || { printf '%s\n' "$default"; return; }
+	_cau_config_slurp
 
-	val="$(sed -nE "s/^[[:space:]]*${key}[[:space:]]*=[[:space:]]*(.*)$/\\1/p" \
-		"$CAU_CONFIG" 2>/dev/null | tail -n1)"
+	# last assignment wins, matching the previous sed|tail behaviour
+	while IFS= read -r line; do
+		[[ $line == *"$key"* ]] || continue
+		[[ $line =~ ^[[:space:]]*"$key"[[:space:]]*=(.*)$ ]] || continue
+		val="${BASH_REMATCH[1]}"
+	done <<< "$CAU_CONFIG_CACHE"
 
 	# strip a trailing comment and surrounding whitespace/quotes
 	val="${val%%#*}"
@@ -78,6 +97,7 @@ cau_config_set() {
 	fi
 
 	mv -f "$tmp" "$CAU_CONFIG"
+	CAU_CONFIG_CACHED=0
 }
 
 # ---------------------------------------------------------------------------

src/lib/menu.sh

@@ -7,6 +7,279 @@
 
 CAU_UNIT="cachy-auto-update.timer"
 
+# Terminal mode.
+#
+# bash flips the terminal into non-canonical mode for each `read -sn1` and back
+# out again in between. That gap matters: in canonical mode DEL is the ERASE
+# character, so the line discipline eats it instead of delivering it, and a
+# backspace typed while the interface was between reads simply vanished.
+# Holding non-canonical mode for the whole interface removes the gap.
+CAU_TERM_SAVED=''
+
+cau_ui_term_raw() {
+	cau_have stty || return 0
+	[[ -t 0 ]] || return 0
+	[[ -n $CAU_TERM_SAVED ]] && return 0
+
+	CAU_TERM_SAVED="$(stty -g 2>/dev/null)" || { CAU_TERM_SAVED=''; return 0; }
+	stty -icanon -echo min 1 time 0 2>/dev/null || true
+}
+
+cau_ui_term_restore() {
+	[[ -n $CAU_TERM_SAVED ]] || return 0
+	stty "$CAU_TERM_SAVED" 2>/dev/null || true
+	CAU_TERM_SAVED=''
+}
+
+# Runs an action with the terminal handed back to normal line mode, so anything
+# it prints - or prompts for - behaves the way a program expects.
+cau_ui_cooked() {
+	cau_ui_term_restore
+	"$@"
+	local rc=$?
+	cau_ui_term_raw
+	return $rc
+}
+
+# cau_read_key
+# One keypress, resolved to a symbolic name: a literal character, or one of
+# up/down/left/right/enter/space/escape. Arrow keys arrive as ESC [ A, so the
+# tail of the sequence is consumed here rather than being mistaken for three
+# separate presses.
+cau_read_key() {
+	local k rest
+
+	IFS= read -rsn1 k || return 1
+
+	case "$k" in
+		$'\e')
+			if IFS= read -rsn2 -t 0.05 rest; then
+				case "$rest" in
+					'[A') printf 'up\n' ;;
+					'[B') printf 'down\n' ;;
+					'[C') printf 'right\n' ;;
+					'[D') printf 'left\n' ;;
+					*)    printf 'escape\n' ;;
+				esac
+			else
+				printf 'escape\n'
+			fi
+			;;
+		# Enter is an empty read in cooked mode and a carriage return in raw
+		# mode, depending on whether the terminal is translating it.
+		''|$'\r')      printf 'enter\n' ;;
+		$'\x7f'|$'\b') printf 'backspace\n' ;;
+		' ')           printf 'space\n' ;;
+		*)             printf '%s\n' "$k" ;;
+	esac
+}
+
+# cau_ui_read_line <initial>
+# A minimal line editor built on cau_read_key, with the result in
+# CAU_LINE_RESULT.
+#
+# This exists instead of bash's own `read -r` because mixing line mode into a
+# single-key interface breaks it: after one cooked-mode read the following
+# `read -sn1` stops receiving keystrokes entirely, reproducibly, on a real pty.
+# Never leaving single-character mode side-steps that completely.
+CAU_LINE_RESULT=''
+
+cau_ui_read_line() {
+	local buf="${1:-}" key
+
+	CAU_LINE_RESULT=''
+	printf '%s' "$buf"
+
+	while true; do
+		key="$(cau_read_key)" || { printf '\n'; return 1; }
+
+		case "$key" in
+			enter)
+				printf '\n'
+				CAU_LINE_RESULT="$buf"
+				return 0
+				;;
+			escape)
+				printf '\n'
+				return 1
+				;;
+			backspace)
+				if [[ -n $buf ]]; then
+					buf="${buf%?}"
+					printf '\b \b'
+				fi
+				;;
+			space)
+				buf+=' '
+				printf ' '
+				;;
+			up|down|left|right) ;;   # no cursor movement in this editor
+			*)
+				# a single printable character; control keys arrive as names
+				[[ ${#key} -eq 1 ]] || continue
+				buf+="$key"
+				printf '%s' "$key"
+				;;
+		esac
+	done
+}
+
+# Everything that can be changed without opening a text editor.
+# Format: Key|type|default|label-msgid
+# type is bool, choice:<space separated values>, or text.
+CAU_SETTINGS=(
+	"NotifyOnStart|bool|yes|Notify when an update starts"
+	"NotifyOnSuccess|bool|yes|Notify after a successful update"
+	"NotifyOnError|bool|yes|Notify when something goes wrong"
+	"NotifyReboot|bool|yes|Notify when a restart is needed"
+	"UpdateInterval|choice:6h 12h 1d 2d 1w|1d|Time between update runs"
+	"SkipWhenGaming|bool|yes|Postpone while a game is running"
+	"RequireAC|bool|no|Only update on mains power"
+	"MinBatteryPercent|choice:0 20 30 40 50 60 70 80|40|Minimum battery level (%)"
+	"UpdateAUR|bool|yes|Update AUR packages"
+	"UpdateFlatpak|bool|yes|Update Flatpaks"
+	"UpdateAppImages|bool|yes|Update AppImages"
+	"UpdateDevel|bool|no|Also rebuild -git packages"
+	"AURHelper|choice:auto paru yay pikaur|auto|AUR helper"
+	"AutoResolveConflicts|bool|yes|Resolve package conflicts automatically"
+	"CleanCache|bool|yes|Trim the package cache"
+	"KeepOldPackages|choice:0 1 2 3 5|3|Cached versions to keep"
+	"RemoveOrphans|bool|no|Remove packages nothing needs any more"
+	"IgnorePkg|text||Never update these packages"
+)
+
+_cau_is_true() {
+	case "${1,,}" in
+		yes|y|true|1|on|enabled) return 0 ;;
+		*) return 1 ;;
+	esac
+}
+
+# _cau_setting_display <type> <value>
+_cau_setting_display() {
+	local type="$1" value="$2"
+
+	case "$type" in
+		bool)
+			if _cau_is_true "$value"; then
+				printf '%s%s%s' "$CAU_C_GREEN" "$(cau_msg "ON")" "$CAU_C_RESET"
+			else
+				printf '%s%s%s' "$CAU_C_DIM" "$(cau_msg "OFF")" "$CAU_C_RESET"
+			fi
+			;;
+		text)
+			if [[ -n $value ]]; then
+				printf '%s' "$value"
+			else
+				printf '%s%s%s' "$CAU_C_DIM" "$(cau_msg "(none)")" "$CAU_C_RESET"
+			fi
+			;;
+		*) printf '%s' "$value" ;;
+	esac
+}
+
+# _cau_setting_cycle <type> <value> <direction: 1|-1>
+# The next value for this setting. Choices wrap around, so one key is enough to
+# reach everything without needing a second one for the other direction.
+_cau_setting_cycle() {
+	local type="$1" value="$2" dir="$3"
+
+	if [[ $type == bool ]]; then
+		_cau_is_true "$value" && printf 'no\n' || printf 'yes\n'
+		return
+	fi
+
+	local -a choices
+	read -r -a choices <<< "${type#choice:}"
+	(( ${#choices[@]} )) || { printf '%s\n' "$value"; return; }
+
+	local i idx=0
+	for i in "${!choices[@]}"; do
+		[[ ${choices[i]} == "$value" ]] && { idx=$i; break; }
+	done
+
+	idx=$(( (idx + dir + ${#choices[@]}) % ${#choices[@]} ))
+	printf '%s\n' "${choices[idx]}"
+}
+
+# cau_ui_settings
+# A cursor list rather than a numbered menu: there are eighteen settings, and
+# numbering them would run out of digits and force paging.
+cau_ui_settings() {
+	local cursor=0 key spec name type default label value line pad
+	local count=${#CAU_SETTINGS[@]}
+
+	while true; do
+		clear 2>/dev/null || true
+		cau_head "  $(cau_msg "Settings")"
+
+		local i=0
+		for spec in "${CAU_SETTINGS[@]}"; do
+			IFS='|' read -r name type default label <<< "$spec"
+			value="$(cau_config_get "$name" "$default")"
+
+			if (( i == cursor )); then
+				line="${CAU_C_BLUE}▸${CAU_C_RESET} "
+			else
+				line="  "
+			fi
+
+			local text
+			text="$(cau_msg "$label")"
+			pad=$(( 42 - ${#text} ))
+			(( pad < 0 )) && pad=0
+
+			printf '  %s%s%*s %s\n' "$line" "$text" "$pad" '' \
+				"$(_cau_setting_display "$type" "$value")"
+			i=$(( i + 1 ))
+		done
+
+		printf '\n  %s%s%s\n' "$CAU_C_DIM" \
+			"$(cau_msg "Up/Down select - Space or Right changes - q goes back")" "$CAU_C_RESET"
+
+		key="$(cau_read_key)" || return 0
+
+		IFS='|' read -r name type default label <<< "${CAU_SETTINGS[cursor]}"
+		value="$(cau_config_get "$name" "$default")"
+
+		case "$key" in
+			up|k)    cursor=$(( (cursor - 1 + count) % count )) ;;
+			down|j)  cursor=$(( (cursor + 1) % count )) ;;
+			space|enter|right|l)
+				if [[ $type == text ]]; then
+					cau_ui_edit_text "$name" "$value"
+				else
+					cau_config_set "$name" "$(_cau_setting_cycle "$type" "$value" 1)" \
+						|| { cau_bad "$(cau_msg "Could not write the configuration file.")"; cau_pause; }
+				fi
+				;;
+			left|h)
+				[[ $type == text ]] || cau_config_set "$name" \
+					"$(_cau_setting_cycle "$type" "$value" -1)" \
+					|| { cau_bad "$(cau_msg "Could not write the configuration file.")"; cau_pause; }
+				;;
+			q|Q|escape) return 0 ;;
+			*) ;;
+		esac
+	done
+}
+
+# cau_ui_edit_text <key> <current>
+# The one setting that is a free-text list rather than a choice.
+cau_ui_edit_text() {
+	local name="$1" current="$2"
+
+	printf '\n  %s\n' "$(cau_msg "Package names separated by spaces, empty to clear:")"
+	printf '  > '
+
+	# pre-filled with the current value so it can be corrected rather than
+	# retyped; Escape leaves it unchanged
+	if cau_ui_read_line "$current"; then
+		cau_config_set "$name" "$CAU_LINE_RESULT" \
+			|| { cau_bad "$(cau_msg "Could not write the configuration file.")"; cau_pause; }
+	fi
+}
+
 # _cau_row <label> <value>
 # printf's %-28s pads by bytes, so a label containing "ü" comes out one column
 # short. ${#s} counts characters in a UTF-8 locale, so the padding is computed
@@ -141,6 +414,10 @@ cau_ui_status_conditions() {
 cau_ui_menu() {
 	local choice
 
+	cau_ui_term_raw
+	# restore the terminal even if this exits through Ctrl-C or an error
+	trap 'cau_ui_term_restore' EXIT INT TERM
+
 	while true; do
 		cau_config_load
 
@@ -153,45 +430,52 @@ cau_ui_menu() {
 		printf '  [3] %s\n' "$(cau_msg "Update now")"
 		printf '  [4] %s\n' "$(cau_msg "Show log")"
 		printf '  [5] %s\n' "$(cau_msg "Show current conditions")"
+		printf '  [6] %s\n' "$(cau_msg "Settings")"
 		printf '  [q] %s\n' "$(cau_msg "Quit")"
 		printf '\n  > '
 
-		# One keypress, no Enter. -s keeps the raw character out of the
-		# display so the echo below is the only thing printed, and a failing
-		# read means EOF (Ctrl-D, or a script piping input) - that quits.
-		read -rsn1 choice || { printf '\n'; return 0; }
+		# One keypress, no Enter. A failing read means EOF (Ctrl-D, or a
+		# script piping input), which quits.
+		choice="$(cau_read_key)" || {
+			printf '\n'; cau_ui_term_restore; trap - EXIT INT TERM; return 0
+		}
+		case "$choice" in
+			enter|space|up|down|left|right|escape) choice='' ;;
+		esac
 		printf '%s\n' "$choice"
 
+		# Actions run in normal line mode: they print program output and some
+		# of them prompt, neither of which behaves in raw mode.
 		case "$choice" in
 			# The two switches flip and return straight to the menu, where the
 			# status block shows the result. Only a warning or an error holds
 			# the screen (see CAU_UI_NEEDS_ACK).
 			1)
 				CAU_UI_NEEDS_ACK=''
-				if [[ $CFG_ENABLED == yes ]]; then cau_do_disable; else cau_do_enable; fi
+				if [[ $CFG_ENABLED == yes ]]; then
+					cau_ui_cooked cau_do_disable
+				else
+					cau_ui_cooked cau_do_enable
+				fi
 				if [[ -n $CAU_UI_NEEDS_ACK ]]; then cau_pause; fi
 				;;
 			2)
 				CAU_UI_NEEDS_ACK=''
 				if [[ $CFG_NOTIFICATIONS == yes ]]; then
-					cau_do_notifications off
+					cau_ui_cooked cau_do_notifications off
 				else
-					cau_do_notifications on
+					cau_ui_cooked cau_do_notifications on
 				fi
 				if [[ -n $CAU_UI_NEEDS_ACK ]]; then cau_pause; fi
 				;;
-			3) cau_do_run --force; cau_pause ;;
-			4) cau_do_log; cau_pause ;;
+			3) cau_ui_cooked cau_do_run --force; cau_pause ;;
+			4) cau_ui_cooked cau_do_log; cau_pause ;;
 			5) cau_ui_status_conditions; cau_pause ;;
-			q|Q) return 0 ;;
-			$'\e')
-				# Arrow keys and friends arrive as ESC [ X. Swallow the rest so
-				# one keypress does not redraw the menu three times. Escape is
-				# deliberately not a quit key: that would make a stray arrow
-				# key close the menu.
-				read -rsn2 -t 0.05 _ 2>/dev/null || true
-				;;
-			# Anything else, Enter included, just redraws.
+			6) cau_ui_settings ;;
+			q|Q) cau_ui_term_restore; trap - EXIT INT TERM; return 0 ;;
+			# Anything else - Enter, arrow keys, stray characters - just
+			# redraws. Escape is deliberately not a quit key, so a mistyped
+			# arrow key cannot close the menu.
 			*) ;;
 		esac
 	done