mirror of
https://github.com/denoland/deno.git
synced 2024-11-21 15:04:11 -05:00
383 lines
9.6 KiB
Rust
383 lines
9.6 KiB
Rust
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
|
use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
|
|
use deno::v8_set_flags;
|
|
|
|
// 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 types: bool,
|
|
pub prefetch: bool,
|
|
pub info: bool,
|
|
pub fmt: bool,
|
|
}
|
|
|
|
impl<'a> From<ArgMatches<'a>> for DenoFlags {
|
|
fn from(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("types") {
|
|
flags.types = true;
|
|
}
|
|
if matches.is_present("prefetch") {
|
|
flags.prefetch = true;
|
|
}
|
|
if matches.is_present("info") {
|
|
flags.info = true;
|
|
}
|
|
if matches.is_present("fmt") {
|
|
flags.fmt = true;
|
|
}
|
|
|
|
flags
|
|
}
|
|
}
|
|
|
|
#[cfg_attr(feature = "cargo-clippy", allow(stutter))]
|
|
pub fn set_flags(
|
|
args: Vec<String>,
|
|
) -> Result<(DenoFlags, Vec<String>), String> {
|
|
let app_settings: Vec<AppSettings> = vec![
|
|
AppSettings::AllowExternalSubcommands,
|
|
AppSettings::DisableHelpSubcommand,
|
|
];
|
|
|
|
let env_variables_help = "ENVIRONMENT VARIABLES:
|
|
DENO_DIR Set deno's base directory
|
|
NO_COLOR Set to disable color";
|
|
|
|
let clap_app = App::new("deno")
|
|
.global_settings(&[AppSettings::ColorNever])
|
|
.settings(&app_settings[..])
|
|
.after_help(env_variables_help)
|
|
.arg(
|
|
Arg::with_name("version")
|
|
.short("v")
|
|
.long("version")
|
|
.help("Print the version"),
|
|
).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)
|
|
.require_equals(true)
|
|
.help("Set V8 command line options"),
|
|
).arg(
|
|
Arg::with_name("types")
|
|
.long("types")
|
|
.help("Print runtime TypeScript declarations"),
|
|
).arg(
|
|
Arg::with_name("prefetch")
|
|
.long("prefetch")
|
|
.help("Prefetch the dependencies"),
|
|
).subcommand(
|
|
// TODO(bartlomieju): version is not handled properly
|
|
SubCommand::with_name("info")
|
|
.about("Show source file related info")
|
|
.arg(Arg::with_name("file").takes_value(true).required(true)),
|
|
).subcommand(
|
|
// TODO(bartlomieju): version is not handled properly
|
|
SubCommand::with_name("fmt").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"),
|
|
);
|
|
|
|
let matches = clap_app.get_matches_from(args);
|
|
|
|
// TODO(bartomieju): compatibility with old "opts" approach - to be refactored
|
|
let mut rest: Vec<String> = vec![String::from("deno")];
|
|
|
|
match matches.subcommand() {
|
|
("info", Some(info_match)) => {
|
|
// TODO(bartlomieju): it still relies on `is_present("info")` check
|
|
// in `set_recognized_flags`
|
|
let file: &str = info_match.value_of("file").unwrap();
|
|
rest.extend(vec![file.to_string()]);
|
|
}
|
|
("fmt", Some(fmt_match)) => {
|
|
// TODO(bartlomieju): it still relies on `is_present("fmt")` check
|
|
// in `set_recognized_flags`
|
|
let files: Vec<String> = fmt_match
|
|
.values_of("files")
|
|
.unwrap()
|
|
.map(String::from)
|
|
.collect();
|
|
rest.extend(files);
|
|
}
|
|
(script, Some(script_match)) => {
|
|
rest.extend(vec![script.to_string()]);
|
|
// check if there are any extra arguments
|
|
if script_match.is_present("") {
|
|
let script_args: Vec<String> = script_match
|
|
.values_of("")
|
|
.unwrap()
|
|
.map(String::from)
|
|
.collect();
|
|
rest.extend(script_args);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
// TODO: end
|
|
|
|
if matches.is_present("v8-options") {
|
|
// display v8 help and exit
|
|
// TODO(bartlomieju): this relies on `v8_set_flags` to swap `--v8-options` to help
|
|
v8_set_flags(vec!["deno".to_string(), "--v8-options".to_string()]);
|
|
}
|
|
|
|
if matches.is_present("v8-flags") {
|
|
let mut v8_flags: Vec<String> = matches
|
|
.values_of("v8-flags")
|
|
.unwrap()
|
|
.map(String::from)
|
|
.collect();
|
|
|
|
v8_flags.insert(1, "deno".to_string());
|
|
v8_set_flags(v8_flags);
|
|
}
|
|
|
|
let flags = DenoFlags::from(matches);
|
|
Ok((flags, rest))
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_1() {
|
|
let (flags, rest) = set_flags(svec!["deno", "--version"]).unwrap();
|
|
assert_eq!(rest, svec!["deno"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
version: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_2() {
|
|
let (flags, rest) =
|
|
set_flags(svec!["deno", "-r", "-D", "script.ts"]).unwrap();
|
|
assert_eq!(rest, svec!["deno", "script.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
log_debug: true,
|
|
reload: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_3() {
|
|
let (flags, rest) =
|
|
set_flags(svec!["deno", "-r", "--allow-write", "script.ts"]).unwrap();
|
|
assert_eq!(rest, svec!["deno", "script.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
reload: true,
|
|
allow_write: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_4() {
|
|
let (flags, rest) =
|
|
set_flags(svec!["deno", "-Dr", "--allow-write", "script.ts"]).unwrap();
|
|
assert_eq!(rest, svec!["deno", "script.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
log_debug: true,
|
|
reload: true,
|
|
allow_write: true,
|
|
..DenoFlags::default()
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_5() {
|
|
let (flags, rest) = set_flags(svec!["deno", "--types"]).unwrap();
|
|
assert_eq!(rest, svec!["deno"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
types: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_6() {
|
|
let (flags, rest) =
|
|
set_flags(svec!["deno", "--allow-net", "gist.ts", "--title", "X"]).unwrap();
|
|
assert_eq!(rest, svec!["deno", "gist.ts", "--title", "X"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
allow_net: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_7() {
|
|
let (flags, rest) =
|
|
set_flags(svec!["deno", "--allow-all", "gist.ts"]).unwrap();
|
|
assert_eq!(rest, svec!["deno", "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, rest) =
|
|
set_flags(svec!["deno", "--allow-read", "gist.ts"]).unwrap();
|
|
assert_eq!(rest, svec!["deno", "gist.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
allow_read: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_flags_9() {
|
|
let (flags, rest) =
|
|
set_flags(svec!["deno", "--allow-high-precision", "script.ts"]).unwrap();
|
|
assert_eq!(rest, svec!["deno", "script.ts"]);
|
|
assert_eq!(
|
|
flags,
|
|
DenoFlags {
|
|
allow_high_precision: true,
|
|
..DenoFlags::default()
|
|
}
|
|
)
|
|
}
|