mirror of
https://github.com/denoland/deno.git
synced 2024-12-23 07:44:48 -05:00
48ede89f1f
This commit changes current "deno_core::resolve_url_or_path" API to "resolve_url_or_path_deprecated" and adds new "resolve_url_or_path" API that requires to explicitly pass the directory from which paths should be resolved to. Some of the call sites were updated to use the new API, the reminder of them will be updated in a follow up PR. Towards landing https://github.com/denoland/deno/pull/15454
343 lines
8.8 KiB
Rust
343 lines
8.8 KiB
Rust
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
|
|
|
|
use std::path::Path;
|
|
use std::path::PathBuf;
|
|
use std::sync::Arc;
|
|
|
|
use deno_ast::ModuleSpecifier;
|
|
use deno_core::anyhow::bail;
|
|
use deno_core::anyhow::Context;
|
|
use deno_core::error::AnyError;
|
|
use deno_core::resolve_url_or_path;
|
|
use log::warn;
|
|
|
|
use crate::args::CliOptions;
|
|
use crate::args::Flags;
|
|
use crate::args::FmtOptionsConfig;
|
|
use crate::args::VendorFlags;
|
|
use crate::proc_state::ProcState;
|
|
use crate::tools::fmt::format_json;
|
|
use crate::util::fs::canonicalize_path;
|
|
use crate::util::fs::resolve_from_cwd;
|
|
use crate::util::path::relative_specifier;
|
|
use crate::util::path::specifier_to_file_path;
|
|
|
|
mod analyze;
|
|
mod build;
|
|
mod import_map;
|
|
mod mappings;
|
|
mod specifiers;
|
|
#[cfg(test)]
|
|
mod test;
|
|
|
|
pub async fn vendor(
|
|
flags: Flags,
|
|
vendor_flags: VendorFlags,
|
|
) -> Result<(), AnyError> {
|
|
let mut cli_options = CliOptions::from_flags(flags)?;
|
|
let raw_output_dir = match &vendor_flags.output_path {
|
|
Some(output_path) => output_path.to_owned(),
|
|
None => PathBuf::from("vendor/"),
|
|
};
|
|
let output_dir = resolve_from_cwd(&raw_output_dir)?;
|
|
validate_output_dir(&output_dir, &vendor_flags)?;
|
|
validate_options(&mut cli_options, &output_dir)?;
|
|
let ps = ProcState::from_options(Arc::new(cli_options)).await?;
|
|
let graph = create_graph(&ps, &vendor_flags).await?;
|
|
let vendored_count = build::build(
|
|
graph,
|
|
&ps.parsed_source_cache,
|
|
&output_dir,
|
|
ps.maybe_import_map.as_deref(),
|
|
ps.lockfile.clone(),
|
|
&build::RealVendorEnvironment,
|
|
)?;
|
|
|
|
log::info!(
|
|
concat!("Vendored {} {} into {} directory.",),
|
|
vendored_count,
|
|
if vendored_count == 1 {
|
|
"module"
|
|
} else {
|
|
"modules"
|
|
},
|
|
raw_output_dir.display(),
|
|
);
|
|
if vendored_count > 0 {
|
|
let import_map_path = raw_output_dir.join("import_map.json");
|
|
if maybe_update_config_file(&output_dir, &ps) {
|
|
log::info!(
|
|
concat!(
|
|
"\nUpdated your local Deno configuration file with a reference to the ",
|
|
"new vendored import map at {}. Invoking Deno subcommands will now ",
|
|
"automatically resolve using the vendored modules. You may override ",
|
|
"this by providing the `--import-map <other-import-map>` flag or by ",
|
|
"manually editing your Deno configuration file.",
|
|
),
|
|
import_map_path.display(),
|
|
);
|
|
} else {
|
|
log::info!(
|
|
concat!(
|
|
"\nTo use vendored modules, specify the `--import-map {}` flag when ",
|
|
r#"invoking Deno subcommands or add an `"importMap": "<path_to_vendored_import_map>"` "#,
|
|
"entry to a deno.json file.",
|
|
),
|
|
import_map_path.display(),
|
|
);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn validate_output_dir(
|
|
output_dir: &Path,
|
|
flags: &VendorFlags,
|
|
) -> Result<(), AnyError> {
|
|
if !flags.force && !is_dir_empty(output_dir)? {
|
|
bail!(concat!(
|
|
"Output directory was not empty. Please specify an empty directory or use ",
|
|
"--force to ignore this error and potentially overwrite its contents.",
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn validate_options(
|
|
options: &mut CliOptions,
|
|
output_dir: &Path,
|
|
) -> Result<(), AnyError> {
|
|
// check the import map
|
|
if let Some(import_map_path) = options
|
|
.resolve_import_map_specifier()?
|
|
.and_then(|p| specifier_to_file_path(&p).ok())
|
|
.and_then(|p| canonicalize_path(&p).ok())
|
|
{
|
|
// make the output directory in order to canonicalize it for the check below
|
|
std::fs::create_dir_all(output_dir)?;
|
|
let output_dir = canonicalize_path(output_dir).with_context(|| {
|
|
format!("Failed to canonicalize: {}", output_dir.display())
|
|
})?;
|
|
|
|
if import_map_path.starts_with(output_dir) {
|
|
// canonicalize to make the test for this pass on the CI
|
|
let cwd = canonicalize_path(&std::env::current_dir()?)?;
|
|
// We don't allow using the output directory to help generate the
|
|
// new state because this may lead to cryptic error messages.
|
|
log::warn!(
|
|
concat!(
|
|
"Ignoring import map. Specifying an import map file ({}) in the ",
|
|
"deno vendor output directory is not supported. If you wish to use ",
|
|
"an import map while vendoring, please specify one located outside ",
|
|
"this directory."
|
|
),
|
|
import_map_path
|
|
.strip_prefix(&cwd)
|
|
.unwrap_or(&import_map_path)
|
|
.display()
|
|
.to_string(),
|
|
);
|
|
|
|
// don't use an import map in the config
|
|
options.set_import_map_specifier(None);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn maybe_update_config_file(output_dir: &Path, ps: &ProcState) -> bool {
|
|
assert!(output_dir.is_absolute());
|
|
let config_file_specifier = match ps.options.maybe_config_file_specifier() {
|
|
Some(f) => f,
|
|
None => return false,
|
|
};
|
|
|
|
let fmt_config = ps
|
|
.options
|
|
.maybe_config_file()
|
|
.as_ref()
|
|
.and_then(|config| config.to_fmt_config().ok())
|
|
.unwrap_or_default()
|
|
.unwrap_or_default();
|
|
let result = update_config_file(
|
|
&config_file_specifier,
|
|
&ModuleSpecifier::from_file_path(output_dir.join("import_map.json"))
|
|
.unwrap(),
|
|
&fmt_config.options,
|
|
);
|
|
match result {
|
|
Ok(()) => true,
|
|
Err(err) => {
|
|
warn!("Error updating config file. {:#}", err);
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update_config_file(
|
|
config_specifier: &ModuleSpecifier,
|
|
import_map_specifier: &ModuleSpecifier,
|
|
fmt_options: &FmtOptionsConfig,
|
|
) -> Result<(), AnyError> {
|
|
if config_specifier.scheme() != "file" {
|
|
return Ok(());
|
|
}
|
|
|
|
let config_path = specifier_to_file_path(config_specifier)?;
|
|
let config_text = std::fs::read_to_string(&config_path)?;
|
|
let relative_text =
|
|
match relative_specifier(config_specifier, import_map_specifier) {
|
|
Some(text) => text,
|
|
None => return Ok(()), // ignore
|
|
};
|
|
if let Some(new_text) =
|
|
update_config_text(&config_text, &relative_text, fmt_options)
|
|
{
|
|
std::fs::write(config_path, new_text)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn update_config_text(
|
|
text: &str,
|
|
import_map_specifier: &str,
|
|
fmt_options: &FmtOptionsConfig,
|
|
) -> Option<String> {
|
|
use jsonc_parser::ast::ObjectProp;
|
|
use jsonc_parser::ast::Value;
|
|
let ast =
|
|
jsonc_parser::parse_to_ast(text, &Default::default(), &Default::default())
|
|
.ok()?;
|
|
let obj = match ast.value {
|
|
Some(Value::Object(obj)) => obj,
|
|
_ => return None, // shouldn't happen, so ignore
|
|
};
|
|
let import_map_specifier = import_map_specifier.replace('\"', "\\\"");
|
|
|
|
match obj.get("importMap") {
|
|
Some(ObjectProp {
|
|
value: Value::StringLit(lit),
|
|
..
|
|
}) => Some(format!(
|
|
"{}{}{}",
|
|
&text[..lit.range.start + 1],
|
|
import_map_specifier,
|
|
&text[lit.range.end - 1..],
|
|
)),
|
|
None => {
|
|
// insert it crudely at a position that won't cause any issues
|
|
// with comments and format after to make it look nice
|
|
let insert_position = obj.range.end - 1;
|
|
let insert_text = format!(
|
|
r#"{}"importMap": "{}""#,
|
|
if obj.properties.is_empty() { "" } else { "," },
|
|
import_map_specifier
|
|
);
|
|
let new_text = format!(
|
|
"{}{}{}",
|
|
&text[..insert_position],
|
|
insert_text,
|
|
&text[insert_position..],
|
|
);
|
|
format_json(&new_text, fmt_options)
|
|
.ok()
|
|
.map(|formatted_text| formatted_text.unwrap_or(new_text))
|
|
}
|
|
// shouldn't happen, so ignore
|
|
Some(_) => None,
|
|
}
|
|
}
|
|
|
|
fn is_dir_empty(dir_path: &Path) -> Result<bool, AnyError> {
|
|
match std::fs::read_dir(dir_path) {
|
|
Ok(mut dir) => Ok(dir.next().is_none()),
|
|
Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(true),
|
|
Err(err) => {
|
|
bail!("Error reading directory {}: {}", dir_path.display(), err)
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn create_graph(
|
|
ps: &ProcState,
|
|
flags: &VendorFlags,
|
|
) -> Result<deno_graph::ModuleGraph, AnyError> {
|
|
let entry_points = flags
|
|
.specifiers
|
|
.iter()
|
|
.map(|p| resolve_url_or_path(p, ps.options.initial_cwd()))
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
|
|
ps.create_graph(entry_points).await
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod internal_test {
|
|
use super::*;
|
|
use pretty_assertions::assert_eq;
|
|
|
|
#[test]
|
|
fn update_config_text_no_existing_props_add_prop() {
|
|
let text = update_config_text(
|
|
"{\n}",
|
|
"./vendor/import_map.json",
|
|
&Default::default(),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
text,
|
|
r#"{
|
|
"importMap": "./vendor/import_map.json"
|
|
}
|
|
"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn update_config_text_existing_props_add_prop() {
|
|
let text = update_config_text(
|
|
r#"{
|
|
"tasks": {
|
|
"task1": "other"
|
|
}
|
|
}
|
|
"#,
|
|
"./vendor/import_map.json",
|
|
&Default::default(),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
text,
|
|
r#"{
|
|
"tasks": {
|
|
"task1": "other"
|
|
},
|
|
"importMap": "./vendor/import_map.json"
|
|
}
|
|
"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn update_config_text_update_prop() {
|
|
let text = update_config_text(
|
|
r#"{
|
|
"importMap": "./local.json"
|
|
}
|
|
"#,
|
|
"./vendor/import_map.json",
|
|
&Default::default(),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
text,
|
|
r#"{
|
|
"importMap": "./vendor/import_map.json"
|
|
}
|
|
"#
|
|
);
|
|
}
|
|
}
|