tomas.mirchev/barg-parser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v1

Browse Source
This commit is contained in:
Tomas Mirchev 2025-10-29 23:01:33 +02:00
parent 9a7411420a
commit f5a64b51ff
5 changed files with 299 additions and 419 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
__test.js Normal file
View File

@ -0,0 +1,15 @@
const inputs = [
"dev build --from mybox2 -abc -q -v --image tm0:node -v -- bla1 bla2",
"dev build --from mybox2 -abc valuec -q -v --image tm0:node mybox -v -- bla1 bla2",
];
let level = 1;
const commands = ["root", "build"];
function ref(...rest) {
return commands
.slice(0, level + 1)
.concat(rest)
.join(".");
}
console.log(ref("from"));

161
arg_parser.sh
View File

@ -1,161 +0,0 @@
#!/usr/bin/env bash
set -euo pipefail
# ===== SPEC =====
SPEC=(
"command;build;Build a dev container"
"argument;name;type:positional;required;help:Name of the container"
"argument;image,i;type:option;required;map:image_name;help:Base image"
"argument;include,I;type:option;repeatable;map:include_paths;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;map:cmd_rest;help:Command and args to run inside the container"
"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"
)
# ===== CONSTANTS =====
ENTRY_COMMAND="command"
ENTRY_ARGUMENT="argument"
ATTR_REQUIRED="required"
ATTR_HELP="help"
ATTR_DEFAULT="default"
ATTR_MAP="map"
ATTR_TYPE="type"
ATTR_REPEATABLE="repeatable"
ATTR_TYPE_POSITIONAL="positional"
ATTR_TYPE_OPTION="option"
ATTR_TYPE_FLAG="flag"
# ===== STORAGE =====
declare -A SPEC_DATA
declare -A SPEC_ALIASES
# ===== GENERATE IDS =====
cmd_id=0
arg_id=0
get_cmd_id() { echo $((cmd_id++)); }
get_arg_id() { echo $((arg_id++)); }
# ===== PARSE SPEC ENTRY =====
parse_spec_entry() {
local raw_entry="$1"
IFS=';' read -r type alias_str rest <<<"$raw_entry"
IFS=',' read -r -a aliases <<<"$alias_str"
declare -A attr
if [[ "$type" == "$ENTRY_COMMAND" ]]; then
attr["$ATTR_HELP"]="$rest"
else
attr["$ATTR_REQUIRED"]=false
attr["$ATTR_REPEATABLE"]=false
attr["$ATTR_TYPE"]="$ATTR_TYPE_POSITIONAL"
attr["$ATTR_MAP"]=""
attr["$ATTR_DEFAULT"]=""
attr["$ATTR_HELP"]=""
# Re-split rest on ';'
IFS=';' read -r -a elements <<<"$rest"
for element in "${elements[@]}"; do
[[ -z "$element" ]] && continue
IFS=':' read -r attribute value <<<"$element"
case "$attribute" in
"$ATTR_REQUIRED") attr["$ATTR_REQUIRED"]=true ;;
"$ATTR_REPEATABLE") attr["$ATTR_REPEATABLE"]=true ;;
"$ATTR_TYPE") attr["$ATTR_TYPE"]="$value" ;;
"$ATTR_MAP") attr["$ATTR_MAP"]="$value" ;;
"$ATTR_DEFAULT") attr["$ATTR_DEFAULT"]="$value" ;;
"$ATTR_HELP") attr["$ATTR_HELP"]="$value" ;;
esac
done
fi
# Serialize attributes to string
local attr_str=""
for k in "${!attr[@]}"; do
attr_str+="$k=${attr[$k]}|"
done
attr_str="${attr_str%|}"
echo "$type;$alias_str;$attr_str"
}
# ===== PARSE SPEC =====
parse_spec() {
local command_filter="${1:-}"
local skip_cmd=false
local exit_on_next_cmd=false
local current_cmd_id=""
for raw_entry in "${SPEC[@]}"; do
local entry
entry="$(parse_spec_entry "$raw_entry")"
IFS=';' read -r type alias_str attr_str <<<"$entry"
IFS=',' read -r -a aliases <<<"$alias_str"
if [[ "$type" == "$ENTRY_COMMAND" ]]; then
if [[ "$exit_on_next_cmd" == true ]]; then
break
fi
if [[ -n "$command_filter" ]]; then
local found=false
for a in "${aliases[@]}"; do
[[ "$a" == "$command_filter" ]] && found=true && break
done
if [[ "$found" == false ]]; then
skip_cmd=true
continue
fi
skip_cmd=false
exit_on_next_cmd=true
fi
current_cmd_id="$(get_cmd_id)"
SPEC_DATA["$current_cmd_id.type"]="$type"
SPEC_DATA["$current_cmd_id.aliases"]="$alias_str"
SPEC_DATA["$current_cmd_id.attr"]="$attr_str"
SPEC_DATA["$current_cmd_id.id"]="$current_cmd_id"
for a in "${aliases[@]}"; do
SPEC_ALIASES["$a"]="$current_cmd_id"
done
elif [[ "$type" == "$ENTRY_ARGUMENT" ]]; then
if [[ "$skip_cmd" == true ]]; then
continue
fi
local this_arg_id
this_arg_id="$(get_arg_id)"
SPEC_DATA["$current_cmd_id.$this_arg_id.type"]="$type"
SPEC_DATA["$current_cmd_id.$this_arg_id.aliases"]="$alias_str"
SPEC_DATA["$current_cmd_id.$this_arg_id.attr"]="$attr_str"
SPEC_DATA["$current_cmd_id.$this_arg_id.id"]="$this_arg_id"
for a in "${aliases[@]}"; do
SPEC_ALIASES["$current_cmd_id.$a"]="$this_arg_id"
done
fi
done
}
# ===== MAIN =====
parse_spec
# Print results as JSON-like structure
echo "{"
echo " \"spec_data\": {"
for k in "${!SPEC_DATA[@]}"; do
printf ' "%s": "%s",\n' "$k" "${SPEC_DATA[$k]}"
done
echo " },"
echo " \"spec_aliases\": {"
for k in "${!SPEC_ALIASES[@]}"; do
printf ' "%s": "%s",\n' "$k" "${SPEC_ALIASES[$k]}"
done
echo " }"
echo "}"

