deno.land / std@0.91.0 / flags / mod.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
import { assert } from "../_util/assert.ts";
export interface Args { /** Contains all the arguments that didn't have an option associated with * them. */ _: Array<string | number>; // deno-lint-ignore no-explicit-any [key: string]: any;}
export interface ArgParsingOptions { /** When `true`, populate the result `_` with everything before the `--` and * the result `['--']` with everything after the `--`. Here's an example: * * // $ deno run example.ts -- a arg1 * import { parse } from "https://deno.land/std/flags/mod.ts"; * console.dir(parse(Deno.args, { "--": false })); * // output: { _: [ "a", "arg1" ] } * console.dir(parse(Deno.args, { "--": true })); * // output: { _: [], --: [ "a", "arg1" ] } * * Defaults to `false`. */ "--"?: boolean;
/** An object mapping string names to strings or arrays of string argument * names to use as aliases */ alias?: Record<string, string | string[]>;
/** A boolean, string or array of strings to always treat as booleans. If * `true` will treat all double hyphenated arguments without equal signs as * `boolean` (e.g. affects `--foo`, not `-f` or `--foo=bar`) */ boolean?: boolean | string | string[];
/** An object mapping string argument names to default values. */ default?: Record<string, unknown>;
/** When `true`, populate the result `_` with everything after the first * non-option. */ stopEarly?: boolean;
/** A string or array of strings argument names to always treat as strings. */ string?: string | string[];
/** A function which is invoked with a command line parameter not defined in * the `options` configuration object. If the function returns `false`, the * unknown option is not added to `parsedArgs`. */ unknown?: (arg: string, key?: string, value?: unknown) => unknown;}
interface Flags { bools: Record<string, boolean>; strings: Record<string, boolean>; unknownFn: (arg: string, key?: string, value?: unknown) => unknown; allBools: boolean;}
interface NestedMapping { [key: string]: NestedMapping | unknown;}
function get<T>(obj: Record<string, T>, key: string): T | undefined { if (Object.prototype.hasOwnProperty.call(obj, key)) { return obj[key]; }}
function getForce<T>(obj: Record<string, T>, key: string): T { const v = get(obj, key); assert(v != null); return v;}
function isNumber(x: unknown): boolean { if (typeof x === "number") return true; if (/^0x[0-9a-f]+$/i.test(String(x))) return true; return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(String(x));}
function hasKey(obj: NestedMapping, keys: string[]): boolean { let o = obj; keys.slice(0, -1).forEach((key) => { o = (get(o, key) ?? {}) as NestedMapping; });
const key = keys[keys.length - 1]; return key in o;}
/** Take a set of command line arguments, with an optional set of options, and * return an object representation of those argument. * * const parsedArgs = parse(Deno.args); */export function parse( args: string[], { "--": doubleDash = false, alias = {}, boolean = false, default: defaults = {}, stopEarly = false, string = [], unknown = (i: string): unknown => i, }: ArgParsingOptions = {},): Args { const flags: Flags = { bools: {}, strings: {}, unknownFn: unknown, allBools: false, };
if (boolean !== undefined) { if (typeof boolean === "boolean") { flags.allBools = !!boolean; } else { const booleanArgs = typeof boolean === "string" ? [boolean] : boolean;
for (const key of booleanArgs.filter(Boolean)) { flags.bools[key] = true; } } }
const aliases: Record<string, string[]> = {}; if (alias !== undefined) { for (const key in alias) { const val = getForce(alias, key); if (typeof val === "string") { aliases[key] = [val]; } else { aliases[key] = val; } for (const alias of getForce(aliases, key)) { aliases[alias] = [key].concat(aliases[key].filter((y) => alias !== y)); } } }
if (string !== undefined) { const stringArgs = typeof string === "string" ? [string] : string;
for (const key of stringArgs.filter(Boolean)) { flags.strings[key] = true; const alias = get(aliases, key); if (alias) { for (const al of alias) { flags.strings[al] = true; } } } }
const argv: Args = { _: [] };
function argDefined(key: string, arg: string): boolean { return ( (flags.allBools && /^--[^=]+$/.test(arg)) || get(flags.bools, key) || !!get(flags.strings, key) || !!get(aliases, key) ); }
function setKey(obj: NestedMapping, keys: string[], value: unknown): void { let o = obj; keys.slice(0, -1).forEach(function (key): void { if (get(o, key) === undefined) { o[key] = {}; } o = get(o, key) as NestedMapping; });
const key = keys[keys.length - 1]; if ( get(o, key) === undefined || get(flags.bools, key) || typeof get(o, key) === "boolean" ) { o[key] = value; } else if (Array.isArray(get(o, key))) { (o[key] as unknown[]).push(value); } else { o[key] = [get(o, key), value]; } }
function setArg( key: string, val: unknown, arg: string | undefined = undefined, ): void { if (arg && flags.unknownFn && !argDefined(key, arg)) { if (flags.unknownFn(arg, key, val) === false) return; }
const value = !get(flags.strings, key) && isNumber(val) ? Number(val) : val; setKey(argv, key.split("."), value);
const alias = get(aliases, key); if (alias) { for (const x of alias) { setKey(argv, x.split("."), value); } } }
function aliasIsBoolean(key: string): boolean { return getForce(aliases, key).some( (x) => typeof get(flags.bools, x) === "boolean", ); }
for (const key of Object.keys(flags.bools)) { setArg(key, defaults[key] === undefined ? false : defaults[key]); }
let notFlags: string[] = [];
// all args after "--" are not parsed if (args.includes("--")) { notFlags = args.slice(args.indexOf("--") + 1); args = args.slice(0, args.indexOf("--")); }
for (let i = 0; i < args.length; i++) { const arg = args[i];
if (/^--.+=/.test(arg)) { const m = arg.match(/^--([^=]+)=(.*)$/s); assert(m != null); const [, key, value] = m;
if (flags.bools[key]) { const booleanValue = value !== "false"; setArg(key, booleanValue, arg); } else { setArg(key, value, arg); } } else if (/^--no-.+/.test(arg)) { const m = arg.match(/^--no-(.+)/); assert(m != null); setArg(m[1], false, arg); } else if (/^--.+/.test(arg)) { const m = arg.match(/^--(.+)/); assert(m != null); const [, key] = m; const next = args[i + 1]; if ( next !== undefined && !/^-/.test(next) && !get(flags.bools, key) && !flags.allBools && (get(aliases, key) ? !aliasIsBoolean(key) : true) ) { setArg(key, next, arg); i++; } else if (/^(true|false)$/.test(next)) { setArg(key, next === "true", arg); i++; } else { setArg(key, get(flags.strings, key) ? "" : true, arg); } } else if (/^-[^-]+/.test(arg)) { const letters = arg.slice(1, -1).split("");
let broken = false; for (let j = 0; j < letters.length; j++) { const next = arg.slice(j + 2);
if (next === "-") { setArg(letters[j], next, arg); continue; }
if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) { setArg(letters[j], next.split(/=(.+)/)[1], arg); broken = true; break; }
if ( /[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next) ) { setArg(letters[j], next, arg); broken = true; break; }
if (letters[j + 1] && letters[j + 1].match(/\W/)) { setArg(letters[j], arg.slice(j + 2), arg); broken = true; break; } else { setArg(letters[j], get(flags.strings, letters[j]) ? "" : true, arg); } }
const [key] = arg.slice(-1); if (!broken && key !== "-") { if ( args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !get(flags.bools, key) && (get(aliases, key) ? !aliasIsBoolean(key) : true) ) { setArg(key, args[i + 1], arg); i++; } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) { setArg(key, args[i + 1] === "true", arg); i++; } else { setArg(key, get(flags.strings, key) ? "" : true, arg); } } } else { if (!flags.unknownFn || flags.unknownFn(arg) !== false) { argv._.push(flags.strings["_"] ?? !isNumber(arg) ? arg : Number(arg)); } if (stopEarly) { argv._.push(...args.slice(i + 1)); break; } } }
for (const key of Object.keys(defaults)) { if (!hasKey(argv, key.split("."))) { setKey(argv, key.split("."), defaults[key]);
if (aliases[key]) { for (const x of aliases[key]) { setKey(argv, x.split("."), defaults[key]); } } } }
if (doubleDash) { argv["--"] = []; for (const key of notFlags) { argv["--"].push(key); } } else { for (const key of notFlags) { argv._.push(key); } }
return argv;}
std
Version Info
3 years ago
External Dependencies
No external dependencies 🎉
