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:
parent
1328a56230
commit
8c4420c005
12 changed files with 138 additions and 132 deletions
cli
|
@ -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()
|
||||
|
|
|
@ -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()),
|
||||
|
|
96
cli/main.rs
96
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");
|
||||
|
||||
|
|
|
@ -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,
|
||||
})
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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?;
|
||||
|
|
|
@ -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)?;
|
||||
|
|
|
@ -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()?;
|
||||
|
|
|
@ -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?;
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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?;
|
||||
|
|
8
cli/tools/vendor/mod.rs
vendored
8
cli/tools/vendor/mod.rs
vendored
|
@ -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() {
|
||||
|
|
Loading…
Reference in a new issue