1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-01-08 07:08:27 -05:00

refactor: rename RootConfig to CliOptions (#15007)

This commit is contained in:
David Sherret 2022-06-29 11:51:11 -04:00 committed by GitHub
parent 1328a56230
commit 8c4420c005
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 138 additions and 132 deletions

View file

@ -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()

View file

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

View file

@ -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");

View file

@ -27,7 +27,7 @@ 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,
})
@ -35,7 +35,7 @@ impl CliModuleLoader {
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,
})

View file

@ -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<String>,
pub file_fetcher: FileFetcher,
pub config: Arc<RootConfig>,
pub options: Arc<CliOptions>,
graph_data: Arc<RwLock<GraphData>>,
pub lockfile: Option<Arc<Mutex<Lockfile>>>,
pub maybe_import_map: Option<Arc<ImportMap>>,
@ -91,13 +91,13 @@ impl Deref for ProcState {
impl ProcState {
pub async fn build(flags: Flags) -> Result<Self, AnyError> {
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<RootConfig>,
pub async fn from_options(
options: Arc<CliOptions>,
) -> Result<Self, AnyError> {
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<Vec<PathBuf>>,
) -> Result<Self, AnyError> {
// 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<RootConfig>,
cli_options: Arc<CliOptions>,
maybe_sender: Option<tokio::sync::mpsc::UnboundedSender<Vec<PathBuf>>>,
) -> Result<Self, AnyError> {
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<dyn deno_graph::source::Resolver + Send + Sync>,
> = 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 {

View file

@ -336,7 +336,7 @@ async fn check_specifiers(
permissions: Permissions,
specifiers: Vec<ModuleSpecifier>,
) -> 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(),
);
@ -424,7 +424,7 @@ async fn bench_specifiers(
specifiers: Vec<ModuleSpecifier>,
options: BenchSpecifierOptions,
) -> Result<(), AnyError> {
let log_level = ps.config.log_level();
let log_level = ps.options.log_level();
let (sender, mut receiver) = unbounded_channel::<BenchEvent>();
@ -527,7 +527,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(),
@ -540,7 +541,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,
@ -561,12 +562,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<Vec<PathBuf>>| {
let mut cache = cache::FetchCacher::new(
@ -582,15 +584,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 =
@ -734,7 +736,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)
@ -749,7 +751,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?;

View file

@ -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)?;

View file

@ -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()?;

View file

@ -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?;

View file

@ -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

View file

@ -1020,7 +1020,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
@ -1088,7 +1088,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();
@ -1333,7 +1333,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()]),
@ -1353,7 +1354,7 @@ pub async fn run_tests(
return Ok(());
}
let compat = ps.config.compat();
let compat = ps.options.compat();
test_specifiers(
ps,
permissions,
@ -1377,12 +1378,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<Vec<PathBuf>>| {
let mut cache = cache::FetchCacher::new(
@ -1398,15 +1400,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 {
@ -1535,9 +1537,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();
@ -1571,7 +1573,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(),
@ -1590,7 +1592,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?;

View file

@ -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() {