development/deno
development/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno synced 2024-07-07 20:06:37 +00:00
Code Issues Projects Releases Wiki Activity

chore(cli): move away from PathBuf in clap (#22036)

Browse Source
This commit is contained in:
Łukasz Czerniawski 2024-03-15 00:53:46 +01:00 committed by GitHub
parent 85116226b3
commit 5403e4f06b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 168 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

189
cli/args/flags.rs
View File

@ -69,7 +69,7 @@ pub struct CheckFlags {
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
pub struct CompileFlags { pub struct CompileFlags {
pub source_file: String, pub source_file: String,
pub output: Option<PathBuf>, pub output: Option<String>,
pub args: Vec<String>, pub args: Vec<String>,
pub target: Option<String>, pub target: Option<String>,
pub no_terminal: bool, pub no_terminal: bool,
@ -102,7 +102,7 @@ pub enum CoverageType {
#[derive(Clone, Debug, Eq, PartialEq, Default)] #[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct CoverageFlags { pub struct CoverageFlags {
pub files: FileFlags, pub files: FileFlags,
pub output: Option<PathBuf>, pub output: Option<String>,
pub include: Vec<String>, pub include: Vec<String>,
pub exclude: Vec<String>, pub exclude: Vec<String>,
pub r#type: CoverageType, pub r#type: CoverageType,
@ -123,7 +123,7 @@ impl Default for DocSourceFileFlag {
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
pub struct DocHtmlFlag { pub struct DocHtmlFlag {
pub name: String, pub name: String,
pub output: PathBuf, pub output: String,
} }
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
@ -186,7 +186,7 @@ pub struct InstallFlags {
pub struct JupyterFlags { pub struct JupyterFlags {
pub install: bool, pub install: bool,
pub kernel: bool, pub kernel: bool,
pub conn_file: Option<PathBuf>, pub conn_file: Option<String>,
} }
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
@ -250,7 +250,7 @@ pub struct WatchFlags {
#[derive(Clone, Default, Debug, Eq, PartialEq)] #[derive(Clone, Default, Debug, Eq, PartialEq)]
pub struct WatchFlagsWithPaths { pub struct WatchFlagsWithPaths {
pub hmr: bool, pub hmr: bool,
pub paths: Vec<PathBuf>, pub paths: Vec<String>,
pub no_clear_screen: bool, pub no_clear_screen: bool,
} }
@ -292,13 +292,13 @@ pub struct UpgradeFlags {
pub force: bool, pub force: bool,
pub canary: bool, pub canary: bool,
pub version: Option<String>, pub version: Option<String>,
pub output: Option<PathBuf>, pub output: Option<String>,
} }
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
pub struct VendorFlags { pub struct VendorFlags {
pub specifiers: Vec<String>, pub specifiers: Vec<String>,
pub output_path: Option<PathBuf>, pub output_path: Option<String>,
pub force: bool, pub force: bool,
} }
@ -440,16 +440,16 @@ pub struct Flags {
pub deny_hrtime: bool, pub deny_hrtime: bool,
pub allow_net: Option<Vec<String>>, pub allow_net: Option<Vec<String>>,
pub deny_net: Option<Vec<String>>, pub deny_net: Option<Vec<String>>,
pub allow_ffi: Option<Vec<PathBuf>>, pub allow_ffi: Option<Vec<String>>,
pub deny_ffi: Option<Vec<PathBuf>>, pub deny_ffi: Option<Vec<String>>,
pub allow_read: Option<Vec<PathBuf>>, pub allow_read: Option<Vec<String>>,
pub deny_read: Option<Vec<PathBuf>>, pub deny_read: Option<Vec<String>>,
pub allow_run: Option<Vec<String>>, pub allow_run: Option<Vec<String>>,
pub deny_run: Option<Vec<String>>, pub deny_run: Option<Vec<String>>,
pub allow_sys: Option<Vec<String>>, pub allow_sys: Option<Vec<String>>,
pub deny_sys: Option<Vec<String>>, pub deny_sys: Option<Vec<String>>,
pub allow_write: Option<Vec<PathBuf>>, pub allow_write: Option<Vec<String>>,
pub deny_write: Option<Vec<PathBuf>>, pub deny_write: Option<Vec<String>>,
pub ca_stores: Option<Vec<String>>, pub ca_stores: Option<Vec<String>>,
pub ca_data: Option<CaData>, pub ca_data: Option<CaData>,
pub cache_blocklist: Vec<String>, pub cache_blocklist: Vec<String>,
@ -464,7 +464,7 @@ pub struct Flags {
pub enable_op_summary_metrics: bool, pub enable_op_summary_metrics: bool,
pub enable_testing_features: bool, pub enable_testing_features: bool,
pub ext: Option<String>, pub ext: Option<String>,
pub ignore: Vec<PathBuf>, pub ignore: Vec<String>,
pub import_map_path: Option<String>, pub import_map_path: Option<String>,
pub env_file: Option<String>, pub env_file: Option<String>,
pub inspect_brk: Option<SocketAddr>, pub inspect_brk: Option<SocketAddr>,
@ -472,7 +472,7 @@ pub struct Flags {
pub inspect: Option<SocketAddr>, pub inspect: Option<SocketAddr>,
pub location: Option<Url>, pub location: Option<Url>,
pub lock_write: bool, pub lock_write: bool,
pub lock: Option<PathBuf>, pub lock: Option<String>,
pub log_level: Option<Level>, pub log_level: Option<Level>,
pub no_remote: bool, pub no_remote: bool,
pub no_lock: bool, pub no_lock: bool,
@ -486,10 +486,10 @@ pub struct Flags {
pub v8_flags: Vec<String>, pub v8_flags: Vec<String>,
} }
fn join_paths(allowlist: &[PathBuf], d: &str) -> String { fn join_paths(allowlist: &[String], d: &str) -> String {
allowlist allowlist
.iter() .iter()
.map(|path| path.to_str().unwrap().to_string()) .map(|path| path.to_string())
.collect::<Vec<String>>() .collect::<Vec<String>>()
.join(d) .join(d)
} }
@ -1348,8 +1348,7 @@ supported in canary.
Arg::new("output") Arg::new("output")
.long("output") .long("output")
.short('o') .short('o')
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.help("Output file (defaults to $PWD/<inferred-name>)") .help("Output file (defaults to $PWD/<inferred-name>)")
.value_hint(ValueHint::FilePath), .value_hint(ValueHint::FilePath),
) )
@ -1473,8 +1472,7 @@ Generate html reports from lcov:
Arg::new("output") Arg::new("output")
.requires("lcov") .requires("lcov")
.long("output") .long("output")
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.help("Output file (defaults to stdout) for lcov") .help("Output file (defaults to stdout) for lcov")
.long_help( .long_help(
"Exports the coverage report in lcov format to the given file. "Exports the coverage report in lcov format to the given file.
@ -1580,8 +1578,7 @@ Show documentation for runtime built-ins:
.action(ArgAction::Set) .action(ArgAction::Set)
.require_equals(true) .require_equals(true)
.value_hint(ValueHint::DirPath) .value_hint(ValueHint::DirPath)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
) )
.arg( .arg(
Arg::new("private") Arg::new("private")
@ -1922,8 +1919,7 @@ fn jupyter_subcommand() -> Command {
Arg::new("conn") Arg::new("conn")
.long("conn") .long("conn")
.help("Path to JSON file describing connection parameters, provided by Jupyter") .help("Path to JSON file describing connection parameters, provided by Jupyter")
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::FilePath) .value_hint(ValueHint::FilePath)
.conflicts_with("install")) .conflicts_with("install"))
.about("Deno kernel for Jupyter notebooks") .about("Deno kernel for Jupyter notebooks")
@ -2346,8 +2342,7 @@ update to a different location, use the --output flag
Arg::new("output") Arg::new("output")
.long("output") .long("output")
.help("The path to output the updated version to") .help("The path to output the updated version to")
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::FilePath), .value_hint(ValueHint::FilePath),
) )
.arg( .arg(
@ -2401,8 +2396,7 @@ Remote modules and multiple modules may also be specified:
Arg::new("output") Arg::new("output")
.long("output") .long("output")
.help("The directory to output the vendored modules to") .help("The directory to output the vendored modules to")
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::DirPath), .value_hint(ValueHint::DirPath),
) )
.arg( .arg(
@ -2656,8 +2650,7 @@ fn permission_args(app: Command) -> Command {
.require_equals(true) .require_equals(true)
.value_name("PATH") .value_name("PATH")
.help(ALLOW_READ_HELP) .help(ALLOW_READ_HELP)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::AnyPath), .value_hint(ValueHint::AnyPath),
) )
.arg( .arg(
@ -2668,8 +2661,7 @@ fn permission_args(app: Command) -> Command {
.require_equals(true) .require_equals(true)
.value_name("PATH") .value_name("PATH")
.help(DENY_READ_HELP) .help(DENY_READ_HELP)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::AnyPath), .value_hint(ValueHint::AnyPath),
) )
.arg( .arg(
@ -2680,8 +2672,7 @@ fn permission_args(app: Command) -> Command {
.require_equals(true) .require_equals(true)
.value_name("PATH") .value_name("PATH")
.help(ALLOW_WRITE_HELP) .help(ALLOW_WRITE_HELP)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::AnyPath), .value_hint(ValueHint::AnyPath),
) )
.arg( .arg(
@ -2692,8 +2683,7 @@ fn permission_args(app: Command) -> Command {
.require_equals(true) .require_equals(true)
.value_name("PATH") .value_name("PATH")
.help(DENY_WRITE_HELP) .help(DENY_WRITE_HELP)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::AnyPath), .value_hint(ValueHint::AnyPath),
) )
.arg( .arg(
@ -2803,8 +2793,7 @@ fn permission_args(app: Command) -> Command {
.require_equals(true) .require_equals(true)
.value_name("PATH") .value_name("PATH")
.help(ALLOW_FFI_HELP) .help(ALLOW_FFI_HELP)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::AnyPath), .value_hint(ValueHint::AnyPath),
) )
.arg( .arg(
@ -2815,8 +2804,7 @@ fn permission_args(app: Command) -> Command {
.require_equals(true) .require_equals(true)
.value_name("PATH") .value_name("PATH")
.help(DENY_FFI_HELP) .help(DENY_FFI_HELP)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::AnyPath), .value_hint(ValueHint::AnyPath),
) )
.arg( .arg(
@ -3056,8 +3044,7 @@ fn hmr_arg(takes_files: bool) -> Arg {
arg arg
.value_name("FILES") .value_name("FILES")
.num_args(0..) .num_args(0..)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.use_value_delimiter(true) .use_value_delimiter(true)
.require_equals(true) .require_equals(true)
.long_help( .long_help(
@ -3083,8 +3070,7 @@ fn watch_arg(takes_files: bool) -> Arg {
arg arg
.value_name("FILES") .value_name("FILES")
.num_args(0..) .num_args(0..)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.use_value_delimiter(true) .use_value_delimiter(true)
.require_equals(true) .require_equals(true)
.long_help( .long_help(
@ -3175,8 +3161,7 @@ fn lock_arg() -> Arg {
If value is not provided, defaults to \"deno.lock\" in the current working directory.") If value is not provided, defaults to \"deno.lock\" in the current working directory.")
.num_args(0..=1) .num_args(0..=1)
// todo(dsherret): remove value_parser!(PathBuf) and instead parse as string .value_parser(value_parser!(String))
.value_parser(value_parser!(PathBuf))
.value_hint(ValueHint::FilePath) .value_hint(ValueHint::FilePath)
} }
@ -3362,7 +3347,7 @@ fn compile_parse(flags: &mut Flags, matches: &mut ArgMatches) {
let mut script = matches.remove_many::<String>("script_arg").unwrap(); let mut script = matches.remove_many::<String>("script_arg").unwrap();
let source_file = script.next().unwrap(); let source_file = script.next().unwrap();
let args = script.collect(); let args = script.collect();
let output = matches.remove_one::<PathBuf>("output"); let output = matches.remove_one::<String>("output");
let target = matches.remove_one::<String>("target"); let target = matches.remove_one::<String>("target");
let no_terminal = matches.get_flag("no-terminal"); let no_terminal = matches.get_flag("no-terminal");
let include = match matches.remove_many::<String>("include") { let include = match matches.remove_many::<String>("include") {
@ -3436,7 +3421,7 @@ fn coverage_parse(flags: &mut Flags, matches: &mut ArgMatches) {
} else { } else {
CoverageType::Summary CoverageType::Summary
}; };
let output = matches.remove_one::<PathBuf>("output"); let output = matches.remove_one::<String>("output");
flags.subcommand = DenoSubcommand::Coverage(CoverageFlags { flags.subcommand = DenoSubcommand::Coverage(CoverageFlags {
files: FileFlags { files: FileFlags {
include: files, include: files,
@ -3482,8 +3467,8 @@ fn doc_parse(flags: &mut Flags, matches: &mut ArgMatches) {
let html = if matches.get_flag("html") { let html = if matches.get_flag("html") {
let name = matches.remove_one::<String>("name").unwrap(); let name = matches.remove_one::<String>("name").unwrap();
let output = matches let output = matches
.remove_one::<PathBuf>("output") .remove_one::<String>("output")
.unwrap_or(PathBuf::from("./docs/")); .unwrap_or(String::from("./docs/"));
Some(DocHtmlFlag { name, output }) Some(DocHtmlFlag { name, output })
} else { } else {
None None
@ -3605,7 +3590,7 @@ fn install_parse(flags: &mut Flags, matches: &mut ArgMatches) {
} }
fn jupyter_parse(flags: &mut Flags, matches: &mut ArgMatches) { fn jupyter_parse(flags: &mut Flags, matches: &mut ArgMatches) {
let conn_file = matches.remove_one::<PathBuf>("conn"); let conn_file = matches.remove_one::<String>("conn");
let kernel = matches.get_flag("kernel"); let kernel = matches.get_flag("kernel");
let install = matches.get_flag("install"); let install = matches.get_flag("install");
@ -3871,7 +3856,7 @@ fn upgrade_parse(flags: &mut Flags, matches: &mut ArgMatches) {
let force = matches.get_flag("force"); let force = matches.get_flag("force");
let canary = matches.get_flag("canary"); let canary = matches.get_flag("canary");
let version = matches.remove_one::<String>("version"); let version = matches.remove_one::<String>("version");
let output = matches.remove_one::<PathBuf>("output"); let output = matches.remove_one::<String>("output");
flags.subcommand = DenoSubcommand::Upgrade(UpgradeFlags { flags.subcommand = DenoSubcommand::Upgrade(UpgradeFlags {
dry_run, dry_run,
force, force,
@ -3894,7 +3879,7 @@ fn vendor_parse(flags: &mut Flags, matches: &mut ArgMatches) {
.remove_many::<String>("specifiers") .remove_many::<String>("specifiers")
.map(|p| p.collect()) .map(|p| p.collect())
.unwrap_or_default(), .unwrap_or_default(),
output_path: matches.remove_one::<PathBuf>("output"), output_path: matches.remove_one::<String>("output"),
force: matches.get_flag("force"), force: matches.get_flag("force"),
}); });
} }
@ -3936,19 +3921,19 @@ fn compile_args_without_check_parse(
fn permission_args_parse(flags: &mut Flags, matches: &mut ArgMatches) { fn permission_args_parse(flags: &mut Flags, matches: &mut ArgMatches) {
unsafely_ignore_certificate_errors_parse(flags, matches); unsafely_ignore_certificate_errors_parse(flags, matches);
if let Some(read_wl) = matches.remove_many::<PathBuf>("allow-read") { if let Some(read_wl) = matches.remove_many::<String>("allow-read") {
flags.allow_read = Some(read_wl.collect()); flags.allow_read = Some(read_wl.collect());
} }
if let Some(read_wl) = matches.remove_many::<PathBuf>("deny-read") { if let Some(read_wl) = matches.remove_many::<String>("deny-read") {
flags.deny_read = Some(read_wl.collect()); flags.deny_read = Some(read_wl.collect());
} }
if let Some(write_wl) = matches.remove_many::<PathBuf>("allow-write") { if let Some(write_wl) = matches.remove_many::<String>("allow-write") {
flags.allow_write = Some(write_wl.collect()); flags.allow_write = Some(write_wl.collect());
} }
if let Some(write_wl) = matches.remove_many::<PathBuf>("deny-write") { if let Some(write_wl) = matches.remove_many::<String>("deny-write") {
flags.deny_write = Some(write_wl.collect()); flags.deny_write = Some(write_wl.collect());
} }
@ -3992,12 +3977,12 @@ fn permission_args_parse(flags: &mut Flags, matches: &mut ArgMatches) {
debug!("sys info denylist: {:#?}", &flags.deny_sys); debug!("sys info denylist: {:#?}", &flags.deny_sys);
} }
if let Some(ffi_wl) = matches.remove_many::<PathBuf>("allow-ffi") { if let Some(ffi_wl) = matches.remove_many::<String>("allow-ffi") {
flags.allow_ffi = Some(ffi_wl.collect()); flags.allow_ffi = Some(ffi_wl.collect());
debug!("ffi allowlist: {:#?}", &flags.allow_ffi); debug!("ffi allowlist: {:#?}", &flags.allow_ffi);
} }
if let Some(ffi_wl) = matches.remove_many::<PathBuf>("deny-ffi") { if let Some(ffi_wl) = matches.remove_many::<String>("deny-ffi") {
flags.deny_ffi = Some(ffi_wl.collect()); flags.deny_ffi = Some(ffi_wl.collect());
debug!("ffi denylist: {:#?}", &flags.deny_ffi); debug!("ffi denylist: {:#?}", &flags.deny_ffi);
} }
@ -4191,8 +4176,8 @@ fn lock_args_parse(flags: &mut Flags, matches: &mut ArgMatches) {
fn lock_arg_parse(flags: &mut Flags, matches: &mut ArgMatches) { fn lock_arg_parse(flags: &mut Flags, matches: &mut ArgMatches) {
if matches.contains_id("lock") { if matches.contains_id("lock") {
let lockfile = matches let lockfile = matches
.remove_one::<PathBuf>("lock") .remove_one::<String>("lock")
.unwrap_or_else(|| PathBuf::from("./deno.lock")); .unwrap_or_else(|| String::from("./deno.lock"));
flags.lock = Some(lockfile); flags.lock = Some(lockfile);
} }
} }
@ -4257,7 +4242,7 @@ fn watch_arg_parse(matches: &mut ArgMatches) -> Option<WatchFlags> {
fn watch_arg_parse_with_paths( fn watch_arg_parse_with_paths(
matches: &mut ArgMatches, matches: &mut ArgMatches,
) -> Option<WatchFlagsWithPaths> { ) -> Option<WatchFlagsWithPaths> {
if let Some(paths) = matches.remove_many::<PathBuf>("watch") { if let Some(paths) = matches.remove_many::<String>("watch") {
return Some(WatchFlagsWithPaths { return Some(WatchFlagsWithPaths {
paths: paths.collect(), paths: paths.collect(),
hmr: false, hmr: false,
@ -4266,7 +4251,7 @@ fn watch_arg_parse_with_paths(
} }
matches matches
.remove_many::<PathBuf>("hmr") .remove_many::<String>("hmr")
.map(|paths| WatchFlagsWithPaths { .map(|paths| WatchFlagsWithPaths {
paths: paths.collect(), paths: paths.collect(),
hmr: true, hmr: true,
@ -4348,6 +4333,24 @@ mod tests {
); );
} }
#[test]
fn upgrade_with_output_flag() {
let r = flags_from_vec(svec!["deno", "upgrade", "--output", "example.txt"]);
assert_eq!(
r.unwrap(),
Flags {
subcommand: DenoSubcommand::Upgrade(UpgradeFlags {
force: false,
dry_run: false,
canary: false,
version: None,
output: Some(String::from("example.txt")),
}),
..Flags::default()
}
);
}
#[test] #[test]
fn version() { fn version() {
let r = flags_from_vec(svec!["deno", "--version"]); let r = flags_from_vec(svec!["deno", "--version"]);
@ -4458,7 +4461,7 @@ mod tests {
script: "script.ts".to_string(), script: "script.ts".to_string(),
watch: Some(WatchFlagsWithPaths { watch: Some(WatchFlagsWithPaths {
hmr: true, hmr: true,
paths: vec![PathBuf::from("foo.txt")], paths: vec![String::from("foo.txt")],
no_clear_screen: true, no_clear_screen: true,
}), }),
}), }),
@ -4483,7 +4486,7 @@ mod tests {
script: "script.ts".to_string(), script: "script.ts".to_string(),
watch: Some(WatchFlagsWithPaths { watch: Some(WatchFlagsWithPaths {
hmr: false, hmr: false,
paths: vec![PathBuf::from("file1"), PathBuf::from("file2")], paths: vec![String::from("file1"), String::from("file2")],
no_clear_screen: false, no_clear_screen: false,
}), }),
}), }),
@ -5517,7 +5520,7 @@ mod tests {
config_flag: ConfigFlag::Path("tsconfig.json".to_owned()), config_flag: ConfigFlag::Path("tsconfig.json".to_owned()),
type_check_mode: TypeCheckMode::None, type_check_mode: TypeCheckMode::None,
reload: true, reload: true,
lock: Some(PathBuf::from("lock.json")), lock: Some(String::from("lock.json")),
lock_write: true, lock_write: true,
ca_data: Some(CaData::File("example.crt".to_string())), ca_data: Some(CaData::File("example.crt".to_string())),
cached_only: true, cached_only: true,
@ -5632,7 +5635,7 @@ mod tests {
config_flag: ConfigFlag::Path("tsconfig.json".to_owned()), config_flag: ConfigFlag::Path("tsconfig.json".to_owned()),
type_check_mode: TypeCheckMode::None, type_check_mode: TypeCheckMode::None,
reload: true, reload: true,
lock: Some(PathBuf::from("lock.json")), lock: Some(String::from("lock.json")),
lock_write: true, lock_write: true,
ca_data: Some(CaData::File("example.crt".to_string())), ca_data: Some(CaData::File("example.crt".to_string())),
cached_only: true, cached_only: true,
@ -5701,18 +5704,18 @@ mod tests {
fn allow_read_allowlist() { fn allow_read_allowlist() {
use test_util::TempDir; use test_util::TempDir;
let temp_dir_guard = TempDir::new(); let temp_dir_guard = TempDir::new();
let temp_dir = temp_dir_guard.path().to_path_buf(); let temp_dir = temp_dir_guard.path().to_string();
let r = flags_from_vec(svec![ let r = flags_from_vec(svec![
"deno", "deno",
"run", "run",
format!("--allow-read=.,{}", temp_dir.to_str().unwrap()), format!("--allow-read=.,{}", temp_dir),
"script.ts" "script.ts"
]); ]);
assert_eq!( assert_eq!(
r.unwrap(), r.unwrap(),
Flags { Flags {
allow_read: Some(vec![PathBuf::from("."), temp_dir]), allow_read: Some(vec![String::from("."), temp_dir]),
subcommand: DenoSubcommand::Run(RunFlags::new_default( subcommand: DenoSubcommand::Run(RunFlags::new_default(
"script.ts".to_string(), "script.ts".to_string(),
)), )),
@ -5725,18 +5728,18 @@ mod tests {
fn deny_read_denylist() { fn deny_read_denylist() {
use test_util::TempDir; use test_util::TempDir;
let temp_dir_guard = TempDir::new(); let temp_dir_guard = TempDir::new();
let temp_dir = temp_dir_guard.path().to_path_buf(); let temp_dir = temp_dir_guard.path().to_string();
let r = flags_from_vec(svec![ let r = flags_from_vec(svec![
"deno", "deno",
"run", "run",
format!("--deny-read=.,{}", temp_dir.to_str().unwrap()), format!("--deny-read=.,{}", temp_dir),
"script.ts" "script.ts"
]); ]);
assert_eq!( assert_eq!(
r.unwrap(), r.unwrap(),
Flags { Flags {
deny_read: Some(vec![PathBuf::from("."), temp_dir]), deny_read: Some(vec![String::from("."), temp_dir]),
subcommand: DenoSubcommand::Run(RunFlags::new_default( subcommand: DenoSubcommand::Run(RunFlags::new_default(
"script.ts".to_string(), "script.ts".to_string(),
)), )),
@ -5749,18 +5752,18 @@ mod tests {
fn allow_write_allowlist() { fn allow_write_allowlist() {
use test_util::TempDir; use test_util::TempDir;
let temp_dir_guard = TempDir::new(); let temp_dir_guard = TempDir::new();
let temp_dir = temp_dir_guard.path().to_path_buf(); let temp_dir = temp_dir_guard.path().to_string();
let r = flags_from_vec(svec![ let r = flags_from_vec(svec![
"deno", "deno",
"run", "run",
format!("--allow-write=.,{}", temp_dir.to_str().unwrap()), format!("--allow-write=.,{}", temp_dir),
"script.ts" "script.ts"
]); ]);
assert_eq!( assert_eq!(
r.unwrap(), r.unwrap(),
Flags { Flags {
allow_write: Some(vec![PathBuf::from("."), temp_dir]), allow_write: Some(vec![String::from("."), temp_dir]),
subcommand: DenoSubcommand::Run(RunFlags::new_default( subcommand: DenoSubcommand::Run(RunFlags::new_default(
"script.ts".to_string(), "script.ts".to_string(),
)), )),
@ -5773,18 +5776,18 @@ mod tests {
fn deny_write_denylist() { fn deny_write_denylist() {
use test_util::TempDir; use test_util::TempDir;
let temp_dir_guard = TempDir::new(); let temp_dir_guard = TempDir::new();
let temp_dir = temp_dir_guard.path().to_path_buf(); let temp_dir = temp_dir_guard.path().to_string();
let r = flags_from_vec(svec![ let r = flags_from_vec(svec![
"deno", "deno",
"run", "run",
format!("--deny-write=.,{}", temp_dir.to_str().unwrap()), format!("--deny-write=.,{}", temp_dir),
"script.ts" "script.ts"
]); ]);
assert_eq!( assert_eq!(
r.unwrap(), r.unwrap(),
Flags { Flags {
deny_write: Some(vec![PathBuf::from("."), temp_dir]), deny_write: Some(vec![String::from("."), temp_dir]),
subcommand: DenoSubcommand::Run(RunFlags::new_default( subcommand: DenoSubcommand::Run(RunFlags::new_default(
"script.ts".to_string(), "script.ts".to_string(),
)), )),
@ -6226,7 +6229,7 @@ mod tests {
}), }),
type_check_mode: TypeCheckMode::Local, type_check_mode: TypeCheckMode::Local,
lock_write: true, lock_write: true,
lock: Some(PathBuf::from("lock.json")), lock: Some(String::from("lock.json")),
..Flags::default() ..Flags::default()
} }
); );
@ -6523,7 +6526,7 @@ mod tests {
config_flag: ConfigFlag::Path("tsconfig.json".to_owned()), config_flag: ConfigFlag::Path("tsconfig.json".to_owned()),
type_check_mode: TypeCheckMode::None, type_check_mode: TypeCheckMode::None,
reload: true, reload: true,
lock: Some(PathBuf::from("lock.json")), lock: Some(String::from("lock.json")),
lock_write: true, lock_write: true,
ca_data: Some(CaData::File("example.crt".to_string())), ca_data: Some(CaData::File("example.crt".to_string())),
cached_only: true, cached_only: true,
@ -7054,7 +7057,7 @@ mod tests {
"script.ts".to_string(), "script.ts".to_string(),
)), )),
lock_write: true, lock_write: true,
lock: Some(PathBuf::from("lock.json")), lock: Some(String::from("lock.json")),
..Flags::default() ..Flags::default()
} }
); );
@ -7085,7 +7088,7 @@ mod tests {
"script.ts".to_string(), "script.ts".to_string(),
)), )),
lock_write: true, lock_write: true,
lock: Some(PathBuf::from("./deno.lock")), lock: Some(String::from("./deno.lock")),
..Flags::default() ..Flags::default()
} }
); );
@ -7105,7 +7108,7 @@ mod tests {
"script.ts".to_string(), "script.ts".to_string(),
)), )),
lock_write: true, lock_write: true,
lock: Some(PathBuf::from("lock.json")), lock: Some(String::from("lock.json")),
..Flags::default() ..Flags::default()
} }
); );
@ -7692,7 +7695,7 @@ mod tests {
lint: false, lint: false,
html: Some(DocHtmlFlag { html: Some(DocHtmlFlag {
name: "My library".to_string(), name: "My library".to_string(),
output: PathBuf::from("./docs/"), output: String::from("./docs/"),
}), }),
source_files: DocSourceFileFlag::Paths(svec!["path/to/module.ts"]), source_files: DocSourceFileFlag::Paths(svec!["path/to/module.ts"]),
filter: None, filter: None,
@ -7718,7 +7721,7 @@ mod tests {
json: false, json: false,
html: Some(DocHtmlFlag { html: Some(DocHtmlFlag {
name: "My library".to_string(), name: "My library".to_string(),
output: PathBuf::from("./foo"), output: String::from("./foo"),
}), }),
lint: true, lint: true,
source_files: DocSourceFileFlag::Paths(svec!["path/to/module.ts"]), source_files: DocSourceFileFlag::Paths(svec!["path/to/module.ts"]),
@ -7979,7 +7982,7 @@ mod tests {
subcommand: DenoSubcommand::Compile(CompileFlags { subcommand: DenoSubcommand::Compile(CompileFlags {
source_file: "https://examples.deno.land/color-logging.ts" source_file: "https://examples.deno.land/color-logging.ts"
.to_string(), .to_string(),
output: Some(PathBuf::from("colors")), output: Some(String::from("colors")),
args: svec!["foo", "bar", "-p", "8080"], args: svec!["foo", "bar", "-p", "8080"],
target: None, target: None,
no_terminal: true, no_terminal: true,
@ -7990,7 +7993,7 @@ mod tests {
config_flag: ConfigFlag::Path("tsconfig.json".to_owned()), config_flag: ConfigFlag::Path("tsconfig.json".to_owned()),
type_check_mode: TypeCheckMode::None, type_check_mode: TypeCheckMode::None,
reload: true, reload: true,
lock: Some(PathBuf::from("lock.json")), lock: Some(String::from("lock.json")),
lock_write: true, lock_write: true,
ca_data: Some(CaData::File("example.crt".to_string())), ca_data: Some(CaData::File("example.crt".to_string())),
cached_only: true, cached_only: true,
@ -8046,7 +8049,7 @@ mod tests {
include: vec![r"^file:".to_string()], include: vec![r"^file:".to_string()],
exclude: vec![r"test\.(js|mjs|ts|jsx|tsx)$".to_string()], exclude: vec![r"test\.(js|mjs|ts|jsx|tsx)$".to_string()],
r#type: CoverageType::Lcov, r#type: CoverageType::Lcov,
output: Some(PathBuf::from("foo.lcov")), output: Some(String::from("foo.lcov")),
}), }),
..Flags::default() ..Flags::default()
} }
@ -8163,11 +8166,11 @@ mod tests {
subcommand: DenoSubcommand::Vendor(VendorFlags { subcommand: DenoSubcommand::Vendor(VendorFlags {
specifiers: svec!["mod.ts", "deps.test.ts"], specifiers: svec!["mod.ts", "deps.test.ts"],
force: true, force: true,
output_path: Some(PathBuf::from("out_dir")), output_path: Some(String::from("out_dir")),
}), }),
config_flag: ConfigFlag::Path("deno.json".to_owned()), config_flag: ConfigFlag::Path("deno.json".to_owned()),
import_map_path: Some("import_map.json".to_string()), import_map_path: Some("import_map.json".to_string()),
lock: Some(PathBuf::from("lock.json")), lock: Some(String::from("lock.json")),
reload: true, reload: true,
..Flags::default() ..Flags::default()
} }
@ -8602,7 +8605,7 @@ mod tests {
subcommand: DenoSubcommand::Jupyter(JupyterFlags { subcommand: DenoSubcommand::Jupyter(JupyterFlags {
install: false, install: false,
kernel: true, kernel: true,
conn_file: Some(PathBuf::from("path/to/conn/file")), conn_file: Some(String::from("path/to/conn/file")),
}), }),
..Flags::default() ..Flags::default()
} }

60
cli/args/mod.rs
View File

@ -1476,16 +1476,34 @@ impl CliOptions {
deny_hrtime: self.flags.deny_hrtime, deny_hrtime: self.flags.deny_hrtime,
allow_net: self.flags.allow_net.clone(), allow_net: self.flags.allow_net.clone(),
deny_net: self.flags.deny_net.clone(), deny_net: self.flags.deny_net.clone(),
allow_ffi: self.flags.allow_ffi.clone(), allow_ffi: convert_option_str_to_path_buf(
deny_ffi: self.flags.deny_ffi.clone(), &self.flags.allow_ffi,
allow_read: self.flags.allow_read.clone(), self.initial_cwd(),
deny_read: self.flags.deny_read.clone(), ),
deny_ffi: convert_option_str_to_path_buf(
&self.flags.deny_ffi,
self.initial_cwd(),
),
allow_read: convert_option_str_to_path_buf(
&self.flags.allow_read,
self.initial_cwd(),
),
deny_read: convert_option_str_to_path_buf(
&self.flags.deny_read,
self.initial_cwd(),
),
allow_run: self.flags.allow_run.clone(), allow_run: self.flags.allow_run.clone(),
deny_run: self.flags.deny_run.clone(), deny_run: self.flags.deny_run.clone(),
allow_sys: self.flags.allow_sys.clone(), allow_sys: self.flags.allow_sys.clone(),
deny_sys: self.flags.deny_sys.clone(), deny_sys: self.flags.deny_sys.clone(),
allow_write: self.flags.allow_write.clone(), allow_write: convert_option_str_to_path_buf(
deny_write: self.flags.deny_write.clone(), &self.flags.allow_write,
self.initial_cwd(),
),
deny_write: convert_option_str_to_path_buf(
&self.flags.deny_write,
self.initial_cwd(),
),
prompt: !self.no_prompt(), prompt: !self.no_prompt(),
} }
} }
@ -1584,29 +1602,29 @@ impl CliOptions {
} }
pub fn watch_paths(&self) -> Vec<PathBuf> { pub fn watch_paths(&self) -> Vec<PathBuf> {
let mut paths = if let DenoSubcommand::Run(RunFlags { let mut full_paths = Vec::new();
if let DenoSubcommand::Run(RunFlags {
watch: Some(WatchFlagsWithPaths { paths, .. }), watch: Some(WatchFlagsWithPaths { paths, .. }),
.. ..
}) = &self.flags.subcommand }) = &self.flags.subcommand
{ {
paths.clone() full_paths.extend(paths.iter().map(|path| self.initial_cwd.join(path)));
} else { }
Vec::with_capacity(2)
};
if let Ok(Some(import_map_path)) = self if let Ok(Some(import_map_path)) = self
.resolve_specified_import_map_specifier() .resolve_specified_import_map_specifier()
.map(|ms| ms.and_then(|ref s| s.to_file_path().ok())) .map(|ms| ms.and_then(|ref s| s.to_file_path().ok()))
{ {
paths.push(import_map_path); full_paths.push(import_map_path);
} }
if let Some(specifier) = self.maybe_config_file_specifier() { if let Some(specifier) = self.maybe_config_file_specifier() {
if specifier.scheme() == "file" { if specifier.scheme() == "file" {
if let Ok(path) = specifier.to_file_path() { if let Ok(path) = specifier.to_file_path() {
paths.push(path); full_paths.push(path);
} }
} }
} }
paths full_paths
} }
} }
@ -1784,6 +1802,20 @@ pub fn npm_pkg_req_ref_to_binary_command(
binary_name.to_string() binary_name.to_string()
} }
fn convert_option_str_to_path_buf(
flag: &Option<Vec<String>>,
initial_cwd: &Path,
) -> Option<Vec<PathBuf>> {
if let Some(allow_ffi_paths) = &flag {
let mut full_paths = Vec::new();
full_paths
.extend(allow_ffi_paths.iter().map(|path| initial_cwd.join(path)));
Some(full_paths)
} else {
None
}
}
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use crate::util::fs::FileCollector; use crate::util::fs::FileCollector;

32
cli/tools/compile.rs
View File

@ -4,7 +4,6 @@ use crate::args::CompileFlags;
use crate::args::Flags; use crate::args::Flags;
use crate::factory::CliFactory; use crate::factory::CliFactory;
use crate::standalone::is_standalone_binary; use crate::standalone::is_standalone_binary;
use crate::util::path::path_has_trailing_slash;
use deno_core::anyhow::bail; use deno_core::anyhow::bail;
use deno_core::anyhow::Context; use deno_core::anyhow::Context;
use deno_core::error::generic_error; use deno_core::error::generic_error;
@ -174,31 +173,34 @@ async fn resolve_compile_executable_output_path(
let module_specifier = let module_specifier =
resolve_url_or_path(&compile_flags.source_file, current_dir)?; resolve_url_or_path(&compile_flags.source_file, current_dir)?;
let mut output = compile_flags.output.clone(); let output_flag = compile_flags.output.clone();
let mut output_path = if let Some(out) = output_flag.as_ref() {
if let Some(out) = output.as_ref() { let mut out_path = PathBuf::from(out);
if path_has_trailing_slash(out) { if out.ends_with('/') || out.ends_with('\\') {
if let Some(infer_file_name) = infer_name_from_url(&module_specifier) if let Some(infer_file_name) = infer_name_from_url(&module_specifier)
.await .await
.map(PathBuf::from) .map(PathBuf::from)
{ {
output = Some(out.join(infer_file_name)); out_path = out_path.join(infer_file_name);
} }
} else { } else {
output = Some(out.to_path_buf()); out_path = out_path.to_path_buf();
} }
} Some(out_path)
} else {
None
};
if output.is_none() { if output_flag.is_none() {
output = infer_name_from_url(&module_specifier) output_path = infer_name_from_url(&module_specifier)
.await .await
.map(PathBuf::from) .map(PathBuf::from)
} }
output.ok_or_else(|| generic_error( output_path.ok_or_else(|| generic_error(
"An executable name was not provided. One could not be inferred from the URL. Aborting.", "An executable name was not provided. One could not be inferred from the URL. Aborting.",
)).map(|output| { )).map(|output_path| {
get_os_specific_filepath(output, &compile_flags.target) get_os_specific_filepath(output_path, &compile_flags.target)
}) })
} }
@ -231,7 +233,7 @@ mod test {
let path = resolve_compile_executable_output_path( let path = resolve_compile_executable_output_path(
&CompileFlags { &CompileFlags {
source_file: "mod.ts".to_string(), source_file: "mod.ts".to_string(),
output: Some(PathBuf::from("./file")), output: Some(String::from("./file")),
args: Vec::new(), args: Vec::new(),
target: Some("x86_64-unknown-linux-gnu".to_string()), target: Some("x86_64-unknown-linux-gnu".to_string()),
no_terminal: false, no_terminal: false,
@ -253,7 +255,7 @@ mod test {
let path = resolve_compile_executable_output_path( let path = resolve_compile_executable_output_path(
&CompileFlags { &CompileFlags {
source_file: "mod.ts".to_string(), source_file: "mod.ts".to_string(),
output: Some(PathBuf::from("./file")), output: Some(String::from("./file")),
args: Vec::new(), args: Vec::new(),
target: Some("x86_64-pc-windows-msvc".to_string()), target: Some("x86_64-pc-windows-msvc".to_string()),
include: vec![], include: vec![],

2
cli/tools/installer.rs
View File

@ -455,7 +455,7 @@ async fn resolve_shim_data(
extra_files.push(( extra_files.push((
copy_path, copy_path,
fs::read_to_string(lock_path) fs::read_to_string(lock_path)
.with_context(|| format!("error reading {}", lock_path.display()))?, .with_context(|| format!("error reading {}", lock_path))?,
)); ));
} else { } else {
// Provide an empty lockfile so that this overwrites any existing lockfile // Provide an empty lockfile so that this overwrites any existing lockfile

11
cli/tools/upgrade.rs
View File

@ -379,8 +379,11 @@ pub async fn upgrade(
let factory = CliFactory::from_flags(flags)?; let factory = CliFactory::from_flags(flags)?;
let client = factory.http_client(); let client = factory.http_client();
let current_exe_path = std::env::current_exe()?; let current_exe_path = std::env::current_exe()?;
let full_path_output_flag = upgrade_flags
.output
.map(|output| factory.cli_options().initial_cwd().join(output));
let output_exe_path = let output_exe_path =
upgrade_flags.output.as_ref().unwrap_or(&current_exe_path); full_path_output_flag.as_ref().unwrap_or(&current_exe_path);
let permissions = if let Ok(metadata) = fs::metadata(output_exe_path) { let permissions = if let Ok(metadata) = fs::metadata(output_exe_path) {
let permissions = metadata.permissions(); let permissions = metadata.permissions();
@ -430,7 +433,7 @@ pub async fn upgrade(
}; };
if !upgrade_flags.force if !upgrade_flags.force
&& upgrade_flags.output.is_none() && full_path_output_flag.is_none()
&& current_is_passed && current_is_passed
{ {
log::info!("Version {} is already installed", crate::version::deno()); log::info!("Version {} is already installed", crate::version::deno());
@ -464,7 +467,7 @@ pub async fn upgrade(
}; };
if !upgrade_flags.force if !upgrade_flags.force
&& upgrade_flags.output.is_none() && full_path_output_flag.is_none()
&& current_is_most_recent && current_is_most_recent
{ {
log::info!( log::info!(
@ -520,7 +523,7 @@ pub async fn upgrade(
} }
} else { } else {
let output_exe_path = let output_exe_path =
upgrade_flags.output.as_ref().unwrap_or(&current_exe_path); full_path_output_flag.as_ref().unwrap_or(&current_exe_path);
let output_result = if *output_exe_path == current_exe_path { let output_result = if *output_exe_path == current_exe_path {
replace_exe(&new_exe_path, output_exe_path) replace_exe(&new_exe_path, output_exe_path)
} else { } else {

2
cli/tools/vendor/mod.rs vendored
View File

@ -40,7 +40,7 @@ pub async fn vendor(
) -> Result<(), AnyError> { ) -> Result<(), AnyError> {
let mut cli_options = CliOptions::from_flags(flags)?; let mut cli_options = CliOptions::from_flags(flags)?;
let raw_output_dir = match &vendor_flags.output_path { let raw_output_dir = match &vendor_flags.output_path {
Some(output_path) => output_path.to_owned(), Some(output_path) => PathBuf::from(output_path).to_owned(),
None => PathBuf::from("vendor/"), None => PathBuf::from("vendor/"),
}; };
let output_dir = resolve_from_cwd(&raw_output_dir)?; let output_dir = resolve_from_cwd(&raw_output_dir)?;

39
cli/util/path.rs
View File

@ -163,20 +163,6 @@ pub fn relative_specifier(
}) })
} }
/// This function checks if input path has trailing slash or not. If input path
/// has trailing slash it will return true else it will return false.
pub fn path_has_trailing_slash(path: &Path) -> bool {
if let Some(path_str) = path.to_str() {
if cfg!(windows) {
path_str.ends_with('\\')
} else {
path_str.ends_with('/')
}
} else {
false
}
}
/// Gets a path with the specified file stem suffix. /// Gets a path with the specified file stem suffix.
/// ///
/// Ex. `file.ts` with suffix `_2` returns `file_2.ts` /// Ex. `file.ts` with suffix `_2` returns `file_2.ts`
@ -432,31 +418,6 @@ mod test {
} }
} }
#[test]
fn test_path_has_trailing_slash() {
#[cfg(not(windows))]
{
run_test("/Users/johndoe/Desktop/deno-project/target/", true);
run_test(r"/Users/johndoe/deno-project/target//", true);
run_test("/Users/johndoe/Desktop/deno-project", false);
run_test(r"/Users/johndoe/deno-project\", false);
}
#[cfg(windows)]
{
run_test(r"C:\test\deno-project\", true);
run_test(r"C:\test\deno-project\\", true);
run_test(r"C:\test\file.txt", false);
run_test(r"C:\test\file.txt/", false);
}
fn run_test(path_str: &str, expected: bool) {
let path = Path::new(path_str);
let result = path_has_trailing_slash(path);
assert_eq!(result, expected);
}
}
#[test] #[test]
fn test_path_with_stem_suffix() { fn test_path_with_stem_suffix() {
assert_eq!( assert_eq!(