taler-util: fix CLI parsing for numberic options
This commit is contained in:
parent
f63765b9f7
commit
a5525eab1e
46
packages/taler-util/src/clk.test.ts
Normal file
46
packages/taler-util/src/clk.test.ts
Normal file
@ -0,0 +1,46 @@
|
||||
/*
|
||||
This file is part of GNU Taler
|
||||
(C) 2018-2019 GNUnet e.V.
|
||||
|
||||
GNU Taler is free software; you can redistribute it and/or modify it under the
|
||||
terms of the GNU General Public License as published by the Free Software
|
||||
Foundation; either version 3, or (at your option) any later version.
|
||||
|
||||
GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along with
|
||||
GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
|
||||
*/
|
||||
|
||||
/**
|
||||
* Type-safe codecs for converting from/to JSON.
|
||||
*/
|
||||
|
||||
import test from "ava";
|
||||
import { clk } from "./clk.js";
|
||||
import {
|
||||
Codec,
|
||||
buildCodecForObject,
|
||||
codecForConstString,
|
||||
codecForString,
|
||||
buildCodecForUnion,
|
||||
} from "./codec.js";
|
||||
|
||||
test("bla", (t) => {
|
||||
const prog = clk.program("foo", {
|
||||
help: "Hello",
|
||||
});
|
||||
|
||||
let success = false;
|
||||
|
||||
prog.maybeOption("opt1", ["-o", "--opt1"], clk.INT).action((args) => {
|
||||
success = true;
|
||||
t.deepEqual(args.foo.opt1, 42);
|
||||
});
|
||||
|
||||
prog.run(["bla", "-o", "42"]);
|
||||
|
||||
t.true(success);
|
||||
});
|
||||
@ -20,6 +20,7 @@
|
||||
import process from "process";
|
||||
import path from "path";
|
||||
import readline from "readline";
|
||||
import { devNull } from "os";
|
||||
|
||||
export namespace clk {
|
||||
class Converter<T> {}
|
||||
@ -329,6 +330,20 @@ export namespace clk {
|
||||
const myArgs: any = (parsedArgs[this.argKey] = {});
|
||||
const foundOptions: { [name: string]: boolean } = {};
|
||||
const currentName = this.name ?? progname;
|
||||
const storeOption = (def: OptionDef, value: string) => {
|
||||
foundOptions[def.name] = true;
|
||||
if (def.conv === INT) {
|
||||
myArgs[def.name] = Number.parseInt(value);
|
||||
} else if (def.conv == null || def.conv === STRING) {
|
||||
myArgs[def.name] = value;
|
||||
} else {
|
||||
throw Error("unknown converter");
|
||||
}
|
||||
};
|
||||
const storeFlag = (def: OptionDef, value: boolean) => {
|
||||
foundOptions[def.name] = true;
|
||||
myArgs[def.name] = value;
|
||||
};
|
||||
for (i = 0; i < unparsedArgs.length; i++) {
|
||||
const argVal = unparsedArgs[i];
|
||||
if (argsTerminated == false) {
|
||||
@ -353,8 +368,7 @@ export namespace clk {
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
foundOptions[d.name] = true;
|
||||
myArgs[d.name] = true;
|
||||
storeFlag(d, true);
|
||||
} else {
|
||||
if (r.value === undefined) {
|
||||
if (i === unparsedArgs.length - 1) {
|
||||
@ -362,12 +376,11 @@ export namespace clk {
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
myArgs[d.name] = unparsedArgs[i + 1];
|
||||
storeOption(d, unparsedArgs[i + 1]);
|
||||
i++;
|
||||
} else {
|
||||
myArgs[d.name] = r.value;
|
||||
storeOption(d, r.value);
|
||||
}
|
||||
foundOptions[d.name] = true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
@ -381,8 +394,7 @@ export namespace clk {
|
||||
process.exit(-1);
|
||||
}
|
||||
if (opt.isFlag) {
|
||||
myArgs[opt.name] = true;
|
||||
foundOptions[opt.name] = true;
|
||||
storeFlag(opt, true);
|
||||
} else {
|
||||
if (si == optShort.length - 1) {
|
||||
if (i === unparsedArgs.length - 1) {
|
||||
@ -390,13 +402,12 @@ export namespace clk {
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
} else {
|
||||
myArgs[opt.name] = unparsedArgs[i + 1];
|
||||
storeOption(opt, unparsedArgs[i + 1]);
|
||||
i++;
|
||||
}
|
||||
} else {
|
||||
myArgs[opt.name] = optShort.substring(si + 1);
|
||||
storeOption(opt, optShort.substring(si + 1));
|
||||
}
|
||||
foundOptions[opt.name] = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -508,16 +519,21 @@ export namespace clk {
|
||||
});
|
||||
}
|
||||
|
||||
run(): void {
|
||||
const args = process.argv;
|
||||
if (args.length < 2) {
|
||||
run(cmdlineArgs?: string[]): void {
|
||||
let args: string[];
|
||||
if (cmdlineArgs) {
|
||||
args = cmdlineArgs;
|
||||
} else {
|
||||
args = process.argv.slice(1);
|
||||
}
|
||||
if (args.length < 1) {
|
||||
console.error(
|
||||
"Error while parsing command line arguments: not enough arguments",
|
||||
);
|
||||
process.exit(-1);
|
||||
}
|
||||
const progname = path.basename(args[1]);
|
||||
const rest = args.slice(2);
|
||||
const progname = path.basename(args[0]);
|
||||
const rest = args.slice(1);
|
||||
|
||||
this.mainCommand.run(progname, [], rest, {});
|
||||
}
|
||||
|
||||
@ -1,614 +0,0 @@
|
||||
/*
|
||||
This file is part of GNU Taler
|
||||
(C) 2019 GNUnet e.V.
|
||||
|
||||
GNU Taler is free software; you can redistribute it and/or modify it under the
|
||||
terms of the GNU General Public License as published by the Free Software
|
||||
Foundation; either version 3, or (at your option) any later version.
|
||||
|
||||
GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along with
|
||||
GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
|
||||
*/
|
||||
|
||||
/**
|
||||
* Imports.
|
||||
*/
|
||||
import process from "process";
|
||||
import path from "path";
|
||||
import readline from "readline";
|
||||
|
||||
class Converter<T> {}
|
||||
|
||||
export const INT = new Converter<number>();
|
||||
export const STRING: Converter<string> = new Converter<string>();
|
||||
|
||||
export interface OptionArgs<T> {
|
||||
help?: string;
|
||||
default?: T;
|
||||
onPresentHandler?: (v: T) => void;
|
||||
}
|
||||
|
||||
export interface ArgumentArgs<T> {
|
||||
metavar?: string;
|
||||
help?: string;
|
||||
default?: T;
|
||||
}
|
||||
|
||||
export interface SubcommandArgs {
|
||||
help?: string;
|
||||
}
|
||||
|
||||
export interface FlagArgs {
|
||||
help?: string;
|
||||
}
|
||||
|
||||
export interface ProgramArgs {
|
||||
help?: string;
|
||||
}
|
||||
|
||||
interface ArgumentDef {
|
||||
name: string;
|
||||
conv: Converter<any>;
|
||||
args: ArgumentArgs<any>;
|
||||
required: boolean;
|
||||
}
|
||||
|
||||
interface SubcommandDef {
|
||||
commandGroup: CommandGroup<any, any>;
|
||||
name: string;
|
||||
args: SubcommandArgs;
|
||||
}
|
||||
|
||||
type ActionFn<TG> = (x: TG) => void;
|
||||
|
||||
type SubRecord<S extends keyof any, N extends keyof any, V> = {
|
||||
[Y in S]: { [X in N]: V };
|
||||
};
|
||||
|
||||
interface OptionDef {
|
||||
name: string;
|
||||
flagspec: string[];
|
||||
/**
|
||||
* Converter, only present for options, not for flags.
|
||||
*/
|
||||
conv?: Converter<any>;
|
||||
args: OptionArgs<any>;
|
||||
isFlag: boolean;
|
||||
required: boolean;
|
||||
}
|
||||
|
||||
function splitOpt(opt: string): { key: string; value?: string } {
|
||||
const idx = opt.indexOf("=");
|
||||
if (idx == -1) {
|
||||
return { key: opt };
|
||||
}
|
||||
return { key: opt.substring(0, idx), value: opt.substring(idx + 1) };
|
||||
}
|
||||
|
||||
function formatListing(key: string, value?: string): string {
|
||||
const res = " " + key;
|
||||
if (!value) {
|
||||
return res;
|
||||
}
|
||||
if (res.length >= 25) {
|
||||
return res + "\n" + " " + value;
|
||||
} else {
|
||||
return res.padEnd(24) + " " + value;
|
||||
}
|
||||
}
|
||||
|
||||
export class CommandGroup<GN extends keyof any, TG> {
|
||||
private shortOptions: { [name: string]: OptionDef } = {};
|
||||
private longOptions: { [name: string]: OptionDef } = {};
|
||||
private subcommandMap: { [name: string]: SubcommandDef } = {};
|
||||
private subcommands: SubcommandDef[] = [];
|
||||
private options: OptionDef[] = [];
|
||||
private arguments: ArgumentDef[] = [];
|
||||
|
||||
private myAction?: ActionFn<TG>;
|
||||
|
||||
constructor(
|
||||
private argKey: string,
|
||||
private name: string | null,
|
||||
private scArgs: SubcommandArgs,
|
||||
) {}
|
||||
|
||||
action(f: ActionFn<TG>): void {
|
||||
if (this.myAction) {
|
||||
throw Error("only one action supported per command");
|
||||
}
|
||||
this.myAction = f;
|
||||
}
|
||||
|
||||
requiredOption<N extends keyof any, V>(
|
||||
name: N,
|
||||
flagspec: string[],
|
||||
conv: Converter<V>,
|
||||
args: OptionArgs<V> = {},
|
||||
): CommandGroup<GN, TG & SubRecord<GN, N, V>> {
|
||||
const def: OptionDef = {
|
||||
args: args,
|
||||
conv: conv,
|
||||
flagspec: flagspec,
|
||||
isFlag: false,
|
||||
required: true,
|
||||
name: name as string,
|
||||
};
|
||||
this.options.push(def);
|
||||
for (const flag of flagspec) {
|
||||
if (flag.startsWith("--")) {
|
||||
const flagname = flag.substring(2);
|
||||
this.longOptions[flagname] = def;
|
||||
} else if (flag.startsWith("-")) {
|
||||
const flagname = flag.substring(1);
|
||||
this.shortOptions[flagname] = def;
|
||||
} else {
|
||||
throw Error("option must start with '-' or '--'");
|
||||
}
|
||||
}
|
||||
return this as any;
|
||||
}
|
||||
|
||||
maybeOption<N extends keyof any, V>(
|
||||
name: N,
|
||||
flagspec: string[],
|
||||
conv: Converter<V>,
|
||||
args: OptionArgs<V> = {},
|
||||
): CommandGroup<GN, TG & SubRecord<GN, N, V | undefined>> {
|
||||
const def: OptionDef = {
|
||||
args: args,
|
||||
conv: conv,
|
||||
flagspec: flagspec,
|
||||
isFlag: false,
|
||||
required: false,
|
||||
name: name as string,
|
||||
};
|
||||
this.options.push(def);
|
||||
for (const flag of flagspec) {
|
||||
if (flag.startsWith("--")) {
|
||||
const flagname = flag.substring(2);
|
||||
this.longOptions[flagname] = def;
|
||||
} else if (flag.startsWith("-")) {
|
||||
const flagname = flag.substring(1);
|
||||
this.shortOptions[flagname] = def;
|
||||
} else {
|
||||
throw Error("option must start with '-' or '--'");
|
||||
}
|
||||
}
|
||||
return this as any;
|
||||
}
|
||||
|
||||
requiredArgument<N extends keyof any, V>(
|
||||
name: N,
|
||||
conv: Converter<V>,
|
||||
args: ArgumentArgs<V> = {},
|
||||
): CommandGroup<GN, TG & SubRecord<GN, N, V>> {
|
||||
const argDef: ArgumentDef = {
|
||||
args: args,
|
||||
conv: conv,
|
||||
name: name as string,
|
||||
required: true,
|
||||
};
|
||||
this.arguments.push(argDef);
|
||||
return this as any;
|
||||
}
|
||||
|
||||
maybeArgument<N extends keyof any, V>(
|
||||
name: N,
|
||||
conv: Converter<V>,
|
||||
args: ArgumentArgs<V> = {},
|
||||
): CommandGroup<GN, TG & SubRecord<GN, N, V | undefined>> {
|
||||
const argDef: ArgumentDef = {
|
||||
args: args,
|
||||
conv: conv,
|
||||
name: name as string,
|
||||
required: false,
|
||||
};
|
||||
this.arguments.push(argDef);
|
||||
return this as any;
|
||||
}
|
||||
|
||||
flag<N extends string, V>(
|
||||
name: N,
|
||||
flagspec: string[],
|
||||
args: OptionArgs<V> = {},
|
||||
): CommandGroup<GN, TG & SubRecord<GN, N, boolean>> {
|
||||
const def: OptionDef = {
|
||||
args: args,
|
||||
flagspec: flagspec,
|
||||
isFlag: true,
|
||||
required: false,
|
||||
name: name as string,
|
||||
};
|
||||
this.options.push(def);
|
||||
for (const flag of flagspec) {
|
||||
if (flag.startsWith("--")) {
|
||||
const flagname = flag.substring(2);
|
||||
this.longOptions[flagname] = def;
|
||||
} else if (flag.startsWith("-")) {
|
||||
const flagname = flag.substring(1);
|
||||
this.shortOptions[flagname] = def;
|
||||
} else {
|
||||
throw Error("option must start with '-' or '--'");
|
||||
}
|
||||
}
|
||||
return this as any;
|
||||
}
|
||||
|
||||
subcommand<GN extends keyof any>(
|
||||
argKey: GN,
|
||||
name: string,
|
||||
args: SubcommandArgs = {},
|
||||
): CommandGroup<GN, TG> {
|
||||
const cg = new CommandGroup<GN, {}>(argKey as string, name, args);
|
||||
const def: SubcommandDef = {
|
||||
commandGroup: cg,
|
||||
name: name as string,
|
||||
args: args,
|
||||
};
|
||||
cg.flag("help", ["-h", "--help"], {
|
||||
help: "Show this message and exit.",
|
||||
});
|
||||
this.subcommandMap[name as string] = def;
|
||||
this.subcommands.push(def);
|
||||
this.subcommands = this.subcommands.sort((x1, x2) => {
|
||||
const a = x1.name;
|
||||
const b = x2.name;
|
||||
if (a === b) {
|
||||
return 0;
|
||||
} else if (a < b) {
|
||||
return -1;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
});
|
||||
return cg as any;
|
||||
}
|
||||
|
||||
printHelp(progName: string, parents: CommandGroup<any, any>[]): void {
|
||||
let usageSpec = "";
|
||||
for (const p of parents) {
|
||||
usageSpec += (p.name ?? progName) + " ";
|
||||
if (p.arguments.length >= 1) {
|
||||
usageSpec += "<ARGS...> ";
|
||||
}
|
||||
}
|
||||
usageSpec += (this.name ?? progName) + " ";
|
||||
if (this.subcommands.length != 0) {
|
||||
usageSpec += "COMMAND ";
|
||||
}
|
||||
for (const a of this.arguments) {
|
||||
const argName = a.args.metavar ?? a.name;
|
||||
usageSpec += `<${argName}> `;
|
||||
}
|
||||
usageSpec = usageSpec.trimRight();
|
||||
console.log(`Usage: ${usageSpec}`);
|
||||
if (this.scArgs.help) {
|
||||
console.log();
|
||||
console.log(this.scArgs.help);
|
||||
}
|
||||
if (this.options.length != 0) {
|
||||
console.log();
|
||||
console.log("Options:");
|
||||
for (const opt of this.options) {
|
||||
let optSpec = opt.flagspec.join(", ");
|
||||
if (!opt.isFlag) {
|
||||
optSpec = optSpec + "=VALUE";
|
||||
}
|
||||
console.log(formatListing(optSpec, opt.args.help));
|
||||
}
|
||||
}
|
||||
|
||||
if (this.subcommands.length != 0) {
|
||||
console.log();
|
||||
console.log("Commands:");
|
||||
for (const subcmd of this.subcommands) {
|
||||
console.log(formatListing(subcmd.name, subcmd.args.help));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Run the (sub-)command with the given command line parameters.
|
||||
*/
|
||||
run(
|
||||
progname: string,
|
||||
parents: CommandGroup<any, any>[],
|
||||
unparsedArgs: string[],
|
||||
parsedArgs: any,
|
||||
): void {
|
||||
let posArgIndex = 0;
|
||||
let argsTerminated = false;
|
||||
let i;
|
||||
let foundSubcommand: CommandGroup<any, any> | undefined = undefined;
|
||||
const myArgs: any = (parsedArgs[this.argKey] = {});
|
||||
const foundOptions: { [name: string]: boolean } = {};
|
||||
const currentName = this.name ?? progname;
|
||||
for (i = 0; i < unparsedArgs.length; i++) {
|
||||
const argVal = unparsedArgs[i];
|
||||
if (argsTerminated == false) {
|
||||
if (argVal === "--") {
|
||||
argsTerminated = true;
|
||||
continue;
|
||||
}
|
||||
if (argVal.startsWith("--")) {
|
||||
const opt = argVal.substring(2);
|
||||
const r = splitOpt(opt);
|
||||
const d = this.longOptions[r.key];
|
||||
if (!d) {
|
||||
console.error(
|
||||
`error: unknown option '--${r.key}' for ${currentName}`,
|
||||
);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
if (d.isFlag) {
|
||||
if (r.value !== undefined) {
|
||||
console.error(`error: flag '--${r.key}' does not take a value`);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
foundOptions[d.name] = true;
|
||||
myArgs[d.name] = true;
|
||||
} else {
|
||||
if (r.value === undefined) {
|
||||
if (i === unparsedArgs.length - 1) {
|
||||
console.error(`error: option '--${r.key}' needs an argument`);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
myArgs[d.name] = unparsedArgs[i + 1];
|
||||
i++;
|
||||
} else {
|
||||
myArgs[d.name] = r.value;
|
||||
}
|
||||
foundOptions[d.name] = true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (argVal.startsWith("-") && argVal != "-") {
|
||||
const optShort = argVal.substring(1);
|
||||
for (let si = 0; si < optShort.length; si++) {
|
||||
const chr = optShort[si];
|
||||
const opt = this.shortOptions[chr];
|
||||
if (!opt) {
|
||||
console.error(`error: option '-${chr}' not known`);
|
||||
process.exit(-1);
|
||||
}
|
||||
if (opt.isFlag) {
|
||||
myArgs[opt.name] = true;
|
||||
foundOptions[opt.name] = true;
|
||||
} else {
|
||||
if (si == optShort.length - 1) {
|
||||
if (i === unparsedArgs.length - 1) {
|
||||
console.error(`error: option '-${chr}' needs an argument`);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
} else {
|
||||
myArgs[opt.name] = unparsedArgs[i + 1];
|
||||
i++;
|
||||
}
|
||||
} else {
|
||||
myArgs[opt.name] = optShort.substring(si + 1);
|
||||
}
|
||||
foundOptions[opt.name] = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (this.subcommands.length != 0) {
|
||||
const subcmd = this.subcommandMap[argVal];
|
||||
if (!subcmd) {
|
||||
console.error(`error: unknown command '${argVal}'`);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
foundSubcommand = subcmd.commandGroup;
|
||||
break;
|
||||
} else {
|
||||
const d = this.arguments[posArgIndex];
|
||||
if (!d) {
|
||||
console.error(`error: too many arguments for ${currentName}`);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
myArgs[d.name] = unparsedArgs[i];
|
||||
posArgIndex++;
|
||||
}
|
||||
}
|
||||
|
||||
if (parsedArgs[this.argKey].help) {
|
||||
this.printHelp(progname, parents);
|
||||
process.exit(0);
|
||||
throw Error("not reached");
|
||||
}
|
||||
|
||||
for (let i = posArgIndex; i < this.arguments.length; i++) {
|
||||
const d = this.arguments[i];
|
||||
if (d.required) {
|
||||
if (d.args.default !== undefined) {
|
||||
myArgs[d.name] = d.args.default;
|
||||
} else {
|
||||
console.error(
|
||||
`error: missing positional argument '${d.name}' for ${currentName}`,
|
||||
);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (const option of this.options) {
|
||||
if (option.isFlag == false && option.required == true) {
|
||||
if (!foundOptions[option.name]) {
|
||||
if (option.args.default !== undefined) {
|
||||
myArgs[option.name] = option.args.default;
|
||||
} else {
|
||||
const name = option.flagspec.join(",");
|
||||
console.error(`error: missing option '${name}'`);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (const option of this.options) {
|
||||
const ph = option.args.onPresentHandler;
|
||||
if (ph && foundOptions[option.name]) {
|
||||
ph(myArgs[option.name]);
|
||||
}
|
||||
}
|
||||
|
||||
if (foundSubcommand) {
|
||||
foundSubcommand.run(
|
||||
progname,
|
||||
Array.prototype.concat(parents, [this]),
|
||||
unparsedArgs.slice(i + 1),
|
||||
parsedArgs,
|
||||
);
|
||||
} else if (this.myAction) {
|
||||
let r;
|
||||
try {
|
||||
r = this.myAction(parsedArgs);
|
||||
} catch (e) {
|
||||
console.error(`An error occurred while running ${currentName}`);
|
||||
console.error(e);
|
||||
process.exit(1);
|
||||
}
|
||||
Promise.resolve(r).catch((e) => {
|
||||
console.error(`An error occurred while running ${currentName}`);
|
||||
console.error(e);
|
||||
process.exit(1);
|
||||
});
|
||||
} else {
|
||||
this.printHelp(progname, parents);
|
||||
process.exit(-1);
|
||||
throw Error("not reached");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export class Program<PN extends keyof any, T> {
|
||||
private mainCommand: CommandGroup<any, any>;
|
||||
|
||||
constructor(argKey: string, args: ProgramArgs = {}) {
|
||||
this.mainCommand = new CommandGroup<any, any>(argKey, null, {
|
||||
help: args.help,
|
||||
});
|
||||
this.mainCommand.flag("help", ["-h", "--help"], {
|
||||
help: "Show this message and exit.",
|
||||
});
|
||||
}
|
||||
|
||||
run(): void {
|
||||
const args = process.argv;
|
||||
if (args.length < 2) {
|
||||
console.error(
|
||||
"Error while parsing command line arguments: not enough arguments",
|
||||
);
|
||||
process.exit(-1);
|
||||
}
|
||||
const progname = path.basename(args[1]);
|
||||
const rest = args.slice(2);
|
||||
|
||||
this.mainCommand.run(progname, [], rest, {});
|
||||
}
|
||||
|
||||
subcommand<GN extends keyof any>(
|
||||
argKey: GN,
|
||||
name: string,
|
||||
args: SubcommandArgs = {},
|
||||
): CommandGroup<GN, T> {
|
||||
const cmd = this.mainCommand.subcommand(argKey, name as string, args);
|
||||
return cmd as any;
|
||||
}
|
||||
|
||||
requiredOption<N extends keyof any, V>(
|
||||
name: N,
|
||||
flagspec: string[],
|
||||
conv: Converter<V>,
|
||||
args: OptionArgs<V> = {},
|
||||
): Program<PN, T & SubRecord<PN, N, V>> {
|
||||
this.mainCommand.requiredOption(name, flagspec, conv, args);
|
||||
return this as any;
|
||||
}
|
||||
|
||||
maybeOption<N extends keyof any, V>(
|
||||
name: N,
|
||||
flagspec: string[],
|
||||
conv: Converter<V>,
|
||||
args: OptionArgs<V> = {},
|
||||
): Program<PN, T & SubRecord<PN, N, V | undefined>> {
|
||||
this.mainCommand.maybeOption(name, flagspec, conv, args);
|
||||
return this as any;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a flag (option without value) to the program.
|
||||
*/
|
||||
flag<N extends string>(
|
||||
name: N,
|
||||
flagspec: string[],
|
||||
args: OptionArgs<boolean> = {},
|
||||
): Program<PN, T & SubRecord<PN, N, boolean>> {
|
||||
this.mainCommand.flag(name, flagspec, args);
|
||||
return this as any;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a required positional argument to the program.
|
||||
*/
|
||||
requiredArgument<N extends keyof any, V>(
|
||||
name: N,
|
||||
conv: Converter<V>,
|
||||
args: ArgumentArgs<V> = {},
|
||||
): Program<N, T & SubRecord<PN, N, V>> {
|
||||
this.mainCommand.requiredArgument(name, conv, args);
|
||||
return this as any;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an optional argument to the program.
|
||||
*/
|
||||
maybeArgument<N extends keyof any, V>(
|
||||
name: N,
|
||||
conv: Converter<V>,
|
||||
args: ArgumentArgs<V> = {},
|
||||
): Program<N, T & SubRecord<PN, N, V | undefined>> {
|
||||
this.mainCommand.maybeArgument(name, conv, args);
|
||||
return this as any;
|
||||
}
|
||||
}
|
||||
|
||||
export type GetArgType<T> = T extends Program<any, infer AT>
|
||||
? AT
|
||||
: T extends CommandGroup<any, infer AT>
|
||||
? AT
|
||||
: any;
|
||||
|
||||
export function program<PN extends keyof any>(
|
||||
argKey: PN,
|
||||
args: ProgramArgs = {},
|
||||
): Program<PN, {}> {
|
||||
return new Program(argKey as string, args);
|
||||
}
|
||||
|
||||
export function prompt(question: string): Promise<string> {
|
||||
const stdinReadline = readline.createInterface({
|
||||
input: process.stdin,
|
||||
output: process.stdout,
|
||||
});
|
||||
return new Promise<string>((resolve, reject) => {
|
||||
stdinReadline.question(question, (res) => {
|
||||
resolve(res);
|
||||
stdinReadline.close();
|
||||
});
|
||||
});
|
||||
}
|
||||
@ -17,65 +17,60 @@
|
||||
/**
|
||||
* Imports.
|
||||
*/
|
||||
import os from "os";
|
||||
import fs from "fs";
|
||||
import path from "path";
|
||||
import { deepStrictEqual } from "assert";
|
||||
import fs from "fs";
|
||||
import os from "os";
|
||||
import path from "path";
|
||||
// Polyfill for encoding which isn't present globally in older nodejs versions
|
||||
import { TextEncoder, TextDecoder } from "util";
|
||||
import {
|
||||
addPaytoQueryParams,
|
||||
AgeRestriction,
|
||||
Amounts,
|
||||
classifyTalerUri,
|
||||
clk,
|
||||
codecForList,
|
||||
codecForString,
|
||||
Configuration,
|
||||
decodeCrock,
|
||||
encodeCrock,
|
||||
getRandomBytes,
|
||||
j2s,
|
||||
Logger,
|
||||
parsePaytoUri,
|
||||
PreparePayResultType,
|
||||
RecoveryMergeStrategy,
|
||||
rsaBlind,
|
||||
setDangerousTimetravel,
|
||||
setGlobalLogLevelFromString,
|
||||
TalerUriType,
|
||||
} from "@gnu-taler/taler-util";
|
||||
import {
|
||||
CryptoDispatcher,
|
||||
getDefaultNodeWallet,
|
||||
getErrorDetailFromException,
|
||||
nativeCrypto,
|
||||
NodeHttpLib,
|
||||
NodeThreadCryptoWorkerFactory,
|
||||
summarizeTalerErrorDetail,
|
||||
SynchronousCryptoWorkerFactory,
|
||||
Wallet,
|
||||
WalletApiOperation,
|
||||
WalletCoreApiClient,
|
||||
walletCoreDebugFlags,
|
||||
} from "@gnu-taler/taler-wallet-core";
|
||||
import type { TalerCryptoInterface } from "@gnu-taler/taler-wallet-core/src/crypto/cryptoImplementation";
|
||||
import { TextDecoder, TextEncoder } from "util";
|
||||
import { runBench1 } from "./bench1.js";
|
||||
import { runBench2 } from "./bench2.js";
|
||||
import { runBench3 } from "./bench3.js";
|
||||
import { runEnv1 } from "./env1.js";
|
||||
import { GlobalTestState, runTestWithState } from "./harness/harness.js";
|
||||
import { getTestInfo, runTests } from "./integrationtests/testrunner.js";
|
||||
import { lintExchangeDeployment } from "./lint.js";
|
||||
// @ts-ignore
|
||||
global.TextEncoder = TextEncoder;
|
||||
// @ts-ignore
|
||||
global.TextDecoder = TextDecoder;
|
||||
import * as clk from "./clk.js";
|
||||
import { getTestInfo, runTests } from "./integrationtests/testrunner.js";
|
||||
import {
|
||||
PreparePayResultType,
|
||||
setDangerousTimetravel,
|
||||
classifyTalerUri,
|
||||
TalerUriType,
|
||||
RecoveryMergeStrategy,
|
||||
Amounts,
|
||||
addPaytoQueryParams,
|
||||
codecForList,
|
||||
codecForString,
|
||||
Logger,
|
||||
Configuration,
|
||||
decodeCrock,
|
||||
rsaBlind,
|
||||
LogLevel,
|
||||
setGlobalLogLevelFromString,
|
||||
parsePaytoUri,
|
||||
AgeRestriction,
|
||||
getRandomBytes,
|
||||
encodeCrock,
|
||||
j2s,
|
||||
} from "@gnu-taler/taler-util";
|
||||
import {
|
||||
NodeHttpLib,
|
||||
getDefaultNodeWallet,
|
||||
NodeThreadCryptoWorkerFactory,
|
||||
walletCoreDebugFlags,
|
||||
WalletApiOperation,
|
||||
WalletCoreApiClient,
|
||||
Wallet,
|
||||
getErrorDetailFromException,
|
||||
CryptoDispatcher,
|
||||
SynchronousCryptoWorkerFactory,
|
||||
nativeCrypto,
|
||||
performanceNow,
|
||||
summarizeTalerErrorDetail,
|
||||
} from "@gnu-taler/taler-wallet-core";
|
||||
import { lintExchangeDeployment } from "./lint.js";
|
||||
import { runBench1 } from "./bench1.js";
|
||||
import { runEnv1 } from "./env1.js";
|
||||
import { GlobalTestState, runTestWithState } from "./harness/harness.js";
|
||||
import { runBench2 } from "./bench2.js";
|
||||
import { runBench3 } from "./bench3.js";
|
||||
import {
|
||||
TalerCryptoInterface,
|
||||
TalerCryptoInterfaceR,
|
||||
} from "@gnu-taler/taler-wallet-core/src/crypto/cryptoImplementation";
|
||||
|
||||
// This module also serves as the entry point for the crypto
|
||||
// thread worker, and thus must expose these two handlers.
|
||||
@ -390,13 +385,10 @@ walletCli
|
||||
help: "Withdraw with a taler://withdraw/ URI",
|
||||
})
|
||||
.requiredArgument("uri", clk.STRING)
|
||||
.maybeOption("restrictAge", ["--restrict-age"], clk.STRING)
|
||||
.maybeOption("restrictAge", ["--restrict-age"], clk.INT)
|
||||
.action(async (args) => {
|
||||
const uri = args.withdraw.uri;
|
||||
const restrictAge =
|
||||
args.withdraw.restrictAge == null
|
||||
? undefined
|
||||
: Number.parseInt(args.withdraw.restrictAge);
|
||||
const restrictAge = args.withdraw.restrictAge;
|
||||
console.log(`age restriction requested (${restrictAge})`);
|
||||
await withWallet(args, async (wallet) => {
|
||||
const withdrawInfo = await wallet.client.call(
|
||||
|
||||
Loading…
Reference in New Issue
Block a user