From 3149cdde569813f324de13134e16b3c69df0e402 Mon Sep 17 00:00:00 2001 From: David Sherret Date: Wed, 29 Jun 2022 11:51:11 -0400 Subject: [PATCH] refactor: rename `RootConfig` to `CliOptions` (#15007) --- cli/args/mod.rs | 8 +-- cli/lsp/testing/execution.rs | 4 +- cli/main.rs | 96 ++++++++++++++++++------------------ cli/module_loader.rs | 4 +- cli/proc_state.rs | 78 ++++++++++++++--------------- cli/tools/bench.rs | 26 +++++----- cli/tools/doc.rs | 2 +- cli/tools/fmt.rs | 4 +- cli/tools/lint.rs | 6 +-- cli/tools/task.rs | 6 +-- cli/tools/test.rs | 28 ++++++----- cli/tools/vendor/mod.rs | 8 +-- 12 files changed, 138 insertions(+), 132 deletions(-) diff --git a/cli/args/mod.rs b/cli/args/mod.rs index 757c6a8f4c..17bbf06033 100644 --- a/cli/args/mod.rs +++ b/cli/args/mod.rs @@ -44,16 +44,16 @@ use crate::file_fetcher::CacheSetting; use crate::lockfile::Lockfile; use crate::version; -/// Holds the common configuration used by many sub commands +/// Holds the common options used by many sub commands /// and provides some helper function for creating common objects. -pub struct RootConfig { - // the source of the configuration is a detail the rest of the +pub struct CliOptions { + // the source of the options is a detail the rest of the // application need not concern itself with, so keep these private flags: Flags, maybe_config_file: Option, } -impl RootConfig { +impl CliOptions { pub fn from_flags(flags: Flags) -> Result { if let Some(insecure_allowlist) = flags.unsafely_ignore_certificate_errors.as_ref() diff --git a/cli/lsp/testing/execution.rs b/cli/lsp/testing/execution.rs index efe05348fc..d487b1396e 100644 --- a/cli/lsp/testing/execution.rs +++ b/cli/lsp/testing/execution.rs @@ -309,7 +309,7 @@ impl TestRun { let flags = flags_from_vec(args.into_iter().map(String::from).collect())?; let ps = proc_state::ProcState::build(flags).await?; let permissions = - Permissions::from_options(&ps.config.permissions_options()); + Permissions::from_options(&ps.options.permissions_options()); test::check_specifiers( &ps, permissions.clone(), @@ -325,7 +325,7 @@ impl TestRun { let sender = TestEventSender::new(sender); let (concurrent_jobs, fail_fast) = - if let DenoSubcommand::Test(test_flags) = ps.config.sub_command() { + if let DenoSubcommand::Test(test_flags) = ps.options.sub_command() { ( test_flags.concurrent_jobs.into(), test_flags.fail_fast.map(|count| count.into()), diff --git a/cli/main.rs b/cli/main.rs index 4abc4c89e9..fb586a5e66 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -70,7 +70,7 @@ use crate::proc_state::ProcState; use crate::resolver::ImportMapResolver; use crate::resolver::JsxResolver; -use args::RootConfig; +use args::CliOptions; use deno_ast::MediaType; use deno_core::error::generic_error; use deno_core::error::AnyError; @@ -109,7 +109,7 @@ use std::sync::Arc; fn create_web_worker_preload_module_callback( ps: ProcState, ) -> Arc { - let compat = ps.config.compat(); + let compat = ps.options.compat(); Arc::new(move |mut worker| { let fut = async move { @@ -144,30 +144,30 @@ fn create_web_worker_callback( let options = WebWorkerOptions { bootstrap: BootstrapOptions { - args: ps.config.argv().clone(), + args: ps.options.argv().clone(), cpu_count: std::thread::available_parallelism() .map(|p| p.get()) .unwrap_or(1), debug_flag: ps - .config + .options .log_level() .map_or(false, |l| l == log::Level::Debug), - enable_testing_features: ps.config.enable_testing_features(), + enable_testing_features: ps.options.enable_testing_features(), location: Some(args.main_module.clone()), no_color: !colors::use_color(), is_tty: colors::is_tty(), runtime_version: version::deno(), ts_version: version::TYPESCRIPT.to_string(), - unstable: ps.config.unstable(), + unstable: ps.options.unstable(), user_agent: version::get_user_agent(), }, extensions, unsafely_ignore_certificate_errors: ps - .config + .options .unsafely_ignore_certificate_errors() .map(ToOwned::to_owned), root_cert_store: Some(ps.root_cert_store.clone()), - seed: ps.config.seed(), + seed: ps.options.seed(), module_loader, create_web_worker_cb, preload_module_cb, @@ -204,14 +204,14 @@ pub fn create_main_worker( let module_loader = CliModuleLoader::new(ps.clone()); let maybe_inspector_server = ps.maybe_inspector_server.clone(); - let should_break_on_first_statement = ps.config.inspect_brk().is_some(); + let should_break_on_first_statement = ps.options.inspect_brk().is_some(); let create_web_worker_cb = create_web_worker_callback(ps.clone(), stdio.clone()); let web_worker_preload_module_cb = create_web_worker_preload_module_callback(ps.clone()); - let maybe_storage_key = ps.config.resolve_storage_key(&main_module); + let maybe_storage_key = ps.options.resolve_storage_key(&main_module); let origin_storage_dir = maybe_storage_key.map(|key| { ps.dir .root @@ -225,30 +225,30 @@ pub fn create_main_worker( let options = WorkerOptions { bootstrap: BootstrapOptions { - args: ps.config.argv().clone(), + args: ps.options.argv().clone(), cpu_count: std::thread::available_parallelism() .map(|p| p.get()) .unwrap_or(1), debug_flag: ps - .config + .options .log_level() .map_or(false, |l| l == log::Level::Debug), - enable_testing_features: ps.config.enable_testing_features(), - location: ps.config.location_flag().map(ToOwned::to_owned), + enable_testing_features: ps.options.enable_testing_features(), + location: ps.options.location_flag().map(ToOwned::to_owned), no_color: !colors::use_color(), is_tty: colors::is_tty(), runtime_version: version::deno(), ts_version: version::TYPESCRIPT.to_string(), - unstable: ps.config.unstable(), + unstable: ps.options.unstable(), user_agent: version::get_user_agent(), }, extensions, unsafely_ignore_certificate_errors: ps - .config + .options .unsafely_ignore_certificate_errors() .map(ToOwned::to_owned), root_cert_store: Some(ps.root_cert_store.clone()), - seed: ps.config.seed(), + seed: ps.options.seed(), source_map_getter: Some(Box::new(ps.clone())), format_js_error_fn: Some(Arc::new(format_js_error)), create_web_worker_cb, @@ -460,7 +460,7 @@ async fn info_command( let maybe_import_map_resolver = ps.maybe_import_map.clone().map(ImportMapResolver::new); let maybe_jsx_resolver = ps - .config + .options .to_maybe_jsx_import_source_module() .map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone())); let maybe_resolver = if maybe_jsx_resolver.is_some() { @@ -489,7 +489,7 @@ async fn info_command( } } else { // If it was just "deno info" print location of caches and exit - print_cache_info(&ps, info_flags.json, ps.config.location_flag())?; + print_cache_info(&ps, info_flags.json, ps.options.location_flag())?; } Ok(0) } @@ -548,7 +548,7 @@ async fn cache_command( cache_flags: CacheFlags, ) -> Result { let ps = ProcState::build(flags).await?; - let lib = ps.config.ts_type_lib_window(); + let lib = ps.options.ts_type_lib_window(); for file in cache_flags.files { let specifier = resolve_url_or_path(&file)?; @@ -617,7 +617,7 @@ async fn eval_command( // to allow module access by TS compiler. ps.file_fetcher.insert_cached(file); debug!("main_module {}", &main_module); - if ps.config.compat() { + if ps.options.compat() { worker.execute_side_module(&compat::GLOBAL_URL).await?; } worker.execute_main_module(&main_module).await?; @@ -639,11 +639,11 @@ async fn create_graph_and_maybe_check( Permissions::allow_all(), ); let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone()); - let maybe_imports = ps.config.to_maybe_imports()?; + let maybe_imports = ps.options.to_maybe_imports()?; let maybe_import_map_resolver = ps.maybe_import_map.clone().map(ImportMapResolver::new); let maybe_jsx_resolver = ps - .config + .options .to_maybe_jsx_import_source_module() .map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone())); let maybe_resolver = if maybe_jsx_resolver.is_some() { @@ -667,36 +667,36 @@ async fn create_graph_and_maybe_check( .await, ); - let check_js = ps.config.check_js(); + let check_js = ps.options.check_js(); graph_valid( &graph, - ps.config.type_check_mode() != TypeCheckMode::None, + ps.options.type_check_mode() != TypeCheckMode::None, check_js, )?; graph_lock_or_exit(&graph); - if ps.config.type_check_mode() != TypeCheckMode::None { + if ps.options.type_check_mode() != TypeCheckMode::None { let ts_config_result = - ps.config.resolve_ts_config_for_emit(TsConfigType::Check { + ps.options.resolve_ts_config_for_emit(TsConfigType::Check { tsc_emit: false, - lib: ps.config.ts_type_lib_window(), + lib: ps.options.ts_type_lib_window(), })?; if let Some(ignored_options) = ts_config_result.maybe_ignored_options { eprintln!("{}", ignored_options); } - let maybe_config_specifier = ps.config.maybe_config_file_specifier(); + let maybe_config_specifier = ps.options.maybe_config_file_specifier(); let check_result = emit::check_and_maybe_emit( &graph.roots, Arc::new(RwLock::new(graph.as_ref().into())), &ps.dir.gen_cache, emit::CheckOptions { - type_check_mode: ps.config.type_check_mode(), + type_check_mode: ps.options.type_check_mode(), debug, emit_with_diagnostics: false, maybe_config_specifier, ts_config: ts_config_result.ts_config, log_checks: true, - reload: ps.config.reload_flag(), + reload: ps.options.reload_flag(), reload_exclusions: Default::default(), }, )?; @@ -715,9 +715,10 @@ fn bundle_module_graph( ) -> Result { info!("{} {}", colors::green("Bundle"), graph.roots[0].0); - let ts_config_result = - ps.config.resolve_ts_config_for_emit(TsConfigType::Bundle)?; - if ps.config.type_check_mode() == TypeCheckMode::None { + let ts_config_result = ps + .options + .resolve_ts_config_for_emit(TsConfigType::Bundle)?; + if ps.options.type_check_mode() == TypeCheckMode::None { if let Some(ignored_options) = ts_config_result.maybe_ignored_options { eprintln!("{}", ignored_options); } @@ -738,16 +739,16 @@ async fn bundle_command( bundle_flags: BundleFlags, ) -> Result { let debug = flags.log_level == Some(log::Level::Debug); - let root_config = Arc::new(RootConfig::from_flags(flags)?); + let cli_options = Arc::new(CliOptions::from_flags(flags)?); let resolver = |_| { - let root_config = root_config.clone(); + let cli_options = cli_options.clone(); let source_file1 = bundle_flags.source_file.clone(); let source_file2 = bundle_flags.source_file.clone(); async move { let module_specifier = resolve_url_or_path(&source_file1)?; debug!(">>>>> bundle START"); - let ps = ProcState::from_root_config(root_config).await?; + let ps = ProcState::from_options(cli_options).await?; let graph = create_graph_and_maybe_check(module_specifier, &ps, debug).await?; @@ -761,7 +762,7 @@ async fn bundle_command( .collect(); if let Ok(Some(import_map_path)) = ps - .config + .options .resolve_import_map_path() .map(|ms| ms.and_then(|ref s| s.to_file_path().ok())) { @@ -823,13 +824,13 @@ async fn bundle_command( } }; - if root_config.watch_paths().is_some() { + if cli_options.watch_paths().is_some() { file_watcher::watch_func( resolver, operation, file_watcher::PrintConfig { job_name: "Bundle".to_string(), - clear_screen: !root_config.no_clear_screen(), + clear_screen: !cli_options.no_clear_screen(), }, ) .await?; @@ -858,7 +859,7 @@ async fn format_command( flags: Flags, fmt_flags: FmtFlags, ) -> Result { - let config = RootConfig::from_flags(flags)?; + let config = CliOptions::from_flags(flags)?; if fmt_flags.files.len() == 1 && fmt_flags.files[0].to_string_lossy() == "-" { let maybe_fmt_config = config.to_fmt_config()?; @@ -882,11 +883,11 @@ async fn repl_command( let mut worker = create_main_worker( &ps, main_module.clone(), - Permissions::from_options(&ps.config.permissions_options()), + Permissions::from_options(&ps.options.permissions_options()), vec![], Default::default(), ); - if ps.config.compat() { + if ps.options.compat() { worker.execute_side_module(&compat::GLOBAL_URL).await?; compat::add_global_require(&mut worker.js_runtime, main_module.as_str())?; worker.run_event_loop(false).await?; @@ -903,7 +904,7 @@ async fn run_from_stdin(flags: Flags) -> Result { let mut worker = create_main_worker( &ps.clone(), main_module.clone(), - Permissions::from_options(&ps.config.permissions_options()), + Permissions::from_options(&ps.options.permissions_options()), vec![], Default::default(), ); @@ -924,7 +925,7 @@ async fn run_from_stdin(flags: Flags) -> Result { ps.file_fetcher.insert_cached(source_file); debug!("main_module {}", main_module); - if ps.config.compat() { + if ps.options.compat() { worker.execute_side_module(&compat::GLOBAL_URL).await?; } worker.execute_main_module(&main_module).await?; @@ -1059,7 +1060,8 @@ async fn run_command( // probably call `ProcState::resolve` instead let main_module = resolve_url_or_path(&run_flags.script)?; let ps = ProcState::build(flags).await?; - let permissions = Permissions::from_options(&ps.config.permissions_options()); + let permissions = + Permissions::from_options(&ps.options.permissions_options()); let mut worker = create_main_worker( &ps, main_module.clone(), @@ -1085,7 +1087,7 @@ async fn run_command( debug!("main_module {}", main_module); - if ps.config.compat() { + if ps.options.compat() { // TODO(bartlomieju): fix me assert_eq!(main_module.scheme(), "file"); diff --git a/cli/module_loader.rs b/cli/module_loader.rs index eda693ee9d..cf94a47671 100644 --- a/cli/module_loader.rs +++ b/cli/module_loader.rs @@ -27,7 +27,7 @@ pub struct CliModuleLoader { impl CliModuleLoader { pub fn new(ps: ProcState) -> Rc { Rc::new(CliModuleLoader { - lib: ps.config.ts_type_lib_window(), + lib: ps.options.ts_type_lib_window(), root_permissions: Permissions::allow_all(), ps, }) @@ -35,7 +35,7 @@ impl CliModuleLoader { pub fn new_for_worker(ps: ProcState, permissions: Permissions) -> Rc { Rc::new(CliModuleLoader { - lib: ps.config.ts_type_lib_worker(), + lib: ps.options.ts_type_lib_worker(), root_permissions: permissions, ps, }) diff --git a/cli/proc_state.rs b/cli/proc_state.rs index e857a21840..47b4ac7527 100644 --- a/cli/proc_state.rs +++ b/cli/proc_state.rs @@ -1,8 +1,8 @@ // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +use crate::args::CliOptions; use crate::args::DenoSubcommand; use crate::args::Flags; -use crate::args::RootConfig; use crate::args::TypeCheckMode; use crate::cache; use crate::compat; @@ -68,7 +68,7 @@ pub struct Inner { pub dir: deno_dir::DenoDir, pub coverage_dir: Option, pub file_fetcher: FileFetcher, - pub config: Arc, + pub options: Arc, graph_data: Arc>, pub lockfile: Option>>, pub maybe_import_map: Option>, @@ -91,13 +91,13 @@ impl Deref for ProcState { impl ProcState { pub async fn build(flags: Flags) -> Result { - Self::from_root_config(Arc::new(RootConfig::from_flags(flags)?)).await + Self::from_options(Arc::new(CliOptions::from_flags(flags)?)).await } - pub async fn from_root_config( - root_config: Arc, + pub async fn from_options( + options: Arc, ) -> Result { - Self::build_with_sender(root_config, None).await + Self::build_with_sender(options, None).await } pub async fn build_for_file_watcher( @@ -105,18 +105,18 @@ impl ProcState { files_to_watch_sender: tokio::sync::mpsc::UnboundedSender>, ) -> Result { // resolve the config each time - let root_config = Arc::new(RootConfig::from_flags(flags)?); + let cli_options = Arc::new(CliOptions::from_flags(flags)?); let ps = - Self::build_with_sender(root_config, Some(files_to_watch_sender.clone())) + Self::build_with_sender(cli_options, Some(files_to_watch_sender.clone())) .await?; // Add the extra files listed in the watch flag - if let Some(watch_paths) = ps.config.watch_paths() { + if let Some(watch_paths) = ps.options.watch_paths() { files_to_watch_sender.send(watch_paths.clone()).unwrap(); } if let Ok(Some(import_map_path)) = ps - .config + .options .resolve_import_map_path() .map(|ms| ms.and_then(|ref s| s.to_file_path().ok())) { @@ -127,33 +127,33 @@ impl ProcState { } async fn build_with_sender( - root_config: Arc, + cli_options: Arc, maybe_sender: Option>>, ) -> Result { let blob_store = BlobStore::default(); let broadcast_channel = InMemoryBroadcastChannel::default(); let shared_array_buffer_store = SharedArrayBufferStore::default(); let compiled_wasm_module_store = CompiledWasmModuleStore::default(); - let dir = root_config.resolve_deno_dir()?; + let dir = cli_options.resolve_deno_dir()?; let deps_cache_location = dir.root.join("deps"); let http_cache = http_cache::HttpCache::new(&deps_cache_location); - let root_cert_store = root_config.resolve_root_cert_store()?; - let cache_usage = root_config.cache_setting(); + let root_cert_store = cli_options.resolve_root_cert_store()?; + let cache_usage = cli_options.cache_setting(); let file_fetcher = FileFetcher::new( http_cache, cache_usage, - !root_config.no_remote(), + !cli_options.no_remote(), Some(root_cert_store.clone()), blob_store.clone(), - root_config + cli_options .unsafely_ignore_certificate_errors() .map(ToOwned::to_owned), )?; - let lockfile = root_config + let lockfile = cli_options .resolve_lock_file()? .map(|f| Arc::new(Mutex::new(f))); - let maybe_import_map_specifier = root_config.resolve_import_map_path()?; + let maybe_import_map_specifier = cli_options.resolve_import_map_path()?; let maybe_import_map = if let Some(import_map_specifier) = maybe_import_map_specifier { @@ -172,9 +172,9 @@ impl ProcState { }; let maybe_inspector_server = - root_config.resolve_inspector_server().map(Arc::new); + cli_options.resolve_inspector_server().map(Arc::new); - let coverage_dir = root_config + let coverage_dir = cli_options .coverage_dir() .map(ToOwned::to_owned) .or_else(|| env::var("DENO_UNSTABLE_COVERAGE_DIR").ok()); @@ -186,12 +186,12 @@ impl ProcState { ); let maybe_import_map_resolver = maybe_import_map.clone().map(ImportMapResolver::new); - let maybe_jsx_resolver = root_config + let maybe_jsx_resolver = cli_options .to_maybe_jsx_import_source_module() .map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone())); let maybe_resolver: Option< Arc, - > = if root_config.compat() { + > = if cli_options.compat() { Some(Arc::new(node_resolver)) } else if let Some(jsx_resolver) = maybe_jsx_resolver { // the JSX resolver offloads to the import map if present, otherwise uses @@ -212,7 +212,7 @@ impl ProcState { Ok(ProcState(Arc::new(Inner { dir, coverage_dir, - config: root_config, + options: cli_options, file_fetcher, graph_data: Default::default(), lockfile, @@ -276,7 +276,7 @@ impl ProcState { // TODO(bartlomieju): this is very make-shift, is there an existing API // that we could include it like with "maybe_imports"? - let roots = if self.config.compat() { + let roots = if self.options.compat() { let mut r = vec![(compat::GLOBAL_URL.clone(), ModuleKind::Esm)]; r.extend(roots); r @@ -285,12 +285,12 @@ impl ProcState { }; if !reload_on_watch { let graph_data = self.graph_data.read(); - if self.config.type_check_mode() == TypeCheckMode::None + if self.options.type_check_mode() == TypeCheckMode::None || graph_data.is_type_checked(&roots, &lib) { if let Some(result) = graph_data.check( &roots, - self.config.type_check_mode() != TypeCheckMode::None, + self.options.type_check_mode() != TypeCheckMode::None, false, ) { return result; @@ -304,7 +304,7 @@ impl ProcState { dynamic_permissions.clone(), ); let maybe_locker = as_maybe_locker(self.lockfile.clone()); - let maybe_imports = self.config.to_maybe_imports()?; + let maybe_imports = self.options.to_maybe_imports()?; struct ProcStateLoader<'a> { inner: &'a mut cache::FetchCacher, @@ -399,17 +399,17 @@ impl ProcState { { let mut graph_data = self.graph_data.write(); graph_data.add_graph(&graph, reload_on_watch); - let check_js = self.config.check_js(); + let check_js = self.options.check_js(); graph_data .check( &roots, - self.config.type_check_mode() != TypeCheckMode::None, + self.options.type_check_mode() != TypeCheckMode::None, check_js, ) .unwrap()?; } - let config_type = if self.config.type_check_mode() == TypeCheckMode::None { + let config_type = if self.options.type_check_mode() == TypeCheckMode::None { TsConfigType::Emit } else { TsConfigType::Check { @@ -419,30 +419,30 @@ impl ProcState { }; let ts_config_result = - self.config.resolve_ts_config_for_emit(config_type)?; + self.options.resolve_ts_config_for_emit(config_type)?; if let Some(ignored_options) = ts_config_result.maybe_ignored_options { log::warn!("{}", ignored_options); } - if self.config.type_check_mode() == TypeCheckMode::None { + if self.options.type_check_mode() == TypeCheckMode::None { let options = emit::EmitOptions { ts_config: ts_config_result.ts_config, - reload: self.config.reload_flag(), + reload: self.options.reload_flag(), reload_exclusions, }; let emit_result = emit::emit(&graph, &self.dir.gen_cache, options)?; log::debug!("{}", emit_result.stats); } else { - let maybe_config_specifier = self.config.maybe_config_file_specifier(); + let maybe_config_specifier = self.options.maybe_config_file_specifier(); let options = emit::CheckOptions { - type_check_mode: self.config.type_check_mode(), - debug: self.config.log_level() == Some(log::Level::Debug), + type_check_mode: self.options.type_check_mode(), + debug: self.options.log_level() == Some(log::Level::Debug), emit_with_diagnostics: false, maybe_config_specifier, ts_config: ts_config_result.ts_config, log_checks: true, - reload: self.config.reload_flag(), + reload: self.options.reload_flag(), reload_exclusions, }; let emit_result = emit::check_and_maybe_emit( @@ -457,7 +457,7 @@ impl ProcState { log::debug!("{}", emit_result.stats); } - if self.config.type_check_mode() != TypeCheckMode::None { + if self.options.type_check_mode() != TypeCheckMode::None { let mut graph_data = self.graph_data.write(); graph_data.set_type_checked(&roots, lib); } @@ -502,7 +502,7 @@ impl ProcState { // and `Deno.core.evalContext` API. Ideally we should always have a referrer filled // but sadly that's not the case due to missing APIs in V8. let referrer = if referrer.is_empty() - && matches!(self.config.sub_command(), DenoSubcommand::Repl(_)) + && matches!(self.options.sub_command(), DenoSubcommand::Repl(_)) { deno_core::resolve_url_or_path("./$deno$repl.ts").unwrap() } else { diff --git a/cli/tools/bench.rs b/cli/tools/bench.rs index d295a2fe27..59c67cf878 100644 --- a/cli/tools/bench.rs +++ b/cli/tools/bench.rs @@ -336,7 +336,7 @@ async fn check_specifiers( permissions: Permissions, specifiers: Vec, ) -> Result<(), AnyError> { - let lib = ps.config.ts_type_lib_window(); + let lib = ps.options.ts_type_lib_window(); ps.prepare_module_load( specifiers, false, @@ -366,7 +366,7 @@ async fn bench_specifier( vec![ops::bench::init( channel.clone(), filter, - ps.config.unstable(), + ps.options.unstable(), )], Default::default(), ); @@ -418,7 +418,7 @@ async fn bench_specifiers( specifiers: Vec, options: BenchSpecifierOptions, ) -> Result<(), AnyError> { - let log_level = ps.config.log_level(); + let log_level = ps.options.log_level(); let (sender, mut receiver) = unbounded_channel::(); @@ -521,7 +521,8 @@ pub async fn run_benchmarks( bench_flags: BenchFlags, ) -> Result<(), AnyError> { let ps = ProcState::build(flags).await?; - let permissions = Permissions::from_options(&ps.config.permissions_options()); + let permissions = + Permissions::from_options(&ps.options.permissions_options()); let specifiers = collect_specifiers( bench_flags.include.unwrap_or_else(|| vec![".".to_string()]), &bench_flags.ignore.clone(), @@ -534,7 +535,7 @@ pub async fn run_benchmarks( check_specifiers(&ps, permissions.clone(), specifiers.clone()).await?; - let compat = ps.config.compat(); + let compat = ps.options.compat(); bench_specifiers( ps, permissions, @@ -555,12 +556,13 @@ pub async fn run_benchmarks_with_watch( bench_flags: BenchFlags, ) -> Result<(), AnyError> { let ps = ProcState::build(flags).await?; - let permissions = Permissions::from_options(&ps.config.permissions_options()); + let permissions = + Permissions::from_options(&ps.options.permissions_options()); let include = bench_flags.include.unwrap_or_else(|| vec![".".to_string()]); let ignore = bench_flags.ignore.clone(); let paths_to_watch: Vec<_> = include.iter().map(PathBuf::from).collect(); - let no_check = ps.config.type_check_mode() == TypeCheckMode::None; + let no_check = ps.options.type_check_mode() == TypeCheckMode::None; let resolver = |changed: Option>| { let mut cache = cache::FetchCacher::new( @@ -576,15 +578,15 @@ pub async fn run_benchmarks_with_watch( let maybe_import_map_resolver = ps.maybe_import_map.clone().map(ImportMapResolver::new); let maybe_jsx_resolver = ps - .config + .options .to_maybe_jsx_import_source_module() .map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone())); let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone()); - let maybe_imports_result = ps.config.to_maybe_imports(); + let maybe_imports_result = ps.options.to_maybe_imports(); let files_changed = changed.is_some(); let include = include.clone(); let ignore = ignore.clone(); - let check_js = ps.config.check_js(); + let check_js = ps.options.check_js(); async move { let bench_modules = @@ -728,7 +730,7 @@ pub async fn run_benchmarks_with_watch( check_specifiers(&ps, permissions.clone(), specifiers.clone()).await?; let specifier_options = BenchSpecifierOptions { - compat_mode: ps.config.compat(), + compat_mode: ps.options.compat(), filter: filter.clone(), }; bench_specifiers(ps, permissions.clone(), specifiers, specifier_options) @@ -743,7 +745,7 @@ pub async fn run_benchmarks_with_watch( operation, file_watcher::PrintConfig { job_name: "Bench".to_string(), - clear_screen: !ps.config.no_clear_screen(), + clear_screen: !ps.options.no_clear_screen(), }, ) .await?; diff --git a/cli/tools/doc.rs b/cli/tools/doc.rs index 068a983894..fbb784f980 100644 --- a/cli/tools/doc.rs +++ b/cli/tools/doc.rs @@ -122,7 +122,7 @@ pub async fn print_docs( doc_parser.parse_source( &source_file_specifier, MediaType::Dts, - get_types(ps.config.unstable()).into(), + get_types(ps.options.unstable()).into(), ) } else { let module_specifier = resolve_url_or_path(&source_file)?; diff --git a/cli/tools/fmt.rs b/cli/tools/fmt.rs index 267b21d888..585bf6e924 100644 --- a/cli/tools/fmt.rs +++ b/cli/tools/fmt.rs @@ -7,10 +7,10 @@ //! the future it can be easily extended to provide //! the same functions as ops available in JS runtime. +use crate::args::CliOptions; use crate::args::FmtFlags; use crate::args::FmtOptionsConfig; use crate::args::ProseWrap; -use crate::args::RootConfig; use crate::colors; use crate::diff::diff; use crate::file_watcher; @@ -43,7 +43,7 @@ use super::incremental_cache::IncrementalCache; /// Format JavaScript/TypeScript files. pub async fn format( - config: &RootConfig, + config: &CliOptions, fmt_flags: FmtFlags, ) -> Result<(), AnyError> { let maybe_fmt_config = config.to_fmt_config()?; diff --git a/cli/tools/lint.rs b/cli/tools/lint.rs index 4e8f8fb0c8..61129b7522 100644 --- a/cli/tools/lint.rs +++ b/cli/tools/lint.rs @@ -76,7 +76,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> { let mut exclude_files = ignore.clone(); let ps = ProcState::build(flags).await?; - let maybe_lint_config = ps.config.to_lint_config()?; + let maybe_lint_config = ps.options.to_lint_config()?; if let Some(lint_config) = maybe_lint_config.as_ref() { if include_files.is_empty() { @@ -202,7 +202,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> { Ok(()) }; - if ps.config.watch_paths().is_some() { + if ps.options.watch_paths().is_some() { if args.len() == 1 && args[0].to_string_lossy() == "-" { return Err(generic_error( "Lint watch on standard input is not supported.", @@ -213,7 +213,7 @@ pub async fn lint(flags: Flags, lint_flags: LintFlags) -> Result<(), AnyError> { operation, file_watcher::PrintConfig { job_name: "Lint".to_string(), - clear_screen: !ps.config.no_clear_screen(), + clear_screen: !ps.options.no_clear_screen(), }, ) .await?; diff --git a/cli/tools/task.rs b/cli/tools/task.rs index fa9f30d7dc..88a0f5be09 100644 --- a/cli/tools/task.rs +++ b/cli/tools/task.rs @@ -30,8 +30,8 @@ pub async fn execute_script( crate::colors::yellow("Warning"), ); let ps = ProcState::build(flags).await?; - let tasks_config = ps.config.resolve_tasks_config()?; - let config_file_url = ps.config.maybe_config_file_specifier().unwrap(); + let tasks_config = ps.options.resolve_tasks_config()?; + let config_file_url = ps.options.maybe_config_file_specifier().unwrap(); let config_file_path = if config_file_url.scheme() == "file" { config_file_url.to_file_path().unwrap() } else { @@ -52,7 +52,7 @@ pub async fn execute_script( if let Some(script) = maybe_script { let additional_args = ps - .config + .options .argv() .iter() // surround all the additional arguments in double quotes diff --git a/cli/tools/test.rs b/cli/tools/test.rs index a06a449be8..d9b3570eca 100644 --- a/cli/tools/test.rs +++ b/cli/tools/test.rs @@ -1013,7 +1013,7 @@ pub async fn check_specifiers( permissions: Permissions, specifiers: Vec<(ModuleSpecifier, TestMode)>, ) -> Result<(), AnyError> { - let lib = ps.config.ts_type_lib_window(); + let lib = ps.options.ts_type_lib_window(); let inline_files = fetch_inline_files( ps.clone(), specifiers @@ -1081,7 +1081,7 @@ async fn test_specifiers( specifiers_with_mode: Vec<(ModuleSpecifier, TestMode)>, options: TestSpecifierOptions, ) -> Result<(), AnyError> { - let log_level = ps.config.log_level(); + let log_level = ps.options.log_level(); let specifiers_with_mode = if let Some(seed) = options.shuffle { let mut rng = SmallRng::seed_from_u64(seed); let mut specifiers_with_mode = specifiers_with_mode.clone(); @@ -1326,7 +1326,8 @@ pub async fn run_tests( test_flags: TestFlags, ) -> Result<(), AnyError> { let ps = ProcState::build(flags).await?; - let permissions = Permissions::from_options(&ps.config.permissions_options()); + let permissions = + Permissions::from_options(&ps.options.permissions_options()); let specifiers_with_mode = fetch_specifiers_with_test_mode( &ps, test_flags.include.unwrap_or_else(|| vec![".".to_string()]), @@ -1346,7 +1347,7 @@ pub async fn run_tests( return Ok(()); } - let compat = ps.config.compat(); + let compat = ps.options.compat(); test_specifiers( ps, permissions, @@ -1370,12 +1371,13 @@ pub async fn run_tests_with_watch( test_flags: TestFlags, ) -> Result<(), AnyError> { let ps = ProcState::build(flags).await?; - let permissions = Permissions::from_options(&ps.config.permissions_options()); + let permissions = + Permissions::from_options(&ps.options.permissions_options()); let include = test_flags.include.unwrap_or_else(|| vec![".".to_string()]); let ignore = test_flags.ignore.clone(); let paths_to_watch: Vec<_> = include.iter().map(PathBuf::from).collect(); - let no_check = ps.config.type_check_mode() == TypeCheckMode::None; + let no_check = ps.options.type_check_mode() == TypeCheckMode::None; let resolver = |changed: Option>| { let mut cache = cache::FetchCacher::new( @@ -1391,15 +1393,15 @@ pub async fn run_tests_with_watch( let maybe_import_map_resolver = ps.maybe_import_map.clone().map(ImportMapResolver::new); let maybe_jsx_resolver = ps - .config + .options .to_maybe_jsx_import_source_module() .map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone())); let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone()); - let maybe_imports_result = ps.config.to_maybe_imports(); + let maybe_imports_result = ps.options.to_maybe_imports(); let files_changed = changed.is_some(); let include = include.clone(); let ignore = ignore.clone(); - let check_js = ps.config.check_js(); + let check_js = ps.options.check_js(); async move { let test_modules = if test_flags.doc { @@ -1528,9 +1530,9 @@ pub async fn run_tests_with_watch( }) }; - let root_config = ps.config.clone(); + let cli_options = ps.options.clone(); let operation = |modules_to_reload: Vec<(ModuleSpecifier, ModuleKind)>| { - let root_config = root_config.clone(); + let cli_options = cli_options.clone(); let filter = test_flags.filter.clone(); let include = include.clone(); let ignore = ignore.clone(); @@ -1564,7 +1566,7 @@ pub async fn run_tests_with_watch( permissions.clone(), specifiers_with_mode, TestSpecifierOptions { - compat_mode: root_config.compat(), + compat_mode: cli_options.compat(), concurrent_jobs: test_flags.concurrent_jobs, fail_fast: test_flags.fail_fast, filter: filter.clone(), @@ -1583,7 +1585,7 @@ pub async fn run_tests_with_watch( operation, file_watcher::PrintConfig { job_name: "Test".to_string(), - clear_screen: !root_config.no_clear_screen(), + clear_screen: !cli_options.no_clear_screen(), }, ) .await?; diff --git a/cli/tools/vendor/mod.rs b/cli/tools/vendor/mod.rs index fc7684b5b4..7c36b5074c 100644 --- a/cli/tools/vendor/mod.rs +++ b/cli/tools/vendor/mod.rs @@ -134,12 +134,12 @@ fn validate_output_dir( fn maybe_update_config_file(output_dir: &Path, ps: &ProcState) -> bool { assert!(output_dir.is_absolute()); - let config_file_specifier = match ps.config.maybe_config_file_specifier() { + let config_file_specifier = match ps.options.maybe_config_file_specifier() { Some(f) => f, None => return false, }; let fmt_config = ps - .config + .options .to_fmt_config() .unwrap_or_default() .unwrap_or_default(); @@ -263,11 +263,11 @@ async fn create_graph( Permissions::allow_all(), ); let maybe_locker = lockfile::as_maybe_locker(ps.lockfile.clone()); - let maybe_imports = ps.config.to_maybe_imports()?; + let maybe_imports = ps.options.to_maybe_imports()?; let maybe_import_map_resolver = ps.maybe_import_map.clone().map(ImportMapResolver::new); let maybe_jsx_resolver = ps - .config + .options .to_maybe_jsx_import_source_module() .map(|im| JsxResolver::new(im, maybe_import_map_resolver.clone())); let maybe_resolver = if maybe_jsx_resolver.is_some() {