mirror of
https://github.com/denoland/deno
synced 2024-09-13 13:21:50 +00:00
354 lines
8.7 KiB
Rust
354 lines
8.7 KiB
Rust
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
|
use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
|
|
|
|
// Creates vector of strings, Vec<String>
|
|
#[cfg(test)]
|
|
macro_rules! svec {
|
|
($($x:expr),*) => (vec![$($x.to_string()),*]);
|
|
}
|
|
|
|
#[cfg_attr(feature = "cargo-clippy", allow(stutter))]
|
|
#[derive(Clone, Debug, PartialEq, Default)]
|
|
pub struct DenoFlags {
|
|
pub log_debug: bool,
|
|
pub version: bool,
|
|
pub reload: bool,
|
|
pub allow_read: bool,
|
|
pub allow_write: bool,
|
|
pub allow_net: bool,
|
|
pub allow_env: bool,
|
|
pub allow_run: bool,
|
|
pub allow_high_precision: bool,
|
|
pub no_prompts: bool,
|
|
pub v8_help: bool,
|
|
pub v8_flags: Option<Vec<String>>,
|
|
}
|
|
|
|
static ENV_VARIABLES_HELP: &str = "ENVIRONMENT VARIABLES:
|
|
DENO_DIR Set deno's base directory
|
|
NO_COLOR Set to disable color";
|
|
|
|
pub fn create_cli_app<'a, 'b>() -> App<'a, 'b> {
|
|
App::new("deno")
|
|
.bin_name("deno")
|
|
.global_settings(&[AppSettings::ColorNever])
|
|
.settings(&[
|
|
AppSettings::AllowExternalSubcommands,
|
|
AppSettings::DisableVersion,
|
|
]).after_help(ENV_VARIABLES_HELP)
|
|
.arg(
|
|
Arg::with_name("allow-read")
|
|
.long("allow-read")
|
|
.help("Allow file system read access"),
|
|
).arg(
|
|
Arg::with_name("allow-write")
|
|
.long("allow-write")
|
|
.help("Allow file system write access"),
|
|
).arg(
|
|
Arg::with_name("allow-net")
|
|
.long("allow-net")
|
|
.help("Allow network access"),
|
|
).arg(
|
|
Arg::with_name("allow-env")
|
|
.long("allow-env")
|
|
.help("Allow environment access"),
|
|
).arg(
|
|
Arg::with_name("allow-run")
|
|
.long("allow-run")
|
|
.help("Allow running subprocesses"),
|
|
).arg(
|
|
Arg::with_name("allow-high-precision")
|
|
.long("allow-high-precision")
|
|
.help("Allow high precision time measurement"),
|
|
).arg(
|
|
Arg::with_name("allow-all")
|
|
.short("A")
|
|
.long("allow-all")
|
|
.help("Allow all permissions"),
|
|
).arg(
|
|
Arg::with_name("no-prompt")
|
|
.long("no-prompt")
|
|
.help("Do not use prompts"),
|
|
).arg(
|
|
Arg::with_name("log-debug")
|
|
.short("D")
|
|
.long("log-debug")
|
|
.help("Log debug output"),
|
|
).arg(
|
|
Arg::with_name("reload")
|
|
.short("r")
|
|
.long("reload")
|
|
.help("Reload source code cache (recompile TypeScript)"),
|
|
).arg(
|
|
Arg::with_name("v8-options")
|
|
.long("v8-options")
|
|
.help("Print V8 command line options"),
|
|
).arg(
|
|
Arg::with_name("v8-flags")
|
|
.long("v8-flags")
|
|
.takes_value(true)
|
|
.use_delimiter(true)
|
|
.require_equals(true)
|
|
.help("Set V8 command line options"),
|
|
).subcommand(SubCommand::with_name("version").about("Print the version"))
|
|
.subcommand(
|
|
SubCommand::with_name("fetch")
|
|
.setting(AppSettings::DisableVersion)
|
|
.about("Fetch the dependencies")
|
|
.arg(Arg::with_name("file").takes_value(true).required(true)),
|
|
).subcommand(
|
|
SubCommand::with_name("types")
|
|
.setting(AppSettings::DisableVersion)
|
|
.about("Print runtime TypeScript declarations"),
|
|
).subcommand(
|
|
SubCommand::with_name("info")
|
|
.setting(AppSettings::DisableVersion)
|
|
.about("Show source file related info")
|
|
.arg(Arg::with_name("file").takes_value(true).required(true)),
|
|
).subcommand(
|
|
SubCommand::with_name("eval")
|
|
.setting(AppSettings::DisableVersion)
|
|
.about("Eval script")
|
|
.arg(Arg::with_name("code").takes_value(true).required(true)),
|
|
).subcommand(
|
|
SubCommand::with_name("fmt")
|
|
.setting(AppSettings::DisableVersion)
|
|
.about("Format files")
|
|
.arg(
|
|
Arg::with_name("files")
|
|
.takes_value(true)
|
|
.multiple(true)
|
|
.required(true),
|
|
),
|
|
).subcommand(
|
|
// this is a fake subcommand - it's used in conjunction with
|
|
// AppSettings:AllowExternalSubcommand to treat it as an
|
|
// entry point script
|
|
SubCommand::with_name("<script>").about("Script to run"),
|
|
)
|
|
}
|
|
|
|
/// Parse ArgMatches into internal DenoFlags structure.
|
|
/// This method should not make any side effects.
|
|
#[cfg_attr(feature = "cargo-clippy", allow(stutter))]
|
|
pub fn parse_flags(matches: ArgMatches) -> DenoFlags {
|
|
let mut flags = DenoFlags::default();
|
|
|
|
if matches.is_present("log-debug") {
|
|
flags.log_debug = true;
|
|
}
|
|
if matches.is_present("version") {
|
|
flags.version = true;
|
|
}
|
|
if matches.is_present("reload") {
|
|
flags.reload = true;
|
|
}
|
|
if matches.is_present("allow-read") {
|
|
flags.allow_read = true;
|
|
}
|
|
if matches.is_present("allow-write") {
|
|
flags.allow_write = true;
|
|
}
|
|
if matches.is_present("allow-net") {
|
|
flags.allow_net = true;
|
|
}
|
|
if matches.is_present("allow-env") {
|
|
flags.allow_env = true;
|
|
}
|
|
if matches.is_present("allow-run") {
|
|
flags.allow_run = true;
|
|
}
|
|
if matches.is_present("allow-high-precision") {
|
|
flags.allow_high_precision = true;
|
|
}
|
|
if matches.is_present("allow-all") {
|
|
flags.allow_read = true;
|
|
flags.allow_env = true;
|
|
flags.allow_net = true;
|
|
flags.allow_run = true;
|
|
flags.allow_read = true;
|
|
flags.allow_write = true;
|
|
flags.allow_high_precision = true;
|
|
}
|
|
if matches.is_present("no-prompt") {
|
|
flags.no_prompts = true;
|
|
}
|
|
if matches.is_present("v8-options") {
|
|
flags.v8_help = true;
|
|
}
|
|
if matches.is_present("v8-flags") {
|
|
let v8_flags: Vec<String> = matches
|
|
.values_of("v8-flags")
|
|
.unwrap()
|
|
.map(String::from)
|
|
.collect();
|
|
|
|
flags.v8_flags = Some(v8_flags);
|
|
}
|
|
|
|
flags
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn flags_from_vec(args: Vec<String>) -> DenoFlags {
|
|
let cli_app = create_cli_app();
|
|
let matches = cli_app.get_matches_from(args);
|
|
parse_flags(matches)
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_1() {
|
|
let flags = flags_from_vec(svec!["deno", "version"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
version: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_2() {
|
|
let flags = flags_from_vec(svec!["deno", "-r", "-D", "script.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
log_debug: true,
|
|
reload: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_3() {
|
|
let flags =
|
|
flags_from_vec(svec!["deno", "-r", "--allow-write", "script.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
reload: true,
|
|
allow_write: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_4() {
|
|
let flags =
|
|
flags_from_vec(svec!["deno", "-Dr", "--allow-write", "script.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
log_debug: true,
|
|
reload: true,
|
|
allow_write: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_5() {
|
|
let flags = flags_from_vec(svec!["deno", "--v8-options"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
v8_help: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
|
|
let flags =
|
|
flags_from_vec(svec!["deno", "--v8-flags=--expose-gc,--gc-stats=1"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
v8_flags: Some(svec!["--expose-gc", "--gc-stats=1"]),
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_6() {
|
|
let flags =
|
|
flags_from_vec(svec!["deno", "--allow-net", "gist.ts", "--title", "X"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
allow_net: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_7() {
|
|
let flags = flags_from_vec(svec!["deno", "--allow-all", "gist.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
allow_net: true,
|
|
allow_env: true,
|
|
allow_run: true,
|
|
allow_read: true,
|
|
allow_write: true,
|
|
allow_high_precision: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_8() {
|
|
let flags = flags_from_vec(svec!["deno", "--allow-read", "gist.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
allow_read: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_9() {
|
|
let flags =
|
|
flags_from_vec(svec!["deno", "--allow-high-precision", "script.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
allow_high_precision: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_10() {
|
|
// notice that flags passed after script name will not
|
|
// be parsed to DenoFlags but instead forwarded to
|
|
// script args as Deno.args
|
|
let flags = flags_from_vec(svec![
|
|
"deno",
|
|
"--allow-write",
|
|
"script.ts",
|
|
"-D",
|
|
"--allow-net"
|
|
]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
allow_write: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|
|
}
|