diff options
Diffstat (limited to 'cli')
| -rw-r--r-- | cli/flags.rs | 460 | ||||
| -rw-r--r-- | cli/main.rs | 278 | ||||
| -rw-r--r-- | cli/ops.rs | 1 | ||||
| -rw-r--r-- | cli/state.rs | 8 | ||||
| -rw-r--r-- | cli/worker.rs | 10 |
5 files changed, 414 insertions, 343 deletions
diff --git a/cli/flags.rs b/cli/flags.rs index 3aac1ecc8..93c07f610 100644 --- a/cli/flags.rs +++ b/cli/flags.rs @@ -1,6 +1,5 @@ // 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)] @@ -21,81 +20,15 @@ pub struct DenoFlags { 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, - pub eval: 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; - } - if matches.is_present("eval") { - flags.eval = true; - } - - flags - } + 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"; -fn create_cli_app<'a, 'b>() -> App<'a, 'b> { +pub fn create_cli_app<'a, 'b>() -> App<'a, 'b> { App::new("deno") .bin_name("deno") .global_settings(&[AppSettings::ColorNever]) @@ -159,16 +92,18 @@ fn create_cli_app<'a, 'b>() -> App<'a, 'b> { Arg::with_name("v8-flags") .long("v8-flags") .takes_value(true) + .use_delimiter(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( + SubCommand::with_name("prefetch") + .setting(AppSettings::DisableVersion) + .about("Prefetch 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) @@ -197,197 +132,226 @@ fn create_cli_app<'a, 'b>() -> App<'a, 'b> { ) } +/// Parse ArgMatches into internal DenoFlags structure. +/// This method should not make any side effects. #[cfg_attr(feature = "cargo-clippy", allow(stutter))] -pub fn set_flags( - args: Vec<String>, -) -> Result<(DenoFlags, Vec<String>), String> { - let mut rest_argv: Vec<String> = vec!["deno".to_string()]; - let cli_app = create_cli_app(); - let matches = cli_app.get_matches_from(args); +pub fn parse_flags(matches: ArgMatches) -> DenoFlags { + let mut flags = DenoFlags::default(); - match matches.subcommand() { - ("eval", Some(info_match)) => { - let code: &str = info_match.value_of("code").unwrap(); - rest_argv.extend(vec![code.to_string()]); - } - ("info", Some(info_match)) => { - let file: &str = info_match.value_of("file").unwrap(); - rest_argv.extend(vec![file.to_string()]); - } - ("fmt", Some(fmt_match)) => { - let files: Vec<String> = fmt_match - .values_of("files") - .unwrap() - .map(String::from) - .collect(); - rest_argv.extend(files); - } - (script, Some(script_match)) => { - rest_argv.extend(vec![script.to_string()]); - // check if there are any extra arguments that should - // be passed to script - if script_match.is_present("") { - let script_args: Vec<String> = script_match - .values_of("") - .unwrap() - .map(String::from) - .collect(); - rest_argv.extend(script_args); - } - } - _ => {} + 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") { - // 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()]); + flags.v8_help = true; } - if matches.is_present("v8-flags") { - let mut v8_flags: Vec<String> = matches + let 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); + flags.v8_flags = Some(v8_flags); } - let flags = DenoFlags::from(matches); - Ok((flags, rest_argv)) + flags } -#[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() - } - ); -} +#[cfg(test)] +mod tests { + use super::*; -#[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() - } - ); -} + 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_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_1() { + let flags = flags_from_vec(svec!["deno", "--version"]); + assert_eq!( + flags, + DenoFlags { + version: 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_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_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_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_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_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_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_5() { + let flags = flags_from_vec(svec!["deno", "--v8-options"]); + assert_eq!( + flags, + DenoFlags { + v8_help: 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() - } - ) -} + 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_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() - } - ) + #[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() + } + ) + } } diff --git a/cli/main.rs b/cli/main.rs index 41aeca1c9..4d12b6c89 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -38,10 +38,13 @@ use crate::errors::RustOrJsError; use crate::state::ThreadSafeState; use crate::worker::root_specifier_to_url; use crate::worker::Worker; +use deno::v8_set_flags; +use flags::DenoFlags; use futures::lazy; use futures::Future; use log::{LevelFilter, Metadata, Record}; use std::env; +use std::path::Path; static LOGGER: Logger = Logger; @@ -123,103 +126,208 @@ pub fn print_file_info(worker: &Worker, url: &str) { } } -fn main() { - #[cfg(windows)] - ansi_term::enable_ansi_support().ok(); // For Windows 10 +fn create_worker_and_state( + flags: DenoFlags, + argv: Vec<String>, +) -> (Worker, ThreadSafeState) { + let state = ThreadSafeState::new(flags, argv, ops::op_selector_std); + let worker = Worker::new( + "main".to_string(), + startup_data::deno_isolate_init(), + state.clone(), + ); - log::set_logger(&LOGGER).unwrap(); - let args = env::args().collect(); - let (mut flags, mut rest_argv) = - flags::set_flags(args).unwrap_or_else(|err| { - eprintln!("{}", err); - std::process::exit(1) - }); + (worker, state) +} - log::set_max_level(if flags.log_debug { - LevelFilter::Debug - } else { - LevelFilter::Warn - }); +fn types_command() { + let p = Path::new(concat!( + env!("GN_OUT_DIR"), + "/gen/cli/lib/lib.deno_runtime.d.ts" + )); + let content_bytes = std::fs::read(p).unwrap(); + let content = std::str::from_utf8(&content_bytes[..]).unwrap(); + println!("{}", content); +} - if flags.fmt { - rest_argv.insert(1, "https://deno.land/std/prettier/main.ts".to_string()); - flags.allow_read = true; - flags.allow_write = true; - } +fn prefetch_or_info_command( + flags: DenoFlags, + argv: Vec<String>, + print_info: bool, +) { + let (mut worker, state) = create_worker_and_state(flags, argv); - let should_prefetch = flags.prefetch || flags.info; - let should_display_info = flags.info; + let main_module = state.main_module().unwrap(); + let main_future = lazy(move || { + // Setup runtime. + js_check(worker.execute("denoMain()")); + debug!("main_module {}", main_module); - let state = ThreadSafeState::new(flags, rest_argv, ops::op_selector_std); - let mut worker = Worker::new( - "main".to_string(), - startup_data::deno_isolate_init(), - state.clone(), + let main_url = root_specifier_to_url(&main_module).unwrap(); + + worker + .execute_mod_async(&main_url, true) + .and_then(move |worker| { + if print_info { + print_file_info(&worker, &main_module); + } + worker.then(|result| { + js_check(result); + Ok(()) + }) + }).map_err(|(err, _worker)| print_err_and_exit(err)) + }); + tokio_util::run(main_future); +} + +fn eval_command(flags: DenoFlags, argv: Vec<String>) { + let (mut worker, state) = create_worker_and_state(flags, argv); + // Wrap provided script in async function so asynchronous methods + // work. This is required until top-level await is not supported. + let js_source = format!( + "async function _topLevelWrapper(){{ + {} + }} + _topLevelWrapper(); + ", + &state.argv[1] ); - // TODO(ry) somehow combine the two branches below. They're very similar but - // it's difficult to get the types to workout. - - if state.flags.eval { - let main_future = lazy(move || { - js_check(worker.execute("denoMain()")); - // Wrap provided script in async function so asynchronous methods - // work. This is required until top-level await is not supported. - let js_source = format!( - "async function _topLevelWrapper(){{ - {} - }} - _topLevelWrapper(); - ", - &state.argv[1] - ); - // ATM imports in `deno eval` are not allowed - // TODO Support ES modules once Worker supports evaluating anonymous modules. - js_check(worker.execute(&js_source)); - worker.then(|result| { + let main_future = lazy(move || { + js_check(worker.execute("denoMain()")); + // ATM imports in `deno eval` are not allowed + // TODO Support ES modules once Worker supports evaluating anonymous modules. + js_check(worker.execute(&js_source)); + worker.then(|result| { + js_check(result); + Ok(()) + }) + }); + tokio_util::run(main_future); +} + +fn run_repl(flags: DenoFlags, argv: Vec<String>) { + let (mut worker, _state) = create_worker_and_state(flags, argv); + + // REPL situation. + let main_future = lazy(move || { + // Setup runtime. + js_check(worker.execute("denoMain()")); + worker + .then(|result| { js_check(result); Ok(()) + }).map_err(|(err, _worker): (RustOrJsError, Worker)| { + print_err_and_exit(err) }) - }); - tokio_util::run(main_future); - } else if let Some(main_module) = state.main_module() { - // Normal situation of executing a module. - - let main_future = lazy(move || { - // Setup runtime. - js_check(worker.execute("denoMain()")); - debug!("main_module {}", main_module); - - let main_url = root_specifier_to_url(&main_module).unwrap(); - - worker - .execute_mod_async(&main_url, should_prefetch) - .and_then(move |worker| { - if should_display_info { - // Display file info and exit. Do not run file - print_file_info(&worker, &main_module); - std::process::exit(0); - } - worker.then(|result| { - js_check(result); - Ok(()) - }) - }).map_err(|(err, _worker)| print_err_and_exit(err)) - }); - tokio_util::run(main_future); - } else { - // REPL situation. - let main_future = lazy(move || { - // Setup runtime. - js_check(worker.execute("denoMain()")); - worker - .then(|result| { + }); + tokio_util::run(main_future); +} + +fn run_script(flags: DenoFlags, argv: Vec<String>) { + let (mut worker, state) = create_worker_and_state(flags, argv); + + let main_module = state.main_module().unwrap(); + // Normal situation of executing a module. + let main_future = lazy(move || { + // Setup runtime. + js_check(worker.execute("denoMain()")); + debug!("main_module {}", main_module); + + let main_url = root_specifier_to_url(&main_module).unwrap(); + + worker + .execute_mod_async(&main_url, false) + .and_then(move |worker| { + worker.then(|result| { js_check(result); Ok(()) - }).map_err(|(err, _worker): (RustOrJsError, Worker)| { - print_err_and_exit(err) }) - }); - tokio_util::run(main_future); + }).map_err(|(err, _worker)| print_err_and_exit(err)) + }); + tokio_util::run(main_future); +} + +fn fmt_command(mut flags: DenoFlags, mut argv: Vec<String>) { + argv.insert(1, "https://deno.land/std/prettier/main.ts".to_string()); + flags.allow_read = true; + flags.allow_write = true; + run_script(flags, argv); +} + +fn main() { + #[cfg(windows)] + ansi_term::enable_ansi_support().ok(); // For Windows 10 + + log::set_logger(&LOGGER).unwrap(); + let args: Vec<String> = env::args().collect(); + let cli_app = flags::create_cli_app(); + let matches = cli_app.get_matches_from(args); + let flags = flags::parse_flags(matches.clone()); + let mut argv: Vec<String> = vec!["deno".to_string()]; + + if flags.v8_help { + // show v8 help and exit + v8_set_flags(vec!["--help".to_string()]); + } + + match &flags.v8_flags { + Some(v8_flags) => { + v8_set_flags(v8_flags.clone()); + } + _ => {} + }; + + log::set_max_level(if flags.log_debug { + LevelFilter::Debug + } else { + LevelFilter::Warn + }); + + match matches.subcommand() { + ("types", Some(_)) => { + types_command(); + } + ("eval", Some(eval_match)) => { + let code: &str = eval_match.value_of("code").unwrap(); + argv.extend(vec![code.to_string()]); + eval_command(flags, argv); + } + ("info", Some(info_match)) => { + let file: &str = info_match.value_of("file").unwrap(); + argv.extend(vec![file.to_string()]); + prefetch_or_info_command(flags, argv, true); + } + ("prefetch", Some(prefetch_match)) => { + let file: &str = prefetch_match.value_of("file").unwrap(); + argv.extend(vec![file.to_string()]); + prefetch_or_info_command(flags, argv, false); + } + ("fmt", Some(fmt_match)) => { + let files: Vec<String> = fmt_match + .values_of("files") + .unwrap() + .map(String::from) + .collect(); + argv.extend(files); + fmt_command(flags, argv); + } + (script, Some(script_match)) => { + argv.extend(vec![script.to_string()]); + // check if there are any extra arguments that should + // be passed to script + if script_match.is_present("") { + let script_args: Vec<String> = script_match + .values_of("") + .unwrap() + .map(String::from) + .collect(); + argv.extend(script_args); + } + run_script(flags, argv); + } + _ => { + run_repl(flags, argv); + } } } diff --git a/cli/ops.rs b/cli/ops.rs index 0ce9d97a4..044e0fc20 100644 --- a/cli/ops.rs +++ b/cli/ops.rs @@ -321,7 +321,6 @@ fn op_start( argv: Some(argv_off), main_module, debug_flag: state.flags.log_debug, - types_flag: state.flags.types, version_flag: state.flags.version, v8_version: Some(v8_version_off), deno_version: Some(deno_version_off), diff --git a/cli/state.rs b/cli/state.rs index 9a74cbfa2..808678b21 100644 --- a/cli/state.rs +++ b/cli/state.rs @@ -158,9 +158,11 @@ impl ThreadSafeState { #[cfg(test)] pub fn mock() -> ThreadSafeState { let argv = vec![String::from("./deno"), String::from("hello.js")]; - // For debugging: argv.push_back(String::from("-D")); - let (flags, rest_argv) = flags::set_flags(argv).unwrap(); - ThreadSafeState::new(flags, rest_argv, ops::op_selector_std) + ThreadSafeState::new( + flags::DenoFlags::default(), + argv, + ops::op_selector_std, + ) } pub fn metrics_op_dispatched( diff --git a/cli/worker.rs b/cli/worker.rs index a7bc7bb7a..408bae1c6 100644 --- a/cli/worker.rs +++ b/cli/worker.rs @@ -267,9 +267,8 @@ mod tests { let js_url = Url::from_file_path(filename).unwrap(); let argv = vec![String::from("./deno"), js_url.to_string()]; - let (flags, rest_argv) = flags::set_flags(argv).unwrap(); - - let state = ThreadSafeState::new(flags, rest_argv, op_selector_std); + let state = + ThreadSafeState::new(flags::DenoFlags::default(), argv, op_selector_std); let state_ = state.clone(); tokio_util::run(lazy(move || { let worker = Worker::new("TEST".to_string(), StartupData::None, state); @@ -294,9 +293,8 @@ mod tests { let js_url = Url::from_file_path(filename).unwrap(); let argv = vec![String::from("./deno"), js_url.to_string()]; - let (flags, rest_argv) = flags::set_flags(argv).unwrap(); - - let state = ThreadSafeState::new(flags, rest_argv, op_selector_std); + let state = + ThreadSafeState::new(flags::DenoFlags::default(), argv, op_selector_std); let state_ = state.clone(); tokio_util::run(lazy(move || { let worker = Worker::new("TEST".to_string(), StartupData::None, state); |