260 lines
7.4 KiB
JavaScript
260 lines
7.4 KiB
JavaScript
function log(text) {
|
|
console.log(JSON.stringify(text, null, 2));
|
|
}
|
|
|
|
function join(...rest) {
|
|
return rest.filter((v) => !!v).join(".");
|
|
}
|
|
|
|
function take_one(list) {
|
|
return list.shift();
|
|
}
|
|
|
|
function take_all(list) {
|
|
const all = [...list];
|
|
list.length = 0;
|
|
return all;
|
|
}
|
|
|
|
function tokenize(input) {
|
|
const raw_tokens = input.trim().split(/\s+/).slice(1); // skip command
|
|
const tokens = [];
|
|
|
|
while (raw_tokens.length) {
|
|
const raw_token = take_one(raw_tokens);
|
|
|
|
if (raw_token === "--") {
|
|
tokens.push(`rest::${take_all(raw_tokens).join(" ")}`);
|
|
break;
|
|
}
|
|
|
|
let key;
|
|
let value;
|
|
|
|
if (raw_token.startsWith("--")) {
|
|
[key, value] = raw_token.slice(2).split("=");
|
|
tokens.push(`narg::${key}`);
|
|
} else if (raw_token.startsWith("-")) {
|
|
[key, value] = raw_token.slice(1).split("=");
|
|
tokens.push(...key.split("").map((k) => `narg::${k}`));
|
|
} else {
|
|
tokens.push(`unk::${raw_token}`);
|
|
}
|
|
|
|
if (value !== undefined) {
|
|
tokens.push(`value::${value}`);
|
|
}
|
|
}
|
|
|
|
return tokens;
|
|
}
|
|
|
|
function parse_input(spec, input) {
|
|
const tokens = tokenize(input);
|
|
const values = {};
|
|
|
|
const schema = {};
|
|
const alias_map = {};
|
|
|
|
let position = 0;
|
|
let level = 1;
|
|
let commands = ["root"];
|
|
|
|
function ref(...rest) {
|
|
return commands.slice(0, level).concat(rest).join(".");
|
|
}
|
|
|
|
function get_entry_ref(key) {
|
|
return alias_map[ref(key)];
|
|
}
|
|
|
|
function get_entry_item(...keys) {
|
|
return schema[join(...keys)];
|
|
}
|
|
|
|
function generate_schema() {
|
|
for (const entry of spec) {
|
|
const elements = entry.split(";");
|
|
const type = elements.shift();
|
|
|
|
switch (type) {
|
|
case "command": {
|
|
const aliases = elements.shift().split(",");
|
|
const name = aliases[0];
|
|
const help = elements.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;
|
|
break;
|
|
}
|
|
case "end": {
|
|
level -= 1;
|
|
commands.pop();
|
|
break;
|
|
}
|
|
case "argument": {
|
|
let aliases = elements.shift().split(",");
|
|
let name = aliases[0];
|
|
|
|
const entry = { required: false, kind: "positional" };
|
|
for (const element of elements) {
|
|
const [attribute, attr_value] = element.split(":");
|
|
|
|
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;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
throw new Error(`Invalid entry type: '${type}'`);
|
|
}
|
|
}
|
|
|
|
commands = ["root"];
|
|
level = 1;
|
|
position = 0;
|
|
}
|
|
|
|
function next_token_value() {
|
|
const token = take_one(tokens);
|
|
const [token_type, token_key] = token.split("::");
|
|
if (token_type !== "unk") {
|
|
throw new Error(`Expected option value, but got: ${token_type}. Token: '${token_key}'`);
|
|
}
|
|
return token_key;
|
|
}
|
|
|
|
generate_schema();
|
|
|
|
while (tokens.length > 0) {
|
|
const token = take_one(tokens);
|
|
const [token_type, token_key] = token.split("::");
|
|
if (token_type === "rest") {
|
|
values["__rest"] = token_key;
|
|
continue;
|
|
}
|
|
|
|
// Bubble up arguments -> Loop over all command levels starting by the latest
|
|
let found = false;
|
|
for (level = commands.length; level >= 1; level--) {
|
|
let entry_ref = get_entry_ref(token);
|
|
|
|
// Positional arguments are valid only for the latest command
|
|
if (!entry_ref && level === commands.length && token_type === "unk") {
|
|
entry_ref = get_entry_ref(`pos::${position}`);
|
|
if (entry_ref) {
|
|
position += 1;
|
|
}
|
|
}
|
|
|
|
// Try with parent command
|
|
if (!entry_ref) {
|
|
continue;
|
|
}
|
|
|
|
const entry_type = get_entry_item(entry_ref, "type");
|
|
if (entry_type === "command") {
|
|
commands.push(token_key);
|
|
} else if (entry_type === "argument") {
|
|
const kind = get_entry_item(entry_ref, "kind");
|
|
const dest = get_entry_item(entry_ref, "dest");
|
|
const value = get_entry_item(entry_ref, "value");
|
|
|
|
values[dest] = value; // default one
|
|
|
|
if (kind === "flag") values[dest] = true;
|
|
else if (kind === "option") values[dest] = next_token_value();
|
|
else if (kind === "positional") values[dest] = token_key;
|
|
else if (kind === "rest") values[dest] = token_key;
|
|
else throw new Error(`Invalid attribute type: '${kind}'`);
|
|
}
|
|
|
|
found = true;
|
|
break;
|
|
}
|
|
|
|
if (!found) {
|
|
console.log(`(Skipping invalid argument: '${token_key}'`);
|
|
}
|
|
}
|
|
|
|
log({ commands, values });
|
|
return values;
|
|
}
|
|
|
|
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);
|
|
});
|