Just: reject a separator value that would run, instead of warning about it

`JUST_CMD_RULE` is interpolated whole into a shell script, so a value that is
not a shell comment gets executed -- with a zero exit status, no diagnostic,
and once for every place the separator appears. The comment above it said so,
and saying so was all that happened, which leaves the obligation with whoever
presets the variable to have first read the file explaining why they mustn't.

A rule is a single line by construction, so demanding one line starting with
`#` rejects exactly the values that would run, without having to describe what
running looks like. Reading the value once instead of twice is what makes that
expressible at all.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: redsun82

misc/just/README.md

@@ -162,7 +162,9 @@ for itself, and the count is one per `mod` reached, however deeply nested, plus
 the file itself. That is cheap, and modules agree anyway since they share a terminal,
 but it is worth knowing before counting measurements. Presetting `JUST_CMD_RULE` skips
 all of them, and is also how to fix the width in CI or in a recording — it is the whole
-separator and ends up in a shell script, so every line of it has to be a comment.
+separator and ends up in a shell script, so it has to be a single line starting with
+`#`. Anything else is rejected rather than documented against, because otherwise it
+runs, silently and once per place the separator appears.
 
 With no terminal to ask — a pipe, a log, a shell without `stty` — it falls back to a
 fixed 57 columns, so logs and CI output are the same width every time. That is one

misc/just/defs.just

@@ -28,19 +28,23 @@ error := f'{{ style("error") }}error{{ NORMAL }}: '
 # With no terminal the value is non-numeric and this falls back to a fixed 57 columns.
 # That is a branch, not a platform test: just runs `sh` everywhere.
 #
-# `JUST_CMD_RULE` is the whole separator and lands in a shell script, so a hand-set
-# value has to be a comment -- every line of it, if it has more than one. Nothing checks
-# that; a value that is not one gets run.
+# `JUST_CMD_RULE` is the whole separator and lands in a shell script, so a hand-set value
+# that is not a shell comment gets run -- silently, with a zero exit, once per place the
+# separator appears. Hence the check rather than a warning in prose: a rule is one line by
+# construction, so demanding one line starting with `#` rejects every value that would
+# run, without having to describe what running looks like.
 #
 # Exported and preferred over measuring: `shell()` runs on every parse, so a forwarded
 # verb would otherwise re-measure in every child it spawns, and `if` is lazy in its
 # branches. Inheritance needs a process, so a `mod` measures for itself; presetting
 # `JUST_CMD_RULE` skips measuring entirely.
-_rule := if env('JUST_CMD_RULE', '') != '' { env('JUST_CMD_RULE', '') } else { shell('''
+_given_rule := env('JUST_CMD_RULE', '')
+
+_rule := if _given_rule == '' { shell('''
     w=$(stty size 2>/dev/null | cut -d" " -f2)
     case "$w" in '' | *[!0-9]*) w=57 ;; esac
     printf "%*s" $w "" | tr " " '#'
-''') }
+''') } else if _given_rule =~ '^#[^\n]*$' { _given_rule } else { error('JUST_CMD_RULE must be a single line starting with `#`') }
 
 export JUST_CMD_RULE := _rule