281
barg.js Normal file
View File

@ -0,0 +1,281 @@
const ELEMENTS_SEP = ";";
const ALIAS_SEP = ",";
const ATTR_SEP = ":";
let var_values = {};
let required_values = [];
let schema = {};
let alias_map = {};
let position = 0;
let level = 1;
let commands = ["root"];
function register_command(raw_entry) {
const header = raw_entry.split(ELEMENTS_SEP).slice(1);
const aliases = header.shift().split(ALIAS_SEP);
const name = aliases[0];
const help = header.shift();
// Schema
schema[ref(name, "type")] = "command";
schema[ref(name, "help")] = help;
// Alias
for (const alias of aliases) {
alias_map[ref(`unk::${alias}`)] = ref(name);
}
// Control
commands.push(name);
level += 1;
position = 0;
}
function end_command() {
level -= 1;
commands.pop();
}
function register_argument(raw_entry) {
const elements = raw_entry.split(ELEMENTS_SEP).slice(1);
let aliases = elements.shift().split(ALIAS_SEP);
let name = aliases[0];
const entry = {
required: false,
kind: "positional",
};
for (const element of elements) {
const [attribute, attr_value] = element.split(ATTR_SEP);
if (attribute === "required") entry.required = true;
else if (attribute === "repeatable") entry.repeatable = true;
else if (attribute === "help") entry.help = attr_value;
else if (attribute === "default") entry.default_value = attr_value;
else if (attribute === "dest") entry.dest = attr_value;
else if (attribute === "type") entry.kind = attr_value;
// Defaults
if (entry.dest === undefined) entry.dest = name;
if (entry.value === undefined) entry.value = entry.default_value;
}
// Alias
if (entry.kind === "positional") {
name = String(position++);
aliases = [`pos::${name}`];
} else if (entry.kind === "rest") {
aliases = ["__rest"];
}
for (const alias of aliases) {
if (entry.kind === "option" || entry.kind === "flag")
alias_map[ref(`narg::${alias}`)] = ref(name);
else alias_map[ref(alias)] = ref(name);
}
// Schema
schema[ref(name, "type")] = "argument";
for (const [key, value] of Object.entries(entry)) {
schema[ref(name, key)] = value;
}
}
function generate_schema(spec) {
for (const entry of spec) {
const elements = entry.split(ELEMENTS_SEP);
const type = elements.shift();
switch (type) {
case "command":
register_command(entry);
break;
case "end":
end_command();
break;
case "argument":
register_argument(entry);
break;
default:
throw new Error(`Invalid entry type: '${type}'`);
}
}
position = 0;
level = 1;
commands = ["root"];
}
function parse_input(spec, input) {
// rest
var_values = {};
required_values = [];
position = 0;
level = 1;
commands = ["root"];
schema = {};
alias_map = {};
// code
generate_schema(spec);
const tokens = tokenize(input);
// log({ schema, alias_map });
function next_token() {
const tagged_token = tokens.shift();
const [type, token] = tagged_token.split("::");
return { original: tagged_token, type, token };
}
function next_value() {
const tagged_token = next_token();
if (tagged_token.type !== "unk") {
throw new Error(`Expected option value, but got: ${tagged_token.token}`);
}
return tagged_token.token;
}
while (tokens.length > 0) {
const {
original: token,
type: token_type,
token: token_value,
} = next_token();
if (token_type === "rest") {
var_values["__rest"] = token_value;
continue;
}
let found = false;
for (let i = commands.length; i >= 1; i--) {
level = i;
let entry_ref = alias_map[ref(token)];
if (!entry_ref && level === commands.length && token_type === "unk") {
entry_ref = alias_map[ref(`pos::${position++}`)];
}
if (!entry_ref) {
continue;
}
const [_token_type, token_value] = token.split("::");
const type = schema[join(entry_ref, "type")];
if (type === "command") {
commands.push(token_value);
level += commands.length;
} else if (type === "argument") {
const kind = schema[join(entry_ref, "kind")];
const dest = schema[join(entry_ref, "dest")];
const value = schema[join(entry_ref, "value")];
var_values[dest] = value; // default one?
if (kind === "flag") var_values[dest] = true;
else if (kind === "option") var_values[dest] = next_value();
else if (kind === "positional") var_values[dest] = token_value;
else if (kind === "rest") var_values[dest] = token_value;
}
found = true;
break;
}
if (!found) {
console.log(`(Skipping invalid argument: '${token_value}'`);
}
}
log({ commands, var_values });
return var_values;
}
function tokenize(input) {
const raw_tokens = input.split(/\s+/);
raw_tokens.shift(); // drop command
const tokens = [];
while (raw_tokens.length > 0) {
let token = take_token(raw_tokens);
let value;
if (token === "--") {
tokens.push(`rest::${take_all(raw_tokens).join(" ")}`);
continue;
}
if (token.startsWith("--")) {
[token, value] = token.slice(2).split("=");
tokens.push(`narg::${token}`);
} else if (token.startsWith("-")) {
[token, value] = token.slice(1).split("=");
tokens.push(...token.split("").map((t) => `narg::${t}`));
} else {
tokens.push(`unk::${token}`);
}
if (value) {
tokens.push(`value::${value}`);
}
}
return tokens;
}
function take_token(tokens) {
return tokens.shift();
}
function take_all(tokens) {
const all = [...tokens];
tokens.length = 0;
return all;
}
function ref(...rest) {
return commands.slice(0, level).concat(rest).join(".");
}
function join(...rest) {
return rest.filter((v) => !!v).join(".");
}
function log(text) {
console.log(JSON.stringify(text, null, 2));
}
const SPEC = [
"command;build;Build a dev container",
"argument;from;type:option;map:from_name;help:Name of the base container",
"argument;name;type:positional;required;help:Name of the container",
"argument;image,i;type:option;required;map:image_name;help:Base image",
"argument;include,I;type:option;repeatable;map:include_paths;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;map:cmd_rest;help:Command and args to run inside the container",
"argument;name;dest:name_opt;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",
"end",
"argument;external;required;help:Name of the external container",
"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",
];
const INPUTS = [
"dev build --from base-dev --image node:18 --include src --include test -v -v -q mycontainer -- npm run start",
"dev build container --dev --name webapp externalContainer",
"dev stop mycontainer --kill",
"dev build --from alpine --image node:20 mybox -- echo hi",
];
INPUTS.forEach((input) => {
console.log("\n\n------------------------\n");
console.log("> ", input);
parse_input(SPEC, input);
});

