torben
c33e8cdfb1
Files changed: - .gitea/workflows/release.yml - CHANGES.md - INSTALL.md - README.md - VERSION - instructions/dev/testing-conventions.md - instructions/preflight.md - tools/CONTRACT.md - tools/README.md - tools/chemenu/tests/test_preflight.py - tools/chemenu/tests/test_preflight_pwsh.py - tools/preflight.ps1 - tools/preflight.sh
693 lines
25 KiB
Bash
Executable File
693 lines
25 KiB
Bash
Executable File
#!/bin/sh
|
|
# Preflight: check that this machine has what the stack needs, record where each
|
|
# tool lives, and set up tools/.venv - before any `wikitool` command can run.
|
|
#
|
|
# tools/preflight.sh check, record, set up
|
|
# tools/preflight.sh --set rg=/opt/rg/rg use a path the user named
|
|
#
|
|
# As the release asset `preflight.sh` - a copy with no tools/prerequisites.txt next
|
|
# to it - the script is the first install step instead: it downloads the stack
|
|
# release named in RELEASE_ARCHIVE_URL / RELEASE_CHECKSUM_URL, checks the sha256,
|
|
# unpacks it into <script folder>/chemenu (or --into <path>), and runs the copy of
|
|
# this script inside the unpacked tree, which does everything above.
|
|
#
|
|
# preflight.sh [--into <path>] [--archive <tarball>] [--set <tool>=<path>]...
|
|
#
|
|
# --archive uses a local tarball instead of a download; <tarball>.sha256 has to lie
|
|
# next to it. Release builds fill the two URL lines below; a tree copy leaves them empty.
|
|
#
|
|
# Exit 0: everything is in place and .wikitool-tools.json is complete.
|
|
# Exit 42: the user has to act. The output says what, why, the command that fixes
|
|
# it and what happens next; show it verbatim and wait (AGENTS.md § Tool
|
|
# error contract). Never install anything on the user's behalf.
|
|
# Exit 1: this script was called wrongly, a download or unpack failed (nothing is
|
|
# unpacked then), or the tree next to it is incomplete.
|
|
#
|
|
# POSIX sh on purpose: it has to run before Python is known to exist, under dash,
|
|
# bash and the Git Bash that Claude Code uses on Windows. The PowerShell
|
|
# counterpart is tools/preflight.ps1; what both check is tools/prerequisites.txt.
|
|
# The procedure around this script: instructions/preflight.md.
|
|
#
|
|
# Two variables exist for the test suite and are read nowhere else:
|
|
# CHEMENU_PREFLIGHT_PLATFORM (windows|macos|linux) and
|
|
# CHEMENU_PREFLIGHT_LONGPATHS (0|1) stand in for `uname` and the registry.
|
|
|
|
set -u
|
|
|
|
DIR=$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd -P)
|
|
ROOT=$(dirname -- "$DIR")
|
|
MANIFEST="$DIR/prerequisites.txt"
|
|
TOOLS_FILE="$ROOT/.wikitool-tools.json"
|
|
VENV="$DIR/.venv"
|
|
REQUIREMENTS="$DIR/requirements.txt"
|
|
STAMP="$VENV/.chemenu-requirements.sha256"
|
|
SELF="tools/preflight.sh"
|
|
|
|
# Filled in by the release build, in the copy attached to the release; empty in a tree.
|
|
RELEASE_ARCHIVE_URL=''
|
|
RELEASE_CHECKSUM_URL=''
|
|
|
|
PYPROBE='import sys; print("%d.%d" % sys.version_info[:2]); print(sys.executable)'
|
|
|
|
usage() {
|
|
cat <<'EOF'
|
|
usage: tools/preflight.sh [--set <tool>=<path>]...
|
|
preflight.sh [--into <path>] [--archive <tarball>] [--set <tool>=<path>]...
|
|
|
|
Checks the tools this stack needs (tools/prerequisites.txt), records their paths
|
|
in .wikitool-tools.json and sets up tools/.venv. Exit 0 means ready; exit 42
|
|
means the user has to act - the output says how.
|
|
|
|
The second form is the release asset: it downloads the release (or takes
|
|
--archive), checks its sha256, unpacks it into <script folder>/chemenu or --into,
|
|
and runs the preflight inside it.
|
|
EOF
|
|
}
|
|
|
|
# --- arguments ----------------------------------------------------------------
|
|
|
|
SETS=""
|
|
INTO="" ARCHIVE=""
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
--into|--archive)
|
|
if [ $# -lt 2 ] || [ -z "$2" ]; then
|
|
echo "preflight: $1 needs a path" >&2
|
|
exit 1
|
|
fi
|
|
if [ "$1" = --into ]; then INTO=$2; else ARCHIVE=$2; fi
|
|
shift
|
|
;;
|
|
--set)
|
|
if [ $# -lt 2 ]; then
|
|
echo "preflight: --set needs <tool>=<path>" >&2
|
|
exit 1
|
|
fi
|
|
SETS="$SETS
|
|
$2"
|
|
shift
|
|
;;
|
|
--set=*) SETS="$SETS
|
|
${1#--set=}" ;;
|
|
-h|--help) usage; exit 0 ;;
|
|
*) echo "preflight: unknown argument: $1" >&2; usage >&2; exit 1 ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
ASSET=0
|
|
if [ ! -f "$MANIFEST" ]; then
|
|
ASSET=1
|
|
elif [ -n "$INTO$ARCHIVE" ]; then
|
|
echo "preflight: --into and --archive belong to the release asset; inside a stack tree there is nothing to unpack." >&2
|
|
exit 1
|
|
fi
|
|
|
|
# --- platform -----------------------------------------------------------------
|
|
|
|
if [ -n "${CHEMENU_PREFLIGHT_PLATFORM:-}" ]; then
|
|
PLATFORM=$CHEMENU_PREFLIGHT_PLATFORM
|
|
else
|
|
case "$(uname -s 2>/dev/null)" in
|
|
MINGW*|MSYS*|CYGWIN*) PLATFORM=windows ;;
|
|
Darwin) PLATFORM=macos ;;
|
|
*) PLATFORM=linux ;;
|
|
esac
|
|
fi
|
|
|
|
# A path as the rest of the machine spells it: under Git Bash `/c/Tools/rg.exe`
|
|
# becomes `C:\Tools\rg.exe`, which is what Python and PowerShell read back.
|
|
native_path() {
|
|
if [ "$PLATFORM" = windows ] && command -v cygpath >/dev/null 2>&1; then
|
|
cygpath -w "$1"
|
|
else
|
|
printf '%s\n' "$1"
|
|
fi
|
|
}
|
|
|
|
# --- problems and the guidance block --------------------------------------------
|
|
|
|
PROBLEMS=0
|
|
GUIDE=""
|
|
BAD_SET=0
|
|
|
|
# problem <what> <why> <fix, may span lines>
|
|
problem() {
|
|
PROBLEMS=$((PROBLEMS + 1))
|
|
fix=$(printf '%s\n' "$3" | sed '2,$s/^/ /')
|
|
GUIDE="$GUIDE
|
|
$PROBLEMS) $1
|
|
Why: $2
|
|
Fix: $fix
|
|
Next: Tell the agent once this is done - it runs this check again.
|
|
"
|
|
}
|
|
|
|
stop() {
|
|
if [ "$PROBLEMS" -eq 1 ]; then
|
|
noun="1 thing needs"
|
|
else
|
|
noun="$PROBLEMS things need"
|
|
fi
|
|
echo ""
|
|
echo "STOP - $noun your attention before this wiki can run."
|
|
echo "(Agent: show this output to the user exactly as it is, then wait. Do not install"
|
|
echo "anything yourself and do not work around it.)"
|
|
printf '%s' "$GUIDE"
|
|
exit 42
|
|
}
|
|
|
|
longpaths_enabled() {
|
|
if [ -n "${CHEMENU_PREFLIGHT_LONGPATHS:-}" ]; then
|
|
[ "$CHEMENU_PREFLIGHT_LONGPATHS" = 1 ]
|
|
return
|
|
fi
|
|
# MSYS would rewrite the `/v` into a path without the exclusion. An unreadable
|
|
# key counts as "off": the limit then protects a machine it did not have to.
|
|
answer=$(MSYS2_ARG_CONV_EXCL='*' reg query 'HKLM\SYSTEM\CurrentControlSet\Control\FileSystem' \
|
|
/v LongPathsEnabled 2>/dev/null) || return 1
|
|
case "$answer" in *0x1*) return 0 ;; esac
|
|
return 1
|
|
}
|
|
|
|
# Length in UTF-16 code units, which is what MAX_PATH counts.
|
|
utf16_length() {
|
|
if command -v iconv >/dev/null 2>&1; then
|
|
bytes=$(printf '%s' "$1" | iconv -f UTF-8 -t UTF-16LE 2>/dev/null | wc -c | tr -d ' ')
|
|
if [ "${bytes:-0}" -gt 0 ]; then
|
|
echo $((bytes / 2))
|
|
return
|
|
fi
|
|
fi
|
|
echo ${#1}
|
|
}
|
|
|
|
# --- asset mode: the release asset unpacks the stack, then hands over ------------------
|
|
#
|
|
# Only when no tools/prerequisites.txt lies next to this script. Nothing here reads
|
|
# the tree; the folder limit comes out of the archive itself. The tools the tree copy
|
|
# checks (Python, git, rg) are not needed until that copy runs.
|
|
|
|
WORK=""
|
|
cleanup() {
|
|
[ -z "$WORK" ] || rm -rf "$WORK"
|
|
[ -z "${UNPACK:-}" ] || rm -rf "$UNPACK"
|
|
}
|
|
|
|
asset_fail() { # <message>
|
|
echo "preflight: $1" >&2
|
|
exit 1
|
|
}
|
|
|
|
sha256_of() { # <file>
|
|
if command -v sha256sum >/dev/null 2>&1; then
|
|
sha256sum "$1" | cut -d' ' -f1
|
|
else
|
|
shasum -a 256 "$1" | cut -d' ' -f1
|
|
fi
|
|
}
|
|
|
|
asset_mode() {
|
|
# GNU tar reads `C:` as a host name; Git Bash has to hand it `/c/...`.
|
|
if [ "$PLATFORM" = windows ] && command -v cygpath >/dev/null 2>&1; then
|
|
[ -z "$ARCHIVE" ] || ARCHIVE=$(cygpath -u "$ARCHIVE")
|
|
[ -z "$INTO" ] || INTO=$(cygpath -u "$INTO")
|
|
fi
|
|
if [ -n "$INTO" ]; then
|
|
case "$INTO" in /*) TARGET=$INTO ;; *) TARGET="$(pwd)/$INTO" ;; esac
|
|
else
|
|
TARGET="$DIR/chemenu"
|
|
fi
|
|
TARGET=${TARGET%/}
|
|
if [ -e "$TARGET" ] || [ -L "$TARGET" ]; then
|
|
asset_fail "$(native_path "$TARGET") already exists - nothing was unpacked. Choose another folder with --into <path>, or move the existing one away."
|
|
fi
|
|
|
|
if [ -z "$ARCHIVE" ] && { [ -z "$RELEASE_ARCHIVE_URL" ] || [ -z "$RELEASE_CHECKSUM_URL" ]; }; then
|
|
asset_fail "this copy of the script does not come from a release (it has no download address). Download preflight.sh from the release page, or pass --archive <tarball>."
|
|
fi
|
|
if [ -n "$ARCHIVE" ]; then
|
|
[ -f "$ARCHIVE" ] || asset_fail "--archive: $ARCHIVE is not a file."
|
|
[ -f "$ARCHIVE.sha256" ] || asset_fail "--archive: $ARCHIVE.sha256 is missing - the checksum file has to lie next to the tarball."
|
|
fi
|
|
|
|
# What has to be here for the download, tested before anything is fetched.
|
|
missing=""
|
|
if [ -z "$ARCHIVE" ] && ! command -v curl >/dev/null 2>&1; then missing="$missing curl"; fi
|
|
command -v tar >/dev/null 2>&1 || missing="$missing tar"
|
|
command -v sha256sum >/dev/null 2>&1 || command -v shasum >/dev/null 2>&1 || missing="$missing sha256sum"
|
|
if [ -n "$missing" ]; then
|
|
case "$PLATFORM" in
|
|
macos) hint="brew install$missing" ;;
|
|
windows) hint="Git for Windows (https://gitforwindows.org) provides all of them in Git Bash." ;;
|
|
*) hint="sudo apt install$(printf '%s' "$missing" | sed 's/ sha256sum/ coreutils/')" ;;
|
|
esac
|
|
problem "Tools needed to fetch and unpack the stack could not be found:$missing" \
|
|
"the first step downloads the release, checks its checksum and unpacks it" \
|
|
"$hint"
|
|
stop
|
|
fi
|
|
|
|
trap cleanup EXIT
|
|
WORK=$(mktemp -d "${TMPDIR:-/tmp}/chemenu-preflight.XXXXXX") || asset_fail "could not create a temporary folder."
|
|
if [ -n "$ARCHIVE" ]; then
|
|
archive=$ARCHIVE
|
|
checksum=$ARCHIVE.sha256
|
|
else
|
|
archive="$WORK/${RELEASE_ARCHIVE_URL##*/}"
|
|
checksum="$WORK/${RELEASE_CHECKSUM_URL##*/}"
|
|
echo "Downloading $RELEASE_ARCHIVE_URL"
|
|
curl -fsSL -o "$archive" "$RELEASE_ARCHIVE_URL" || asset_fail "the download failed: $RELEASE_ARCHIVE_URL (check the internet connection, then run this again)."
|
|
curl -fsSL -o "$checksum" "$RELEASE_CHECKSUM_URL" || asset_fail "the download failed: $RELEASE_CHECKSUM_URL (check the internet connection, then run this again)."
|
|
fi
|
|
|
|
want=$(sed -n '1s/^\([0-9A-Fa-f]\{64\}\).*/\1/p' "$checksum" | tr 'A-F' 'a-f')
|
|
[ -n "$want" ] || asset_fail "the checksum file holds no sha256 in its first line - nothing was unpacked."
|
|
have=$(sha256_of "$archive" | tr 'A-F' 'a-f')
|
|
if [ "$want" != "$have" ]; then
|
|
asset_fail "the sha256 of the archive does not match its checksum file (expected $want, got $have) - nothing was unpacked. Delete the download and run this again."
|
|
fi
|
|
echo "sha256 OK"
|
|
|
|
listing=$(tar -tzf "$archive" 2>/dev/null) || asset_fail "the archive could not be read - nothing was unpacked."
|
|
tops=$(printf '%s\n' "$listing" | sed 's|^\./||; s|/.*||; /^\.\{0,1\}$/d')
|
|
top=$(printf '%s\n' "$tops" | head -n 1)
|
|
other=$(printf '%s\n' "$tops" | grep -v -x -F -- "$top" | head -n 1)
|
|
if [ -z "$top" ] || [ -n "$other" ]; then
|
|
asset_fail "the archive does not hold exactly one top-level folder - nothing was unpacked."
|
|
fi
|
|
|
|
manifest=$(tar -xOzf "$archive" "$top/tools/prerequisites.txt" 2>/dev/null) \
|
|
|| asset_fail "the archive holds no $top/tools/prerequisites.txt - nothing was unpacked."
|
|
limit=$(printf '%s\n' "$manifest" | sed -n 's/^limit|install_dir_max|\([0-9][0-9]*\).*/\1/p' | head -n 1)
|
|
|
|
if [ "$PLATFORM" = windows ] && [ -n "$limit" ] && ! longpaths_enabled; then
|
|
folder=$(native_path "$TARGET")
|
|
length=$(utf16_length "$folder")
|
|
if [ "$length" -gt "$limit" ]; then
|
|
problem "The folder this wiki would be installed in is too long ($length characters, at most $limit): $folder" \
|
|
"Windows on this computer only allows paths of up to 259 characters, and the wiki's own files need the rest" \
|
|
"Run this again with a shorter folder, for example: --into C:\\\\Chemenu
|
|
Alternatively, someone with administrator rights can turn on long paths in Windows."
|
|
stop
|
|
fi
|
|
fi
|
|
|
|
parent=$(dirname -- "$TARGET")
|
|
mkdir -p "$parent" || asset_fail "could not create $parent."
|
|
UNPACK="$parent/.chemenu-unpack.$$"
|
|
mkdir "$UNPACK" || asset_fail "could not create a temporary folder next to the target."
|
|
tar -xzf "$archive" -C "$UNPACK" || asset_fail "unpacking failed - the target was not created."
|
|
[ -d "$UNPACK/$top" ] || asset_fail "unpacking produced no $top folder - the target was not created."
|
|
mv "$UNPACK/$top" "$TARGET" || asset_fail "could not move the unpacked stack to $(native_path "$TARGET")."
|
|
rm -rf "$UNPACK"
|
|
UNPACK=""
|
|
|
|
[ -f "$TARGET/tools/preflight.sh" ] || asset_fail "the unpacked stack has no tools/preflight.sh."
|
|
echo "Unpacked into $(native_path "$TARGET")."
|
|
echo "If a later step stops, run tools/preflight.sh from inside that folder."
|
|
echo ""
|
|
set --
|
|
while IFS= read -r entry; do
|
|
[ -n "$entry" ] || continue
|
|
set -- "$@" --set "$entry"
|
|
done <<EOT
|
|
$SETS
|
|
EOT
|
|
trap - EXIT
|
|
cleanup
|
|
exec /bin/sh "$TARGET/tools/preflight.sh" "$@"
|
|
}
|
|
|
|
[ "$ASSET" -eq 0 ] || asset_mode
|
|
|
|
# --- the manifest ---------------------------------------------------------------
|
|
|
|
manifest_field() { # <kind> <name> <field number, 1-based>
|
|
while IFS='|' read -r kind name rest; do
|
|
case "$kind" in ''|'#'*) continue ;; esac
|
|
if [ "$kind" = "$1" ] && [ "$name" = "$2" ]; then
|
|
printf '%s|%s|%s\n' "$kind" "$name" "$rest" | cut -d'|' -f"$3"
|
|
return 0
|
|
fi
|
|
done < "$MANIFEST"
|
|
return 1
|
|
}
|
|
|
|
TOOLS=""
|
|
while IFS='|' read -r kind name minimum platforms rest; do
|
|
case "$kind" in ''|'#'*) continue ;; esac
|
|
[ "$kind" = tool ] || continue
|
|
case "$name" in *[!a-z0-9]*|'') echo "preflight: bad tool name '$name' in $MANIFEST" >&2; exit 1 ;; esac
|
|
if [ "$platforms" = all ] || [ "$platforms" = "$PLATFORM" ]; then
|
|
TOOLS="$TOOLS $name"
|
|
fi
|
|
done < "$MANIFEST"
|
|
|
|
# The install command for this machine's package manager, or every known one.
|
|
install_hint() { # <tool>
|
|
choco=$(manifest_field tool "$1" 7)
|
|
winget=$(manifest_field tool "$1" 8)
|
|
brew=$(manifest_field tool "$1" 9)
|
|
apt=$(manifest_field tool "$1" 10)
|
|
pacman=$(manifest_field tool "$1" 11)
|
|
hint=""
|
|
case "$PLATFORM" in
|
|
windows)
|
|
if command -v choco >/dev/null 2>&1 && [ "$choco" != - ]; then
|
|
hint="$choco (in a terminal opened as administrator)"
|
|
elif command -v winget >/dev/null 2>&1 && [ "$winget" != - ]; then
|
|
hint=$winget
|
|
fi ;;
|
|
macos)
|
|
if command -v brew >/dev/null 2>&1 && [ "$brew" != - ]; then hint=$brew; fi ;;
|
|
*)
|
|
if command -v apt-get >/dev/null 2>&1 && [ "$apt" != - ]; then
|
|
hint=$apt
|
|
elif command -v pacman >/dev/null 2>&1 && [ "$pacman" != - ]; then
|
|
hint=$pacman
|
|
fi ;;
|
|
esac
|
|
if [ -n "$hint" ]; then
|
|
printf '%s\n' "$hint"
|
|
return
|
|
fi
|
|
printf 'Install it with the package manager this computer uses, for example:\n'
|
|
for entry in "choco:$choco" "winget:$winget" "brew:$brew" "apt:$apt" "pacman:$pacman"; do
|
|
case "$entry" in *:-) continue ;; esac
|
|
printf ' %s\n' "${entry#*:}"
|
|
done
|
|
}
|
|
|
|
# --- version helpers ------------------------------------------------------------
|
|
|
|
# major.minor of the first version-looking token in $1 ("git version 2.47.1" -> 2.47)
|
|
version_of() {
|
|
printf '%s\n' "$1" | sed -n '1{s/^[^0-9]*\([0-9][0-9]*\)\(\.[0-9][0-9]*\)\{0,1\}.*/\1\2/p;}'
|
|
}
|
|
|
|
version_ge() { # <have> <want>, both major[.minor]
|
|
have=$1 want=$2
|
|
case "$have" in *.*) ;; *) have="$have.0" ;; esac
|
|
case "$want" in *.*) ;; *) want="$want.0" ;; esac
|
|
hm=${have%%.*} hn=${have#*.}
|
|
wm=${want%%.*} wn=${want#*.}
|
|
[ "$hm" -gt "$wm" ] || { [ "$hm" -eq "$wm" ] && [ "$hn" -ge "$wn" ]; }
|
|
}
|
|
|
|
# --- finding tools --------------------------------------------------------------
|
|
|
|
# The Microsoft Store's app-execution aliases: a python.exe that opens the Store
|
|
# instead of running anything. Never executed, never recorded.
|
|
is_store_alias() {
|
|
case "$1" in *[Ww]indows[Aa]pps/*|*[Ww]indows[Aa]pps\\*) return 0 ;; esac
|
|
return 1
|
|
}
|
|
|
|
# Every executable called <name> on PATH, in PATH order, store aliases dropped.
|
|
on_path() {
|
|
set -f
|
|
old_ifs=$IFS
|
|
IFS=:
|
|
for d in $PATH; do
|
|
[ -n "$d" ] || d=.
|
|
for f in "$d/$1" "$d/$1.exe"; do
|
|
if [ -f "$f" ] && [ -x "$f" ] && ! is_store_alias "$f"; then
|
|
printf '%s\n' "$f"
|
|
fi
|
|
done
|
|
done
|
|
IFS=$old_ifs
|
|
set +f
|
|
}
|
|
|
|
usable() { # <path>
|
|
[ -n "$1" ] && [ -f "$1" ] && [ -x "$1" ] && ! is_store_alias "$1"
|
|
}
|
|
|
|
# Runs a Python candidate; prints "<major.minor>\n<sys.executable>".
|
|
probe_python() { # <path> [extra argument, e.g. -3 for py]
|
|
if [ $# -gt 1 ]; then
|
|
"$1" "$2" -c "$PYPROBE" 2>/dev/null | tr -d '\r'
|
|
else
|
|
"$1" -c "$PYPROBE" 2>/dev/null | tr -d '\r'
|
|
fi
|
|
}
|
|
|
|
# The value recorded for <name> in .wikitool-tools.json, unescaped.
|
|
recorded() {
|
|
[ -f "$TOOLS_FILE" ] || return 1
|
|
value=$(sed -n "s/^ *\"$1\": *\"\(.*\)\",\{0,1\} *\$/\1/p" "$TOOLS_FILE" | head -n 1)
|
|
[ -n "$value" ] || return 1
|
|
printf '%s\n' "$value" | sed 's/\\"/"/g; s/\\\\/\\/g'
|
|
}
|
|
|
|
set_value() { # <name> -> the path given with --set, if any
|
|
printf '%s\n' "$SETS" | sed -n "s/^$1=//p" | head -n 1
|
|
}
|
|
|
|
# --- --set: every named path has to work, or nothing is written -------------------
|
|
|
|
for entry in $(printf '%s\n' "$SETS" | sed -n 's/^\([^=]*\)=.*/\1/p'); do
|
|
case " $TOOLS " in
|
|
*" $entry "*) ;;
|
|
*) echo "preflight: --set names '$entry', which is not a tool this platform needs:$TOOLS" >&2
|
|
exit 1 ;;
|
|
esac
|
|
done
|
|
|
|
# --- python -------------------------------------------------------------------------
|
|
|
|
PY="" PY_VERSION="" PY_OLD=""
|
|
PY_MIN=$(manifest_field tool python 3)
|
|
|
|
try_python() { # <path> [extra] -> sets PY/PY_VERSION on success, PY_OLD when too old
|
|
out=$(probe_python "$@") || return 1
|
|
version=$(printf '%s\n' "$out" | sed -n 1p)
|
|
executable=$(printf '%s\n' "$out" | sed -n 2p)
|
|
[ -n "$version" ] && [ -n "$executable" ] || return 1
|
|
if version_ge "$version" "$PY_MIN"; then
|
|
PY=$executable PY_VERSION=$version
|
|
return 0
|
|
fi
|
|
PY_OLD="$version $1"
|
|
return 1
|
|
}
|
|
|
|
python_extra() { # py and py.exe are the launcher: they need -3
|
|
case "${1##*/}" in py|py.exe) printf '%s\n' -3 ;; esac
|
|
}
|
|
|
|
given=$(set_value python)
|
|
if [ -n "$given" ]; then
|
|
extra=$(python_extra "$given")
|
|
if ! usable "$given" || ! try_python "$given" $extra; then
|
|
problem "The path given for Python does not work: $given" \
|
|
"every wikitool command runs on Python $PY_MIN or newer, and this path did not start one" \
|
|
"Check the path - it has to be the python executable itself, version $PY_MIN or newer.
|
|
Then run: $SELF --set python=<full path to python>"
|
|
BAD_SET=1
|
|
fi
|
|
else
|
|
previous=$(recorded python) || previous=""
|
|
if [ -n "$previous" ] && usable "$previous"; then
|
|
try_python "$previous" || true
|
|
fi
|
|
if [ -z "$PY" ]; then
|
|
if [ "$PLATFORM" = windows ]; then
|
|
order="python: py:-3 python3:"
|
|
else
|
|
order="python3: python:"
|
|
fi
|
|
for candidate in $order; do
|
|
name=${candidate%%:*}
|
|
extra=${candidate#*:}
|
|
found=$(on_path "$name")
|
|
[ -n "$found" ] || continue
|
|
# A here-document, not a pipe: `break 2` has to leave the outer loop
|
|
# of this shell, and a path may contain spaces ("Program Files").
|
|
while IFS= read -r path; do
|
|
if [ -n "$extra" ]; then
|
|
try_python "$path" "$extra" && break 2
|
|
else
|
|
try_python "$path" && break 2
|
|
fi
|
|
done <<EOF
|
|
$found
|
|
EOF
|
|
done
|
|
fi
|
|
fi
|
|
|
|
# --- the other tools --------------------------------------------------------------
|
|
|
|
REPORT=""
|
|
report() { # <status> <name> <version> <path>
|
|
REPORT="$REPORT$(printf '%-8s %-7s %-8s %s' "$1" "$2" "$3" "$4")
|
|
"
|
|
}
|
|
|
|
if [ -n "$PY" ]; then
|
|
report OK python "$PY_VERSION" "$PY"
|
|
eval "FOUND_python=\$PY"
|
|
elif [ "$BAD_SET" -eq 0 ]; then
|
|
label=$(manifest_field tool python 5)
|
|
why=$(manifest_field tool python 6)
|
|
if [ -n "$PY_OLD" ]; then
|
|
report TOO_OLD python "${PY_OLD%% *}" "${PY_OLD#* }"
|
|
problem "$label ${PY_OLD%% *} is too old - this stack needs $PY_MIN or newer." "$why" \
|
|
"$(install_hint python)
|
|
Or, if a newer one is already installed, give its full path:
|
|
$SELF --set python=<full path to python>"
|
|
else
|
|
report MISSING python - -
|
|
problem "$label $PY_MIN or newer was not found." "$why" \
|
|
"$(install_hint python)
|
|
Or, if it is installed somewhere this check did not look, give its full path:
|
|
$SELF --set python=<full path to python>"
|
|
fi
|
|
fi
|
|
|
|
for tool in $TOOLS; do
|
|
[ "$tool" = python ] && continue
|
|
label=$(manifest_field tool "$tool" 5)
|
|
why=$(manifest_field tool "$tool" 6)
|
|
minimum=$(manifest_field tool "$tool" 3)
|
|
given=$(set_value "$tool")
|
|
path=""
|
|
if [ -n "$given" ]; then
|
|
if usable "$given"; then
|
|
path=$given
|
|
else
|
|
problem "The path given for $label does not work: $given" "$why" \
|
|
"Check the path - it has to be the $tool executable itself.
|
|
Then run: $SELF --set $tool=<full path to $tool>"
|
|
BAD_SET=1
|
|
continue
|
|
fi
|
|
else
|
|
previous=$(recorded "$tool") || previous=""
|
|
if [ -n "$previous" ] && usable "$previous"; then
|
|
path=$previous
|
|
else
|
|
path=$(on_path "$tool" | head -n 1)
|
|
fi
|
|
fi
|
|
if [ -z "$path" ]; then
|
|
report MISSING "$tool" - -
|
|
problem "$label was not found." "$why" \
|
|
"$(install_hint "$tool")
|
|
Or, if it is installed somewhere this check did not look, give its full path:
|
|
$SELF --set $tool=<full path to $tool>"
|
|
continue
|
|
fi
|
|
version=$(version_of "$("$path" --version 2>/dev/null | tr -d '\r')")
|
|
if [ "$minimum" != - ] && { [ -z "$version" ] || ! version_ge "$version" "$minimum"; }; then
|
|
report TOO_OLD "$tool" "${version:-unknown}" "$path"
|
|
problem "$label ${version:-of unknown version} is too old - this stack needs $minimum or newer." "$why" \
|
|
"$(install_hint "$tool")"
|
|
continue
|
|
fi
|
|
native=$(native_path "$path")
|
|
report OK "$tool" "${version:--}" "$native"
|
|
eval "FOUND_$tool=\$native"
|
|
done
|
|
|
|
# --- install folder length (Windows, long paths off) ------------------------------
|
|
|
|
if [ "$PLATFORM" = windows ] && ! longpaths_enabled; then
|
|
limit=$(manifest_field limit install_dir_max 3)
|
|
folder=$(native_path "$ROOT")
|
|
length=$(utf16_length "$folder")
|
|
if [ "$length" -gt "$limit" ]; then
|
|
problem "The folder this wiki is installed in is too long ($length characters, at most $limit): $folder" \
|
|
"Windows on this computer only allows paths of up to 259 characters, and the wiki's own files need the rest" \
|
|
"Move the wiki to a shorter folder, for example C:\\Chemenu, and run this check there.
|
|
Alternatively, someone with administrator rights can turn on long paths in Windows."
|
|
fi
|
|
fi
|
|
|
|
# --- record what was found ----------------------------------------------------------
|
|
|
|
json_string() {
|
|
printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g'
|
|
}
|
|
|
|
write_tools_file() { # <true|false>
|
|
tmp="$TOOLS_FILE.tmp.$$"
|
|
{
|
|
printf '{\n "schema": 1,\n "complete": %s,\n "tools": {' "$1"
|
|
separator=""
|
|
for tool in $TOOLS; do
|
|
eval "value=\${FOUND_$tool:-}"
|
|
[ -n "$value" ] || continue
|
|
printf '%s\n "%s": "%s"' "$separator" "$tool" "$(json_string "$value")"
|
|
separator=","
|
|
done
|
|
printf '\n }\n}\n'
|
|
} > "$tmp" && mv -f "$tmp" "$TOOLS_FILE"
|
|
}
|
|
|
|
printf '%s' "$REPORT"
|
|
|
|
if [ "$BAD_SET" -eq 1 ]; then
|
|
stop # nothing is written for a path that does not work
|
|
fi
|
|
write_tools_file false
|
|
if [ "$PROBLEMS" -gt 0 ]; then
|
|
stop
|
|
fi
|
|
|
|
# --- tools/.venv ----------------------------------------------------------------------
|
|
|
|
venv_python() {
|
|
if [ -x "$VENV/bin/python" ]; then
|
|
printf '%s\n' "$VENV/bin/python"
|
|
elif [ -f "$VENV/Scripts/python.exe" ]; then
|
|
printf '%s\n' "$VENV/Scripts/python.exe"
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
last_lines() {
|
|
printf '%s\n' "$1" | tail -n 5 | sed 's/^/ /'
|
|
}
|
|
|
|
VPY=$(venv_python) || VPY=""
|
|
if [ -z "$VPY" ] || ! "$VPY" -m pip --version >/dev/null 2>&1; then
|
|
if ! output=$("$PY" -m venv --clear "$VENV" 2>&1) || ! VPY=$(venv_python); then
|
|
fix="Python said:
|
|
$(last_lines "$output")"
|
|
if [ "$PLATFORM" = linux ] && command -v apt-get >/dev/null 2>&1; then
|
|
fix="sudo apt install python3-venv
|
|
$fix"
|
|
fi
|
|
problem "The wiki's own Python environment (tools/.venv) could not be created." \
|
|
"wikitool runs in that environment, so that nothing it installs touches the rest of the computer" \
|
|
"$fix"
|
|
stop
|
|
fi
|
|
fi
|
|
|
|
want=$("$VPY" -c 'import hashlib, sys; print(hashlib.sha256(open(sys.argv[1], "rb").read()).hexdigest())' \
|
|
"$REQUIREMENTS" 2>/dev/null | tr -d '\r')
|
|
have=$(cat "$STAMP" 2>/dev/null) || have=""
|
|
if [ -z "$want" ] || [ "$want" != "$have" ]; then
|
|
if ! output=$("$VPY" -m pip install --disable-pip-version-check --quiet -r "$REQUIREMENTS" 2>&1); then
|
|
problem "The libraries wikitool needs could not be installed into tools/.venv." \
|
|
"they are downloaded once from the internet; without them no wikitool command starts" \
|
|
"Check that this computer can reach the internet (a proxy or a security program can block it; if so, ask whoever looks after this computer).
|
|
pip said:
|
|
$(last_lines "$output")"
|
|
stop
|
|
fi
|
|
printf '%s\n' "$want" > "$STAMP"
|
|
fi
|
|
echo "OK venv - $(native_path "$VENV")"
|
|
|
|
write_tools_file true
|
|
echo ""
|
|
echo "Preflight passed. Tool paths are recorded in .wikitool-tools.json; tools/wikitool is ready."
|
|
exit 0
|