380 lines
9.9 KiB
Bash
380 lines
9.9 KiB
Bash
#!/usr/bin/env bash
|
|
# Bash 5+
|
|
|
|
# TODO (NOT IMPLEMENTED):
|
|
# - repeatable attribute
|
|
|
|
# ---------- helpers ----------
|
|
join() {
|
|
local out="" sep="" x
|
|
for x in "$@"; do
|
|
[[ -n "$x" ]] || continue
|
|
out+="${sep}${x}"
|
|
sep="."
|
|
done
|
|
printf '%s' "$out"
|
|
}
|
|
|
|
# ---------- tokenizer ----------
|
|
tokenize() {
|
|
local input=$1
|
|
TOKENS=()
|
|
read -r -a args <<<"$input"
|
|
local root=${args[0]}
|
|
TOKENS+=("root::${root}")
|
|
args=("${args[@]:1}")
|
|
|
|
while ((${#args[@]})); do
|
|
local token=${args[0]}
|
|
args=("${args[@]:1}")
|
|
|
|
if [[ "$token" == "--" ]]; then
|
|
TOKENS+=("rest::${args[*]}")
|
|
break
|
|
fi
|
|
|
|
if [[ "$token" == --* ]]; then
|
|
local kv=${token#--}
|
|
local key=${kv%%=*}
|
|
TOKENS+=("narg::${key}")
|
|
if [[ "$kv" == *"="* ]]; then
|
|
local value=${kv#*=}
|
|
TOKENS+=("value::${value}")
|
|
fi
|
|
continue
|
|
fi
|
|
|
|
if [[ "$token" == -* ]]; then
|
|
local sv=${token#-}
|
|
local flags=${sv%%=*}
|
|
local value=
|
|
if [[ "$sv" == *"="* ]]; then value=${sv#*=}; fi
|
|
local i ch
|
|
for ((i = 0; i < ${#flags}; i++)); do
|
|
ch=${flags:i:1}
|
|
TOKENS+=("narg::${ch}")
|
|
done
|
|
[[ -n "$value" ]] && TOKENS+=("value::${value}")
|
|
continue
|
|
fi
|
|
|
|
TOKENS+=("unk::${token}")
|
|
done
|
|
}
|
|
|
|
# ---------- parser ----------
|
|
declare -A S A
|
|
|
|
generate_schema() {
|
|
S=()
|
|
A=()
|
|
local spec_name=$1
|
|
local -n SPEC_REF="$spec_name"
|
|
|
|
local _id=100
|
|
local level=-1
|
|
local -a pos=()
|
|
local -a cmds=()
|
|
|
|
for entry in "${SPEC_REF[@]}"; do
|
|
IFS=';' read -r -a parts <<<"$entry"
|
|
local type=${parts[0]}
|
|
case "$type" in
|
|
command)
|
|
local id=$_id
|
|
_id=$((_id + 1))
|
|
IFS=',' read -r -a aliases <<<"${parts[1]}"
|
|
local help="${parts[2]}"
|
|
S["$id.entryType"]="command"
|
|
S["$id.name"]="${aliases[0]}"
|
|
S["$id.help"]="$help"
|
|
S["$id.args"]=""
|
|
|
|
if ((${#cmds[@]} == 0)); then
|
|
A["cmd::root"]=$id
|
|
else
|
|
local last=$((${#cmds[@]} - 1))
|
|
for alias in "${aliases[@]}"; do
|
|
A["$(join "${cmds[$last]}" "cmd::${alias}")"]=$id
|
|
done
|
|
fi
|
|
|
|
level=$((level + 1))
|
|
cmds+=("$id")
|
|
pos+=(0)
|
|
;;
|
|
end)
|
|
level=$((level - 1))
|
|
if ((${#cmds[@]} > 0)); then cmds=("${cmds[@]:0:${#cmds[@]}-1}"); fi
|
|
if ((${#pos[@]} > 0)); then pos=("${pos[@]:0:${#pos[@]}-1}"); fi
|
|
;;
|
|
argument)
|
|
local id=$_id
|
|
_id=$((_id + 1))
|
|
IFS=',' read -r -a aliases <<<"${parts[1]}"
|
|
local name="${aliases[0]}"
|
|
|
|
local dest="$name"
|
|
local required="false"
|
|
local atype="positional"
|
|
local value=""
|
|
local help=""
|
|
local i kv k v
|
|
for ((i = 2; i < ${#parts[@]}; i++)); do
|
|
kv=${parts[i]}
|
|
if [[ "$kv" == *":"* ]]; then
|
|
k=${kv%%:*}
|
|
v=${kv#*:}
|
|
else
|
|
k=$kv
|
|
v="true"
|
|
fi
|
|
case "$k" in
|
|
dest) dest="$v" ;;
|
|
required) required="$v" ;;
|
|
type) atype="$v" ;;
|
|
help) help="$v" ;;
|
|
default) value="$v" ;;
|
|
repeatable) S["$id.repeatable"]="$v" ;;
|
|
esac
|
|
done
|
|
|
|
S["$id.entryType"]="argument"
|
|
S["$id.name"]="$name"
|
|
S["$id.dest"]="$dest"
|
|
S["$id.required"]="$required"
|
|
S["$id.type"]="$atype"
|
|
[[ -n "$help" ]] && S["$id.help"]="$help"
|
|
[[ -n "$value" ]] && S["$id.value"]="$value"
|
|
|
|
local last=$((${#cmds[@]} - 1))
|
|
local cmdArgsKey
|
|
cmdArgsKey="$(join "${cmds[$last]}" "args")"
|
|
if [[ -z "${S[$cmdArgsKey]}" ]]; then
|
|
S["$cmdArgsKey"]="$id"
|
|
else
|
|
S["$cmdArgsKey"]+=",${id}"
|
|
fi
|
|
|
|
case "$atype" in
|
|
positional)
|
|
A["$(join "${cmds[$last]}" "pos::${pos[$last]}")"]=$id
|
|
pos[$last]=$((pos[$last] + 1))
|
|
;;
|
|
rest)
|
|
A["$(join "${cmds[$last]}" "rest")"]=$id
|
|
;;
|
|
option | flag)
|
|
for alias in "${aliases[@]}"; do
|
|
A["$(join "${cmds[$last]}" "narg::${alias}")"]=$id
|
|
done
|
|
;;
|
|
esac
|
|
;;
|
|
*)
|
|
printf 'Error: Invalid entry type: "%s"\n' "$type" >&2
|
|
return 1
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
print_result() {
|
|
local -a COMMANDS=("${!1}")
|
|
declare -n VALUES_REF="$2"
|
|
|
|
printf 'commands:'
|
|
local c
|
|
for c in "${COMMANDS[@]}"; do printf ' %s' "$c"; done
|
|
printf '\n'
|
|
printf 'values:\n'
|
|
local k v
|
|
for k in "${!VALUES_REF[@]}"; do
|
|
v=${VALUES_REF[$k]}
|
|
if [[ "$v" == *" "* ]]; then
|
|
printf ' %s="%s"\n' "$k" "$v"
|
|
else
|
|
printf ' %s=%s\n' "$k" "$v"
|
|
fi
|
|
done
|
|
}
|
|
|
|
parse_input() {
|
|
local spec_name=$1
|
|
local input=$2
|
|
tokenize "$input"
|
|
generate_schema "$spec_name" || return 1
|
|
|
|
local -a cmds=()
|
|
local -a pos=()
|
|
local tagged token tokenTag
|
|
|
|
while ((${#TOKENS[@]})); do
|
|
tagged=${TOKENS[0]}
|
|
TOKENS=("${TOKENS[@]:1}")
|
|
tokenTag=${tagged%%::*}
|
|
token=${tagged#*::}
|
|
|
|
local found=0
|
|
local level start_level entryId id
|
|
start_level=$((${#cmds[@]} ? ${#cmds[@]} - 1 : 0))
|
|
|
|
for ((level = start_level; level >= 0; level--)); do
|
|
entryId=""
|
|
case "$tokenTag" in
|
|
root)
|
|
entryId="${A["cmd::root"]}"
|
|
;;
|
|
rest)
|
|
((${#cmds[@]})) || {
|
|
entryId=""
|
|
break
|
|
}
|
|
entryId="${A["$(join "${cmds[$level]}" "rest")"]}"
|
|
;;
|
|
narg)
|
|
((${#cmds[@]})) || {
|
|
entryId=""
|
|
break
|
|
}
|
|
entryId="${A["$(join "${cmds[$level]}" "$tagged")"]}"
|
|
;;
|
|
unk)
|
|
((${#cmds[@]})) || { entryId=""; } # cannot be positional before a command
|
|
if [[ -z "$entryId" && ${#cmds[@]} -gt 0 ]]; then
|
|
id="${A["$(join "${cmds[$level]}" "cmd::${token}")"]}"
|
|
if [[ -z "$id" && $level -eq $((${#pos[@]} - 1)) ]]; then
|
|
id="${A["$(join "${cmds[$level]}" "pos::${pos[$level]}")"]}"
|
|
[[ -n "$id" ]] && pos[$level]=$((pos[$level] + 1))
|
|
fi
|
|
entryId="$id"
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
[[ -z "$entryId" ]] && continue
|
|
|
|
local entryType=${S["$entryId.entryType"]}
|
|
case "$entryType" in
|
|
command)
|
|
cmds+=("$entryId")
|
|
pos+=(0)
|
|
if [[ "$tokenTag" == "root" ]]; then
|
|
S["$entryId.name"]="$token"
|
|
fi
|
|
;;
|
|
argument)
|
|
local atype=${S["$entryId.type"]}
|
|
local val=""
|
|
case "$atype" in
|
|
rest | positional) val="$token" ;;
|
|
flag) val="true" ;;
|
|
option)
|
|
if ((${#TOKENS[@]} == 0)); then
|
|
printf 'Error: No value provided for option argument: "%s"\n' "$token" >&2
|
|
return 1
|
|
fi
|
|
local nTagged=${TOKENS[0]}
|
|
local nTag=${nTagged%%::*}
|
|
local nTok=${nTagged#*::}
|
|
if [[ "$nTag" != "value" && "$nTag" != "unk" ]]; then
|
|
printf 'Error: Expected option argument, but got: "%s" (%s). Skipping...\n' "$nTok" "$nTag" >&2
|
|
else
|
|
TOKENS=("${TOKENS[@]:1}")
|
|
val="$nTok"
|
|
fi
|
|
;;
|
|
esac
|
|
S["$entryId.value"]="$val"
|
|
;;
|
|
esac
|
|
|
|
found=1
|
|
break
|
|
done
|
|
|
|
if ((found == 0)); then
|
|
printf 'Invalid argument: "%s" (%s). Skipping...\n' "$token" "$tokenTag"
|
|
fi
|
|
done
|
|
|
|
# finalize
|
|
local -a COMMANDS=()
|
|
declare -A VALUES=()
|
|
|
|
local cmdId cmdName cmdArgs argId name dest value required
|
|
for cmdId in "${cmds[@]}"; do
|
|
cmdName=${S["$cmdId.name"]}
|
|
COMMANDS+=("$cmdName")
|
|
cmdArgs=${S["$cmdId.args"]}
|
|
[[ -z "$cmdArgs" ]] && continue
|
|
IFS=',' read -r -a argIds <<<"$cmdArgs"
|
|
for argId in "${argIds[@]}"; do
|
|
name=${S["$argId.name"]}
|
|
dest=${S["$argId.dest"]}
|
|
value=${S["$argId.value"]}
|
|
required=${S["$argId.required"]}
|
|
|
|
if [[ "$required" == "true" && -z "$value" ]]; then
|
|
printf 'Error: Argument "%s" is required in command "%s"\n' "$name" "$cmdName" >&2
|
|
return 1
|
|
fi
|
|
if [[ -n "${VALUES[$dest]+x}" ]]; then
|
|
VALUES["${cmdName}_${dest}"]="$value"
|
|
else
|
|
VALUES["$dest"]="$value"
|
|
fi
|
|
done
|
|
done
|
|
|
|
print_result COMMANDS[@] VALUES
|
|
}
|
|
|
|
parse_input_wrap() {
|
|
local spec_name=$1
|
|
local input=$2
|
|
parse_input "$spec_name" "$input" || printf 'Error: Failed to parse input\n'
|
|
}
|
|
|
|
# ---------- spec and tests ----------
|
|
SPEC=(
|
|
"command;barg;Barg - Bash Argument Parser"
|
|
"argument;global;type:flag"
|
|
"command;build;Build a dev container"
|
|
"argument;from;type:option;dest:fromName;help:Name of the base container"
|
|
"argument;name;type:positional;required;help:Name of the container"
|
|
"argument;nametwo;help:Name of the container"
|
|
"argument;image,i;type:option;required;dest:imageName;help:Base image"
|
|
"argument;include,I;type:option;repeatable;dest:includePaths;help:Include paths"
|
|
"argument;verbose,v;type:flag;repeatable;default:0;help:Increase verbosity (-v, -vv, ...)"
|
|
"argument;quiet,q;type:flag;default:false;help:Suppress all output"
|
|
"argument;cmd;type:rest;help:Command and args to run inside the container"
|
|
"argument;name;dest:nameOpt;type:option;help:Building container name"
|
|
"command;container;Container building"
|
|
"argument;dev;type:flag;help:Is dev or not"
|
|
"argument;name;required;help:Building container name"
|
|
"argument;cmd;type:rest;dest:cmdRest;help:Command and args to run inside the container"
|
|
"end"
|
|
"end"
|
|
"command;stop;Stop a dev container"
|
|
"argument;name;type:positional;required;help:Name of the container"
|
|
"argument;kill,k;type:flag;default:false;help:Force kill the container"
|
|
"end"
|
|
"end"
|
|
)
|
|
|
|
INPUTS=(
|
|
"dev build -i myimage buildtwo --from base-dev --image node:18 --include src --include test -v -v -q mycontainer -- npm run start"
|
|
"dev build buildname container -i myimage --dev --name webapp externalContainer"
|
|
"dev --global build --image debian mybox container --dev --name webapp externalContainer -- echo hi"
|
|
"dev stop mycontainer --kill"
|
|
"dev stop mycontainer --kill -- not specified one"
|
|
"dev build --from alpine --image node:20 mybox -- echo hi"
|
|
"dev build --aaaaa --from alpine --image node:20 --bbbbb orb mybox ccccc -- echo hi"
|
|
)
|
|
|
|
for input in "${INPUTS[@]}"; do
|
|
printf "\n\n------------------------\n\n> %s\n" "$input"
|
|
parse_input_wrap SPEC "$input"
|
|
done
|