3
package.json Normal file
View File

@ -0,0 +1,3 @@
{
"type": "module"
}

258
parser.js
View File

@ -1,258 +0,0 @@
const SPEC = [
"command;build;Build a dev container",
"argument;name;type:positional;required;help:Name of the container",
"argument;image,i;type:option;required;map:image_name;help:Base image",
"argument;include,I;type:option;repeatable;map:include_paths;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;map:cmd_rest;help:Command and args to run inside the container",
"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",
];
const ENTRY = {
COMMAND: "command",
ARGUMENT: "argument",
};
const ATTR = {
REQUIRED: "required",
HELP: "help",
DEFAULT: "default",
MAP: "map",
TYPE: "type",
REPEATABLE: "repeatable",
POSITION: "position",
};
const ATTR_TYPE = {
POSITIONAL: "positional",
OPTION: "option",
FLAG: "flag",
REST: "rest",
};
const CONTEXT = {
POS_COUNT: "pos_count",
};
/**
* Spec = Entry[]
* Entry = "<element>;...<element>"
* Entry.type "command": "<entry_type>;<identifiers>;<help_text>"
* Entry.type "argument": "<entry_type>;<identifiers>;<attribute>;...<attribute>"
*
* "arg_end", "arg_rest" are provided without need to specify it in the spec.
*
* Attributes:
* - required
* - help:<text>
* - default:<value>
* - map:<var_name>
* - type:<"positional"|"option"|"flag">
* For type.{option,flag}:
* - repeatable
*
*/
function parse_spec_entry(raw_entry, context) {
const elements = raw_entry.split(";");
const entry = {
type: elements.shift(),
aliases: elements.shift().split(","),
};
const attributes = {
[ENTRY.COMMAND]: () => {
return { help: elements.shift() };
},
[ENTRY.ARGUMENT]: () => {
const attributes = {
[ATTR.REQUIRED]: false,
[ATTR.REPEATABLE]: false,
[ATTR.TYPE]: ATTR_TYPE.POSITIONAL,
[ATTR.POSITION]: 0,
[ATTR.MAP]: null,
[ATTR.DEFAULT]: null,
[ATTR.HELP]: null,
};
elements.forEach((element) => {
const [attribute, attribute_value = null] = element.split(":");
({
[ATTR.REQUIRED]: (_) => {
attributes[ATTR.REQUIRED] = true;
},
[ATTR.REPEATABLE]: (_) => {
attributes[ATTR.REPEATABLE] = true;
},
[ATTR.TYPE]: (value) => {
attributes[ATTR.TYPE] = value;
if (value === ATTR_TYPE.POSITIONAL) {
attributes[ATTR.POSITION] = context[CONTEXT.POS_COUNT];
context[CONTEXT.POS_COUNT] += 1;
}
},
[ATTR.MAP]: (value) => {
attributes[ATTR.MAP] = value;
},
[ATTR.DEFAULT]: (value) => {
attributes[ATTR.DEFAULT] = value;
},
[ATTR.HELP]: (value) => {
attributes[ATTR.HELP] = value;
},
})[attribute](attribute_value);
});
// Set default values
if (!attributes[ATTR.MAP]) {
attributes[ATTR.MAP] = entry.aliases[0]; // alias 0 is always the larger format
}
return attributes;
},
}[entry.type]();
return { ...entry, attr: attributes };
}
function generate_id() {
let id = 0;
return () => id++;
}
function parse_spec(spec, command = null) {
const spec_data = {};
const spec_aliases = {};
const get_cmd_id = generate_id();
const get_arg_id = generate_id();
let skip_cmd = false;
let exit_on_next_cmd = false;
let cmd_id = null;
const ctx_defaults = { [CONTEXT.POS_COUNT]: 0 };
const context = {
...ctx_defaults,
reset() {
Object.assign(this, ctx_defaults);
},
};
for (const raw_entry of spec) {
const entry = parse_spec_entry(raw_entry, context);
const exit = {
[ENTRY.COMMAND]: () => {
// Previous command was populated
if (exit_on_next_cmd) return true;
// Looking for a single command
if (command !== null) {
// Not this one
if (!entry.aliases.includes(command)) {
skip_cmd = true;
return;
}
// Populate and exit
skip_cmd = false;
exit_on_next_cmd = true;
}
entry.id = cmd_id = get_cmd_id();
spec_data[entry.id] = entry;
entry.aliases.forEach((alias) => {
spec_aliases[alias] = entry.id;
});
},
[ENTRY.ARGUMENT]: () => {
// Do not populate command
if (skip_cmd) return;
entry.id = get_arg_id();
spec_data[`${cmd_id}.${entry.id}`] = entry;
entry.aliases.forEach((alias) => {
if (entry.attr.type === ATTR_TYPE.POSITIONAL) {
const alias_id = `${cmd_id}.${entry.attr[ATTR.POSITION]}`;
spec_aliases[alias_id] = `${cmd_id}.${entry.id}`;
} else if (
entry.attr.type === ATTR_TYPE.OPTION ||
entry.attr.type === ATTR_TYPE.FLAG
) {
const alias_id = `${cmd_id}.${alias}`;
spec_aliases[alias_id] = `${cmd_id}.${entry.id}`;
} else if (entry.attr.type === ATTR_TYPE.REST) {
const alias_id = `${cmd_id}._rest`;
spec_aliases[alias_id] = `${cmd_id}.${entry.id}`;
}
});
},
}[entry.type]();
context.reset();
if (exit) break;
}
if (command && cmd_id === null) {
throw new Error(`Invalid command: ${command}`);
}
return {
data: spec_data,
aliases: spec_aliases,
cmd_id: command ? cmd_id : null,
};
}
const r = parse_spec(SPEC);
// console.log(JSON.stringify(r, null, 2));
/**
* @return {<variable_name>:<value>}
*/
const inspect = (v) => console.log(JSON.stringify(v, null, 2));
function parse_args(spec, args_raw) {
const vars = {};
const args = args_raw.split(" ");
args.shift(); // script name
const cmd = args.shift();
const get_next = () => args[0];
const consume = () => args.shift();
const consume_all = () => args.splice(0);
const cmd_spec = parse_spec(spec, cmd);
const cmd_info = cmd_spec.data[cmd_spec.cmd_id];
let positional_count = 0;
while (args.length > 0) {
const next = get_next();
const [type, next_arg] = (() => {
if (next === "--") {
return [ATTR_TYPE.REST, "_rest"]; // check if spec if expecing a rest arg
} else if (next.startsWith("--")) {
return [ATTR_TYPE.OPTION, next.slice(2)]; // invalid type. use only to know if to search per key or whole string
} else if (next.startsWith("-")) {
return [ATTR_TYPE.FLAG, next.slice(1)]; // same
} else {
return [ATTR_TYPE.POSITIONAL, positional_count++];
}
})();
const alias_id = `${cmd_info.id}.${next_arg}`;
const next_arg_id = cmd_spec.aliases[alias_id];
if (typeof next_arg_id !== "undefined") {
consume();
const next_arg_info = cmd_spec.data[next_arg_id];
if (next_arg_info.attr.type === ATTR_TYPE.OPTION) {
vars[next_arg_info.attr.map] = consume();
} else if (next_arg_info.attr.type === ATTR_TYPE.FLAG) {
vars[next_arg_info.attr.map] = true;
} else if (next_arg_info.attr.type === ATTR_TYPE.REST) {
vars[next_arg_info.attr.map] = consume_all();
} else if (next_arg_info.attr.type === ATTR_TYPE.POSITIONAL) {
vars[next_arg_info.attr.map] = next;
}
} else {
inspect(vars);
throw new Error(`Invalid argument: '${next_arg}'`);
}
}
return vars;
}
const args = "dev build -q -v --image tm0:node mybox -v -- bla1 bla2";
inspect(parse_args(SPEC, args));