refactor: rename RootConfig to CliOptions (denoland#15007)

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<ConfigFile>,
 }
 
-impl RootConfig {
+impl CliOptions {
  pub fn from_flags(flags: Flags) -> Result<Self, AnyError> {
  if let Some(insecure_allowlist) =
  flags.unsafely_ignore_certificate_errors.as_ref()

cli/lsp/testing/execution.rs

@@ -315,7 +315,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(),
@@ -331,7 +331,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()),

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<PreloadModuleCb> {
- 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<i32, AnyError> {
  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?;
@@ -645,11 +645,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() {
@@ -673,36 +673,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(),
  },
  )?;
@@ -721,9 +721,10 @@ fn bundle_module_graph(
 ) -> Result<deno_emit::BundleEmit, AnyError> {
  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);
  }
@@ -744,16 +745,16 @@ async fn bundle_command(
  bundle_flags: BundleFlags,
 ) -> Result<i32, AnyError> {
  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?;
@@ -767,7 +768,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()))
  {
@@ -829,13 +830,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?;
@@ -864,7 +865,7 @@ async fn format_command(
  flags: Flags,
  fmt_flags: FmtFlags,
 ) -> Result<i32, AnyError> {
- 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()?;
@@ -888,11 +889,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?;
@@ -909,7 +910,7 @@ async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> {
  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(),
  );
@@ -930,7 +931,7 @@ async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> {
  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?;
@@ -1078,7 +1079,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(),
@@ -1104,7 +1106,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");
 

cli/module_loader.rs

@@ -27,15 +27,15 @@ pub struct CliModuleLoader {
 impl CliModuleLoader {
  pub fn new(ps: ProcState) -> Rc<Self> {
  Rc::new(CliModuleLoader {
- lib: ps.config.ts_type_lib_window(),
+ lib: ps.options.ts_type_lib_window(),
  root_permissions: Permissions::allow_all(),
  ps,
  })
  }
 
  pub fn new_for_worker(ps: ProcState, permissions: Permissions) -> Rc<Self> {
  Rc::new(CliModuleLoader {
- lib: ps.config.ts_type_lib_worker(),
+ lib: ps.options.ts_type_lib_worker(),
  root_permissions: permissions,
  ps,
  })