2023-01-02 21:00:42 +00:00
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
2020-09-06 00:34:02 +00:00
2019-06-26 10:02:13 +00:00
use clap ::Arg ;
use clap ::ArgMatches ;
2022-01-14 16:38:17 +00:00
use clap ::ColorChoice ;
2022-03-28 01:57:56 +00:00
use clap ::Command ;
2022-03-14 18:41:35 +00:00
use clap ::ValueHint ;
2022-09-29 10:34:16 +00:00
use deno_core ::error ::AnyError ;
2023-03-14 01:12:09 +00:00
use deno_core ::resolve_url_or_path ;
2021-01-07 18:06:08 +00:00
use deno_core ::url ::Url ;
2022-09-29 10:34:16 +00:00
use deno_runtime ::permissions ::parse_sys_kind ;
2021-03-26 16:34:25 +00:00
use log ::debug ;
2019-06-22 16:02:51 +00:00
use log ::Level ;
2021-12-18 21:14:42 +00:00
use once_cell ::sync ::Lazy ;
2022-04-18 19:08:30 +00:00
use std ::env ;
2020-04-03 17:40:11 +00:00
use std ::net ::SocketAddr ;
2021-09-13 20:06:45 +00:00
use std ::num ::NonZeroU32 ;
use std ::num ::NonZeroU8 ;
2021-08-23 10:35:38 +00:00
use std ::num ::NonZeroUsize ;
2023-03-14 01:12:09 +00:00
use std ::path ::Path ;
2020-05-29 15:27:43 +00:00
use std ::path ::PathBuf ;
2020-11-12 22:17:31 +00:00
use std ::str ::FromStr ;
2019-11-26 16:06:32 +00:00
2023-02-23 15:58:10 +00:00
use crate ::util ::fs ::canonicalize_path ;
2022-06-27 20:54:09 +00:00
use super ::flags_allow_net ;
2021-12-18 21:14:42 +00:00
static LONG_VERSION : Lazy < String > = Lazy ::new ( | | {
format! (
2021-03-26 16:34:25 +00:00
" {} ({}, {}) \n v8 {} \n typescript {} " ,
crate ::version ::deno ( ) ,
if crate ::version ::is_canary ( ) {
" canary "
} else {
env! ( " PROFILE " )
} ,
env! ( " TARGET " ) ,
deno_core ::v8_version ( ) ,
crate ::version ::TYPESCRIPT
2021-12-18 21:14:42 +00:00
)
} ) ;
2021-03-26 16:34:25 +00:00
2022-05-09 18:16:34 +00:00
static SHORT_VERSION : Lazy < String > = Lazy ::new ( | | {
crate ::version ::deno ( )
. split ( '+' )
. next ( )
. unwrap ( )
. to_string ( )
} ) ;
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
pub struct FileFlags {
2022-03-11 22:07:02 +00:00
pub ignore : Vec < PathBuf > ,
2023-01-07 20:22:09 +00:00
pub include : Vec < PathBuf > ,
}
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
pub struct BenchFlags {
pub files : FileFlags ,
2022-03-11 22:07:02 +00:00
pub filter : Option < String > ,
2023-02-12 17:40:45 +00:00
pub json : bool ,
2022-03-11 22:07:02 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct BundleFlags {
pub source_file : String ,
pub out_file : Option < PathBuf > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct CacheFlags {
pub files : Vec < String > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-04-10 23:12:51 +00:00
pub struct CheckFlags {
pub files : Vec < String > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct CompileFlags {
pub source_file : String ,
pub output : Option < PathBuf > ,
pub args : Vec < String > ,
pub target : Option < String > ,
2023-03-18 23:43:07 +00:00
pub include : Vec < String > ,
2021-09-03 23:33:35 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct CompletionsFlags {
pub buf : Box < [ u8 ] > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct CoverageFlags {
2023-01-13 21:56:29 +00:00
pub files : FileFlags ,
2022-02-15 15:33:21 +00:00
pub output : Option < PathBuf > ,
2021-09-03 23:33:35 +00:00
pub include : Vec < String > ,
pub exclude : Vec < String > ,
pub lcov : bool ,
}
2023-01-14 17:39:56 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub enum DocSourceFileFlag {
Builtin ,
Path ( String ) ,
}
impl Default for DocSourceFileFlag {
fn default ( ) -> Self {
Self ::Builtin
}
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct DocFlags {
pub private : bool ,
pub json : bool ,
2023-01-14 17:39:56 +00:00
pub source_file : DocSourceFileFlag ,
2021-09-03 23:33:35 +00:00
pub filter : Option < String > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct EvalFlags {
pub print : bool ,
pub code : String ,
pub ext : String ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct FmtFlags {
pub check : bool ,
pub ext : String ,
2023-01-07 20:22:09 +00:00
pub files : FileFlags ,
2021-09-13 20:06:45 +00:00
pub use_tabs : Option < bool > ,
pub line_width : Option < NonZeroU32 > ,
pub indent_width : Option < NonZeroU8 > ,
pub single_quote : Option < bool > ,
pub prose_wrap : Option < String > ,
2023-01-25 20:06:00 +00:00
pub no_semicolons : Option < bool > ,
2021-09-03 23:33:35 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-08-19 23:37:05 +00:00
pub struct InitFlags {
pub dir : Option < String > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct InfoFlags {
pub json : bool ,
pub file : Option < String > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct InstallFlags {
pub module_url : String ,
pub args : Vec < String > ,
pub name : Option < String > ,
pub root : Option < PathBuf > ,
pub force : bool ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-30 15:38:07 +00:00
pub struct UninstallFlags {
pub name : String ,
pub root : Option < PathBuf > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct LintFlags {
2023-01-07 20:22:09 +00:00
pub files : FileFlags ,
2021-09-03 23:33:35 +00:00
pub rules : bool ,
2021-11-04 15:12:12 +00:00
pub maybe_rules_tags : Option < Vec < String > > ,
pub maybe_rules_include : Option < Vec < String > > ,
pub maybe_rules_exclude : Option < Vec < String > > ,
2021-09-03 23:33:35 +00:00
pub json : bool ,
2022-09-28 16:47:48 +00:00
pub compact : bool ,
2021-09-03 23:33:35 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct ReplFlags {
2022-04-20 12:16:37 +00:00
pub eval_files : Option < Vec < String > > ,
2021-09-03 23:33:35 +00:00
pub eval : Option < String > ,
2022-12-07 19:21:18 +00:00
pub is_default_command : bool ,
2021-09-03 23:33:35 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct RunFlags {
pub script : String ,
}
2022-08-12 19:21:17 +00:00
impl RunFlags {
pub fn is_stdin ( & self ) -> bool {
self . script = = " - "
}
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-03-11 01:56:14 +00:00
pub struct TaskFlags {
2022-06-08 21:30:16 +00:00
pub cwd : Option < String > ,
2023-02-23 03:45:35 +00:00
pub task : Option < String > ,
2022-03-11 01:56:14 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct TestFlags {
pub doc : bool ,
pub no_run : bool ,
pub fail_fast : Option < NonZeroUsize > ,
2023-01-07 20:22:09 +00:00
pub files : FileFlags ,
2021-09-03 23:33:35 +00:00
pub allow_none : bool ,
pub filter : Option < String > ,
pub shuffle : Option < u64 > ,
2023-01-07 20:22:09 +00:00
pub concurrent_jobs : Option < NonZeroUsize > ,
2022-02-25 15:14:46 +00:00
pub trace_ops : bool ,
2021-09-03 23:33:35 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2021-09-03 23:33:35 +00:00
pub struct UpgradeFlags {
pub dry_run : bool ,
pub force : bool ,
pub canary : bool ,
pub version : Option < String > ,
pub output : Option < PathBuf > ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-02-16 18:14:19 +00:00
pub struct VendorFlags {
pub specifiers : Vec < String > ,
pub output_path : Option < PathBuf > ,
pub force : bool ,
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2019-11-26 16:06:32 +00:00
pub enum DenoSubcommand {
2022-03-11 22:07:02 +00:00
Bench ( BenchFlags ) ,
2021-09-03 23:33:35 +00:00
Bundle ( BundleFlags ) ,
Cache ( CacheFlags ) ,
2022-04-10 23:12:51 +00:00
Check ( CheckFlags ) ,
2021-09-03 23:33:35 +00:00
Compile ( CompileFlags ) ,
Completions ( CompletionsFlags ) ,
Coverage ( CoverageFlags ) ,
Doc ( DocFlags ) ,
Eval ( EvalFlags ) ,
Fmt ( FmtFlags ) ,
2022-08-19 23:37:05 +00:00
Init ( InitFlags ) ,
2021-09-03 23:33:35 +00:00
Info ( InfoFlags ) ,
Install ( InstallFlags ) ,
2021-09-30 15:38:07 +00:00
Uninstall ( UninstallFlags ) ,
2021-06-23 01:48:01 +00:00
Lsp ,
2021-09-03 23:33:35 +00:00
Lint ( LintFlags ) ,
Repl ( ReplFlags ) ,
Run ( RunFlags ) ,
2022-03-11 01:56:14 +00:00
Task ( TaskFlags ) ,
2021-09-03 23:33:35 +00:00
Test ( TestFlags ) ,
2019-11-26 16:06:32 +00:00
Types ,
2021-09-03 23:33:35 +00:00
Upgrade ( UpgradeFlags ) ,
2022-02-16 18:14:19 +00:00
Vendor ( VendorFlags ) ,
2019-11-26 16:06:32 +00:00
}
impl Default for DenoSubcommand {
fn default ( ) -> DenoSubcommand {
2022-04-20 12:16:37 +00:00
DenoSubcommand ::Repl ( ReplFlags {
eval_files : None ,
eval : None ,
2022-12-07 19:21:18 +00:00
is_default_command : true ,
2022-04-20 12:16:37 +00:00
} )
2019-11-26 16:06:32 +00:00
}
2018-08-17 20:34:30 +00:00
}
2022-09-19 08:25:03 +00:00
#[ derive(Debug, Clone, Copy, Eq, PartialEq) ]
2022-04-10 23:12:51 +00:00
pub enum TypeCheckMode {
2022-06-18 16:11:15 +00:00
/// Type-check all modules.
2021-11-29 22:23:30 +00:00
All ,
2022-06-18 16:11:15 +00:00
/// Skip type-checking of all modules. The default value for "deno run" and
2022-06-13 21:13:16 +00:00
/// several other subcommands.
2021-11-29 22:23:30 +00:00
None ,
2022-06-18 16:11:15 +00:00
/// Only type-check local modules. The default value for "deno test" and
2022-06-13 21:13:16 +00:00
/// several other subcommands.
2021-11-29 22:23:30 +00:00
Local ,
}
2022-04-10 23:12:51 +00:00
impl Default for TypeCheckMode {
2021-11-29 22:23:30 +00:00
fn default ( ) -> Self {
2022-06-13 21:13:16 +00:00
Self ::None
2022-04-10 23:12:51 +00:00
}
}
2022-09-19 08:25:03 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2022-05-13 15:40:50 +00:00
pub enum ConfigFlag {
Discover ,
Path ( String ) ,
Disabled ,
}
impl Default for ConfigFlag {
fn default ( ) -> Self {
Self ::Discover
}
}
2023-01-18 00:18:24 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub enum CaData {
/// The string is a file path
File ( String ) ,
/// This variant is not exposed as an option in the CLI, it is used internally
/// for standalone binaries.
Bytes ( Vec < u8 > ) ,
}
2022-09-19 08:25:03 +00:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
2020-02-26 10:52:15 +00:00
pub struct Flags {
2019-12-03 22:23:10 +00:00
/// Vector of CLI arguments - these are user script arguments, all Deno
/// specific flags are removed.
2019-11-26 16:06:32 +00:00
pub argv : Vec < String > ,
pub subcommand : DenoSubcommand ,
2022-01-10 14:22:03 +00:00
pub allow_all : bool ,
2021-04-13 11:25:21 +00:00
pub allow_env : Option < Vec < String > > ,
2019-05-23 16:28:29 +00:00
pub allow_hrtime : bool ,
2020-12-29 18:34:35 +00:00
pub allow_net : Option < Vec < String > > ,
2021-10-13 17:04:44 +00:00
pub allow_ffi : Option < Vec < PathBuf > > ,
2020-12-29 18:34:35 +00:00
pub allow_read : Option < Vec < PathBuf > > ,
2021-04-09 22:12:00 +00:00
pub allow_run : Option < Vec < String > > ,
2022-09-28 12:46:50 +00:00
pub allow_sys : Option < Vec < String > > ,
2020-12-29 18:34:35 +00:00
pub allow_write : Option < Vec < PathBuf > > ,
2021-08-07 12:49:38 +00:00
pub ca_stores : Option < Vec < String > > ,
2023-01-18 00:18:24 +00:00
pub ca_data : Option < CaData > ,
2021-07-23 14:31:16 +00:00
pub cache_blocklist : Vec < String > ,
2021-07-27 21:25:09 +00:00
/// This is not exposed as an option in the CLI, it is used internally when
/// the language server is configured with an explicit cache option.
pub cache_path : Option < PathBuf > ,
2019-12-03 22:48:53 +00:00
pub cached_only : bool ,
2022-04-10 23:12:51 +00:00
pub type_check_mode : TypeCheckMode ,
2022-05-13 15:40:50 +00:00
pub config_flag : ConfigFlag ,
2023-02-20 18:14:06 +00:00
pub node_modules_dir : Option < bool > ,
2020-12-21 13:04:25 +00:00
pub coverage_dir : Option < String > ,
2021-07-23 14:31:16 +00:00
pub enable_testing_features : bool ,
2020-10-21 11:12:01 +00:00
pub ignore : Vec < PathBuf > ,
2020-04-30 15:23:40 +00:00
pub import_map_path : Option < String > ,
2020-04-03 17:40:11 +00:00
pub inspect_brk : Option < SocketAddr > ,
2022-12-12 14:33:30 +00:00
pub inspect_wait : Option < SocketAddr > ,
2021-07-23 14:31:16 +00:00
pub inspect : Option < SocketAddr > ,
pub location : Option < Url > ,
2019-11-03 15:39:27 +00:00
pub lock_write : bool ,
2021-07-23 14:31:16 +00:00
pub lock : Option < PathBuf > ,
2020-04-30 15:23:40 +00:00
pub log_level : Option < Level > ,
pub no_remote : bool ,
2022-11-03 15:42:56 +00:00
pub no_lock : bool ,
2022-09-07 13:33:51 +00:00
pub no_npm : bool ,
2022-02-13 03:13:21 +00:00
pub no_prompt : bool ,
2020-04-30 15:23:40 +00:00
pub reload : bool ,
pub seed : Option < u64 > ,
pub unstable : bool ,
2021-08-10 11:19:45 +00:00
pub unsafely_ignore_certificate_errors : Option < Vec < String > > ,
2020-12-06 17:19:21 +00:00
pub v8_flags : Vec < String > ,
2020-04-30 15:23:40 +00:00
pub version : bool ,
2021-12-15 21:04:43 +00:00
pub watch : Option < Vec < PathBuf > > ,
2022-01-31 16:39:39 +00:00
pub no_clear_screen : bool ,
2018-11-15 17:56:17 +00:00
}
2020-06-13 17:09:39 +00:00
fn join_paths ( allowlist : & [ PathBuf ] , d : & str ) -> String {
allowlist
2020-02-11 09:29:36 +00:00
. iter ( )
. map ( | path | path . to_str ( ) . unwrap ( ) . to_string ( ) )
. collect ::< Vec < String > > ( )
. join ( d )
}
2020-02-26 10:52:15 +00:00
impl Flags {
2020-01-30 23:42:39 +00:00
/// Return list of permission arguments that are equivalent
/// to the ones used to create `self`.
pub fn to_permission_args ( & self ) -> Vec < String > {
let mut args = vec! [ ] ;
2022-01-10 14:22:03 +00:00
if self . allow_all {
args . push ( " --allow-all " . to_string ( ) ) ;
return args ;
}
2020-12-29 18:34:35 +00:00
match & self . allow_read {
Some ( read_allowlist ) if read_allowlist . is_empty ( ) = > {
args . push ( " --allow-read " . to_string ( ) ) ;
}
Some ( read_allowlist ) = > {
let s = format! ( " --allow-read= {} " , join_paths ( read_allowlist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 23:42:39 +00:00
}
2020-12-29 18:34:35 +00:00
match & self . allow_write {
Some ( write_allowlist ) if write_allowlist . is_empty ( ) = > {
args . push ( " --allow-write " . to_string ( ) ) ;
}
Some ( write_allowlist ) = > {
let s = format! ( " --allow-write= {} " , join_paths ( write_allowlist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 23:42:39 +00:00
}
2020-12-29 18:34:35 +00:00
match & self . allow_net {
Some ( net_allowlist ) if net_allowlist . is_empty ( ) = > {
args . push ( " --allow-net " . to_string ( ) ) ;
}
Some ( net_allowlist ) = > {
let s = format! ( " --allow-net= {} " , net_allowlist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 23:42:39 +00:00
}
2021-08-10 11:19:45 +00:00
match & self . unsafely_ignore_certificate_errors {
2021-08-09 14:53:21 +00:00
Some ( ic_allowlist ) if ic_allowlist . is_empty ( ) = > {
2021-08-10 12:19:42 +00:00
args . push ( " --unsafely-ignore-certificate-errors " . to_string ( ) ) ;
2021-08-09 14:53:21 +00:00
}
Some ( ic_allowlist ) = > {
let s = format! (
2021-08-10 12:19:42 +00:00
" --unsafely-ignore-certificate-errors={} " ,
2021-08-09 14:53:21 +00:00
ic_allowlist . join ( " , " )
) ;
args . push ( s ) ;
}
_ = > { }
}
2021-04-13 11:25:21 +00:00
match & self . allow_env {
Some ( env_allowlist ) if env_allowlist . is_empty ( ) = > {
args . push ( " --allow-env " . to_string ( ) ) ;
}
Some ( env_allowlist ) = > {
let s = format! ( " --allow-env= {} " , env_allowlist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 23:42:39 +00:00
}
2021-04-09 22:12:00 +00:00
match & self . allow_run {
Some ( run_allowlist ) if run_allowlist . is_empty ( ) = > {
args . push ( " --allow-run " . to_string ( ) ) ;
}
Some ( run_allowlist ) = > {
let s = format! ( " --allow-run= {} " , run_allowlist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
2020-01-30 23:42:39 +00:00
}
2022-09-28 12:46:50 +00:00
match & self . allow_sys {
Some ( sys_allowlist ) if sys_allowlist . is_empty ( ) = > {
args . push ( " --allow-sys " . to_string ( ) ) ;
}
Some ( sys_allowlist ) = > {
let s = format! ( " --allow-sys= {} " , sys_allowlist . join ( " , " ) ) ;
args . push ( s )
}
_ = > { }
}
2021-08-06 21:28:10 +00:00
match & self . allow_ffi {
Some ( ffi_allowlist ) if ffi_allowlist . is_empty ( ) = > {
args . push ( " --allow-ffi " . to_string ( ) ) ;
}
Some ( ffi_allowlist ) = > {
2021-10-13 17:04:44 +00:00
let s = format! ( " --allow-ffi= {} " , join_paths ( ffi_allowlist , " , " ) ) ;
2021-08-06 21:28:10 +00:00
args . push ( s ) ;
}
_ = > { }
2020-01-30 23:42:39 +00:00
}
if self . allow_hrtime {
args . push ( " --allow-hrtime " . to_string ( ) ) ;
}
args
}
2022-01-18 01:10:17 +00:00
/// Extract path arguments for config search paths.
2022-02-25 05:39:18 +00:00
/// If it returns Some(vec), the config should be discovered
2023-03-14 01:12:09 +00:00
/// from the passed `current_dir` after trying to discover from each entry in
/// the returned vector.
2022-02-25 05:39:18 +00:00
/// If it returns None, the config file shouldn't be discovered at all.
2023-03-14 01:12:09 +00:00
pub fn config_path_args ( & self , current_dir : & Path ) -> Option < Vec < PathBuf > > {
2022-01-18 01:10:17 +00:00
use DenoSubcommand ::* ;
2023-01-15 04:06:46 +00:00
match & self . subcommand {
Fmt ( FmtFlags { files , .. } ) = > Some ( files . include . clone ( ) ) ,
Lint ( LintFlags { files , .. } ) = > Some ( files . include . clone ( ) ) ,
Run ( RunFlags { script } ) = > {
2023-03-14 01:12:09 +00:00
if let Ok ( module_specifier ) = resolve_url_or_path ( script , current_dir ) {
2023-01-15 04:06:46 +00:00
if module_specifier . scheme ( ) = = " file "
| | module_specifier . scheme ( ) = = " npm "
{
if let Ok ( p ) = module_specifier . to_file_path ( ) {
Some ( vec! [ p ] )
} else {
Some ( vec! [ ] )
}
2022-02-25 05:39:18 +00:00
} else {
2023-01-15 04:06:46 +00:00
// When the entrypoint doesn't have file: scheme (it's the remote
// script), then we don't auto discover config file.
None
2022-02-25 05:39:18 +00:00
}
2022-01-18 01:10:17 +00:00
} else {
2023-01-15 04:06:46 +00:00
Some ( vec! [ ] )
2022-01-18 01:10:17 +00:00
}
}
2023-02-23 15:58:10 +00:00
Task ( TaskFlags {
cwd : Some ( path ) , ..
} ) = > {
// attempt to resolve the config file from the task subcommand's
// `--cwd` when specified
match canonicalize_path ( & PathBuf ::from ( path ) ) {
Ok ( path ) = > Some ( vec! [ path ] ) ,
Err ( _ ) = > Some ( vec! [ ] ) ,
}
}
2023-01-15 04:06:46 +00:00
_ = > Some ( vec! [ ] ) ,
2022-01-18 01:10:17 +00:00
}
}
2020-01-30 23:42:39 +00:00
2023-02-20 18:14:06 +00:00
/// Extract path argument for `package.json` search paths.
/// If it returns Some(path), the `package.json` should be discovered
/// from the `path` dir.
/// If it returns None, the `package.json` file shouldn't be discovered at
/// all.
2023-03-14 01:12:09 +00:00
pub fn package_json_search_dir ( & self , current_dir : & Path ) -> Option < PathBuf > {
2023-02-20 18:14:06 +00:00
use DenoSubcommand ::* ;
2023-02-23 03:45:35 +00:00
match & self . subcommand {
Run ( RunFlags { script } ) = > {
2023-03-14 01:12:09 +00:00
let module_specifier = resolve_url_or_path ( script , current_dir ) . ok ( ) ? ;
2023-02-20 18:14:06 +00:00
if module_specifier . scheme ( ) = = " file " {
let p = module_specifier
. to_file_path ( )
. unwrap ( )
. parent ( ) ?
. to_owned ( ) ;
2023-02-23 03:45:35 +00:00
Some ( p )
2023-02-20 18:14:06 +00:00
} else if module_specifier . scheme ( ) = = " npm " {
2023-02-23 03:45:35 +00:00
Some ( std ::env ::current_dir ( ) . unwrap ( ) )
} else {
None
2023-02-20 18:14:06 +00:00
}
}
2023-02-23 03:45:35 +00:00
Task ( TaskFlags { cwd : Some ( cwd ) , .. } ) = > {
2023-03-14 01:12:09 +00:00
resolve_url_or_path ( cwd , current_dir )
2023-02-23 03:45:35 +00:00
. ok ( ) ?
. to_file_path ( )
. ok ( )
}
2023-02-23 15:58:10 +00:00
Task ( _ ) | Check ( _ ) | Coverage ( _ ) | Cache ( _ ) | Info ( _ ) | Eval ( _ )
| Test ( _ ) | Bench ( _ ) = > std ::env ::current_dir ( ) . ok ( ) ,
2023-02-23 03:45:35 +00:00
_ = > None ,
2023-02-20 18:14:06 +00:00
}
}
2022-11-24 03:00:31 +00:00
pub fn has_permission ( & self ) -> bool {
self . allow_all
| | self . allow_hrtime
| | self . allow_env . is_some ( )
| | self . allow_ffi . is_some ( )
| | self . allow_net . is_some ( )
| | self . allow_read . is_some ( )
| | self . allow_run . is_some ( )
| | self . allow_sys . is_some ( )
| | self . allow_write . is_some ( )
}
pub fn has_permission_in_argv ( & self ) -> bool {
self . argv . iter ( ) . any ( | arg | {
arg = = " --allow-all "
| | arg = = " --allow-hrtime "
| | arg . starts_with ( " --allow-env " )
| | arg . starts_with ( " --allow-ffi " )
| | arg . starts_with ( " --allow-net " )
| | arg . starts_with ( " --allow-read " )
| | arg . starts_with ( " --allow-run " )
| | arg . starts_with ( " --allow-sys " )
| | arg . starts_with ( " --allow-write " )
} )
}
2020-12-29 18:34:35 +00:00
}
2021-02-16 02:50:27 +00:00
static ENV_VARIABLES_HELP : & str = r #" ENVIRONMENT VARIABLES:
DENO_AUTH_TOKENS A semi - colon separated list of bearer tokens and
hostnames to use when fetching remote modules from
private repositories
( e . g . " abcde12345@deno.land;54321edcba@github.com " )
2022-04-11 05:01:02 +00:00
DENO_TLS_CA_STORE Comma - separated list of order dependent certificate
stores . Possible values : " system " , " mozilla " .
Defaults to " mozilla " .
2021-02-16 02:50:27 +00:00
DENO_CERT Load certificate authority from PEM encoded file
2020-06-15 16:29:39 +00:00
DENO_DIR Set the cache directory
2020-04-16 22:15:42 +00:00
DENO_INSTALL_ROOT Set deno install ' s output directory
( defaults to $HOME / . deno / bin )
2023-03-16 16:22:24 +00:00
DENO_REPL_HISTORY Set REPL history file path
History file is disabled when the value is empty
( defaults to $DENO_DIR / deno_history . txt )
2023-02-24 19:23:07 +00:00
DENO_NO_PACKAGE_JSON Disables auto - resolution of package . json
2022-04-18 19:08:30 +00:00
DENO_NO_PROMPT Set to disable permission prompts on access
( alternative to passing - - no - prompt on invocation )
2022-10-22 18:31:25 +00:00
DENO_NO_UPDATE_CHECK Set to disable checking if a newer Deno version is
2022-10-20 14:15:21 +00:00
available
2023-01-25 04:03:03 +00:00
DENO_V8_FLAGS Set V8 command line options
2022-07-20 21:36:54 +00:00
DENO_JOBS Number of parallel workers used for the - - parallel
flag with the test subcommand . Defaults to number
of available CPUs .
2020-04-16 22:15:42 +00:00
HTTP_PROXY Proxy address for HTTP requests
( module downloads , fetch )
2020-06-08 16:06:06 +00:00
HTTPS_PROXY Proxy address for HTTPS requests
2020-08-15 13:48:29 +00:00
( module downloads , fetch )
2022-12-07 21:10:50 +00:00
NPM_CONFIG_REGISTRY URL to use for the npm registry .
2021-02-16 02:50:27 +00:00
NO_COLOR Set to disable color
2020-08-15 13:48:29 +00:00
NO_PROXY Comma - separated list of hosts which do not use a proxy
2021-02-16 02:50:27 +00:00
( module downloads , fetch ) " #;
2019-06-05 17:44:46 +00:00
2022-05-09 18:16:34 +00:00
static DENO_HELP : Lazy < String > = Lazy ::new ( | | {
format! (
" A modern JavaScript and TypeScript runtime
2019-05-06 14:48:19 +00:00
2022-05-09 18:16:34 +00:00
Docs : https ://deno.land/manual@v{}
2020-03-10 23:23:08 +00:00
Modules : https ://deno.land/std/ https://deno.land/x/
2019-05-23 18:57:44 +00:00
Bugs : https ://github.com/denoland/deno/issues
2020-05-04 11:03:30 +00:00
To start the REPL :
2021-04-18 13:12:55 +00:00
2019-05-23 18:57:44 +00:00
deno
2019-11-26 16:06:32 +00:00
To execute a script :
2021-04-18 13:12:55 +00:00
2020-03-10 23:23:08 +00:00
deno run https ://deno.land/std/examples/welcome.ts
2019-05-23 18:57:44 +00:00
2020-03-10 23:23:08 +00:00
To evaluate code in the shell :
2021-04-18 13:12:55 +00:00
2020-03-10 23:23:08 +00:00
deno eval \ " console.log(30933 + 404) \"
2022-05-09 18:16:34 +00:00
" ,
SHORT_VERSION . as_str ( )
)
} ) ;
2019-05-23 18:57:44 +00:00
2019-11-26 16:06:32 +00:00
/// Main entry point for parsing deno's command line flags.
2022-04-27 19:43:36 +00:00
pub fn flags_from_vec ( args : Vec < String > ) -> clap ::Result < Flags > {
2020-11-25 10:30:14 +00:00
let version = crate ::version ::deno ( ) ;
2022-09-19 11:37:49 +00:00
let mut app = clap_root ( & version ) ;
let matches = app . try_get_matches_from_mut ( & args ) ? ;
2019-11-26 16:06:32 +00:00
2020-02-26 10:52:15 +00:00
let mut flags = Flags ::default ( ) ;
2019-11-26 16:06:32 +00:00
2020-09-20 11:45:00 +00:00
if matches . is_present ( " unstable " ) {
flags . unstable = true ;
}
2023-01-15 04:06:46 +00:00
2020-03-10 12:26:17 +00:00
if matches . is_present ( " quiet " ) {
flags . log_level = Some ( Level ::Error ) ;
2023-01-15 04:06:46 +00:00
} else {
match matches . value_of ( " log-level " ) {
Some ( " debug " ) = > flags . log_level = Some ( Level ::Debug ) ,
Some ( " info " ) = > flags . log_level = Some ( Level ::Info ) ,
_ = > { }
}
2020-03-10 12:26:17 +00:00
}
2019-11-26 16:06:32 +00:00
2022-01-14 16:38:17 +00:00
match matches . subcommand ( ) {
2022-03-11 22:07:02 +00:00
Some ( ( " bench " , m ) ) = > bench_parse ( & mut flags , m ) ,
Some ( ( " bundle " , m ) ) = > bundle_parse ( & mut flags , m ) ,
2022-01-14 16:38:17 +00:00
Some ( ( " cache " , m ) ) = > cache_parse ( & mut flags , m ) ,
2022-04-10 23:12:51 +00:00
Some ( ( " check " , m ) ) = > check_parse ( & mut flags , m ) ,
2022-03-11 22:07:02 +00:00
Some ( ( " compile " , m ) ) = > compile_parse ( & mut flags , m ) ,
Some ( ( " completions " , m ) ) = > completions_parse ( & mut flags , m , app ) ,
2022-01-14 16:38:17 +00:00
Some ( ( " coverage " , m ) ) = > coverage_parse ( & mut flags , m ) ,
2022-03-11 22:07:02 +00:00
Some ( ( " doc " , m ) ) = > doc_parse ( & mut flags , m ) ,
2022-01-14 16:38:17 +00:00
Some ( ( " eval " , m ) ) = > eval_parse ( & mut flags , m ) ,
2022-03-11 22:07:02 +00:00
Some ( ( " fmt " , m ) ) = > fmt_parse ( & mut flags , m ) ,
2022-08-19 23:37:05 +00:00
Some ( ( " init " , m ) ) = > init_parse ( & mut flags , m ) ,
2022-03-11 22:07:02 +00:00
Some ( ( " info " , m ) ) = > info_parse ( & mut flags , m ) ,
2022-01-14 16:38:17 +00:00
Some ( ( " install " , m ) ) = > install_parse ( & mut flags , m ) ,
Some ( ( " lint " , m ) ) = > lint_parse ( & mut flags , m ) ,
Some ( ( " lsp " , m ) ) = > lsp_parse ( & mut flags , m ) ,
2022-03-11 22:07:02 +00:00
Some ( ( " repl " , m ) ) = > repl_parse ( & mut flags , m ) ,
Some ( ( " run " , m ) ) = > run_parse ( & mut flags , m ) ,
2022-04-27 19:43:36 +00:00
Some ( ( " task " , m ) ) = > task_parse ( & mut flags , m , & args ) ,
2022-03-11 22:07:02 +00:00
Some ( ( " test " , m ) ) = > test_parse ( & mut flags , m ) ,
Some ( ( " types " , m ) ) = > types_parse ( & mut flags , m ) ,
Some ( ( " uninstall " , m ) ) = > uninstall_parse ( & mut flags , m ) ,
Some ( ( " upgrade " , m ) ) = > upgrade_parse ( & mut flags , m ) ,
Some ( ( " vendor " , m ) ) = > vendor_parse ( & mut flags , m ) ,
2022-04-20 12:16:37 +00:00
_ = > handle_repl_flags (
& mut flags ,
ReplFlags {
eval_files : None ,
eval : None ,
2022-12-07 19:21:18 +00:00
is_default_command : true ,
2022-04-20 12:16:37 +00:00
} ,
) ,
2019-11-26 16:06:32 +00:00
}
Ok ( flags )
}
2022-01-14 16:38:17 +00:00
fn handle_repl_flags ( flags : & mut Flags , repl_flags : ReplFlags ) {
2022-12-07 19:21:18 +00:00
// If user runs just `deno` binary we enter REPL and allow all permissions.
if repl_flags . is_default_command {
flags . allow_net = Some ( vec! [ ] ) ;
flags . allow_env = Some ( vec! [ ] ) ;
flags . allow_run = Some ( vec! [ ] ) ;
flags . allow_read = Some ( vec! [ ] ) ;
flags . allow_sys = Some ( vec! [ ] ) ;
flags . allow_write = Some ( vec! [ ] ) ;
flags . allow_ffi = Some ( vec! [ ] ) ;
flags . allow_hrtime = true ;
}
2022-01-14 16:38:17 +00:00
flags . subcommand = DenoSubcommand ::Repl ( repl_flags ) ;
}
2022-03-28 01:57:56 +00:00
fn clap_root ( version : & str ) -> Command {
clap ::Command ::new ( " deno " )
2019-11-26 16:06:32 +00:00
. bin_name ( " deno " )
2022-01-14 16:38:17 +00:00
. color ( ColorChoice ::Never )
2022-04-11 05:01:02 +00:00
. max_term_width ( 80 )
2020-11-25 10:30:14 +00:00
. version ( version )
2019-12-15 13:38:34 +00:00
. long_version ( LONG_VERSION . as_str ( ) )
2020-09-20 11:45:00 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " unstable " )
2020-09-20 11:45:00 +00:00
. long ( " unstable " )
. help ( " Enable unstable features and APIs " )
. global ( true ) ,
)
2019-04-06 22:13:06 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " log-level " )
. short ( 'L' )
2019-06-22 16:02:51 +00:00
. long ( " log-level " )
. help ( " Set log level " )
2022-04-11 05:01:02 +00:00
. hide ( true )
2019-06-22 16:02:51 +00:00
. takes_value ( true )
2022-11-18 01:59:10 +00:00
. possible_values ( [ " debug " , " info " ] )
2019-05-03 21:15:16 +00:00
. global ( true ) ,
2019-07-31 15:02:20 +00:00
)
2020-03-10 12:26:17 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " quiet " )
. short ( 'q' )
2020-03-10 12:26:17 +00:00
. long ( " quiet " )
. help ( " Suppress diagnostic output " )
. global ( true ) ,
)
2022-03-11 22:07:02 +00:00
. subcommand ( bench_subcommand ( ) )
2019-11-26 16:06:32 +00:00
. subcommand ( bundle_subcommand ( ) )
2020-06-08 12:06:20 +00:00
. subcommand ( cache_subcommand ( ) )
2022-04-10 23:12:51 +00:00
. subcommand ( check_subcommand ( ) )
2020-11-30 19:35:12 +00:00
. subcommand ( compile_subcommand ( ) )
2019-11-26 16:06:32 +00:00
. subcommand ( completions_subcommand ( ) )
2021-02-24 14:27:51 +00:00
. subcommand ( coverage_subcommand ( ) )
2020-06-08 12:06:20 +00:00
. subcommand ( doc_subcommand ( ) )
2019-11-26 16:06:32 +00:00
. subcommand ( eval_subcommand ( ) )
. subcommand ( fmt_subcommand ( ) )
2022-08-19 23:37:05 +00:00
. subcommand ( init_subcommand ( ) )
2019-11-26 16:06:32 +00:00
. subcommand ( info_subcommand ( ) )
. subcommand ( install_subcommand ( ) )
2021-09-30 15:38:07 +00:00
. subcommand ( uninstall_subcommand ( ) )
2021-02-26 14:51:25 +00:00
. subcommand ( lsp_subcommand ( ) )
2020-06-08 12:06:20 +00:00
. subcommand ( lint_subcommand ( ) )
2019-11-26 16:06:32 +00:00
. subcommand ( repl_subcommand ( ) )
. subcommand ( run_subcommand ( ) )
2022-03-11 01:56:14 +00:00
. subcommand ( task_subcommand ( ) )
2019-11-26 16:06:32 +00:00
. subcommand ( test_subcommand ( ) )
. subcommand ( types_subcommand ( ) )
2020-03-23 15:37:24 +00:00
. subcommand ( upgrade_subcommand ( ) )
2022-02-16 18:14:19 +00:00
. subcommand ( vendor_subcommand ( ) )
2022-05-09 18:16:34 +00:00
. long_about ( DENO_HELP . as_str ( ) )
2019-11-26 16:06:32 +00:00
. after_help ( ENV_VARIABLES_HELP )
}
2019-11-13 15:35:56 +00:00
2022-03-28 01:57:56 +00:00
fn bench_subcommand < ' a > ( ) -> Command < ' a > {
runtime_args ( Command ::new ( " bench " ) , true , false )
. trailing_var_arg ( true )
2023-02-12 17:40:45 +00:00
. arg (
Arg ::new ( " json " )
. long ( " json " )
. help ( " UNSTABLE: Output benchmark result in JSON format " )
. takes_value ( false ) ,
)
2022-03-11 22:07:02 +00:00
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2022-03-11 22:07:02 +00:00
. require_equals ( true )
. help ( " Ignore files " ) ,
)
. arg (
Arg ::new ( " filter " )
2022-03-28 01:57:56 +00:00
. allow_hyphen_values ( true )
2022-03-11 22:07:02 +00:00
. long ( " filter " )
. takes_value ( true )
. help ( " Run benchmarks with this string or pattern in the bench name " ) ,
)
. arg (
Arg ::new ( " files " )
. help ( " List of file names to run " )
. takes_value ( true )
. multiple_values ( true )
. multiple_occurrences ( true ) ,
)
. arg ( watch_arg ( false ) )
. arg ( no_clear_screen_arg ( ) )
. arg ( script_arg ( ) . last ( true ) )
. about ( " Run benchmarks " )
. long_about (
" Run benchmarks using Deno's built-in bench tool.
2022-04-11 05:01:02 +00:00
Evaluate the given modules , run all benches declared with ' Deno . bench ( ) ' \
and report results to standard output :
2022-03-11 22:07:02 +00:00
deno bench src / fetch_bench . ts src / signal_bench . ts
2022-04-11 05:01:02 +00:00
Directory arguments are expanded to all contained files matching the \
2022-08-15 19:16:23 +00:00
glob { * _ , * . , } bench . { js , mjs , ts , mts , jsx , tsx } :
2022-03-11 22:07:02 +00:00
deno bench src / " ,
)
}
2022-03-28 01:57:56 +00:00
fn bundle_subcommand < ' a > ( ) -> Command < ' a > {
compile_args ( Command ::new ( " bundle " ) )
2023-02-14 01:13:44 +00:00
. hide ( true )
2022-03-14 18:41:35 +00:00
. arg (
Arg ::new ( " source_file " )
. takes_value ( true )
. required ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
. arg (
Arg ::new ( " out_file " )
. takes_value ( true )
. required ( false )
. value_hint ( ValueHint ::FilePath ) ,
)
2021-12-15 21:04:43 +00:00
. arg ( watch_arg ( false ) )
2022-01-31 16:39:39 +00:00
. arg ( no_clear_screen_arg ( ) )
2021-04-16 13:28:41 +00:00
. about ( " Bundle module and dependencies into single file " )
. long_about (
" Output a single JavaScript file with all dependencies.
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno bundle https ://deno.land/std/examples/colors.ts colors.bundle.js
If no output file is given , the output is written to standard output :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno bundle https ://deno.land/std/examples/colors.ts",
)
2019-11-26 16:06:32 +00:00
}
2019-06-11 18:38:19 +00:00
2022-03-28 01:57:56 +00:00
fn cache_subcommand < ' a > ( ) -> Command < ' a > {
compile_args ( Command ::new ( " cache " ) )
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " file " )
2021-04-16 13:28:41 +00:00
. takes_value ( true )
. required ( true )
2022-03-14 18:41:35 +00:00
. min_values ( 1 )
. value_hint ( ValueHint ::FilePath ) ,
2021-04-16 13:28:41 +00:00
)
. about ( " Cache the dependencies " )
. long_about (
" Cache and compile remote dependencies recursively.
2021-01-19 17:39:35 +00:00
2022-04-11 05:01:02 +00:00
Download and compile a module with all of its static dependencies and save \
them in the local cache , without running any code :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno cache https ://deno.land/std/http/file_server.ts
2022-04-11 05:01:02 +00:00
Future runs of this module will trigger no downloads or compilation unless \
2021-04-16 13:28:41 +00:00
- - reload is specified . " ,
)
2019-11-26 16:06:32 +00:00
}
2019-05-01 23:15:37 +00:00
2022-04-10 23:12:51 +00:00
fn check_subcommand < ' a > ( ) -> Command < ' a > {
2022-05-17 21:53:42 +00:00
compile_args_without_check_args ( Command ::new ( " check " ) )
2022-12-07 18:33:26 +00:00
. arg (
Arg ::new ( " all " )
. long ( " all " )
. help ( " Type-check all code, including remote modules and npm packages " )
. conflicts_with ( " no-remote " )
2022-04-10 23:12:51 +00:00
)
2022-12-07 18:33:26 +00:00
. arg (
// past alias for --all
Arg ::new ( " remote " )
. long ( " remote " )
. help ( " Type-check all modules, including remote " )
. conflicts_with ( " no-remote " )
. hide ( true )
)
2022-04-10 23:12:51 +00:00
. arg (
Arg ::new ( " file " )
. takes_value ( true )
. required ( true )
. min_values ( 1 )
. value_hint ( ValueHint ::FilePath ) ,
)
. about ( " Type-check the dependencies " )
. long_about (
" Download and type-check without execution.
deno check https ://deno.land/std/http/file_server.ts
Unless - - reload is specified , this command will not re - download already cached dependencies . " ,
)
}
2022-03-28 01:57:56 +00:00
fn compile_subcommand < ' a > ( ) -> Command < ' a > {
runtime_args ( Command ::new ( " compile " ) , true , false )
. trailing_var_arg ( true )
2022-04-11 05:01:02 +00:00
. arg ( script_arg ( ) . required ( true ) )
2023-03-18 23:43:07 +00:00
. arg (
Arg ::new ( " include " )
. long ( " include " )
. help ( " UNSTABLE: Additional module to include in the module graph " )
. long_help (
" Includes an additional module in the compiled executable's module \
graph . Use this flag if a dynamically imported module or a web worker main \
module fails to load in the executable . This flag can be passed multiple \
times , to include multiple additional modules . " ,
)
. takes_value ( true )
. multiple_occurrences ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " output " )
2021-04-16 13:28:41 +00:00
. long ( " output " )
2022-01-14 16:38:17 +00:00
. short ( 'o' )
2021-04-16 13:28:41 +00:00
. help ( " Output file (defaults to $PWD/<inferred-name>) " )
. takes_value ( true )
2022-04-11 05:01:02 +00:00
. value_hint ( ValueHint ::FilePath ) ,
2021-04-16 13:28:41 +00:00
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " target " )
2021-04-16 13:28:41 +00:00
. long ( " target " )
. help ( " Target OS architecture " )
. takes_value ( true )
2022-11-18 01:59:10 +00:00
. possible_values ( [
2022-04-11 05:01:02 +00:00
" x86_64-unknown-linux-gnu " ,
" x86_64-pc-windows-msvc " ,
" x86_64-apple-darwin " ,
" aarch64-apple-darwin " ,
] ) ,
2021-04-16 13:28:41 +00:00
)
2021-04-27 10:44:36 +00:00
. about ( " UNSTABLE: Compile the script into a self contained executable " )
2021-04-16 13:28:41 +00:00
. long_about (
2021-04-27 10:44:36 +00:00
" UNSTABLE: Compiles the given script into a self contained executable.
2021-04-18 13:12:55 +00:00
2021-04-27 10:44:36 +00:00
deno compile - A https ://deno.land/std/http/file_server.ts
2022-04-11 05:01:02 +00:00
deno compile - - output color_util https ://deno.land/std/examples/colors.ts
Any flags passed which affect runtime behavior , such as ' - - unstable ' , \
' - - allow - * ' , ' - - v8 - flags ' , etc . are encoded into the output executable and \
used at runtime as if they were passed to a similar ' deno run ' command .
The executable name is inferred by default : Attempt to take the file stem of \
the URL path . The above example would become ' file_server ' . If the file stem \
is something generic like ' main ' , ' mod ' , ' index ' or ' cli ' , and the path has no \
parent , take the file name of the parent path . Otherwise settle with the \
generic name . If the resulting name has an ' @ .. . ' suffix , strip it .
Cross - compiling to different target architectures is supported using the \
` - - target ` flag . On the first invocation with deno will download proper \
binary and cache it in $DENO_DIR . The aarch64 - apple - darwin target is not \
supported in canary .
2021-04-16 13:28:41 +00:00
" ,
)
2019-11-26 16:06:32 +00:00
}
2019-05-01 23:15:37 +00:00
2022-03-28 01:57:56 +00:00
fn completions_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " completions " )
. disable_help_subcommand ( true )
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " shell " )
2022-11-18 01:59:10 +00:00
. possible_values ( [ " bash " , " fish " , " powershell " , " zsh " , " fig " ] )
2021-04-16 13:28:41 +00:00
. required ( true ) ,
)
. about ( " Generate shell completions " )
. long_about (
" Output shell completion script to standard output.
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno completions bash > / usr / local / etc / bash_completion . d / deno . bash
source / usr / local / etc / bash_completion . d / deno . bash " ,
)
2020-11-30 19:35:12 +00:00
}
2022-03-28 01:57:56 +00:00
fn coverage_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " coverage " )
2021-04-16 13:28:41 +00:00
. about ( " Print coverage reports " )
. long_about (
" Print coverage reports from coverage profiles.
2020-02-17 16:59:51 +00:00
2021-04-16 13:28:41 +00:00
Collect a coverage profile with deno test :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno test - - coverage = cov_profile
2020-02-04 19:24:33 +00:00
2021-04-16 13:28:41 +00:00
Print a report to stdout :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno coverage cov_profile
2020-02-04 19:24:33 +00:00
2021-04-16 13:28:41 +00:00
Include urls that start with the file schema :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno coverage - - include = \ " ^file: \" cov_profile
2020-11-22 20:45:44 +00:00
2021-04-16 13:28:41 +00:00
Exclude urls ending with test . ts and test . js :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno coverage - - exclude = \ " test \\ .(ts|js) \" cov_profile
2019-05-23 18:57:44 +00:00
2022-04-11 05:01:02 +00:00
Include urls that start with the file schema and exclude files ending with \
test . ts and test . js , for an url to match it must match the include pattern and \
not match the exclude pattern :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno coverage - - include = \ " ^file: \" --exclude= \" test \\ .(ts|js) \" cov_profile
2020-02-04 19:24:33 +00:00
2021-04-16 13:28:41 +00:00
Write a report using the lcov format :
2021-04-18 13:12:55 +00:00
2022-02-15 15:33:21 +00:00
deno coverage - - lcov - - output = cov . lcov cov_profile /
2021-04-16 13:28:41 +00:00
Generate html reports from lcov :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
genhtml - o html_cov cov . lcov
" ,
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " ignore " )
2021-04-16 13:28:41 +00:00
. long ( " ignore " )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-04-16 13:28:41 +00:00
. require_equals ( true )
2022-03-14 18:41:35 +00:00
. help ( " Ignore coverage files " )
. value_hint ( ValueHint ::AnyPath ) ,
2021-04-16 13:28:41 +00:00
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " include " )
2021-04-16 13:28:41 +00:00
. long ( " include " )
. takes_value ( true )
. value_name ( " regex " )
2022-01-14 16:38:17 +00:00
. multiple_values ( true )
. multiple_occurrences ( true )
2021-04-16 13:28:41 +00:00
. require_equals ( true )
. default_value ( r "^file:" )
. help ( " Include source files in the report " ) ,
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " exclude " )
2021-04-16 13:28:41 +00:00
. long ( " exclude " )
. takes_value ( true )
. value_name ( " regex " )
2022-01-14 16:38:17 +00:00
. multiple_values ( true )
. multiple_occurrences ( true )
2021-04-16 13:28:41 +00:00
. require_equals ( true )
. default_value ( r "test\.(js|mjs|ts|jsx|tsx)$" )
. help ( " Exclude source files from the report " ) ,
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " lcov " )
2021-04-16 13:28:41 +00:00
. long ( " lcov " )
. help ( " Output coverage report in lcov format " )
. takes_value ( false ) ,
)
2022-04-11 05:01:02 +00:00
. arg (
Arg ::new ( " output " )
. requires ( " lcov " )
. long ( " output " )
. help ( " Output file (defaults to stdout) for lcov " )
. long_help (
" Exports the coverage report in lcov format to the given file. \
Filename should be passed along with '=' For example ' - - output = foo . lcov ' \
If no - - output arg is specified then the report is written to stdout . " ,
)
. takes_value ( true )
. require_equals ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " files " )
2021-04-16 13:28:41 +00:00
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. multiple_values ( true )
. multiple_occurrences ( true )
2022-03-14 18:41:35 +00:00
. required ( true )
. value_hint ( ValueHint ::AnyPath ) ,
2021-04-16 13:28:41 +00:00
)
2019-11-26 16:06:32 +00:00
}
2019-08-12 00:43:01 +00:00
2022-03-28 01:57:56 +00:00
fn doc_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " doc " )
2021-04-16 13:28:41 +00:00
. about ( " Show documentation for a module " )
. long_about (
" Show documentation for a module.
2019-05-01 23:15:37 +00:00
2021-04-16 13:28:41 +00:00
Output documentation to standard output :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno doc . / path / to / module . ts
2019-05-01 23:15:37 +00:00
2021-04-16 13:28:41 +00:00
Output private documentation to standard output :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno doc - - private . / path / to / module . ts
2019-05-01 23:15:37 +00:00
2021-04-16 13:28:41 +00:00
Output documentation in JSON format :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno doc - - json . / path / to / module . ts
2021-02-24 14:27:51 +00:00
2021-04-16 13:28:41 +00:00
Target a specific symbol :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno doc . / path / to / module . ts MyClass . someField
2019-05-06 14:48:19 +00:00
2021-04-16 13:28:41 +00:00
Show documentation for runtime built - ins :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno doc
deno doc - - builtin Deno . Listener " ,
)
2020-10-20 12:30:59 +00:00
. arg ( import_map_arg ( ) )
2020-09-18 17:09:11 +00:00
. arg ( reload_arg ( ) )
2023-03-13 21:04:00 +00:00
. arg ( lock_arg ( ) )
. arg ( no_lock_arg ( ) )
. arg ( no_npm_arg ( ) )
. arg ( no_remote_arg ( ) )
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " json " )
2021-04-16 13:28:41 +00:00
. long ( " json " )
. help ( " Output documentation in JSON format " )
. takes_value ( false ) ,
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " private " )
2021-04-16 13:28:41 +00:00
. long ( " private " )
. help ( " Output private documentation " )
. takes_value ( false ) ,
)
// TODO(nayeemrmn): Make `--builtin` a proper option. Blocked by
// https://github.com/clap-rs/clap/issues/1794. Currently `--builtin` is
// just a possible value of `source_file` so leading hyphens must be
// enabled.
2022-03-28 01:57:56 +00:00
. allow_hyphen_values ( true )
2022-03-14 18:41:35 +00:00
. arg (
Arg ::new ( " source_file " )
. takes_value ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " filter " )
2021-04-16 13:28:41 +00:00
. help ( " Dot separated path to symbol " )
. takes_value ( true )
. required ( false )
2022-01-14 16:38:17 +00:00
. conflicts_with ( " json " ) ,
2021-04-16 13:28:41 +00:00
)
2020-09-18 17:09:11 +00:00
}
2022-03-28 01:57:56 +00:00
fn eval_subcommand < ' a > ( ) -> Command < ' a > {
runtime_args ( Command ::new ( " eval " ) , false , true )
2021-04-16 13:28:41 +00:00
. about ( " Eval script " )
. long_about (
" Evaluate JavaScript from the command line.
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno eval \ " console.log('hello world') \"
2019-11-26 16:06:32 +00:00
2021-04-16 13:28:41 +00:00
To evaluate as TypeScript :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno eval - - ext = ts \ " const v: string = 'hello'; console.log(v) \"
2019-11-26 16:06:32 +00:00
2021-04-16 13:28:41 +00:00
This command has implicit access to all permissions ( - - allow - all ) . " ,
)
. arg (
// TODO(@satyarohith): remove this argument in 2.0.
2022-01-14 16:38:17 +00:00
Arg ::new ( " ts " )
2021-04-16 13:28:41 +00:00
. long ( " ts " )
2022-01-14 16:38:17 +00:00
. short ( 'T' )
2021-04-16 13:28:41 +00:00
. help ( " Treat eval input as TypeScript " )
. takes_value ( false )
2022-01-14 16:38:17 +00:00
. multiple_occurrences ( false )
. multiple_values ( false )
. hide ( true ) ,
2021-04-16 13:28:41 +00:00
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " ext " )
2021-04-16 13:28:41 +00:00
. long ( " ext " )
. help ( " Set standard input (stdin) content type " )
. takes_value ( true )
. default_value ( " js " )
2022-11-18 01:59:10 +00:00
. possible_values ( [ " ts " , " tsx " , " js " , " jsx " ] ) ,
2021-04-16 13:28:41 +00:00
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " print " )
2021-04-16 13:28:41 +00:00
. long ( " print " )
2022-01-14 16:38:17 +00:00
. short ( 'p' )
2021-04-16 13:28:41 +00:00
. help ( " print result to stdout " )
. takes_value ( false )
2022-01-14 16:38:17 +00:00
. multiple_occurrences ( false )
. multiple_values ( false ) ,
2021-04-16 13:28:41 +00:00
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " code_arg " )
. multiple_values ( true )
. multiple_occurrences ( true )
2021-04-16 13:28:41 +00:00
. help ( " Code arg " )
. value_name ( " CODE_ARG " )
. required ( true ) ,
)
2019-11-26 16:06:32 +00:00
}
2022-03-28 01:57:56 +00:00
fn fmt_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " fmt " )
2021-04-16 13:28:41 +00:00
. about ( " Format source files " )
. long_about (
" Auto-format JavaScript, TypeScript, Markdown, and JSON files.
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno fmt
deno fmt myfile1 . ts myfile2 . ts
deno fmt - - check
2020-02-09 10:19:05 +00:00
2020-03-10 23:23:08 +00:00
Format stdin and write to stdout :
2021-04-18 13:12:55 +00:00
2020-05-04 19:17:15 +00:00
cat file . ts | deno fmt -
Ignore formatting code by preceding it with an ignore comment :
2021-04-18 13:12:55 +00:00
2020-05-04 19:17:15 +00:00
// deno-fmt-ignore
Ignore formatting a file by adding an ignore comment at the top of the file :
2021-04-18 13:12:55 +00:00
2020-05-04 19:17:15 +00:00
// deno-fmt-ignore-file",
2020-01-30 02:16:48 +00:00
)
2022-06-28 19:47:51 +00:00
. arg ( config_arg ( ) )
. arg ( no_config_arg ( ) )
2020-01-30 02:16:48 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " check " )
2020-01-30 02:16:48 +00:00
. long ( " check " )
2020-09-20 11:45:00 +00:00
. help ( " Check if the source files are formatted " )
2020-01-30 02:16:48 +00:00
. takes_value ( false ) ,
)
2021-01-19 17:39:35 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " ext " )
2021-01-19 17:39:35 +00:00
. long ( " ext " )
. help ( " Set standard input (stdin) content type " )
. takes_value ( true )
. default_value ( " ts " )
2022-11-18 01:59:10 +00:00
. possible_values ( [ " ts " , " tsx " , " js " , " jsx " , " md " , " json " , " jsonc " ] ) ,
2021-01-19 17:39:35 +00:00
)
2020-07-30 16:09:08 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " ignore " )
2020-07-30 16:09:08 +00:00
. long ( " ignore " )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2020-07-30 16:09:08 +00:00
. require_equals ( true )
2022-03-14 18:41:35 +00:00
. help ( " Ignore formatting particular source files " )
. value_hint ( ValueHint ::AnyPath ) ,
2020-07-30 16:09:08 +00:00
)
2020-01-30 02:16:48 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " files " )
2020-01-30 02:16:48 +00:00
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. multiple_values ( true )
. multiple_occurrences ( true )
2022-03-14 18:41:35 +00:00
. required ( false )
. value_hint ( ValueHint ::AnyPath ) ,
2020-01-30 02:16:48 +00:00
)
2021-12-15 21:04:43 +00:00
. arg ( watch_arg ( false ) )
2022-01-31 16:39:39 +00:00
. arg ( no_clear_screen_arg ( ) )
2021-09-13 20:06:45 +00:00
. arg (
2023-02-11 17:39:56 +00:00
Arg ::new ( " use-tabs " )
. long ( " use-tabs " )
. alias ( " options-use-tabs " )
2023-01-25 20:06:00 +00:00
. takes_value ( true )
. min_values ( 0 )
. max_values ( 1 )
. require_equals ( true )
. possible_values ( [ " true " , " false " ] )
2021-09-13 20:06:45 +00:00
. help ( " Use tabs instead of spaces for indentation. Defaults to false. " ) ,
)
. arg (
2023-02-11 17:39:56 +00:00
Arg ::new ( " line-width " )
. long ( " line-width " )
. alias ( " options-line-width " )
2021-09-13 20:06:45 +00:00
. help ( " Define maximum line width. Defaults to 80. " )
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. validator ( | val : & str | match val . parse ::< NonZeroUsize > ( ) {
2021-09-13 20:06:45 +00:00
Ok ( _ ) = > Ok ( ( ) ) ,
2023-02-11 17:39:56 +00:00
Err ( _ ) = > Err ( " line-width should be a non zero integer " . to_string ( ) ) ,
2021-09-13 20:06:45 +00:00
} ) ,
)
. arg (
2023-02-11 17:39:56 +00:00
Arg ::new ( " indent-width " )
. long ( " indent-width " )
. alias ( " options-indent-width " )
2021-09-13 20:06:45 +00:00
. help ( " Define indentation width. Defaults to 2. " )
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. validator ( | val : & str | match val . parse ::< NonZeroUsize > ( ) {
2021-09-13 20:06:45 +00:00
Ok ( _ ) = > Ok ( ( ) ) ,
Err ( _ ) = > {
2023-02-11 17:39:56 +00:00
Err ( " indent-width should be a non zero integer " . to_string ( ) )
2021-09-13 20:06:45 +00:00
}
} ) ,
)
. arg (
2023-02-11 17:39:56 +00:00
Arg ::new ( " single-quote " )
. long ( " single-quote " )
. alias ( " options-single-quote " )
2023-01-25 20:06:00 +00:00
. min_values ( 0 )
. max_values ( 1 )
. takes_value ( true )
. require_equals ( true )
. possible_values ( [ " true " , " false " ] )
2021-09-13 20:06:45 +00:00
. help ( " Use single quotes. Defaults to false. " ) ,
)
. arg (
2023-02-11 17:39:56 +00:00
Arg ::new ( " prose-wrap " )
. long ( " prose-wrap " )
. alias ( " options-prose-wrap " )
2021-09-13 20:06:45 +00:00
. takes_value ( true )
2022-11-18 01:59:10 +00:00
. possible_values ( [ " always " , " never " , " preserve " ] )
2021-09-13 20:06:45 +00:00
. help ( " Define how prose should be wrapped. Defaults to always. " ) ,
)
2023-01-24 20:07:00 +00:00
. arg (
2023-02-11 17:39:56 +00:00
Arg ::new ( " no-semicolons " )
. long ( " no-semicolons " )
. alias ( " options-no-semicolons " )
2023-01-25 20:06:00 +00:00
. min_values ( 0 )
. max_values ( 1 )
2023-01-24 20:07:00 +00:00
. takes_value ( true )
2023-01-25 20:06:00 +00:00
. require_equals ( true )
. possible_values ( [ " true " , " false " ] )
. help ( " Don't use semicolons except where necessary. " ) ,
2023-01-24 20:07:00 +00:00
)
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2022-08-19 23:37:05 +00:00
fn init_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " init " ) . about ( " Initialize a new project " ) . arg (
Arg ::new ( " dir " )
. takes_value ( true )
. required ( false )
. value_hint ( ValueHint ::DirPath ) ,
)
}
2022-03-28 01:57:56 +00:00
fn info_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " info " )
2021-04-16 13:28:41 +00:00
. about ( " Show info about cache or info related to source file " )
. long_about (
" Information about a module or the cache directories.
Get information about a module :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno info https ://deno.land/std/http/file_server.ts
The following information is shown :
local : Local path of the file .
type : JavaScript , TypeScript , or JSON .
2021-09-13 11:50:04 +00:00
emit : Local path of compiled source code . ( TypeScript only . )
dependencies : Dependency tree of the source file .
2021-04-16 13:28:41 +00:00
Without any additional arguments , ' deno info ' shows :
DENO_DIR : Directory containing Deno - managed files .
Remote modules cache : Subdirectory containing downloaded remote modules .
TypeScript compiler cache : Subdirectory containing TS compiler output . " ,
)
2022-03-14 18:41:35 +00:00
. arg ( Arg ::new ( " file " ) . takes_value ( true ) . required ( false ) . value_hint ( ValueHint ::FilePath ) )
2021-04-16 13:28:41 +00:00
. arg ( reload_arg ( ) . requires ( " file " ) )
. arg ( ca_file_arg ( ) )
2021-05-27 05:23:12 +00:00
. arg (
location_arg ( )
. conflicts_with ( " file " )
. help ( " Show files used for origin bound APIs like the Web Storage API when running a script with '--location=<HREF>' " )
)
2023-03-13 21:04:00 +00:00
. arg ( no_check_arg ( ) . hide ( true ) ) // TODO(lucacasonato): remove for 2.0
2022-06-28 19:47:51 +00:00
. arg ( no_config_arg ( ) )
2023-03-13 21:04:00 +00:00
. arg ( no_remote_arg ( ) )
. arg ( no_npm_arg ( ) )
. arg ( no_lock_arg ( ) )
. arg ( lock_arg ( ) )
2022-06-28 19:47:51 +00:00
. arg ( config_arg ( ) )
2021-04-16 13:28:41 +00:00
. arg ( import_map_arg ( ) )
2022-10-28 20:19:55 +00:00
. arg ( local_npm_arg ( ) )
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " json " )
2021-04-16 13:28:41 +00:00
. long ( " json " )
2021-04-27 10:44:36 +00:00
. help ( " UNSTABLE: Outputs the information in JSON format " )
2021-04-16 13:28:41 +00:00
. takes_value ( false ) ,
)
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2022-03-28 01:57:56 +00:00
fn install_subcommand < ' a > ( ) -> Command < ' a > {
runtime_args ( Command ::new ( " install " ) , true , true )
. trailing_var_arg ( true )
2022-03-14 18:41:35 +00:00
. arg ( Arg ::new ( " cmd " ) . required ( true ) . multiple_values ( true ) . value_hint ( ValueHint ::FilePath ) )
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " name " )
2021-04-16 13:28:41 +00:00
. long ( " name " )
2022-01-14 16:38:17 +00:00
. short ( 'n' )
2021-04-16 13:28:41 +00:00
. help ( " Executable file name " )
. takes_value ( true )
. required ( false ) )
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " root " )
2021-04-16 13:28:41 +00:00
. long ( " root " )
. help ( " Installation root " )
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. multiple_occurrences ( false )
2022-03-14 18:41:35 +00:00
. multiple_values ( false )
. value_hint ( ValueHint ::DirPath ) )
2021-04-16 13:28:41 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " force " )
2021-04-16 13:28:41 +00:00
. long ( " force " )
2022-01-14 16:38:17 +00:00
. short ( 'f' )
2021-04-16 13:28:41 +00:00
. help ( " Forcefully overwrite existing installation " )
. takes_value ( false ) )
. about ( " Install script as an executable " )
. long_about (
" Installs a script as an executable in the installation root's bin directory.
2021-04-18 13:12:55 +00:00
2020-05-01 19:33:11 +00:00
deno install - - allow - net - - allow - read https ://deno.land/std/http/file_server.ts
deno install https ://deno.land/std/examples/colors.ts
To change the executable name , use - n / - - name :
2021-04-18 13:12:55 +00:00
2020-05-01 19:33:11 +00:00
deno install - - allow - net - - allow - read - n serve https ://deno.land/std/http/file_server.ts
The executable name is inferred by default :
- Attempt to take the file stem of the URL path . The above example would
become ' file_server ' .
- If the file stem is something generic like ' main ' , ' mod ' , ' index ' or ' cli ' ,
and the path has no parent , take the file name of the parent path . Otherwise
settle with the generic name .
2020-08-27 20:55:58 +00:00
- If the resulting name has an ' @ .. . ' suffix , strip it .
2019-05-03 21:15:16 +00:00
2020-04-16 22:15:42 +00:00
To change the installation root , use - - root :
2021-04-18 13:12:55 +00:00
2020-05-01 19:33:11 +00:00
deno install - - allow - net - - allow - read - - root / usr / local https ://deno.land/std/http/file_server.ts
2020-04-16 22:15:42 +00:00
The installation root is determined , in order of precedence :
- - - root option
- DENO_INSTALL_ROOT environment variable
- $HOME / . deno
These must be added to the path manually if required . " )
2019-11-26 16:06:32 +00:00
}
2019-05-03 21:15:16 +00:00
2022-03-28 01:57:56 +00:00
fn uninstall_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " uninstall " )
. trailing_var_arg ( true )
2021-09-30 15:38:07 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " name " )
2021-09-30 15:38:07 +00:00
. required ( true )
2023-01-06 02:09:39 +00:00
. multiple_occurrences ( false ) )
2021-09-30 15:38:07 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " root " )
2021-09-30 15:38:07 +00:00
. long ( " root " )
. help ( " Installation root " )
. takes_value ( true )
2022-03-14 18:41:35 +00:00
. multiple_occurrences ( false )
. value_hint ( ValueHint ::DirPath ) )
2021-09-30 15:38:07 +00:00
. about ( " Uninstall a script previously installed with deno install " )
. long_about (
" Uninstalls an executable script in the installation root's bin directory.
deno uninstall serve
To change the installation root , use - - root :
deno uninstall - - root / usr / local serve
The installation root is determined , in order of precedence :
- - - root option
- DENO_INSTALL_ROOT environment variable
- $HOME / . deno " )
}
2022-05-09 18:16:34 +00:00
static LSP_HELP : Lazy < String > = Lazy ::new ( | | {
format! (
" The 'deno lsp' subcommand provides a way for code editors and IDEs to
2021-04-16 13:28:41 +00:00
interact with Deno using the Language Server Protocol . Usually humans do not
use this subcommand directly . For example , ' deno lsp ' can provide IDEs with
go - to - definition support and automatic code formatting .
How to connect various editors and IDEs to ' deno lsp ' :
2022-05-09 18:16:34 +00:00
https ://deno.land/manual@v{}/getting_started/setup_your_environment#editors-and-ides",
SHORT_VERSION . as_str ( )
)
} ) ;
fn lsp_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " lsp " )
. about ( " Start the language server " )
. long_about ( LSP_HELP . as_str ( ) )
2021-04-16 13:28:41 +00:00
}
2022-03-28 01:57:56 +00:00
fn lint_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " lint " )
2021-06-05 13:57:31 +00:00
. about ( " Lint source files " )
2021-04-16 13:28:41 +00:00
. long_about (
2021-06-05 13:57:31 +00:00
" Lint JavaScript/TypeScript source code.
2021-04-18 13:12:55 +00:00
2021-04-27 10:44:36 +00:00
deno lint
deno lint myfile1 . ts myfile2 . js
2021-04-16 13:28:41 +00:00
Print result as JSON :
2021-04-18 13:12:55 +00:00
2021-04-27 10:44:36 +00:00
deno lint - - json
2021-04-16 13:28:41 +00:00
Read from stdin :
2021-04-18 13:12:55 +00:00
2021-04-27 10:44:36 +00:00
cat file . ts | deno lint -
cat file . ts | deno lint - - json -
2021-04-16 13:28:41 +00:00
List available rules :
2021-04-18 13:12:55 +00:00
2021-04-27 10:44:36 +00:00
deno lint - - rules
2021-04-16 13:28:41 +00:00
Ignore diagnostics on the next line by preceding it with an ignore comment and
rule name :
2021-04-18 13:12:55 +00:00
// deno-lint-ignore no-explicit-any
2021-04-16 13:28:41 +00:00
// deno-lint-ignore require-await no-empty
Names of rules to ignore must be specified after ignore comment .
Ignore linting a file by adding an ignore comment at the top of the file :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
// deno-lint-ignore-file
" ,
2020-11-30 19:35:12 +00:00
)
2022-01-14 16:38:17 +00:00
. arg ( Arg ::new ( " rules " ) . long ( " rules " ) . help ( " List available rules " ) )
2020-12-01 14:11:02 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " rules-tags " )
2021-09-03 15:01:58 +00:00
. long ( " rules-tags " )
. require_equals ( true )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-09-03 15:01:58 +00:00
. conflicts_with ( " rules " )
. help ( " Use set of rules with a tag " ) ,
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " rules-include " )
2021-09-03 15:01:58 +00:00
. long ( " rules-include " )
. require_equals ( true )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-09-03 15:01:58 +00:00
. conflicts_with ( " rules " )
. help ( " Include lint rules " ) ,
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " rules-exclude " )
2021-09-03 15:01:58 +00:00
. long ( " rules-exclude " )
. require_equals ( true )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-09-03 15:01:58 +00:00
. conflicts_with ( " rules " )
. help ( " Exclude lint rules " ) ,
)
2022-06-28 19:47:51 +00:00
. arg ( no_config_arg ( ) )
. arg ( config_arg ( ) )
2021-01-19 02:40:22 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " ignore " )
2021-04-16 13:28:41 +00:00
. long ( " ignore " )
2021-01-19 02:40:22 +00:00
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-04-16 13:28:41 +00:00
. require_equals ( true )
2022-03-14 18:41:35 +00:00
. help ( " Ignore linting particular source files " )
. value_hint ( ValueHint ::AnyPath ) ,
2021-01-19 02:40:22 +00:00
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " json " )
2021-04-16 13:28:41 +00:00
. long ( " json " )
. help ( " Output lint result in JSON format " )
. takes_value ( false ) ,
2021-01-19 02:40:22 +00:00
)
2022-09-28 16:47:48 +00:00
. arg (
Arg ::new ( " compact " )
. long ( " compact " )
. help ( " Output lint result in compact format " )
. takes_value ( false )
. conflicts_with ( " json " ) ,
)
2019-11-26 16:06:32 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " files " )
2019-11-26 16:06:32 +00:00
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. multiple_values ( true )
. multiple_occurrences ( true )
2022-03-14 18:41:35 +00:00
. required ( false )
. value_hint ( ValueHint ::AnyPath ) ,
2019-11-26 16:06:32 +00:00
)
2021-12-15 21:04:43 +00:00
. arg ( watch_arg ( false ) )
2022-01-31 16:39:39 +00:00
. arg ( no_clear_screen_arg ( ) )
2021-04-16 13:28:41 +00:00
}
2019-05-16 14:39:19 +00:00
2022-03-28 01:57:56 +00:00
fn repl_subcommand < ' a > ( ) -> Command < ' a > {
2022-12-07 19:21:18 +00:00
runtime_args ( Command ::new ( " repl " ) , true , true )
2021-04-16 13:28:41 +00:00
. about ( " Read Eval Print Loop " )
2022-04-20 12:16:37 +00:00
. arg (
Arg ::new ( " eval-file " )
. long ( " eval-file " )
. min_values ( 1 )
. takes_value ( true )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Evaluates the provided file(s) as scripts when the REPL starts. Accepts file paths and URLs. " )
. value_hint ( ValueHint ::AnyPath ) ,
)
2021-08-06 21:30:28 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " eval " )
2021-08-06 21:30:28 +00:00
. long ( " eval " )
. help ( " Evaluates the provided code when the REPL starts. " )
. takes_value ( true )
. value_name ( " code " ) ,
)
2019-11-26 16:06:32 +00:00
}
2022-03-28 01:57:56 +00:00
fn run_subcommand < ' a > ( ) -> Command < ' a > {
runtime_args ( Command ::new ( " run " ) , true , true )
2019-11-26 16:06:32 +00:00
. arg (
2021-12-15 21:04:43 +00:00
watch_arg ( true )
2021-04-16 13:28:41 +00:00
. conflicts_with ( " inspect " )
2022-12-12 14:33:30 +00:00
. conflicts_with ( " inspect-wait " )
2021-04-18 13:12:55 +00:00
. conflicts_with ( " inspect-brk " ) ,
2019-11-26 16:06:32 +00:00
)
2022-01-31 16:39:39 +00:00
. arg ( no_clear_screen_arg ( ) )
2022-03-28 01:57:56 +00:00
. trailing_var_arg ( true )
2021-04-18 13:12:55 +00:00
. arg ( script_arg ( ) . required ( true ) )
. about ( " Run a JavaScript or TypeScript program " )
2019-11-26 16:06:32 +00:00
. long_about (
2021-04-18 13:12:55 +00:00
" Run a JavaScript or TypeScript program
2020-02-28 14:17:56 +00:00
2021-04-16 13:28:41 +00:00
By default all programs are run in sandbox without access to disk , network or
ability to spawn subprocesses .
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno run https ://deno.land/std/examples/welcome.ts
2020-03-10 23:23:08 +00:00
2021-04-16 13:28:41 +00:00
Grant all permissions :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno run - A https ://deno.land/std/http/file_server.ts
Grant permission to read from disk and listen to network :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno run - - allow - read - - allow - net https ://deno.land/std/http/file_server.ts
Grant permission to read allow - listed files from disk :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno run - - allow - read = / etc https ://deno.land/std/http/file_server.ts
2022-04-11 05:01:02 +00:00
Specifying the filename '-' to read the file from stdin .
2021-04-18 13:12:55 +00:00
2021-07-02 08:43:53 +00:00
curl https ://deno.land/std/examples/welcome.ts | deno run -",
2020-02-28 14:17:56 +00:00
)
2021-04-16 13:28:41 +00:00
}
2022-03-28 01:57:56 +00:00
fn task_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " task " )
. trailing_var_arg ( true )
2022-06-28 19:47:51 +00:00
. arg ( config_arg ( ) )
2022-06-08 21:30:16 +00:00
. arg (
Arg ::new ( " cwd " )
. long ( " cwd " )
. value_name ( " DIR " )
. help ( " Specify the directory to run the task in " )
. takes_value ( true )
. value_hint ( ValueHint ::DirPath )
)
2022-05-11 16:58:35 +00:00
// Ideally the task name and trailing arguments should be two separate clap
// arguments, but there is a bug in clap that's preventing us from doing
// this (https://github.com/clap-rs/clap/issues/1538). Once that's fixed,
// then we can revert this back to what it used to be.
. arg ( Arg ::new ( " task_name_and_args " )
2022-03-11 01:56:14 +00:00
. multiple_values ( true )
. multiple_occurrences ( true )
2022-04-29 14:29:14 +00:00
. allow_hyphen_values ( true )
2022-05-11 16:58:35 +00:00
. help ( " Task to be executed with any additional arguments passed to the task " ) )
2022-03-11 01:56:14 +00:00
. about ( " Run a task defined in the configuration file " )
. long_about (
" Run a task defined in the configuration file
deno task build " ,
)
}
2022-03-28 01:57:56 +00:00
fn test_subcommand < ' a > ( ) -> Command < ' a > {
runtime_args ( Command ::new ( " test " ) , true , true )
. trailing_var_arg ( true )
2021-08-24 15:23:29 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " ignore " )
2021-08-24 15:23:29 +00:00
. long ( " ignore " )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-08-24 15:23:29 +00:00
. require_equals ( true )
2022-03-14 18:41:35 +00:00
. help ( " Ignore files " )
. value_hint ( ValueHint ::AnyPath ) ,
2021-08-24 15:23:29 +00:00
)
2020-02-28 14:17:56 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " no-run " )
2021-04-16 13:28:41 +00:00
. long ( " no-run " )
. help ( " Cache test modules, but don't run tests " )
2021-04-27 10:44:36 +00:00
. takes_value ( false ) ,
2021-02-21 16:58:32 +00:00
)
2022-02-25 15:14:46 +00:00
. arg (
Arg ::new ( " trace-ops " )
. long ( " trace-ops " )
. help ( " Enable tracing of async ops. Useful when debugging leaking ops in test, but impacts test execution time. " )
. takes_value ( false ) ,
)
2021-05-10 23:54:39 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " doc " )
2021-05-10 23:54:39 +00:00
. long ( " doc " )
2023-02-15 23:50:30 +00:00
. help ( " Type-check code blocks in JSDoc and Markdown " )
2021-05-10 23:54:39 +00:00
. takes_value ( false ) ,
)
2021-02-21 16:58:32 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " fail-fast " )
2021-04-16 13:28:41 +00:00
. long ( " fail-fast " )
. alias ( " failfast " )
2021-07-12 10:55:42 +00:00
. help ( " Stop after N errors. Defaults to stopping after first failure. " )
. min_values ( 0 )
. required ( false )
. takes_value ( true )
. require_equals ( true )
. value_name ( " N " )
2022-01-14 16:38:17 +00:00
. validator ( | val : & str | match val . parse ::< NonZeroUsize > ( ) {
2021-08-23 10:37:02 +00:00
Ok ( _ ) = > Ok ( ( ) ) ,
Err ( _ ) = > Err ( " fail-fast should be a non zero integer " . to_string ( ) ) ,
2021-07-12 10:55:42 +00:00
} ) ,
2019-04-17 13:25:51 +00:00
)
2020-05-21 14:35:36 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-none " )
2021-04-16 13:28:41 +00:00
. long ( " allow-none " )
. help ( " Don't return error code if no test files are found " )
. takes_value ( false ) ,
2020-05-21 14:35:36 +00:00
)
2020-11-30 02:10:21 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " filter " )
2022-03-28 01:57:56 +00:00
. allow_hyphen_values ( true )
2021-04-16 13:28:41 +00:00
. long ( " filter " )
. takes_value ( true )
. help ( " Run tests with this string or pattern in the test name " ) ,
2019-11-26 16:06:32 +00:00
)
2021-07-06 01:20:33 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " shuffle " )
2021-07-06 01:20:33 +00:00
. long ( " shuffle " )
. value_name ( " NUMBER " )
2023-02-15 23:50:30 +00:00
. help ( " Shuffle the order in which the tests are run " )
2021-07-06 01:20:33 +00:00
. min_values ( 0 )
. max_values ( 1 )
. require_equals ( true )
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. validator ( | val : & str | match val . parse ::< u64 > ( ) {
2021-07-06 01:20:33 +00:00
Ok ( _ ) = > Ok ( ( ) ) ,
Err ( _ ) = > Err ( " Shuffle seed should be a number " . to_string ( ) ) ,
} ) ,
)
2020-07-08 14:50:12 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " coverage " )
2021-04-16 13:28:41 +00:00
. long ( " coverage " )
. require_equals ( true )
. takes_value ( true )
2021-08-12 08:21:38 +00:00
. value_name ( " DIR " )
2021-04-16 13:28:41 +00:00
. conflicts_with ( " inspect " )
2022-12-12 14:33:30 +00:00
. conflicts_with ( " inspect-wait " )
2021-04-16 13:28:41 +00:00
. conflicts_with ( " inspect-brk " )
2023-02-15 23:50:30 +00:00
. help ( " Collect coverage profile data into DIR " ) ,
2020-07-08 14:50:12 +00:00
)
2022-07-20 21:36:54 +00:00
. arg (
Arg ::new ( " parallel " )
. long ( " parallel " )
. help ( " Run test modules in parallel. Parallelism defaults to the number of available CPUs or the value in the DENO_JOBS environment variable. " )
. conflicts_with ( " jobs " )
. takes_value ( false )
)
2021-04-28 18:17:04 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " jobs " )
. short ( 'j' )
2021-04-28 18:17:04 +00:00
. long ( " jobs " )
2022-07-20 21:36:54 +00:00
. help ( " deprecated: Number of parallel workers, defaults to number of available CPUs when no value is provided. Defaults to 1 when the option is not present. " )
. hide ( true )
2021-04-28 18:17:04 +00:00
. min_values ( 0 )
. max_values ( 1 )
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. validator ( | val : & str | match val . parse ::< NonZeroUsize > ( ) {
2021-04-28 18:17:04 +00:00
Ok ( _ ) = > Ok ( ( ) ) ,
2021-08-23 10:35:38 +00:00
Err ( _ ) = > Err ( " jobs should be a non zero unsigned integer " . to_string ( ) ) ,
2021-04-28 18:17:04 +00:00
} ) ,
)
2020-01-31 21:07:37 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " files " )
2021-04-16 13:28:41 +00:00
. help ( " List of file names to run " )
2020-01-31 21:07:37 +00:00
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. multiple_values ( true )
2022-03-14 18:41:35 +00:00
. multiple_occurrences ( true )
. value_hint ( ValueHint ::AnyPath ) ,
2020-01-31 21:07:37 +00:00
)
2021-05-10 06:06:13 +00:00
. arg (
2021-12-15 21:04:43 +00:00
watch_arg ( false )
2021-05-10 06:06:13 +00:00
. conflicts_with ( " no-run " )
. conflicts_with ( " coverage " ) ,
)
2022-01-31 16:39:39 +00:00
. arg ( no_clear_screen_arg ( ) )
2021-04-16 13:28:41 +00:00
. arg ( script_arg ( ) . last ( true ) )
. about ( " Run tests " )
2019-11-26 16:06:32 +00:00
. long_about (
2021-04-16 13:28:41 +00:00
" Run tests using Deno's built-in test runner.
2019-04-06 22:13:06 +00:00
2021-04-16 13:28:41 +00:00
Evaluate the given modules , run all tests declared with ' Deno . test ( ) ' and
report results to standard output :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno test src / fetch_test . ts src / signal_test . ts
2019-04-06 22:13:06 +00:00
2021-04-16 13:28:41 +00:00
Directory arguments are expanded to all contained files matching the glob
2022-08-15 19:16:23 +00:00
{ * _ , * . , } test . { js , mjs , ts , mts , jsx , tsx } :
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno test src / " ,
2019-11-26 16:06:32 +00:00
)
2019-06-05 17:44:46 +00:00
}
2022-03-28 01:57:56 +00:00
fn types_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " types " )
2021-04-16 13:28:41 +00:00
. about ( " Print runtime TypeScript declarations " )
2021-02-24 14:27:51 +00:00
. long_about (
2021-04-16 13:28:41 +00:00
" Print runtime TypeScript declarations.
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno types > lib . deno . d . ts
2021-02-24 14:27:51 +00:00
2021-04-16 13:28:41 +00:00
The declaration file could be saved and used for typing information . " ,
)
}
2021-02-24 14:27:51 +00:00
2022-03-28 01:57:56 +00:00
fn upgrade_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " upgrade " )
2021-04-16 13:28:41 +00:00
. about ( " Upgrade deno executable to given version " )
. long_about (
" Upgrade deno executable to the given version.
Defaults to latest .
2021-02-24 14:27:51 +00:00
2021-04-16 13:28:41 +00:00
The version is downloaded from
https ://github.com/denoland/deno/releases
and is used to replace the current executable .
2021-02-24 14:27:51 +00:00
2021-04-16 13:28:41 +00:00
If you want to not replace the current Deno executable but instead download an
update to a different location , use the - - output flag
2021-04-18 13:12:55 +00:00
2021-04-16 13:28:41 +00:00
deno upgrade - - output $HOME / my_deno " ,
2020-03-23 15:37:24 +00:00
)
2020-05-09 10:31:15 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " version " )
2020-05-09 10:31:15 +00:00
. long ( " version " )
. help ( " The version to upgrade to " )
. takes_value ( true ) ,
)
2020-07-06 22:21:26 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " output " )
2020-07-06 22:21:26 +00:00
. long ( " output " )
. help ( " The path to output the updated version to " )
2022-03-14 18:41:35 +00:00
. takes_value ( true )
. value_hint ( ValueHint ::FilePath ) ,
2020-07-06 22:21:26 +00:00
)
2020-03-23 15:37:24 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " dry-run " )
2020-03-23 15:37:24 +00:00
. long ( " dry-run " )
. help ( " Perform all checks without replacing old exe " ) ,
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " force " )
2020-03-23 15:37:24 +00:00
. long ( " force " )
2022-01-14 16:38:17 +00:00
. short ( 'f' )
2020-03-23 15:37:24 +00:00
. help ( " Replace current exe even if not out-of-date " ) ,
)
2020-11-29 19:00:35 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " canary " )
2020-11-29 19:00:35 +00:00
. long ( " canary " )
. help ( " Upgrade to canary builds " ) ,
)
2020-07-06 03:58:23 +00:00
. arg ( ca_file_arg ( ) )
2020-03-23 15:37:24 +00:00
}
2022-03-28 01:57:56 +00:00
fn vendor_subcommand < ' a > ( ) -> Command < ' a > {
Command ::new ( " vendor " )
2022-02-16 18:14:19 +00:00
. about ( " Vendor remote modules into a local directory " )
. long_about (
" Vendor remote modules into a local directory.
Analyzes the provided modules along with their dependencies , downloads
remote modules to the output directory , and produces an import map that
maps remote specifiers to the downloaded files .
deno vendor main . ts
deno run - - import - map vendor / import_map . json main . ts
Remote modules and multiple modules may also be specified :
deno vendor main . ts test . deps . ts https ://deno.land/std/path/mod.ts",
)
. arg (
Arg ::new ( " specifiers " )
. takes_value ( true )
. multiple_values ( true )
. multiple_occurrences ( true )
. required ( true ) ,
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. help ( " The directory to output the vendored modules to " )
2022-03-14 18:41:35 +00:00
. takes_value ( true )
. value_hint ( ValueHint ::DirPath ) ,
2022-02-16 18:14:19 +00:00
)
. arg (
Arg ::new ( " force " )
. long ( " force " )
. short ( 'f' )
. help (
" Forcefully overwrite conflicting files in existing output directory " ,
)
. takes_value ( false ) ,
)
2022-06-28 19:47:51 +00:00
. arg ( no_config_arg ( ) )
. arg ( config_arg ( ) )
2022-02-16 18:14:19 +00:00
. arg ( import_map_arg ( ) )
. arg ( lock_arg ( ) )
. arg ( reload_arg ( ) )
. arg ( ca_file_arg ( ) )
}
2022-03-28 01:57:56 +00:00
fn compile_args ( app : Command ) -> Command {
2023-03-13 21:04:00 +00:00
compile_args_without_check_args ( app . arg ( no_check_arg ( ) ) . arg ( check_arg ( ) ) )
2020-06-08 12:06:20 +00:00
}
2022-05-17 21:53:42 +00:00
fn compile_args_without_check_args ( app : Command ) -> Command {
2022-04-10 23:12:51 +00:00
app
. arg ( import_map_arg ( ) )
. arg ( no_remote_arg ( ) )
2022-09-07 13:33:51 +00:00
. arg ( no_npm_arg ( ) )
2022-09-22 15:17:02 +00:00
. arg ( local_npm_arg ( ) )
2022-06-28 19:47:51 +00:00
. arg ( config_arg ( ) )
. arg ( no_config_arg ( ) )
2022-04-10 23:12:51 +00:00
. arg ( reload_arg ( ) )
. arg ( lock_arg ( ) )
. arg ( lock_write_arg ( ) )
2022-11-03 15:42:56 +00:00
. arg ( no_lock_arg ( ) )
2022-04-10 23:12:51 +00:00
. arg ( ca_file_arg ( ) )
}
2022-03-28 01:57:56 +00:00
fn permission_args ( app : Command ) -> Command {
2019-11-26 16:06:32 +00:00
app
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-read " )
2019-11-26 16:06:32 +00:00
. long ( " allow-read " )
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2019-11-26 16:06:32 +00:00
. require_equals ( true )
2022-03-14 18:41:35 +00:00
. help ( " Allow file system read access " )
. value_hint ( ValueHint ::AnyPath ) ,
2019-11-26 16:06:32 +00:00
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-write " )
2019-11-26 16:06:32 +00:00
. long ( " allow-write " )
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2019-11-26 16:06:32 +00:00
. require_equals ( true )
2022-03-14 18:41:35 +00:00
. help ( " Allow file system write access " )
. value_hint ( ValueHint ::AnyPath ) ,
2019-11-26 16:06:32 +00:00
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-net " )
2019-11-26 16:06:32 +00:00
. long ( " allow-net " )
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2019-11-26 16:06:32 +00:00
. require_equals ( true )
2020-06-26 12:09:02 +00:00
. help ( " Allow network access " )
2022-06-27 20:54:09 +00:00
. validator ( flags_allow_net ::validator ) ,
2019-11-26 16:06:32 +00:00
)
2022-01-14 16:38:17 +00:00
. arg ( unsafely_ignore_certificate_errors_arg ( ) )
2019-11-26 16:06:32 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-env " )
2019-11-26 16:06:32 +00:00
. long ( " allow-env " )
2021-04-13 11:25:21 +00:00
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-04-13 11:25:21 +00:00
. require_equals ( true )
. help ( " Allow environment access " )
. validator ( | keys | {
for key in keys . split ( ',' ) {
if key . is_empty ( ) | | key . contains ( & [ '=' , '\0' ] as & [ char ] ) {
2023-01-27 15:43:16 +00:00
return Err ( format! ( " invalid key \" {key} \" " ) ) ;
2021-04-13 11:25:21 +00:00
}
}
Ok ( ( ) )
} ) ,
2019-11-26 16:06:32 +00:00
)
2022-09-28 12:46:50 +00:00
. arg (
Arg ::new ( " allow-sys " )
. long ( " allow-sys " )
. min_values ( 0 )
. takes_value ( true )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Allow access to system info " )
. validator ( | keys | {
for key in keys . split ( ',' ) {
2022-09-29 10:34:16 +00:00
parse_sys_kind ( key ) ? ;
2022-09-28 12:46:50 +00:00
}
2022-09-29 10:34:16 +00:00
Ok ::< ( ) , AnyError > ( ( ) )
2022-09-28 12:46:50 +00:00
} ) ,
)
2019-11-26 16:06:32 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-run " )
2019-11-26 16:06:32 +00:00
. long ( " allow-run " )
2021-04-09 22:12:00 +00:00
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-04-09 22:12:00 +00:00
. require_equals ( true )
2019-11-26 16:06:32 +00:00
. help ( " Allow running subprocesses " ) ,
)
2019-12-05 20:30:20 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-ffi " )
2021-08-06 21:28:10 +00:00
. long ( " allow-ffi " )
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-08-06 21:28:10 +00:00
. require_equals ( true )
2022-03-14 18:41:35 +00:00
. help ( " Allow loading dynamic libraries " )
. value_hint ( ValueHint ::AnyPath ) ,
2019-12-05 20:30:20 +00:00
)
2019-11-26 16:06:32 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-hrtime " )
2019-11-26 16:06:32 +00:00
. long ( " allow-hrtime " )
. help ( " Allow high resolution time measurement " ) ,
)
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " allow-all " )
. short ( 'A' )
2019-11-26 16:06:32 +00:00
. long ( " allow-all " )
. help ( " Allow all permissions " ) ,
)
2022-04-11 05:01:02 +00:00
. arg ( Arg ::new ( " prompt " ) . long ( " prompt " ) . hide ( true ) . help (
2022-02-13 03:13:21 +00:00
" deprecated: Fallback to prompt if required permission wasn't passed " ,
) )
2021-04-12 02:15:43 +00:00
. arg (
2022-02-13 03:13:21 +00:00
Arg ::new ( " no-prompt " )
. long ( " no-prompt " )
. help ( " Always throw if required permission wasn't passed " ) ,
2021-04-12 02:15:43 +00:00
)
2020-01-30 23:42:39 +00:00
}
2022-03-28 01:57:56 +00:00
fn runtime_args (
app : Command ,
include_perms : bool ,
include_inspector : bool ,
) -> Command {
2021-04-16 13:28:41 +00:00
let app = compile_args ( app ) ;
let app = if include_perms {
permission_args ( app )
} else {
app
} ;
let app = if include_inspector {
inspect_args ( app )
} else {
app
} ;
app
. arg ( cached_only_arg ( ) )
. arg ( location_arg ( ) )
. arg ( v8_flags_arg ( ) )
. arg ( seed_arg ( ) )
2021-07-23 14:31:16 +00:00
. arg ( enable_testing_features_arg ( ) )
2021-04-16 13:28:41 +00:00
}
2022-03-28 01:57:56 +00:00
fn inspect_args ( app : Command ) -> Command {
2021-04-16 13:28:41 +00:00
app
2020-12-11 12:18:30 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " inspect " )
2021-04-16 13:28:41 +00:00
. long ( " inspect " )
2023-01-09 12:29:43 +00:00
. value_name ( " HOST_AND_PORT " )
2021-04-16 13:28:41 +00:00
. help ( " Activate inspector on host:port (default: 127.0.0.1:9229) " )
. min_values ( 0 )
. max_values ( 1 )
. require_equals ( true )
. takes_value ( true )
. validator ( inspect_arg_validate ) ,
2020-12-11 12:18:30 +00:00
)
2020-10-26 00:25:43 +00:00
. arg (
2022-01-14 16:38:17 +00:00
Arg ::new ( " inspect-brk " )
2021-04-16 13:28:41 +00:00
. long ( " inspect-brk " )
2023-01-09 12:29:43 +00:00
. value_name ( " HOST_AND_PORT " )
2021-04-16 13:28:41 +00:00
. help (
2022-12-12 14:33:30 +00:00
" Activate inspector on host:port, wait for debugger to connect and break at the start of user script " ,
)
. min_values ( 0 )
. max_values ( 1 )
. require_equals ( true )
. takes_value ( true )
. validator ( inspect_arg_validate ) ,
)
. arg (
Arg ::new ( " inspect-wait " )
. long ( " inspect-wait " )
2023-01-09 12:29:43 +00:00
. value_name ( " HOST_AND_PORT " )
2022-12-12 14:33:30 +00:00
. help (
" Activate inspector on host:port and wait for debugger to connect before running user code " ,
2021-04-16 13:28:41 +00:00
)
. min_values ( 0 )
. max_values ( 1 )
. require_equals ( true )
. takes_value ( true )
. validator ( inspect_arg_validate ) ,
2019-11-26 16:06:32 +00:00
)
2019-04-29 23:43:06 +00:00
}
2022-05-09 18:16:34 +00:00
static IMPORT_MAP_HELP : Lazy < String > = Lazy ::new ( | | {
format! (
" Load import map file from local file or remote URL.
Docs : https ://deno.land/manual@v{}/linking_to_external_code/import_maps
Specification : https ://wicg.github.io/import-maps/
Examples : https ://github.com/WICG/import-maps#the-import-map",
SHORT_VERSION . as_str ( )
)
} ) ;
2022-01-14 16:38:17 +00:00
fn import_map_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " import-map " )
2021-04-16 13:28:41 +00:00
. long ( " import-map " )
. alias ( " importmap " )
. value_name ( " FILE " )
. help ( " Load import map file " )
2022-05-09 18:16:34 +00:00
. long_help ( IMPORT_MAP_HELP . as_str ( ) )
2021-04-16 13:28:41 +00:00
. takes_value ( true )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn reload_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " reload " )
. short ( 'r' )
2021-04-16 13:28:41 +00:00
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-04-16 13:28:41 +00:00
. require_equals ( true )
. long ( " reload " )
. help ( " Reload source code cache (recompile TypeScript) " )
. value_name ( " CACHE_BLOCKLIST " )
. long_help (
" Reload source code cache (recompile TypeScript)
- - reload
Reload everything
- - reload = https ://deno.land/std
Reload only standard modules
- - reload = https ://deno.land/std/fs/utils.ts,https://deno.land/std/fmt/colors.ts
2022-09-22 14:39:58 +00:00
Reloads specific modules
- - reload = npm :
Reload all npm modules
- - reload = npm :chalk
Reload specific npm module " ,
2020-09-13 13:01:30 +00:00
)
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::FilePath )
2022-09-06 16:30:42 +00:00
. validator ( reload_arg_validate )
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn ca_file_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " cert " )
2021-04-16 13:28:41 +00:00
. long ( " cert " )
. value_name ( " FILE " )
. help ( " Load certificate authority from PEM encoded file " )
. takes_value ( true )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn cached_only_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " cached-only " )
2021-04-16 13:28:41 +00:00
. long ( " cached-only " )
. help ( " Require that remote dependencies are already cached " )
}
2022-01-14 16:38:17 +00:00
fn location_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " location " )
2021-04-16 13:28:41 +00:00
. long ( " location " )
. takes_value ( true )
. value_name ( " HREF " )
. validator ( | href | {
2022-01-14 16:38:17 +00:00
let url = Url ::parse ( href ) ;
2021-04-16 13:28:41 +00:00
if url . is_err ( ) {
return Err ( " Failed to parse URL " . to_string ( ) ) ;
}
let mut url = url . unwrap ( ) ;
if ! [ " http " , " https " ] . contains ( & url . scheme ( ) ) {
return Err ( " Expected protocol \" http \" or \" https \" " . to_string ( ) ) ;
}
url . set_username ( " " ) . unwrap ( ) ;
url . set_password ( None ) . unwrap ( ) ;
Ok ( ( ) )
} )
. help ( " Value of 'globalThis.location' used by some web APIs " )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::Url )
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn enable_testing_features_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " enable-testing-features-do-not-use " )
2021-07-23 14:31:16 +00:00
. long ( " enable-testing-features-do-not-use " )
. help ( " INTERNAL: Enable internal features used during integration testing " )
2022-01-14 16:38:17 +00:00
. hide ( true )
2021-07-23 14:31:16 +00:00
}
2022-01-14 16:38:17 +00:00
fn v8_flags_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " v8-flags " )
2021-04-16 13:28:41 +00:00
. long ( " v8-flags " )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-04-16 13:28:41 +00:00
. require_equals ( true )
2022-04-11 05:01:02 +00:00
. help ( " Set V8 command line options " )
2023-03-07 16:07:28 +00:00
. long_help ( " To see a list of all available flags use --v8-flags=--help. \
2023-01-25 04:03:03 +00:00
Any flags set with this flag are appended after the DENO_V8_FLAGS environmental variable " )
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn seed_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " seed " )
2021-04-16 13:28:41 +00:00
. long ( " seed " )
. value_name ( " NUMBER " )
2022-04-11 05:01:02 +00:00
. help ( " Set the random number generator seed " )
2021-04-16 13:28:41 +00:00
. takes_value ( true )
2022-01-14 16:38:17 +00:00
. validator ( | val | match val . parse ::< u64 > ( ) {
2021-04-16 13:28:41 +00:00
Ok ( _ ) = > Ok ( ( ) ) ,
Err ( _ ) = > Err ( " Seed should be a number " . to_string ( ) ) ,
} )
}
2022-01-14 16:38:17 +00:00
fn watch_arg < ' a > ( takes_files : bool ) -> Arg < ' a > {
let arg = Arg ::new ( " watch " )
2021-04-16 13:28:41 +00:00
. long ( " watch " )
2022-06-26 22:28:45 +00:00
. help ( " Watch for file changes and restart automatically " ) ;
2021-12-15 21:04:43 +00:00
if takes_files {
arg
. value_name ( " FILES " )
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-12-15 21:04:43 +00:00
. require_equals ( true )
. long_help (
2022-06-26 22:28:45 +00:00
" Watch for file changes and restart process automatically.
2021-12-15 21:04:43 +00:00
Local files from entry point module graph are watched by default .
Additional paths might be watched by passing them as arguments to this flag . " ,
)
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::AnyPath )
2021-12-15 21:04:43 +00:00
} else {
arg . long_help (
2022-06-26 22:28:45 +00:00
" Watch for file changes and restart process automatically. \
2022-04-11 05:01:02 +00:00
Only local files from entry point module graph are watched . " ,
2019-11-26 16:06:32 +00:00
)
2021-12-15 21:04:43 +00:00
}
2021-04-16 13:28:41 +00:00
}
2022-01-31 16:39:39 +00:00
fn no_clear_screen_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " no-clear-screen " )
. requires ( " watch " )
. long ( " no-clear-screen " )
. help ( " Do not clear terminal screen when under watch mode " )
}
2022-01-14 16:38:17 +00:00
fn no_check_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " no-check " )
2021-11-29 22:23:30 +00:00
. takes_value ( true )
. require_equals ( true )
. min_values ( 0 )
. value_name ( " NO_CHECK_TYPE " )
2021-04-16 13:28:41 +00:00
. long ( " no-check " )
2022-06-18 16:11:15 +00:00
. help ( " Skip type-checking modules " )
2021-11-29 22:23:30 +00:00
. long_help (
2022-04-11 05:01:02 +00:00
" Skip type-checking. If the value of '--no-check=remote' is supplied, \
diagnostic errors from remote modules will be ignored . " ,
2021-11-29 22:23:30 +00:00
)
2021-04-16 13:28:41 +00:00
}
2022-04-10 23:12:51 +00:00
fn check_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " check " )
. conflicts_with ( " no-check " )
. long ( " check " )
. takes_value ( true )
. require_equals ( true )
. min_values ( 0 )
. value_name ( " CHECK_TYPE " )
2022-06-18 16:11:15 +00:00
. help ( " Type-check modules " )
2022-04-10 23:12:51 +00:00
. long_help (
2022-06-18 16:11:15 +00:00
" Type-check modules.
Deno does not type - check modules automatically from v1 . 23 onwards . Pass this \
flag to enable type - checking or use the ' deno check ' subcommand .
2022-04-10 23:12:51 +00:00
If the value of ' - - check = all ' is supplied , diagnostic errors from remote modules
will be included . " ,
)
}
2022-01-14 16:38:17 +00:00
fn script_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " script_arg " )
. multiple_values ( true )
. multiple_occurrences ( true )
2021-04-16 13:28:41 +00:00
// NOTE: these defaults are provided
// so `deno run --v8-flags=--help` works
// without specifying file to run.
. default_value_ifs ( & [
2022-01-14 16:38:17 +00:00
( " v8-flags " , Some ( " --help " ) , Some ( " _ " ) ) ,
( " v8-flags " , Some ( " -help " ) , Some ( " _ " ) ) ,
2021-04-16 13:28:41 +00:00
] )
. help ( " Script arg " )
. value_name ( " SCRIPT_ARG " )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn lock_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " lock " )
2021-04-16 13:28:41 +00:00
. long ( " lock " )
. value_name ( " FILE " )
2022-11-02 15:32:30 +00:00
. help ( " Check the specified lock file. If value is not provided, defaults to \" deno.lock \" in the current working directory. " )
2021-04-16 13:28:41 +00:00
. takes_value ( true )
2022-11-02 15:32:30 +00:00
. min_values ( 0 )
. max_values ( 1 )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn lock_write_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " lock-write " )
2021-04-16 13:28:41 +00:00
. long ( " lock-write " )
2022-11-02 15:32:30 +00:00
. help ( " Force overwriting the lock file. " )
2023-03-13 21:04:00 +00:00
. conflicts_with ( " no-lock " )
2021-04-16 13:28:41 +00:00
}
2022-11-03 15:42:56 +00:00
fn no_lock_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " no-lock " )
. long ( " no-lock " )
. help ( " Disable auto discovery of the lock file. " )
. conflicts_with ( " lock " )
}
2022-05-09 18:16:34 +00:00
static CONFIG_HELP : Lazy < String > = Lazy ::new ( | | {
format! (
" The configuration file can be used to configure different aspects of \
deno including TypeScript , linting , and code formatting . Typically the \
configuration file will be called ` deno . json ` or ` deno . jsonc ` and \
automatically detected ; in that case this flag is not necessary . \
See https ://deno.land/manual@v{}/getting_started/configuration_file",
SHORT_VERSION . as_str ( )
)
} ) ;
2022-06-28 19:47:51 +00:00
fn config_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " config " )
. short ( 'c' )
. long ( " config " )
. value_name ( " FILE " )
. help ( " Specify the configuration file " )
. long_help ( CONFIG_HELP . as_str ( ) )
. takes_value ( true )
. value_hint ( ValueHint ::FilePath )
}
fn no_config_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " no-config " )
. long ( " no-config " )
. help ( " Disable automatic loading of the configuration file. " )
. conflicts_with ( " config " )
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn no_remote_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " no-remote " )
2021-04-16 13:28:41 +00:00
. long ( " no-remote " )
. help ( " Do not resolve remote modules " )
}
2022-09-07 13:33:51 +00:00
fn no_npm_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " no-npm " )
. long ( " no-npm " )
. help ( " Do not resolve npm modules " )
}
2022-09-22 15:17:02 +00:00
fn local_npm_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " node-modules-dir " )
. long ( " node-modules-dir " )
2023-02-20 18:14:06 +00:00
. min_values ( 0 )
. max_values ( 1 )
. takes_value ( true )
. require_equals ( true )
. possible_values ( [ " true " , " false " ] )
. help ( " Creates a local node_modules folder. This option is implicitly true when a package.json is auto-discovered. " )
2022-09-22 15:17:02 +00:00
}
2022-01-14 16:38:17 +00:00
fn unsafely_ignore_certificate_errors_arg < ' a > ( ) -> Arg < ' a > {
Arg ::new ( " unsafely-ignore-certificate-errors " )
2021-12-10 14:47:55 +00:00
. long ( " unsafely-ignore-certificate-errors " )
. min_values ( 0 )
. takes_value ( true )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-12-10 14:47:55 +00:00
. require_equals ( true )
. value_name ( " HOSTNAMES " )
. help ( " DANGER: Disables verification of TLS certificates " )
2022-06-27 20:54:09 +00:00
. validator ( flags_allow_net ::validator )
2021-12-10 14:47:55 +00:00
}
2022-03-11 22:07:02 +00:00
fn bench_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-06-13 21:13:16 +00:00
flags . type_check_mode = TypeCheckMode ::Local ;
2022-03-11 22:07:02 +00:00
runtime_args_parse ( flags , matches , true , false ) ;
// NOTE: `deno bench` always uses `--no-prompt`, tests shouldn't ever do
// interactive prompts, unless done by user code
flags . no_prompt = true ;
2023-02-12 17:40:45 +00:00
let json = matches . is_present ( " json " ) ;
2022-03-11 22:07:02 +00:00
let ignore = match matches . values_of ( " ignore " ) {
Some ( f ) = > f . map ( PathBuf ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let filter = matches . value_of ( " filter " ) . map ( String ::from ) ;
if matches . is_present ( " script_arg " ) {
let script_arg : Vec < String > = matches
. values_of ( " script_arg " )
. unwrap ( )
. map ( String ::from )
. collect ( ) ;
for v in script_arg {
flags . argv . push ( v ) ;
}
}
let include = if matches . is_present ( " files " ) {
2023-01-07 20:22:09 +00:00
let files = matches
2022-03-11 22:07:02 +00:00
. values_of ( " files " )
. unwrap ( )
2023-01-07 20:22:09 +00:00
. map ( PathBuf ::from )
2022-03-11 22:07:02 +00:00
. collect ( ) ;
2023-01-07 20:22:09 +00:00
files
2022-03-11 22:07:02 +00:00
} else {
2023-01-07 20:22:09 +00:00
Vec ::new ( )
2022-03-11 22:07:02 +00:00
} ;
watch_arg_parse ( flags , matches , false ) ;
flags . subcommand = DenoSubcommand ::Bench ( BenchFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags { include , ignore } ,
2022-03-11 22:07:02 +00:00
filter ,
2023-02-12 17:40:45 +00:00
json ,
2022-03-11 22:07:02 +00:00
} ) ;
}
2021-04-16 13:28:41 +00:00
fn bundle_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-06-13 21:13:16 +00:00
flags . type_check_mode = TypeCheckMode ::Local ;
2021-04-16 13:28:41 +00:00
compile_args_parse ( flags , matches ) ;
let source_file = matches . value_of ( " source_file " ) . unwrap ( ) . to_string ( ) ;
let out_file = if let Some ( out_file ) = matches . value_of ( " out_file " ) {
flags . allow_write = Some ( vec! [ ] ) ;
Some ( PathBuf ::from ( out_file ) )
} else {
None
} ;
2021-12-15 21:04:43 +00:00
watch_arg_parse ( flags , matches , false ) ;
2021-04-16 13:28:41 +00:00
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Bundle ( BundleFlags {
2021-04-16 13:28:41 +00:00
source_file ,
out_file ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
fn cache_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
compile_args_parse ( flags , matches ) ;
let files = matches
. values_of ( " file " )
. unwrap ( )
. map ( String ::from )
. collect ( ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Cache ( CacheFlags { files } ) ;
2021-04-16 13:28:41 +00:00
}
2022-04-10 23:12:51 +00:00
fn check_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-06-13 21:13:16 +00:00
flags . type_check_mode = TypeCheckMode ::Local ;
2023-03-13 21:04:00 +00:00
compile_args_without_check_parse ( flags , matches ) ;
2022-04-10 23:12:51 +00:00
let files = matches
. values_of ( " file " )
. unwrap ( )
. map ( String ::from )
. collect ( ) ;
2022-12-07 18:33:26 +00:00
if matches . is_present ( " all " ) | | matches . is_present ( " remote " ) {
2022-06-13 21:13:16 +00:00
flags . type_check_mode = TypeCheckMode ::All ;
}
flags . subcommand = DenoSubcommand ::Check ( CheckFlags { files } ) ;
2022-04-10 23:12:51 +00:00
}
2021-04-16 13:28:41 +00:00
fn compile_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-06-13 21:13:16 +00:00
flags . type_check_mode = TypeCheckMode ::Local ;
2021-04-16 13:28:41 +00:00
runtime_args_parse ( flags , matches , true , false ) ;
let mut script : Vec < String > = matches
. values_of ( " script_arg " )
. unwrap ( )
. map ( String ::from )
. collect ( ) ;
assert! ( ! script . is_empty ( ) ) ;
let args = script . split_off ( 1 ) ;
let source_file = script [ 0 ] . to_string ( ) ;
let output = matches . value_of ( " output " ) . map ( PathBuf ::from ) ;
let target = matches . value_of ( " target " ) . map ( String ::from ) ;
2023-03-18 23:43:07 +00:00
let include = match matches . values_of ( " include " ) {
Some ( f ) = > f . map ( String ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
2021-04-16 13:28:41 +00:00
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Compile ( CompileFlags {
2021-04-16 13:28:41 +00:00
source_file ,
output ,
args ,
target ,
2023-03-18 23:43:07 +00:00
include ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
2022-01-14 16:38:17 +00:00
fn completions_parse (
flags : & mut Flags ,
matches : & clap ::ArgMatches ,
2022-03-28 01:57:56 +00:00
mut app : clap ::Command ,
2022-01-14 16:38:17 +00:00
) {
use clap_complete ::generate ;
2023-01-15 04:18:58 +00:00
use clap_complete ::shells ::Bash ;
use clap_complete ::shells ::Fish ;
use clap_complete ::shells ::PowerShell ;
use clap_complete ::shells ::Zsh ;
2022-01-14 16:38:17 +00:00
use clap_complete_fig ::Fig ;
2021-04-16 13:28:41 +00:00
let mut buf : Vec < u8 > = vec! [ ] ;
2022-01-14 16:38:17 +00:00
let name = " deno " ;
match matches . value_of ( " shell " ) . unwrap ( ) {
" bash " = > generate ( Bash , & mut app , name , & mut buf ) ,
" fish " = > generate ( Fish , & mut app , name , & mut buf ) ,
" powershell " = > generate ( PowerShell , & mut app , name , & mut buf ) ,
" zsh " = > generate ( Zsh , & mut app , name , & mut buf ) ,
" fig " = > generate ( Fig , & mut app , name , & mut buf ) ,
_ = > unreachable! ( ) ,
}
2021-04-16 13:28:41 +00:00
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Completions ( CompletionsFlags {
2021-04-16 13:28:41 +00:00
buf : buf . into_boxed_slice ( ) ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
fn coverage_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
let files = match matches . values_of ( " files " ) {
Some ( f ) = > f . map ( PathBuf ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let ignore = match matches . values_of ( " ignore " ) {
Some ( f ) = > f . map ( PathBuf ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let include = match matches . values_of ( " include " ) {
Some ( f ) = > f . map ( String ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let exclude = match matches . values_of ( " exclude " ) {
Some ( f ) = > f . map ( String ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let lcov = matches . is_present ( " lcov " ) ;
2022-02-15 15:33:21 +00:00
let output = matches . value_of ( " output " ) . map ( PathBuf ::from ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Coverage ( CoverageFlags {
2023-01-13 21:56:29 +00:00
files : FileFlags {
include : files ,
ignore ,
} ,
2022-02-15 15:33:21 +00:00
output ,
2021-04-16 13:28:41 +00:00
include ,
exclude ,
lcov ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
fn doc_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
import_map_arg_parse ( flags , matches ) ;
reload_arg_parse ( flags , matches ) ;
2023-03-13 21:04:00 +00:00
lock_arg_parse ( flags , matches ) ;
no_lock_arg_parse ( flags , matches ) ;
no_npm_arg_parse ( flags , matches ) ;
no_remote_arg_parse ( flags , matches ) ;
2021-04-16 13:28:41 +00:00
2023-01-14 17:39:56 +00:00
let source_file = matches
. value_of ( " source_file " )
. map ( | value | {
if value = = " --builtin " {
DocSourceFileFlag ::Builtin
} else {
DocSourceFileFlag ::Path ( value . to_string ( ) )
}
} )
. unwrap_or_default ( ) ;
2021-04-16 13:28:41 +00:00
let private = matches . is_present ( " private " ) ;
let json = matches . is_present ( " json " ) ;
let filter = matches . value_of ( " filter " ) . map ( String ::from ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Doc ( DocFlags {
2021-04-16 13:28:41 +00:00
source_file ,
json ,
filter ,
private ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
fn eval_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
runtime_args_parse ( flags , matches , false , true ) ;
flags . allow_net = Some ( vec! [ ] ) ;
flags . allow_env = Some ( vec! [ ] ) ;
flags . allow_run = Some ( vec! [ ] ) ;
flags . allow_read = Some ( vec! [ ] ) ;
2022-09-28 12:46:50 +00:00
flags . allow_sys = Some ( vec! [ ] ) ;
2021-04-16 13:28:41 +00:00
flags . allow_write = Some ( vec! [ ] ) ;
2021-08-06 21:28:10 +00:00
flags . allow_ffi = Some ( vec! [ ] ) ;
2021-04-16 13:28:41 +00:00
flags . allow_hrtime = true ;
// TODO(@satyarohith): remove this flag in 2.0.
let as_typescript = matches . is_present ( " ts " ) ;
let ext = if as_typescript {
" ts " . to_string ( )
} else {
matches . value_of ( " ext " ) . unwrap ( ) . to_string ( )
} ;
let print = matches . is_present ( " print " ) ;
let mut code : Vec < String > = matches
. values_of ( " code_arg " )
. unwrap ( )
. map ( String ::from )
. collect ( ) ;
assert! ( ! code . is_empty ( ) ) ;
let code_args = code . split_off ( 1 ) ;
let code = code [ 0 ] . to_string ( ) ;
for v in code_args {
flags . argv . push ( v ) ;
}
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Eval ( EvalFlags { print , code , ext } ) ;
2021-04-16 13:28:41 +00:00
}
fn fmt_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-05-13 15:40:50 +00:00
config_args_parse ( flags , matches ) ;
2021-12-15 21:04:43 +00:00
watch_arg_parse ( flags , matches , false ) ;
2022-01-31 16:39:39 +00:00
2023-01-07 20:22:09 +00:00
let include = match matches . values_of ( " files " ) {
2021-04-16 13:28:41 +00:00
Some ( f ) = > f . map ( PathBuf ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let ignore = match matches . values_of ( " ignore " ) {
Some ( f ) = > f . map ( PathBuf ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let ext = matches . value_of ( " ext " ) . unwrap ( ) . to_string ( ) ;
2019-04-29 23:43:06 +00:00
2023-02-11 17:39:56 +00:00
let use_tabs = optional_bool_parse ( matches , " use-tabs " ) ;
let line_width = if matches . is_present ( " line-width " ) {
Some ( matches . value_of ( " line-width " ) . unwrap ( ) . parse ( ) . unwrap ( ) )
2021-09-13 20:06:45 +00:00
} else {
None
} ;
2023-02-11 17:39:56 +00:00
let indent_width = if matches . is_present ( " indent-width " ) {
2021-09-13 20:06:45 +00:00
Some (
matches
2023-02-11 17:39:56 +00:00
. value_of ( " indent-width " )
2023-01-25 20:06:00 +00:00
. unwrap_or ( " true " )
2021-09-13 20:06:45 +00:00
. parse ( )
. unwrap ( ) ,
)
} else {
None
} ;
2023-02-11 17:39:56 +00:00
let single_quote = optional_bool_parse ( matches , " single-quote " ) ;
let prose_wrap = matches . value_of ( " prose-wrap " ) . map ( ToString ::to_string ) ;
let no_semicolons = optional_bool_parse ( matches , " no-semicolons " ) ;
2021-09-13 20:06:45 +00:00
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Fmt ( FmtFlags {
2021-04-16 13:28:41 +00:00
check : matches . is_present ( " check " ) ,
ext ,
2023-01-07 20:22:09 +00:00
files : FileFlags { include , ignore } ,
2021-09-13 20:06:45 +00:00
use_tabs ,
line_width ,
indent_width ,
single_quote ,
prose_wrap ,
2023-01-25 20:06:00 +00:00
no_semicolons ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
2019-07-27 09:20:40 +00:00
2023-01-25 20:06:00 +00:00
fn optional_bool_parse ( matches : & ArgMatches , name : & str ) -> Option < bool > {
if matches . is_present ( name ) {
Some ( matches . value_of ( name ) . unwrap_or ( " true " ) . parse ( ) . unwrap ( ) )
} else {
None
}
}
2022-08-19 23:37:05 +00:00
fn init_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
flags . subcommand = DenoSubcommand ::Init ( InitFlags {
dir : matches . value_of ( " dir " ) . map ( | f | f . to_string ( ) ) ,
} ) ;
}
2021-04-16 13:28:41 +00:00
fn info_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
reload_arg_parse ( flags , matches ) ;
2022-06-13 18:09:04 +00:00
config_args_parse ( flags , matches ) ;
2021-04-16 13:28:41 +00:00
import_map_arg_parse ( flags , matches ) ;
2021-05-27 05:23:12 +00:00
location_arg_parse ( flags , matches ) ;
2021-04-16 13:28:41 +00:00
ca_file_arg_parse ( flags , matches ) ;
2022-10-28 20:19:55 +00:00
local_npm_args_parse ( flags , matches ) ;
2023-03-13 21:04:00 +00:00
lock_arg_parse ( flags , matches ) ;
no_lock_arg_parse ( flags , matches ) ;
no_remote_arg_parse ( flags , matches ) ;
no_npm_arg_parse ( flags , matches ) ;
2021-04-16 13:28:41 +00:00
let json = matches . is_present ( " json " ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Info ( InfoFlags {
2021-04-16 13:28:41 +00:00
file : matches . value_of ( " file " ) . map ( | f | f . to_string ( ) ) ,
json ,
2021-09-03 23:33:35 +00:00
} ) ;
2019-11-26 16:06:32 +00:00
}
2019-05-16 14:11:35 +00:00
2021-04-16 13:28:41 +00:00
fn install_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
runtime_args_parse ( flags , matches , true , true ) ;
2023-01-15 04:06:46 +00:00
let root = matches . value_of ( " root " ) . map ( PathBuf ::from ) ;
2021-04-16 13:28:41 +00:00
let force = matches . is_present ( " force " ) ;
let name = matches . value_of ( " name " ) . map ( | s | s . to_string ( ) ) ;
let cmd_values = matches . values_of ( " cmd " ) . unwrap ( ) ;
let mut cmd = vec! [ ] ;
for value in cmd_values {
cmd . push ( value . to_string ( ) ) ;
}
let module_url = cmd [ 0 ] . to_string ( ) ;
let args = cmd [ 1 .. ] . to_vec ( ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Install ( InstallFlags {
2021-04-16 13:28:41 +00:00
name ,
module_url ,
args ,
root ,
force ,
2021-09-03 23:33:35 +00:00
} ) ;
2020-01-08 19:59:53 +00:00
}
2021-09-30 15:38:07 +00:00
fn uninstall_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2023-01-15 04:06:46 +00:00
let root = matches . value_of ( " root " ) . map ( PathBuf ::from ) ;
2021-09-30 15:38:07 +00:00
let name = matches . value_of ( " name " ) . unwrap ( ) . to_string ( ) ;
flags . subcommand = DenoSubcommand ::Uninstall ( UninstallFlags { name , root } ) ;
}
2021-06-23 01:48:01 +00:00
fn lsp_parse ( flags : & mut Flags , _matches : & clap ::ArgMatches ) {
flags . subcommand = DenoSubcommand ::Lsp ;
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2021-04-16 13:28:41 +00:00
fn lint_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-05-13 15:40:50 +00:00
config_args_parse ( flags , matches ) ;
2021-12-15 21:04:43 +00:00
watch_arg_parse ( flags , matches , false ) ;
2021-04-16 13:28:41 +00:00
let files = match matches . values_of ( " files " ) {
Some ( f ) = > f . map ( PathBuf ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let ignore = match matches . values_of ( " ignore " ) {
Some ( f ) = > f . map ( PathBuf ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
let rules = matches . is_present ( " rules " ) ;
2021-11-04 15:12:12 +00:00
let maybe_rules_tags = matches
. values_of ( " rules-tags " )
. map ( | f | f . map ( String ::from ) . collect ( ) ) ;
let maybe_rules_include = matches
. values_of ( " rules-include " )
. map ( | f | f . map ( String ::from ) . collect ( ) ) ;
let maybe_rules_exclude = matches
. values_of ( " rules-exclude " )
. map ( | f | f . map ( String ::from ) . collect ( ) ) ;
2021-04-16 13:28:41 +00:00
let json = matches . is_present ( " json " ) ;
2022-09-28 16:47:48 +00:00
let compact = matches . is_present ( " compact " ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : files ,
ignore ,
} ,
2021-04-16 13:28:41 +00:00
rules ,
2021-11-04 15:12:12 +00:00
maybe_rules_tags ,
maybe_rules_include ,
maybe_rules_exclude ,
2023-01-07 20:22:09 +00:00
2021-04-16 13:28:41 +00:00
json ,
2022-09-28 16:47:48 +00:00
compact ,
2021-09-03 23:33:35 +00:00
} ) ;
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2021-04-16 13:28:41 +00:00
fn repl_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-12-07 19:21:18 +00:00
runtime_args_parse ( flags , matches , true , true ) ;
2022-01-14 16:38:17 +00:00
unsafely_ignore_certificate_errors_parse ( flags , matches ) ;
2022-04-20 12:16:37 +00:00
let eval_files : Option < Vec < String > > = matches
. values_of ( " eval-file " )
. map ( | values | values . map ( String ::from ) . collect ( ) ) ;
2022-01-14 16:38:17 +00:00
handle_repl_flags (
flags ,
ReplFlags {
2022-04-20 12:16:37 +00:00
eval_files ,
2022-01-14 16:38:17 +00:00
eval : matches . value_of ( " eval " ) . map ( ToOwned ::to_owned ) ,
2022-12-07 19:21:18 +00:00
is_default_command : false ,
2022-01-14 16:38:17 +00:00
} ,
) ;
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2021-04-16 13:28:41 +00:00
fn run_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
runtime_args_parse ( flags , matches , true , true ) ;
let mut script : Vec < String > = matches
. values_of ( " script_arg " )
. unwrap ( )
. map ( String ::from )
. collect ( ) ;
assert! ( ! script . is_empty ( ) ) ;
let script_args = script . split_off ( 1 ) ;
let script = script [ 0 ] . to_string ( ) ;
for v in script_args {
flags . argv . push ( v ) ;
}
2021-12-15 21:04:43 +00:00
watch_arg_parse ( flags , matches , true ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Run ( RunFlags { script } ) ;
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2022-04-27 19:43:36 +00:00
fn task_parse (
flags : & mut Flags ,
matches : & clap ::ArgMatches ,
raw_args : & [ String ] ,
) {
2022-06-28 19:47:51 +00:00
flags . config_flag = if let Some ( config ) = matches . value_of ( " config " ) {
ConfigFlag ::Path ( config . to_string ( ) )
} else {
ConfigFlag ::Discover
} ;
2022-03-11 01:56:14 +00:00
2022-06-08 21:30:16 +00:00
let mut task_flags = TaskFlags {
cwd : None ,
2023-02-23 03:45:35 +00:00
task : None ,
2022-06-08 21:30:16 +00:00
} ;
if let Some ( cwd ) = matches . value_of ( " cwd " ) {
task_flags . cwd = Some ( cwd . to_string ( ) ) ;
}
2022-05-11 16:58:35 +00:00
if let Some ( mut index ) = matches . index_of ( " task_name_and_args " ) {
2022-08-10 15:55:34 +00:00
let task_word_index = raw_args . iter ( ) . position ( | el | el = = " task " ) . unwrap ( ) ;
let raw_args = & raw_args [ task_word_index .. ] ;
2022-05-11 16:58:35 +00:00
// temporary workaround until https://github.com/clap-rs/clap/issues/1538 is fixed
while index < raw_args . len ( ) {
match raw_args [ index ] . as_str ( ) {
" -c " | " --config " = > {
2022-05-13 15:40:50 +00:00
flags . config_flag = ConfigFlag ::Path ( raw_args [ index + 1 ] . to_string ( ) ) ;
2022-05-11 16:58:35 +00:00
index + = 2 ;
}
2022-06-08 21:30:16 +00:00
" --cwd " = > {
task_flags . cwd = Some ( raw_args [ index + 1 ] . to_string ( ) ) ;
index + = 2 ;
}
2022-05-13 15:40:50 +00:00
" --no-config " = > {
flags . config_flag = ConfigFlag ::Disabled ;
index + = 1 ;
}
2022-05-11 16:58:35 +00:00
" -q " | " --quiet " = > {
flags . log_level = Some ( Level ::Error ) ;
index + = 1 ;
}
_ = > break ,
}
}
if index < raw_args . len ( ) {
2023-02-23 03:45:35 +00:00
task_flags . task = Some ( raw_args [ index ] . to_string ( ) ) ;
2022-05-11 16:58:35 +00:00
index + = 1 ;
2022-03-11 01:56:14 +00:00
2022-05-11 16:58:35 +00:00
if index < raw_args . len ( ) {
flags
. argv
. extend ( raw_args [ index .. ] . iter ( ) . map ( String ::from ) ) ;
}
2022-03-11 01:56:14 +00:00
}
}
2022-06-08 21:30:16 +00:00
flags . subcommand = DenoSubcommand ::Task ( task_flags ) ;
2022-03-11 01:56:14 +00:00
}
2021-04-16 13:28:41 +00:00
fn test_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-06-13 21:13:16 +00:00
flags . type_check_mode = TypeCheckMode ::Local ;
2021-04-16 13:28:41 +00:00
runtime_args_parse ( flags , matches , true , true ) ;
2022-02-26 13:49:50 +00:00
// NOTE: `deno test` always uses `--no-prompt`, tests shouldn't ever do
// interactive prompts, unless done by user code
flags . no_prompt = true ;
2021-04-16 13:28:41 +00:00
2021-08-24 15:23:29 +00:00
let ignore = match matches . values_of ( " ignore " ) {
Some ( f ) = > f . map ( PathBuf ::from ) . collect ( ) ,
None = > vec! [ ] ,
} ;
2021-04-16 13:28:41 +00:00
let no_run = matches . is_present ( " no-run " ) ;
2022-02-25 15:14:46 +00:00
let trace_ops = matches . is_present ( " trace-ops " ) ;
2021-05-10 23:54:39 +00:00
let doc = matches . is_present ( " doc " ) ;
2021-04-16 13:28:41 +00:00
let allow_none = matches . is_present ( " allow-none " ) ;
let filter = matches . value_of ( " filter " ) . map ( String ::from ) ;
2021-07-12 10:55:42 +00:00
let fail_fast = if matches . is_present ( " fail-fast " ) {
if let Some ( value ) = matches . value_of ( " fail-fast " ) {
Some ( value . parse ( ) . unwrap ( ) )
} else {
2021-08-23 10:37:02 +00:00
Some ( NonZeroUsize ::new ( 1 ) . unwrap ( ) )
2021-07-12 10:55:42 +00:00
}
} else {
None
} ;
2021-07-06 01:20:33 +00:00
let shuffle = if matches . is_present ( " shuffle " ) {
let value = if let Some ( value ) = matches . value_of ( " shuffle " ) {
value . parse ::< u64 > ( ) . unwrap ( )
} else {
rand ::random ::< u64 > ( )
} ;
Some ( value )
} else {
None
} ;
2021-05-10 06:06:13 +00:00
2021-04-16 13:28:41 +00:00
if matches . is_present ( " script_arg " ) {
let script_arg : Vec < String > = matches
. values_of ( " script_arg " )
. unwrap ( )
. map ( String ::from )
. collect ( ) ;
for v in script_arg {
flags . argv . push ( v ) ;
}
}
2022-07-20 21:36:54 +00:00
let concurrent_jobs = if matches . is_present ( " parallel " ) {
if let Ok ( value ) = env ::var ( " DENO_JOBS " ) {
2023-01-07 20:22:09 +00:00
value . parse ::< NonZeroUsize > ( ) . ok ( )
2021-04-28 18:17:04 +00:00
} else {
2023-01-07 20:22:09 +00:00
std ::thread ::available_parallelism ( ) . ok ( )
2021-04-28 18:17:04 +00:00
}
2022-07-20 21:36:54 +00:00
} else if matches . is_present ( " jobs " ) {
2022-12-09 15:54:24 +00:00
// We can't change this to use the log crate because its not configured
// yet at this point since the flags haven't been parsed. This flag is
// deprecated though so it's not worth changing the code to use the log
// crate here and this is only done for testing anyway.
eprintln! (
2022-07-20 21:36:54 +00:00
" {} " ,
crate ::colors ::yellow ( " Warning: --jobs flag is deprecated. Use the --parallel flag with possibly the 'DENO_JOBS' environment variable. " ) ,
) ;
if let Some ( value ) = matches . value_of ( " jobs " ) {
2023-01-07 20:22:09 +00:00
Some ( value . parse ( ) . unwrap ( ) )
2022-07-20 21:36:54 +00:00
} else {
2023-01-07 20:22:09 +00:00
std ::thread ::available_parallelism ( ) . ok ( )
2022-07-20 21:36:54 +00:00
}
2021-04-28 18:17:04 +00:00
} else {
2023-01-07 20:22:09 +00:00
None
2021-04-28 18:17:04 +00:00
} ;
2023-01-07 20:22:09 +00:00
let include = if matches . is_present ( " files " ) {
2022-07-18 19:12:19 +00:00
matches
2021-04-16 13:28:41 +00:00
. values_of ( " files " )
. unwrap ( )
2023-01-07 20:22:09 +00:00
. map ( PathBuf ::from )
2022-07-18 19:12:19 +00:00
. collect ::< Vec < _ > > ( )
2021-04-16 13:28:41 +00:00
} else {
2022-07-18 19:12:19 +00:00
Vec ::new ( )
2021-04-16 13:28:41 +00:00
} ;
flags . coverage_dir = matches . value_of ( " coverage " ) . map ( String ::from ) ;
2021-12-15 21:04:43 +00:00
watch_arg_parse ( flags , matches , false ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Test ( TestFlags {
2021-04-16 13:28:41 +00:00
no_run ,
2021-05-10 23:54:39 +00:00
doc ,
2021-04-16 13:28:41 +00:00
fail_fast ,
2023-01-07 20:22:09 +00:00
files : FileFlags { include , ignore } ,
2021-04-16 13:28:41 +00:00
filter ,
2021-07-06 01:20:33 +00:00
shuffle ,
2021-04-16 13:28:41 +00:00
allow_none ,
2021-04-28 18:17:04 +00:00
concurrent_jobs ,
2022-02-25 15:14:46 +00:00
trace_ops ,
2021-09-03 23:33:35 +00:00
} ) ;
2020-02-17 16:59:51 +00:00
}
2020-04-03 17:40:11 +00:00
2021-04-16 13:28:41 +00:00
fn types_parse ( flags : & mut Flags , _matches : & clap ::ArgMatches ) {
flags . subcommand = DenoSubcommand ::Types ;
2020-02-17 16:59:51 +00:00
}
2021-04-16 13:28:41 +00:00
fn upgrade_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
ca_file_arg_parse ( flags , matches ) ;
let dry_run = matches . is_present ( " dry-run " ) ;
let force = matches . is_present ( " force " ) ;
let canary = matches . is_present ( " canary " ) ;
let version = matches . value_of ( " version " ) . map ( | s | s . to_string ( ) ) ;
let output = if matches . is_present ( " output " ) {
let install_root = matches . value_of ( " output " ) . unwrap ( ) ;
Some ( PathBuf ::from ( install_root ) )
} else {
None
} ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Upgrade ( UpgradeFlags {
2021-04-16 13:28:41 +00:00
dry_run ,
force ,
canary ,
version ,
output ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-01-07 18:06:08 +00:00
}
2022-02-16 18:14:19 +00:00
fn vendor_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
ca_file_arg_parse ( flags , matches ) ;
2022-05-13 15:40:50 +00:00
config_args_parse ( flags , matches ) ;
2022-02-16 18:14:19 +00:00
import_map_arg_parse ( flags , matches ) ;
lock_arg_parse ( flags , matches ) ;
reload_arg_parse ( flags , matches ) ;
flags . subcommand = DenoSubcommand ::Vendor ( VendorFlags {
specifiers : matches
. values_of ( " specifiers " )
. map ( | p | p . map ( ToString ::to_string ) . collect ( ) )
. unwrap_or_default ( ) ,
output_path : matches . value_of ( " output " ) . map ( PathBuf ::from ) ,
force : matches . is_present ( " force " ) ,
} ) ;
}
2021-04-16 13:28:41 +00:00
fn compile_args_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2023-03-13 21:04:00 +00:00
compile_args_without_check_parse ( flags , matches ) ;
2021-04-16 13:28:41 +00:00
no_check_arg_parse ( flags , matches ) ;
2022-06-13 21:13:16 +00:00
check_arg_parse ( flags , matches ) ;
2021-01-07 18:06:08 +00:00
}
2023-03-13 21:04:00 +00:00
fn compile_args_without_check_parse (
2022-04-10 23:12:51 +00:00
flags : & mut Flags ,
matches : & clap ::ArgMatches ,
) {
import_map_arg_parse ( flags , matches ) ;
no_remote_arg_parse ( flags , matches ) ;
2022-09-07 13:33:51 +00:00
no_npm_arg_parse ( flags , matches ) ;
2022-09-22 15:17:02 +00:00
local_npm_args_parse ( flags , matches ) ;
2022-05-13 15:40:50 +00:00
config_args_parse ( flags , matches ) ;
2022-04-10 23:12:51 +00:00
reload_arg_parse ( flags , matches ) ;
lock_args_parse ( flags , matches ) ;
ca_file_arg_parse ( flags , matches ) ;
}
2021-04-16 13:28:41 +00:00
fn permission_args_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-01-14 16:38:17 +00:00
unsafely_ignore_certificate_errors_parse ( flags , matches ) ;
2021-04-16 13:28:41 +00:00
if let Some ( read_wl ) = matches . values_of ( " allow-read " ) {
let read_allowlist : Vec < PathBuf > = read_wl . map ( PathBuf ::from ) . collect ( ) ;
flags . allow_read = Some ( read_allowlist ) ;
}
if let Some ( write_wl ) = matches . values_of ( " allow-write " ) {
let write_allowlist : Vec < PathBuf > = write_wl . map ( PathBuf ::from ) . collect ( ) ;
flags . allow_write = Some ( write_allowlist ) ;
}
if let Some ( net_wl ) = matches . values_of ( " allow-net " ) {
let net_allowlist : Vec < String > =
2022-06-27 20:54:09 +00:00
flags_allow_net ::parse ( net_wl . map ( ToString ::to_string ) . collect ( ) )
2021-04-16 13:28:41 +00:00
. unwrap ( ) ;
flags . allow_net = Some ( net_allowlist ) ;
2021-08-09 14:53:21 +00:00
}
2021-04-16 13:28:41 +00:00
if let Some ( env_wl ) = matches . values_of ( " allow-env " ) {
let env_allowlist : Vec < String > = env_wl
. map ( | env : & str | {
if cfg! ( windows ) {
env . to_uppercase ( )
} else {
env . to_string ( )
}
} )
. collect ( ) ;
flags . allow_env = Some ( env_allowlist ) ;
debug! ( " env allowlist: {:#?} " , & flags . allow_env ) ;
}
if let Some ( run_wl ) = matches . values_of ( " allow-run " ) {
let run_allowlist : Vec < String > = run_wl . map ( ToString ::to_string ) . collect ( ) ;
flags . allow_run = Some ( run_allowlist ) ;
debug! ( " run allowlist: {:#?} " , & flags . allow_run ) ;
}
2022-09-28 12:46:50 +00:00
if let Some ( sys_wl ) = matches . values_of ( " allow-sys " ) {
let sys_allowlist : Vec < String > = sys_wl . map ( ToString ::to_string ) . collect ( ) ;
flags . allow_sys = Some ( sys_allowlist ) ;
debug! ( " sys info allowlist: {:#?} " , & flags . allow_sys ) ;
}
2021-08-06 21:28:10 +00:00
if let Some ( ffi_wl ) = matches . values_of ( " allow-ffi " ) {
2021-10-13 17:04:44 +00:00
let ffi_allowlist : Vec < PathBuf > = ffi_wl . map ( PathBuf ::from ) . collect ( ) ;
2021-08-06 21:28:10 +00:00
flags . allow_ffi = Some ( ffi_allowlist ) ;
debug! ( " ffi allowlist: {:#?} " , & flags . allow_ffi ) ;
2021-04-16 13:28:41 +00:00
}
2021-08-06 21:28:10 +00:00
2021-04-16 13:28:41 +00:00
if matches . is_present ( " allow-hrtime " ) {
flags . allow_hrtime = true ;
}
if matches . is_present ( " allow-all " ) {
2022-01-10 14:22:03 +00:00
flags . allow_all = true ;
2021-04-16 13:28:41 +00:00
flags . allow_read = Some ( vec! [ ] ) ;
flags . allow_env = Some ( vec! [ ] ) ;
flags . allow_net = Some ( vec! [ ] ) ;
flags . allow_run = Some ( vec! [ ] ) ;
flags . allow_write = Some ( vec! [ ] ) ;
2022-09-28 12:46:50 +00:00
flags . allow_sys = Some ( vec! [ ] ) ;
2021-08-06 21:28:10 +00:00
flags . allow_ffi = Some ( vec! [ ] ) ;
2021-04-16 13:28:41 +00:00
flags . allow_hrtime = true ;
}
2022-12-08 16:50:09 +00:00
if matches . is_present ( " no-prompt " ) {
2022-02-13 03:13:21 +00:00
flags . no_prompt = true ;
2021-04-16 13:28:41 +00:00
}
2020-03-27 20:09:51 +00:00
}
2022-01-14 16:38:17 +00:00
fn unsafely_ignore_certificate_errors_parse (
2021-12-10 14:47:55 +00:00
flags : & mut Flags ,
matches : & clap ::ArgMatches ,
) {
if let Some ( ic_wl ) = matches . values_of ( " unsafely-ignore-certificate-errors " ) {
let ic_allowlist : Vec < String > =
2022-06-27 20:54:09 +00:00
flags_allow_net ::parse ( ic_wl . map ( ToString ::to_string ) . collect ( ) ) . unwrap ( ) ;
2021-12-10 14:47:55 +00:00
flags . unsafely_ignore_certificate_errors = Some ( ic_allowlist ) ;
}
}
2023-03-13 21:04:00 +00:00
2021-04-16 13:28:41 +00:00
fn runtime_args_parse (
flags : & mut Flags ,
matches : & clap ::ArgMatches ,
include_perms : bool ,
include_inspector : bool ,
) {
compile_args_parse ( flags , matches ) ;
cached_only_arg_parse ( flags , matches ) ;
if include_perms {
permission_args_parse ( flags , matches ) ;
}
if include_inspector {
inspect_arg_parse ( flags , matches ) ;
2020-04-03 17:40:11 +00:00
}
2021-04-16 13:28:41 +00:00
location_arg_parse ( flags , matches ) ;
v8_flags_arg_parse ( flags , matches ) ;
seed_arg_parse ( flags , matches ) ;
2021-07-23 14:31:16 +00:00
enable_testing_features_arg_parse ( flags , matches ) ;
2020-04-03 17:40:11 +00:00
}
2020-03-27 20:09:51 +00:00
fn inspect_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2020-04-03 17:40:11 +00:00
let default = | | " 127.0.0.1:9229 " . parse ::< SocketAddr > ( ) . unwrap ( ) ;
2020-03-27 20:09:51 +00:00
flags . inspect = if matches . is_present ( " inspect " ) {
if let Some ( host ) = matches . value_of ( " inspect " ) {
2020-04-03 17:40:11 +00:00
Some ( host . parse ( ) . unwrap ( ) )
2020-03-27 20:09:51 +00:00
} else {
2020-04-03 17:40:11 +00:00
Some ( default ( ) )
2020-03-27 20:09:51 +00:00
}
} else {
None
} ;
flags . inspect_brk = if matches . is_present ( " inspect-brk " ) {
if let Some ( host ) = matches . value_of ( " inspect-brk " ) {
2020-04-03 17:40:11 +00:00
Some ( host . parse ( ) . unwrap ( ) )
2020-03-27 20:09:51 +00:00
} else {
2020-04-03 17:40:11 +00:00
Some ( default ( ) )
2020-03-27 20:09:51 +00:00
}
} else {
None
} ;
2022-12-12 14:33:30 +00:00
flags . inspect_wait = if matches . is_present ( " inspect-wait " ) {
if let Some ( host ) = matches . value_of ( " inspect-wait " ) {
Some ( host . parse ( ) . unwrap ( ) )
} else {
Some ( default ( ) )
}
} else {
None
} ;
2020-03-27 20:09:51 +00:00
}
2021-04-16 13:28:41 +00:00
fn import_map_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
flags . import_map_path = matches . value_of ( " import-map " ) . map ( ToOwned ::to_owned ) ;
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2020-02-26 10:52:15 +00:00
fn reload_arg_parse ( flags : & mut Flags , matches : & ArgMatches ) {
2020-05-16 13:41:32 +00:00
if let Some ( cache_bl ) = matches . values_of ( " reload " ) {
2020-06-13 17:09:39 +00:00
let raw_cache_blocklist : Vec < String > =
2020-11-12 22:17:31 +00:00
cache_bl . map ( ToString ::to_string ) . collect ( ) ;
2020-06-13 17:09:39 +00:00
if raw_cache_blocklist . is_empty ( ) {
2020-05-16 13:41:32 +00:00
flags . reload = true ;
} else {
2020-06-13 17:09:39 +00:00
flags . cache_blocklist = resolve_urls ( raw_cache_blocklist ) ;
debug! ( " cache blocklist: {:#?} " , & flags . cache_blocklist ) ;
2019-11-26 16:06:32 +00:00
flags . reload = false ;
2019-05-03 21:15:16 +00:00
}
2019-11-26 16:06:32 +00:00
}
}
2019-10-04 13:02:36 +00:00
2021-04-16 13:28:41 +00:00
fn ca_file_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2023-01-18 00:18:24 +00:00
flags . ca_data = matches
. value_of ( " cert " )
. map ( ToOwned ::to_owned )
. map ( CaData ::File ) ;
2019-11-26 16:06:32 +00:00
}
2019-10-04 13:02:36 +00:00
2021-07-23 14:31:16 +00:00
fn enable_testing_features_arg_parse (
flags : & mut Flags ,
matches : & clap ::ArgMatches ,
) {
if matches . is_present ( " enable-testing-features-do-not-use " ) {
flags . enable_testing_features = true
}
}
2021-04-16 13:28:41 +00:00
fn cached_only_arg_parse ( flags : & mut Flags , matches : & ArgMatches ) {
if matches . is_present ( " cached-only " ) {
flags . cached_only = true ;
}
2019-11-26 16:06:32 +00:00
}
2019-10-04 13:02:36 +00:00
2021-04-16 13:28:41 +00:00
fn location_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
flags . location = matches
. value_of ( " location " )
. map ( | href | Url ::parse ( href ) . unwrap ( ) ) ;
2019-11-27 04:25:14 +00:00
}
2020-02-26 10:52:15 +00:00
fn v8_flags_arg_parse ( flags : & mut Flags , matches : & ArgMatches ) {
2019-11-27 04:25:14 +00:00
if let Some ( v8_flags ) = matches . values_of ( " v8-flags " ) {
2020-12-06 17:19:21 +00:00
flags . v8_flags = v8_flags . map ( String ::from ) . collect ( ) ;
2019-11-27 04:25:14 +00:00
}
}
2020-09-18 17:09:11 +00:00
fn seed_arg_parse ( flags : & mut Flags , matches : & ArgMatches ) {
if matches . is_present ( " seed " ) {
let seed_string = matches . value_of ( " seed " ) . unwrap ( ) ;
let seed = seed_string . parse ::< u64 > ( ) . unwrap ( ) ;
flags . seed = Some ( seed ) ;
2023-01-27 15:43:16 +00:00
flags . v8_flags . push ( format! ( " --random-seed= {seed} " ) ) ;
2020-09-18 17:09:11 +00:00
}
}
2020-07-08 09:26:39 +00:00
fn no_check_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2021-11-29 22:23:30 +00:00
if let Some ( cache_type ) = matches . value_of ( " no-check " ) {
match cache_type {
2022-04-10 23:12:51 +00:00
" remote " = > flags . type_check_mode = TypeCheckMode ::Local ,
2021-11-29 22:23:30 +00:00
_ = > debug! (
" invalid value for 'no-check' of '{}' using default " ,
cache_type
) ,
}
} else if matches . is_present ( " no-check " ) {
2022-04-10 23:12:51 +00:00
flags . type_check_mode = TypeCheckMode ::None ;
}
}
fn check_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
if let Some ( cache_type ) = matches . value_of ( " check " ) {
match cache_type {
2022-06-13 21:13:16 +00:00
" all " = > flags . type_check_mode = TypeCheckMode ::All ,
2022-04-10 23:12:51 +00:00
_ = > debug! (
" invalid value for 'check' of '{}' using default " ,
cache_type
) ,
}
} else if matches . is_present ( " check " ) {
2022-06-13 21:13:16 +00:00
flags . type_check_mode = TypeCheckMode ::Local ;
2020-07-08 09:26:39 +00:00
}
}
2021-04-16 13:28:41 +00:00
fn lock_args_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2022-02-16 18:14:19 +00:00
lock_arg_parse ( flags , matches ) ;
2023-03-13 21:04:00 +00:00
no_lock_arg_parse ( flags , matches ) ;
2022-02-16 18:14:19 +00:00
if matches . is_present ( " lock-write " ) {
flags . lock_write = true ;
}
}
fn lock_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2021-04-16 13:28:41 +00:00
if matches . is_present ( " lock " ) {
2022-11-02 15:32:30 +00:00
let lockfile = if let Some ( path ) = matches . value_of ( " lock " ) {
path
} else {
" ./deno.lock "
} ;
2021-04-16 13:28:41 +00:00
flags . lock = Some ( PathBuf ::from ( lockfile ) ) ;
}
}
2023-03-13 21:04:00 +00:00
fn no_lock_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
if matches . is_present ( " no-lock " ) {
flags . no_lock = true ;
}
}
2022-05-13 15:40:50 +00:00
fn config_args_parse ( flags : & mut Flags , matches : & ArgMatches ) {
flags . config_flag = if matches . is_present ( " no-config " ) {
ConfigFlag ::Disabled
} else if let Some ( config ) = matches . value_of ( " config " ) {
ConfigFlag ::Path ( config . to_string ( ) )
} else {
ConfigFlag ::Discover
} ;
2019-12-03 22:48:53 +00:00
}
2020-02-26 10:52:15 +00:00
fn no_remote_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
2019-12-03 22:48:53 +00:00
if matches . is_present ( " no-remote " ) {
flags . no_remote = true ;
}
}
2022-09-07 13:33:51 +00:00
fn no_npm_arg_parse ( flags : & mut Flags , matches : & clap ::ArgMatches ) {
if matches . is_present ( " no-npm " ) {
flags . no_npm = true ;
}
}
2022-09-22 15:17:02 +00:00
fn local_npm_args_parse ( flags : & mut Flags , matches : & ArgMatches ) {
2023-02-20 18:14:06 +00:00
flags . node_modules_dir = optional_bool_parse ( matches , " node-modules-dir " ) ;
2022-09-22 15:17:02 +00:00
}
2022-01-14 16:38:17 +00:00
fn inspect_arg_validate ( val : & str ) -> Result < ( ) , String > {
2021-04-16 13:28:41 +00:00
match val . parse ::< SocketAddr > ( ) {
Ok ( _ ) = > Ok ( ( ) ) ,
Err ( e ) = > Err ( e . to_string ( ) ) ,
2021-04-12 02:15:43 +00:00
}
2020-01-30 23:42:39 +00:00
}
2022-09-06 16:30:42 +00:00
fn reload_arg_validate ( urlstr : & str ) -> Result < ( ) , String > {
if urlstr . is_empty ( ) {
return Err ( String ::from ( " Missing url. Check for extra commas. " ) ) ;
}
match Url ::from_str ( urlstr ) {
Ok ( _ ) = > Ok ( ( ) ) ,
Err ( e ) = > Err ( e . to_string ( ) ) ,
}
}
2021-12-15 21:04:43 +00:00
fn watch_arg_parse (
flags : & mut Flags ,
matches : & clap ::ArgMatches ,
allow_extra : bool ,
) {
if allow_extra {
if let Some ( f ) = matches . values_of ( " watch " ) {
flags . watch = Some ( f . map ( PathBuf ::from ) . collect ( ) ) ;
}
} else if matches . is_present ( " watch " ) {
flags . watch = Some ( vec! [ ] ) ;
}
2022-01-31 16:39:39 +00:00
if matches . is_present ( " no-clear-screen " ) {
flags . no_clear_screen = true ;
}
2021-12-15 21:04:43 +00:00
}
2019-11-26 16:06:32 +00:00
// TODO(ry) move this to utility module and add test.
/// Strips fragment part of URL. Panics on bad URL.
pub fn resolve_urls ( urls : Vec < String > ) -> Vec < String > {
let mut out : Vec < String > = vec! [ ] ;
for urlstr in urls . iter ( ) {
2020-11-12 22:17:31 +00:00
if let Ok ( mut url ) = Url ::from_str ( urlstr ) {
url . set_fragment ( None ) ;
let mut full_url = String ::from ( url . as_str ( ) ) ;
if full_url . len ( ) > 1 & & full_url . ends_with ( '/' ) {
full_url . pop ( ) ;
}
out . push ( full_url ) ;
} else {
2023-01-27 15:43:16 +00:00
panic! ( " Bad Url: {urlstr} " ) ;
2019-06-05 17:44:46 +00:00
}
2019-11-26 16:06:32 +00:00
}
out
2019-04-29 23:43:06 +00:00
}
2019-11-26 16:06:32 +00:00
#[ cfg(test) ]
mod tests {
use super ::* ;
2022-04-27 19:43:36 +00:00
use pretty_assertions ::assert_eq ;
2019-11-26 16:06:32 +00:00
2020-12-06 17:19:21 +00:00
/// Creates vector of strings, Vec<String>
macro_rules ! svec {
2022-02-16 18:14:19 +00:00
( $( $x :expr ) , * $(, ) ? ) = > ( vec! [ $( $x . to_string ( ) ) , * ] ) ;
}
2020-12-06 17:19:21 +00:00
2020-09-20 11:45:00 +00:00
#[ test ]
fn global_flags ( ) {
#[ rustfmt::skip ]
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " --unstable " , " --log-level " , " debug " , " --quiet " , " run " , " script.ts " ] ) ;
2023-01-07 20:22:09 +00:00
2020-09-20 11:45:00 +00:00
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-09-20 11:45:00 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-09-20 11:45:00 +00:00
unstable : true ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
#[ rustfmt::skip ]
2021-01-07 18:06:08 +00:00
let r2 = flags_from_vec ( svec! [ " deno " , " run " , " --unstable " , " --log-level " , " debug " , " --quiet " , " script.ts " ] ) ;
2020-09-20 11:45:00 +00:00
let flags2 = r2 . unwrap ( ) ;
assert_eq! ( flags2 , flags ) ;
}
2020-03-23 15:37:24 +00:00
#[ test ]
fn upgrade ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " upgrade " , " --dry-run " , " --force " ] ) ;
2020-03-23 15:37:24 +00:00
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Upgrade ( UpgradeFlags {
2020-03-23 15:37:24 +00:00
force : true ,
dry_run : true ,
2020-11-29 19:00:35 +00:00
canary : false ,
2020-07-06 03:58:23 +00:00
version : None ,
2020-07-06 22:21:26 +00:00
output : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-03-23 15:37:24 +00:00
.. Flags ::default ( )
}
) ;
}
2019-11-26 16:06:32 +00:00
#[ test ]
fn version ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " --version " ] ) ;
2022-03-28 01:57:56 +00:00
assert_eq! ( r . unwrap_err ( ) . kind ( ) , clap ::ErrorKind ::DisplayVersion ) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " -V " ] ) ;
2022-03-28 01:57:56 +00:00
assert_eq! ( r . unwrap_err ( ) . kind ( ) , clap ::ErrorKind ::DisplayVersion ) ;
2019-04-21 15:34:18 +00:00
}
2018-08-24 19:26:40 +00:00
2019-04-21 15:34:18 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn run_reload ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " -r " , " script.ts " ] ) ;
2019-11-26 16:06:32 +00:00
let flags = r . unwrap ( ) ;
2019-04-21 15:34:18 +00:00
assert_eq! (
flags ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2019-04-21 15:34:18 +00:00
reload : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
) ;
}
2018-10-11 21:23:22 +00:00
2020-09-11 16:19:49 +00:00
#[ test ]
fn run_watch ( ) {
2021-04-27 10:44:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --watch " , " script.ts " ] ) ;
2020-09-11 16:19:49 +00:00
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-09-11 16:19:49 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-12-15 21:04:43 +00:00
watch : Some ( vec! [ ] ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn run_watch_with_external ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --watch=file1,file2 " , " script.ts " ] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
watch : Some ( vec! [ PathBuf ::from ( " file1 " ) , PathBuf ::from ( " file2 " ) ] ) ,
2020-09-11 16:19:49 +00:00
.. Flags ::default ( )
}
) ;
}
2022-01-31 16:39:39 +00:00
#[ test ]
fn run_watch_with_no_clear_screen ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --watch " ,
" --no-clear-screen " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
watch : Some ( vec! [ ] ) ,
no_clear_screen : true ,
.. Flags ::default ( )
}
) ;
}
2019-04-21 15:34:18 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn run_reload_allow_write ( ) {
2021-01-07 18:06:08 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " run " , " -r " , " --allow-write " , " script.ts " ] ) ;
2019-04-21 15:34:18 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2019-04-21 15:34:18 +00:00
reload : true ,
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
) ;
}
2018-10-15 18:26:22 +00:00
2019-04-21 15:34:18 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn run_v8_flags ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --v8-flags=--help " ] ) ;
2019-04-21 15:34:18 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-11-21 22:33:42 +00:00
script : " _ " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --help " ] ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
) ;
2019-01-09 16:59:54 +00:00
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-05-03 21:15:16 +00:00
" deno " ,
" run " ,
2019-11-26 16:06:32 +00:00
" --v8-flags=--expose-gc,--gc-stats=1 " ,
2019-05-03 21:15:16 +00:00
" script.ts "
] ) ;
2019-04-21 15:34:18 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --expose-gc " , " --gc-stats=1 " ] ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
) ;
}
2022-11-24 03:00:31 +00:00
#[ test ]
fn has_permission ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-read " , " x.ts " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission ( ) , true ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " x.ts " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission ( ) , false ) ;
}
#[ test ]
fn has_permission_in_argv ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " x.ts " , " --allow-read " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission_in_argv ( ) , true ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " x.ts " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission_in_argv ( ) , false ) ;
}
2019-04-21 15:34:18 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn script_args ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-05-03 21:15:16 +00:00
" deno " ,
" run " ,
" --allow-net " ,
" gist.ts " ,
" --title " ,
" X "
] ) ;
2019-04-21 15:34:18 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " gist.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-04 19:24:33 +00:00
argv : svec ! [ " --title " , " X " ] ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
2019-04-29 23:43:06 +00:00
) ;
2019-04-21 15:34:18 +00:00
}
#[ test ]
2019-11-26 16:06:32 +00:00
fn allow_all ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-all " , " gist.ts " ] ) ;
2019-04-21 15:34:18 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " gist.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-01-10 14:22:03 +00:00
allow_all : true ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 22:12:00 +00:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 12:46:50 +00:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 21:28:10 +00:00
allow_ffi : Some ( vec! [ ] ) ,
2019-05-23 16:28:29 +00:00
allow_hrtime : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
2019-04-29 23:43:06 +00:00
) ;
2019-04-21 15:34:18 +00:00
}
#[ test ]
2019-11-26 16:06:32 +00:00
fn allow_read ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-read " , " gist.ts " ] ) ;
2019-04-21 15:34:18 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " gist.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
2019-04-29 23:43:06 +00:00
) ;
2019-04-21 15:34:18 +00:00
}
#[ test ]
2019-11-26 16:06:32 +00:00
fn allow_hrtime ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-hrtime " , " gist.ts " ] ) ;
2019-04-21 15:34:18 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " gist.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2019-05-23 16:28:29 +00:00
allow_hrtime : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
2019-04-29 23:43:06 +00:00
) ;
2019-04-21 15:34:18 +00:00
}
2019-04-08 20:22:40 +00:00
2019-04-21 15:34:18 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn double_hyphen ( ) {
2019-06-29 22:32:54 +00:00
// notice that flags passed after double dash will not
2020-02-26 10:52:15 +00:00
// be parsed to Flags but instead forwarded to
2019-04-21 15:34:18 +00:00
// script args as Deno.args
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-04-21 15:34:18 +00:00
" deno " ,
2019-05-03 21:15:16 +00:00
" run " ,
2019-04-21 15:34:18 +00:00
" --allow-write " ,
" script.ts " ,
2019-06-29 22:32:54 +00:00
" -- " ,
2019-04-21 15:34:18 +00:00
" -D " ,
" --allow-net "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-04 19:24:33 +00:00
argv : svec ! [ " -- " , " -D " , " --allow-net " ] ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
2019-04-29 23:43:06 +00:00
) ;
}
#[ test ]
2019-11-26 16:06:32 +00:00
fn fmt ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " fmt " , " script_1.ts " , " script_2.ts " ] ) ;
2019-04-29 23:43:06 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-01-30 02:16:48 +00:00
check : false ,
2021-09-13 20:06:45 +00:00
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [
PathBuf ::from ( " script_1.ts " ) ,
PathBuf ::from ( " script_2.ts " )
] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 20:06:45 +00:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 20:06:00 +00:00
no_semicolons : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2020-01-30 02:16:48 +00:00
}
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " fmt " , " --check " ] ) ;
2020-01-30 02:16:48 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-01-30 02:16:48 +00:00
check : true ,
2021-01-19 17:39:35 +00:00
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 20:06:45 +00:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 20:06:00 +00:00
no_semicolons : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-29 23:43:06 +00:00
}
) ;
2020-02-09 10:19:05 +00:00
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " fmt " ] ) ;
2020-02-09 10:19:05 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-02-09 10:19:05 +00:00
check : false ,
2021-01-19 17:39:35 +00:00
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 20:06:45 +00:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 20:06:00 +00:00
no_semicolons : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2020-02-09 10:19:05 +00:00
}
) ;
2020-11-22 20:45:44 +00:00
2021-04-27 10:44:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " fmt " , " --watch " ] ) ;
2020-11-22 20:45:44 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-11-22 20:45:44 +00:00
check : false ,
2021-01-19 17:39:35 +00:00
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 20:06:45 +00:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 20:06:00 +00:00
no_semicolons : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-12-15 21:04:43 +00:00
watch : Some ( vec! [ ] ) ,
2020-11-22 20:45:44 +00:00
.. Flags ::default ( )
}
) ;
2022-01-31 16:39:39 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " fmt " , " --watch " , " --no-clear-screen " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2022-01-31 16:39:39 +00:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 20:06:00 +00:00
no_semicolons : None ,
2022-01-31 16:39:39 +00:00
} ) ,
watch : Some ( vec! [ ] ) ,
no_clear_screen : true ,
.. Flags ::default ( )
}
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-11-22 20:45:44 +00:00
" deno " ,
" fmt " ,
" --check " ,
" --watch " ,
" foo.ts " ,
" --ignore=bar.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
2020-11-22 20:45:44 +00:00
check : true ,
2021-01-19 17:39:35 +00:00
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " foo.ts " ) ] ,
ignore : vec ! [ PathBuf ::from ( " bar.js " ) ] ,
} ,
2021-09-13 20:06:45 +00:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 20:06:00 +00:00
no_semicolons : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-12-15 21:04:43 +00:00
watch : Some ( vec! [ ] ) ,
2021-09-13 18:19:10 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " fmt " , " --config " , " deno.jsonc " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
2021-09-13 20:06:45 +00:00
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 20:06:45 +00:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 20:06:00 +00:00
no_semicolons : None ,
2021-09-13 18:19:10 +00:00
} ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2021-09-13 18:19:10 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" fmt " ,
" --config " ,
" deno.jsonc " ,
" --watch " ,
" foo.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
2021-09-13 20:06:45 +00:00
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " foo.ts " ) ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 20:06:45 +00:00
use_tabs : None ,
line_width : None ,
indent_width : None ,
single_quote : None ,
prose_wrap : None ,
2023-01-25 20:06:00 +00:00
no_semicolons : None ,
2021-09-13 18:19:10 +00:00
} ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2021-12-15 21:04:43 +00:00
watch : Some ( vec! [ ] ) ,
2020-11-22 20:45:44 +00:00
.. Flags ::default ( )
}
) ;
2021-09-13 20:06:45 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" fmt " ,
2023-02-11 17:39:56 +00:00
" --use-tabs " ,
" --line-width " ,
2021-09-13 20:06:45 +00:00
" 60 " ,
2023-02-11 17:39:56 +00:00
" --indent-width " ,
2021-09-13 20:06:45 +00:00
" 4 " ,
2023-02-11 17:39:56 +00:00
" --single-quote " ,
" --prose-wrap " ,
2023-01-24 20:07:00 +00:00
" never " ,
2023-02-11 17:39:56 +00:00
" --no-semicolons " ,
2021-09-13 20:06:45 +00:00
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
ext : " ts " . to_string ( ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-13 20:06:45 +00:00
use_tabs : Some ( true ) ,
line_width : Some ( NonZeroU32 ::new ( 60 ) . unwrap ( ) ) ,
indent_width : Some ( NonZeroU8 ::new ( 4 ) . unwrap ( ) ) ,
single_quote : Some ( true ) ,
prose_wrap : Some ( " never " . to_string ( ) ) ,
2023-01-25 20:06:00 +00:00
no_semicolons : Some ( true ) ,
} ) ,
.. Flags ::default ( )
}
) ;
// try providing =false to the booleans
let r = flags_from_vec ( svec! [
" deno " ,
" fmt " ,
2023-02-11 17:39:56 +00:00
" --use-tabs=false " ,
" --single-quote=false " ,
" --no-semicolons=false " ,
2023-01-25 20:06:00 +00:00
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Fmt ( FmtFlags {
check : false ,
ext : " ts " . to_string ( ) ,
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
use_tabs : Some ( false ) ,
line_width : None ,
indent_width : None ,
single_quote : Some ( false ) ,
prose_wrap : None ,
no_semicolons : Some ( false ) ,
2021-09-13 20:06:45 +00:00
} ) ,
.. Flags ::default ( )
}
) ;
2019-04-29 23:43:06 +00:00
}
2020-06-10 21:29:48 +00:00
#[ test ]
fn lint ( ) {
2021-04-27 10:44:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " lint " , " script_1.ts " , " script_2.ts " ] ) ;
2020-06-10 21:29:48 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [
PathBuf ::from ( " script_1.ts " ) ,
PathBuf ::from ( " script_2.ts " )
] ,
ignore : vec ! [ ] ,
} ,
2020-06-12 14:42:12 +00:00
rules : false ,
2021-11-04 15:12:12 +00:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2020-08-13 15:30:46 +00:00
json : false ,
2022-09-28 16:47:48 +00:00
compact : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-06-10 21:29:48 +00:00
.. Flags ::default ( )
}
) ;
2022-01-31 16:39:39 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --watch " ,
" script_1.ts " ,
" script_2.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [
PathBuf ::from ( " script_1.ts " ) ,
PathBuf ::from ( " script_2.ts " )
] ,
ignore : vec ! [ ] ,
} ,
2022-01-31 16:39:39 +00:00
rules : false ,
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
json : false ,
2022-09-28 16:47:48 +00:00
compact : false ,
2022-01-31 16:39:39 +00:00
} ) ,
watch : Some ( vec! [ ] ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --watch " ,
" --no-clear-screen " ,
" script_1.ts " ,
" script_2.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [
PathBuf ::from ( " script_1.ts " ) ,
PathBuf ::from ( " script_2.ts " )
] ,
ignore : vec ! [ ] ,
} ,
2022-01-31 16:39:39 +00:00
rules : false ,
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
json : false ,
2022-09-28 16:47:48 +00:00
compact : false ,
2022-01-31 16:39:39 +00:00
} ) ,
watch : Some ( vec! [ ] ) ,
no_clear_screen : true ,
.. Flags ::default ( )
}
) ;
2021-04-27 10:44:36 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " lint " , " --ignore=script_1.ts,script_2.ts " ] ) ;
2020-06-10 21:29:48 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [
PathBuf ::from ( " script_1.ts " ) ,
PathBuf ::from ( " script_2.ts " )
] ,
} ,
2020-06-12 14:42:12 +00:00
rules : false ,
2021-11-04 15:12:12 +00:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2020-08-13 15:30:46 +00:00
json : false ,
2022-09-28 16:47:48 +00:00
compact : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-06-12 14:42:12 +00:00
.. Flags ::default ( )
}
) ;
2021-04-27 10:44:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " lint " , " --rules " ] ) ;
2020-06-12 14:42:12 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2020-08-12 13:47:44 +00:00
rules : true ,
2021-11-04 15:12:12 +00:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2021-09-03 15:01:58 +00:00
json : false ,
2022-09-28 16:47:48 +00:00
compact : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-09-03 15:01:58 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --rules-tags= " ,
" --rules-include=ban-untagged-todo,no-undef " ,
" --rules-exclude=no-const-assign "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2021-09-03 15:01:58 +00:00
rules : false ,
2021-11-04 15:12:12 +00:00
maybe_rules_tags : Some ( svec! [ " " ] ) ,
maybe_rules_include : Some ( svec! [ " ban-untagged-todo " , " no-undef " ] ) ,
maybe_rules_exclude : Some ( svec! [ " no-const-assign " ] ) ,
2020-08-13 15:30:46 +00:00
json : false ,
2022-09-28 16:47:48 +00:00
compact : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-08-13 15:30:46 +00:00
.. Flags ::default ( )
}
) ;
2021-04-27 10:44:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " lint " , " --json " , " script_1.ts " ] ) ;
2020-08-13 15:30:46 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " script_1.ts " ) ] ,
ignore : vec ! [ ] ,
} ,
2020-08-13 15:30:46 +00:00
rules : false ,
2021-11-04 15:12:12 +00:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2021-09-03 15:01:58 +00:00
json : true ,
2022-09-28 16:47:48 +00:00
compact : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-09-03 15:01:58 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --config " ,
" Deno.jsonc " ,
" --json " ,
" script_1.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " script_1.ts " ) ] ,
ignore : vec ! [ ] ,
} ,
2021-09-03 15:01:58 +00:00
rules : false ,
2021-11-04 15:12:12 +00:00
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
2020-08-13 15:30:46 +00:00
json : true ,
2022-09-28 16:47:48 +00:00
compact : false ,
} ) ,
config_flag : ConfigFlag ::Path ( " Deno.jsonc " . to_string ( ) ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --config " ,
" Deno.jsonc " ,
" --compact " ,
" script_1.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Lint ( LintFlags {
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " script_1.ts " ) ] ,
ignore : vec ! [ ] ,
} ,
2022-09-28 16:47:48 +00:00
rules : false ,
maybe_rules_tags : None ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
json : false ,
compact : true ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " Deno.jsonc " . to_string ( ) ) ,
2020-06-10 21:29:48 +00:00
.. Flags ::default ( )
}
) ;
}
2019-04-29 23:43:06 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn types ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " types " ] ) ;
2019-11-26 16:06:32 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2019-11-26 16:06:32 +00:00
subcommand : DenoSubcommand ::Types ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-11-26 16:06:32 +00:00
}
) ;
2019-04-29 23:43:06 +00:00
}
#[ test ]
2020-04-07 15:24:47 +00:00
fn cache ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " cache " , " script.ts " ] ) ;
2019-11-26 16:06:32 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Cache ( CacheFlags {
2020-02-04 19:24:33 +00:00
files : svec ! [ " script.ts " ] ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-11-26 16:06:32 +00:00
}
) ;
2019-04-29 23:43:06 +00:00
}
2022-04-10 23:12:51 +00:00
#[ test ]
fn check ( ) {
let r = flags_from_vec ( svec! [ " deno " , " check " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Check ( CheckFlags {
files : svec ! [ " script.ts " ] ,
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-04-10 23:12:51 +00:00
.. Flags ::default ( )
}
) ;
2022-12-07 18:33:26 +00:00
for all_flag in [ " --remote " , " --all " ] {
let r = flags_from_vec ( svec! [ " deno " , " check " , all_flag , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Check ( CheckFlags {
files : svec ! [ " script.ts " ] ,
} ) ,
type_check_mode : TypeCheckMode ::All ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" check " ,
all_flag ,
" --no-remote " ,
" script.ts "
] ) ;
assert_eq! ( r . unwrap_err ( ) . kind ( ) , clap ::ErrorKind ::ArgumentConflict ) ;
}
2022-04-10 23:12:51 +00:00
}
2019-04-29 23:43:06 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn info ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " info " , " script.ts " ] ) ;
2019-11-26 16:06:32 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 14:50:12 +00:00
json : false ,
file : Some ( " script.ts " . to_string ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-07-08 14:50:12 +00:00
.. Flags ::default ( )
}
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " info " , " --reload " , " script.ts " ] ) ;
2020-08-12 10:58:50 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-08-12 10:58:50 +00:00
json : false ,
file : Some ( " script.ts " . to_string ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-08-12 10:58:50 +00:00
reload : true ,
.. Flags ::default ( )
}
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " info " , " --json " , " script.ts " ] ) ;
2020-07-08 14:50:12 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 14:50:12 +00:00
json : true ,
2020-02-04 19:24:33 +00:00
file : Some ( " script.ts " . to_string ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-11-26 16:06:32 +00:00
}
) ;
2019-08-12 00:43:01 +00:00
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " info " ] ) ;
2019-11-26 16:06:32 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 14:50:12 +00:00
json : false ,
file : None
2021-09-03 23:33:35 +00:00
} ) ,
2020-07-08 14:50:12 +00:00
.. Flags ::default ( )
}
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " info " , " --json " ] ) ;
2020-07-08 14:50:12 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 14:50:12 +00:00
json : true ,
file : None
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-11-26 16:06:32 +00:00
}
) ;
2022-06-13 18:09:04 +00:00
2023-03-13 21:04:00 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" info " ,
" --no-npm " ,
" --no-remote " ,
" --config " ,
" tsconfig.json "
] ) ;
2022-06-13 18:09:04 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Info ( InfoFlags {
json : false ,
file : None
} ) ,
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2023-03-13 21:04:00 +00:00
no_npm : true ,
no_remote : true ,
2022-06-13 18:09:04 +00:00
.. Flags ::default ( )
}
) ;
2019-04-21 15:34:18 +00:00
}
2019-04-29 14:58:31 +00:00
2019-05-03 20:24:09 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn tsconfig ( ) {
2021-01-07 18:06:08 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " run " , " -c " , " tsconfig.json " , " script.ts " ] ) ;
2019-05-03 21:15:16 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-05-03 21:15:16 +00:00
}
) ;
}
#[ test ]
2019-11-26 16:06:32 +00:00
fn eval ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " eval " , " 'console.log( \" hello \" )' " ] ) ;
2019-05-03 21:15:16 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-05-21 14:35:36 +00:00
print : false ,
2020-02-04 19:24:33 +00:00
code : " 'console.log( \" hello \" )' " . to_string ( ) ,
2021-02-21 16:58:32 +00:00
ext : " js " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 22:12:00 +00:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 12:46:50 +00:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 21:28:10 +00:00
allow_ffi : Some ( vec! [ ] ) ,
2020-02-28 14:17:56 +00:00
allow_hrtime : true ,
.. Flags ::default ( )
}
) ;
}
2020-05-21 14:35:36 +00:00
#[ test ]
fn eval_p ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " eval " , " -p " , " 1+2 " ] ) ;
2020-05-21 14:35:36 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-05-21 14:35:36 +00:00
print : true ,
code : " 1+2 " . to_string ( ) ,
2021-02-21 16:58:32 +00:00
ext : " js " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 22:12:00 +00:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 12:46:50 +00:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 21:28:10 +00:00
allow_ffi : Some ( vec! [ ] ) ,
2020-05-21 14:35:36 +00:00
allow_hrtime : true ,
.. Flags ::default ( )
}
) ;
}
2020-02-28 14:17:56 +00:00
#[ test ]
fn eval_typescript ( ) {
2021-01-07 18:06:08 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " eval " , " -T " , " 'console.log( \" hello \" )' " ] ) ;
2020-02-28 14:17:56 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-05-21 14:35:36 +00:00
print : false ,
2020-02-28 14:17:56 +00:00
code : " 'console.log( \" hello \" )' " . to_string ( ) ,
2021-02-21 16:58:32 +00:00
ext : " ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 22:12:00 +00:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 12:46:50 +00:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 21:28:10 +00:00
allow_ffi : Some ( vec! [ ] ) ,
2019-05-23 16:28:29 +00:00
allow_hrtime : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-05-03 21:15:16 +00:00
}
) ;
}
2020-01-26 14:49:34 +00:00
#[ test ]
2020-09-18 17:09:11 +00:00
fn eval_with_flags ( ) {
#[ rustfmt::skip ]
2021-03-01 11:41:22 +00:00
let r = flags_from_vec ( svec! [ " deno " , " eval " , " --import-map " , " import_map.json " , " --no-remote " , " --config " , " tsconfig.json " , " --no-check " , " --reload " , " --lock " , " lock.json " , " --lock-write " , " --cert " , " example.crt " , " --cached-only " , " --location " , " https:foo " , " --v8-flags=--help " , " --seed " , " 1 " , " --inspect=127.0.0.1:9229 " , " 42 " ] ) ;
2020-01-26 14:49:34 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-05-21 14:35:36 +00:00
print : false ,
2020-02-04 19:24:33 +00:00
code : " 42 " . to_string ( ) ,
2021-02-21 16:58:32 +00:00
ext : " js " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-09-18 17:09:11 +00:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
no_remote : true ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2020-09-18 17:09:11 +00:00
reload : true ,
2020-10-19 19:19:20 +00:00
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
2020-09-18 17:09:11 +00:00
lock_write : true ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_string ( ) ) ) ,
2020-09-18 17:09:11 +00:00
cached_only : true ,
2021-01-07 18:06:08 +00:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
2020-09-18 17:09:11 +00:00
seed : Some ( 1 ) ,
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 22:12:00 +00:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 12:46:50 +00:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 21:28:10 +00:00
allow_ffi : Some ( vec! [ ] ) ,
2020-01-26 14:49:34 +00:00
allow_hrtime : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2020-01-26 14:49:34 +00:00
}
) ;
}
2020-11-30 02:10:21 +00:00
#[ test ]
fn eval_args ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-11-30 02:10:21 +00:00
" deno " ,
" eval " ,
" console.log(Deno.args) " ,
" arg1 " ,
" arg2 "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Eval ( EvalFlags {
2020-11-30 02:10:21 +00:00
print : false ,
code : " console.log(Deno.args) " . to_string ( ) ,
2021-02-21 16:58:32 +00:00
ext : " js " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-11-30 02:10:21 +00:00
argv : svec ! [ " arg1 " , " arg2 " ] ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 22:12:00 +00:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 12:46:50 +00:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 21:28:10 +00:00
allow_ffi : Some ( vec! [ ] ) ,
2020-11-30 02:10:21 +00:00
allow_hrtime : true ,
.. Flags ::default ( )
}
) ;
}
2019-05-03 21:15:16 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn repl ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " ] ) ;
2019-05-03 21:15:16 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2022-04-20 12:16:37 +00:00
subcommand : DenoSubcommand ::Repl ( ReplFlags {
eval_files : None ,
2022-12-07 19:21:18 +00:00
eval : None ,
is_default_command : true ,
2022-04-20 12:16:37 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : None ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 22:12:00 +00:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 12:46:50 +00:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 21:28:10 +00:00
allow_ffi : Some ( vec! [ ] ) ,
2019-05-23 16:28:29 +00:00
allow_hrtime : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-05-03 21:15:16 +00:00
}
) ;
}
2020-04-30 15:23:40 +00:00
#[ test ]
2020-09-18 17:09:11 +00:00
fn repl_with_flags ( ) {
#[ rustfmt::skip ]
2022-12-07 19:21:18 +00:00
let r = flags_from_vec ( svec! [ " deno " , " repl " , " -A " , " --import-map " , " import_map.json " , " --no-remote " , " --config " , " tsconfig.json " , " --no-check " , " --reload " , " --lock " , " lock.json " , " --lock-write " , " --cert " , " example.crt " , " --cached-only " , " --location " , " https:foo " , " --v8-flags=--help " , " --seed " , " 1 " , " --inspect=127.0.0.1:9229 " , " --unsafely-ignore-certificate-errors " ] ) ;
2020-04-30 15:23:40 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2022-04-20 12:16:37 +00:00
subcommand : DenoSubcommand ::Repl ( ReplFlags {
eval_files : None ,
2022-12-07 19:21:18 +00:00
eval : None ,
is_default_command : false ,
2022-04-20 12:16:37 +00:00
} ) ,
2020-09-18 17:09:11 +00:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
no_remote : true ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2020-09-18 17:09:11 +00:00
reload : true ,
2020-10-19 19:19:20 +00:00
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
2020-09-18 17:09:11 +00:00
lock_write : true ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_string ( ) ) ) ,
2020-09-18 17:09:11 +00:00
cached_only : true ,
2021-01-07 18:06:08 +00:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
2020-09-18 17:09:11 +00:00
seed : Some ( 1 ) ,
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2022-12-07 19:21:18 +00:00
allow_all : true ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( vec! [ ] ) ,
2021-04-09 22:12:00 +00:00
allow_run : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2022-09-28 12:46:50 +00:00
allow_sys : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2021-08-06 21:28:10 +00:00
allow_ffi : Some ( vec! [ ] ) ,
2020-04-30 15:23:40 +00:00
allow_hrtime : true ,
2021-12-10 14:47:55 +00:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2020-04-30 15:23:40 +00:00
.. Flags ::default ( )
}
) ;
}
2021-08-06 21:30:28 +00:00
#[ test ]
fn repl_with_eval_flag ( ) {
#[ rustfmt::skip ]
2022-12-07 19:21:18 +00:00
let r = flags_from_vec ( svec! [ " deno " , " repl " , " --allow-write " , " --eval " , " console.log('hello'); " ] ) ;
2021-08-06 21:30:28 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Repl ( ReplFlags {
2022-04-20 12:16:37 +00:00
eval_files : None ,
2021-08-06 21:30:28 +00:00
eval : Some ( " console.log('hello'); " . to_string ( ) ) ,
2022-12-07 19:21:18 +00:00
is_default_command : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-08-06 21:30:28 +00:00
allow_write : Some ( vec! [ ] ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2021-08-06 21:30:28 +00:00
.. Flags ::default ( )
}
) ;
}
2022-04-20 12:16:37 +00:00
#[ test ]
fn repl_with_eval_file_flag ( ) {
#[ rustfmt::skip ]
let r = flags_from_vec ( svec! [ " deno " , " repl " , " --eval-file=./a.js,./b.ts,https://examples.deno.land/hello-world.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Repl ( ReplFlags {
eval_files : Some ( vec! [
" ./a.js " . to_string ( ) ,
" ./b.ts " . to_string ( ) ,
" https://examples.deno.land/hello-world.ts " . to_string ( )
] ) ,
eval : None ,
2022-12-07 19:21:18 +00:00
is_default_command : false ,
2022-04-20 12:16:37 +00:00
} ) ,
type_check_mode : TypeCheckMode ::None ,
.. Flags ::default ( )
}
) ;
}
2019-05-08 23:20:30 +00:00
#[ test ]
2020-06-13 17:09:39 +00:00
fn allow_read_allowlist ( ) {
2022-04-01 15:15:37 +00:00
use test_util ::TempDir ;
let temp_dir_guard = TempDir ::new ( ) ;
let temp_dir = temp_dir_guard . path ( ) . to_path_buf ( ) ;
2019-05-09 16:20:34 +00:00
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-05-08 23:20:30 +00:00
" deno " ,
" run " ,
2020-02-11 09:29:36 +00:00
format! ( " --allow-read=., {} " , temp_dir . to_str ( ) . unwrap ( ) ) ,
2019-05-08 23:20:30 +00:00
" script.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ PathBuf ::from ( " . " ) , temp_dir ] ) ,
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-05-08 23:20:30 +00:00
}
) ;
}
2019-06-09 13:08:20 +00:00
2019-05-08 23:20:30 +00:00
#[ test ]
2020-06-13 17:09:39 +00:00
fn allow_write_allowlist ( ) {
2022-04-01 15:15:37 +00:00
use test_util ::TempDir ;
let temp_dir_guard = TempDir ::new ( ) ;
let temp_dir = temp_dir_guard . path ( ) . to_path_buf ( ) ;
2019-05-09 16:20:34 +00:00
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-05-08 23:20:30 +00:00
" deno " ,
" run " ,
2020-02-11 09:29:36 +00:00
format! ( " --allow-write=., {} " , temp_dir . to_str ( ) . unwrap ( ) ) ,
2019-05-08 23:20:30 +00:00
" script.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ PathBuf ::from ( " . " ) , temp_dir ] ) ,
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-05-08 23:20:30 +00:00
}
) ;
}
2019-06-09 13:08:20 +00:00
2019-05-08 23:20:30 +00:00
#[ test ]
2020-06-13 17:09:39 +00:00
fn allow_net_allowlist ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-05-08 23:20:30 +00:00
" deno " ,
" run " ,
" --allow-net=127.0.0.1 " ,
" script.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( svec! [ " 127.0.0.1 " ] ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-05-08 23:20:30 +00:00
}
) ;
}
2019-06-01 12:54:32 +00:00
2021-04-13 11:25:21 +00:00
#[ test ]
fn allow_env_allowlist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-env=HOME " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2021-04-13 11:25:21 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( svec! [ " HOME " ] ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn allow_env_allowlist_multiple ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --allow-env=HOME,PATH " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2021-04-13 11:25:21 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-04-13 11:25:21 +00:00
allow_env : Some ( svec! [ " HOME " , " PATH " ] ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn allow_env_allowlist_validator ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-env=HOME " , " script.ts " ] ) ;
assert! ( r . is_ok ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-env=H=ME " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-env=H \0 ME " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
}
2022-09-28 12:46:50 +00:00
#[ test ]
fn allow_sys ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
allow_sys : Some ( vec! [ ] ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn allow_sys_allowlist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys=hostname " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
allow_sys : Some ( svec! [ " hostname " ] ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn allow_sys_allowlist_multiple ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --allow-sys=hostname,osRelease " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
allow_sys : Some ( svec! [ " hostname " , " osRelease " ] ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn allow_sys_allowlist_validator ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys=hostname " , " script.ts " ] ) ;
assert! ( r . is_ok ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --allow-sys=hostname,osRelease " ,
" script.ts "
] ) ;
assert! ( r . is_ok ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys=foo " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --allow-sys=hostname,foo " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) ) ;
}
2022-09-06 16:30:42 +00:00
#[ test ]
fn reload_validator ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=http://deno.land/ " ,
" script.ts "
] ) ;
assert! ( r . is_ok ( ) , " should accept valid urls " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=http://deno.land/a,http://deno.land/b " ,
" script.ts "
] ) ;
assert! ( r . is_ok ( ) , " should accept accept multiple valid urls " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=./relativeurl/ " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject relative urls that start with ./ " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=relativeurl/ " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject relative urls " ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --reload=/absolute " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , " Should reject absolute urls " ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --reload=/ " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , " Should reject absolute root url " ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --reload= " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , " Should reject when nothing is provided " ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --reload=, " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , " Should reject when a single comma is provided " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=,http://deno.land/a " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject a leading comma " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=http://deno.land/a, " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject a trailing comma " ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --reload=http://deno.land/a,,http://deno.land/b " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , " Should reject adjacent commas " ) ;
}
2019-06-08 18:42:28 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn bundle ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " source.ts " ] ) ;
2019-06-08 18:42:28 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-02-04 19:24:33 +00:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-11-26 16:06:32 +00:00
}
) ;
}
2020-05-07 15:02:03 +00:00
#[ test ]
fn bundle_with_config ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-05-07 15:02:03 +00:00
" deno " ,
" bundle " ,
2020-09-18 17:09:11 +00:00
" --no-remote " ,
2020-05-07 15:02:03 +00:00
" --config " ,
" tsconfig.json " ,
" source.ts " ,
" bundle.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-05-07 15:02:03 +00:00
source_file : " source.ts " . to_string ( ) ,
out_file : Some ( PathBuf ::from ( " bundle.js " ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2020-09-18 17:09:11 +00:00
no_remote : true ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2020-05-07 15:02:03 +00:00
.. Flags ::default ( )
}
) ;
}
2019-11-26 16:06:32 +00:00
#[ test ]
fn bundle_with_output ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " source.ts " , " bundle.js " ] ) ;
2019-11-26 16:06:32 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-02-04 19:24:33 +00:00
source_file : " source.ts " . to_string ( ) ,
2020-02-11 09:29:36 +00:00
out_file : Some ( PathBuf ::from ( " bundle.js " ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2020-12-29 18:34:35 +00:00
allow_write : Some ( vec! [ ] ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2020-07-07 11:05:28 +00:00
}
) ;
}
#[ test ]
fn bundle_with_lock ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-07-07 11:05:28 +00:00
" deno " ,
" bundle " ,
" --lock-write " ,
" --lock=lock.json " ,
" source.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-07-07 11:05:28 +00:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2020-07-07 11:05:28 +00:00
lock_write : true ,
2020-10-19 19:19:20 +00:00
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
2020-07-07 11:05:28 +00:00
.. Flags ::default ( )
2019-06-08 18:42:28 +00:00
}
) ;
}
2019-06-09 13:08:20 +00:00
2020-08-12 15:32:03 +00:00
#[ test ]
fn bundle_with_reload ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " --reload " , " source.ts " ] ) ;
2020-08-12 15:32:03 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
reload : true ,
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-08-12 15:32:03 +00:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2020-08-12 15:32:03 +00:00
.. Flags ::default ( )
}
) ;
}
2020-10-20 03:10:42 +00:00
#[ test ]
fn bundle_nocheck ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " --no-check " , " script.ts " ] )
. unwrap ( ) ;
2020-10-20 03:10:42 +00:00
assert_eq! (
r ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-10-20 03:10:42 +00:00
source_file : " script.ts " . to_string ( ) ,
out_file : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2020-10-20 03:10:42 +00:00
.. Flags ::default ( )
}
) ;
}
2020-11-22 20:45:44 +00:00
#[ test ]
fn bundle_watch ( ) {
2021-04-27 10:44:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " bundle " , " --watch " , " source.ts " ] ) ;
2020-11-22 20:45:44 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-11-22 20:45:44 +00:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2021-12-15 21:04:43 +00:00
watch : Some ( vec! [ ] ) ,
2020-11-22 20:45:44 +00:00
.. Flags ::default ( )
}
)
}
2022-01-31 16:39:39 +00:00
#[ test ]
fn bundle_watch_with_no_clear_screen ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" bundle " ,
" --watch " ,
" --no-clear-screen " ,
" source.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-01-31 16:39:39 +00:00
watch : Some ( vec! [ ] ) ,
no_clear_screen : true ,
.. Flags ::default ( )
}
)
}
2019-06-09 13:08:20 +00:00
#[ test ]
2020-10-20 12:30:59 +00:00
fn run_import_map ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-06-09 13:08:20 +00:00
" deno " ,
" run " ,
2020-10-20 12:30:59 +00:00
" --import-map=import_map.json " ,
2019-06-09 13:08:20 +00:00
" script.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-10-20 12:30:59 +00:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-06-09 13:08:20 +00:00
}
) ;
2019-11-26 16:06:32 +00:00
}
2019-06-09 13:08:20 +00:00
2020-09-21 13:07:19 +00:00
#[ test ]
2020-10-20 12:30:59 +00:00
fn info_import_map ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-09-21 13:07:19 +00:00
" deno " ,
" info " ,
2020-10-20 12:30:59 +00:00
" --import-map=import_map.json " ,
2020-09-21 13:07:19 +00:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-09-21 13:07:19 +00:00
file : Some ( " script.ts " . to_string ( ) ) ,
json : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-10-20 12:30:59 +00:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2020-09-21 13:07:19 +00:00
.. Flags ::default ( )
}
) ;
}
2019-11-26 16:06:32 +00:00
#[ test ]
2020-10-20 12:30:59 +00:00
fn cache_import_map ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-07-27 14:37:03 +00:00
" deno " ,
2020-04-07 15:24:47 +00:00
" cache " ,
2020-10-20 12:30:59 +00:00
" --import-map=import_map.json " ,
2019-07-27 14:37:03 +00:00
" script.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Cache ( CacheFlags {
2020-02-04 19:24:33 +00:00
files : svec ! [ " script.ts " ] ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-10-20 12:30:59 +00:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2020-10-11 23:05:46 +00:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
2020-10-20 12:30:59 +00:00
fn doc_import_map ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-10-11 23:05:46 +00:00
" deno " ,
" doc " ,
2020-10-20 12:30:59 +00:00
" --import-map=import_map.json " ,
2020-10-11 23:05:46 +00:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2023-01-14 17:39:56 +00:00
source_file : DocSourceFileFlag ::Path ( " script.ts " . to_owned ( ) ) ,
2020-10-11 23:05:46 +00:00
private : false ,
json : false ,
filter : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-10-20 12:30:59 +00:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-07-27 14:37:03 +00:00
}
) ;
2019-06-09 13:08:20 +00:00
}
2019-06-11 14:34:39 +00:00
2020-01-31 21:07:37 +00:00
#[ test ]
2020-04-07 15:24:47 +00:00
fn cache_multiple ( ) {
2020-01-31 21:07:37 +00:00
let r =
2021-01-07 18:06:08 +00:00
flags_from_vec ( svec! [ " deno " , " cache " , " script.ts " , " script_two.ts " ] ) ;
2020-01-31 21:07:37 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Cache ( CacheFlags {
2020-02-04 19:24:33 +00:00
files : svec ! [ " script.ts " , " script_two.ts " ] ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2020-01-31 21:07:37 +00:00
}
) ;
}
2019-06-11 14:34:39 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn run_seed ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --seed " , " 250 " , " script.ts " ] ) ;
2019-06-11 14:34:39 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-11-27 19:47:35 +00:00
seed : Some ( 250_ u64 ) ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --random-seed=250 " ] ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-06-11 14:34:39 +00:00
}
) ;
}
#[ test ]
2019-11-26 16:06:32 +00:00
fn run_seed_with_v8_flags ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-06-11 14:34:39 +00:00
" deno " ,
2019-11-26 16:06:32 +00:00
" run " ,
2019-06-11 14:34:39 +00:00
" --seed " ,
" 250 " ,
" --v8-flags=--expose-gc " ,
" script.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-11-27 19:47:35 +00:00
seed : Some ( 250_ u64 ) ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --expose-gc " , " --random-seed=250 " ] ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-06-11 14:34:39 +00:00
}
) ;
2019-06-15 14:08:11 +00:00
}
#[ test ]
2019-11-26 16:06:32 +00:00
fn install ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-06-15 14:08:11 +00:00
" deno " ,
" install " ,
" https://deno.land/std/examples/colors.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Install ( InstallFlags {
2020-05-01 19:33:11 +00:00
name : None ,
2020-01-30 23:42:39 +00:00
module_url : " https://deno.land/std/examples/colors.ts " . to_string ( ) ,
args : vec ! [ ] ,
2020-05-01 19:33:11 +00:00
root : None ,
2020-02-08 08:49:55 +00:00
force : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-06-15 14:08:11 +00:00
}
) ;
2019-11-26 16:06:32 +00:00
}
2019-06-15 14:08:11 +00:00
2019-11-26 16:06:32 +00:00
#[ test ]
2020-10-19 19:19:20 +00:00
fn install_with_flags ( ) {
#[ rustfmt::skip ]
2021-08-10 11:19:45 +00:00
let r = flags_from_vec ( svec! [ " deno " , " install " , " --import-map " , " import_map.json " , " --no-remote " , " --config " , " tsconfig.json " , " --no-check " , " --unsafely-ignore-certificate-errors " , " --reload " , " --lock " , " lock.json " , " --lock-write " , " --cert " , " example.crt " , " --cached-only " , " --allow-read " , " --allow-net " , " --v8-flags=--help " , " --seed " , " 1 " , " --inspect=127.0.0.1:9229 " , " --name " , " file_server " , " --root " , " /foo " , " --force " , " https://deno.land/std/http/file_server.ts " , " foo " , " bar " ] ) ;
2019-06-20 18:25:13 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Install ( InstallFlags {
2020-05-01 19:33:11 +00:00
name : Some ( " file_server " . to_string ( ) ) ,
2020-01-30 23:42:39 +00:00
module_url : " https://deno.land/std/http/file_server.ts " . to_string ( ) ,
2020-10-19 19:19:20 +00:00
args : svec ! [ " foo " , " bar " ] ,
root : Some ( PathBuf ::from ( " /foo " ) ) ,
2020-02-08 08:49:55 +00:00
force : true ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-10-19 19:19:20 +00:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
no_remote : true ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2020-10-19 19:19:20 +00:00
reload : true ,
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
lock_write : true ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_string ( ) ) ) ,
2020-10-19 19:19:20 +00:00
cached_only : true ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
2020-10-19 19:19:20 +00:00
seed : Some ( 1 ) ,
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-06-20 18:25:13 +00:00
}
) ;
2019-06-11 14:34:39 +00:00
}
2019-06-22 16:02:51 +00:00
2023-01-06 02:09:39 +00:00
#[ test ]
fn uninstall ( ) {
let r = flags_from_vec ( svec! [ " deno " , " uninstall " , " file_server " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Uninstall ( UninstallFlags {
name : " file_server " . to_string ( ) ,
root : None ,
} ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn uninstall_with_help_flag ( ) {
let r = flags_from_vec ( svec! [ " deno " , " uninstall " , " --help " ] ) ;
assert_eq! ( r . err ( ) . unwrap ( ) . kind ( ) , clap ::ErrorKind ::DisplayHelp ) ;
}
2019-06-22 16:02:51 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn log_level ( ) {
2021-01-07 18:06:08 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --log-level=debug " , " script.ts " ] ) ;
2019-06-22 16:02:51 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2019-06-22 16:02:51 +00:00
log_level : Some ( Level ::Debug ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-06-22 16:02:51 +00:00
}
) ;
}
2019-06-26 10:02:13 +00:00
2020-03-10 12:26:17 +00:00
#[ test ]
fn quiet ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " -q " , " script.ts " ] ) ;
2020-03-10 12:26:17 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-03-10 12:26:17 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-03-10 12:26:17 +00:00
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
}
2019-06-26 10:02:13 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn completions ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " completions " , " zsh " ] ) . unwrap ( ) ;
2020-02-04 19:24:33 +00:00
match r . subcommand {
2021-09-03 23:33:35 +00:00
DenoSubcommand ::Completions ( CompletionsFlags { buf } ) = > {
assert! ( ! buf . is_empty ( ) )
}
2020-02-04 19:24:33 +00:00
_ = > unreachable! ( ) ,
}
2019-06-26 10:02:13 +00:00
}
2019-06-29 22:32:54 +00:00
#[ test ]
2020-08-28 23:20:57 +00:00
fn run_with_args ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-08-28 23:20:57 +00:00
" deno " ,
" run " ,
" script.ts " ,
" --allow-read " ,
" --allow-net "
] ) ;
2019-06-29 22:32:54 +00:00
assert_eq! (
2020-08-28 23:20:57 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-08-28 23:20:57 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " --allow-read " , " --allow-net " ] ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-06-29 22:32:54 +00:00
}
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-06-29 22:32:54 +00:00
" deno " ,
" run " ,
2021-01-07 18:06:08 +00:00
" --location " ,
" https:foo " ,
2019-11-26 16:06:32 +00:00
" --allow-read " ,
2019-06-29 22:32:54 +00:00
" script.ts " ,
" --allow-net " ,
" -r " ,
" --help " ,
" --foo " ,
" bar "
] ) ;
assert_eq! (
2020-08-28 23:20:57 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-08-28 23:20:57 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-01-07 18:06:08 +00:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2020-12-29 18:34:35 +00:00
allow_read : Some ( vec! [ ] ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " --allow-net " , " -r " , " --help " , " --foo " , " bar " ] ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-06-29 22:32:54 +00:00
}
) ;
2020-08-28 23:20:57 +00:00
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " script.ts " , " foo " , " bar " ] ) ;
2020-08-28 23:20:57 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-08-28 23:20:57 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " foo " , " bar " ] ,
.. Flags ::default ( )
}
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " script.ts " , " - " ] ) ;
2020-08-28 23:20:57 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-08-28 23:20:57 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " - " ] ,
.. Flags ::default ( )
}
) ;
let r =
2021-01-07 18:06:08 +00:00
flags_from_vec ( svec! [ " deno " , " run " , " script.ts " , " - " , " foo " , " bar " ] ) ;
2020-08-28 23:20:57 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-08-28 23:20:57 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " - " , " foo " , " bar " ] ,
.. Flags ::default ( )
}
) ;
}
2019-07-20 13:19:06 +00:00
2020-07-08 09:26:39 +00:00
#[ test ]
fn no_check ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-check " , " script.ts " ] ) ;
2020-07-08 09:26:39 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-07-08 09:26:39 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2021-11-29 22:23:30 +00:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn no_check_remote ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --no-check=remote " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::Local ,
2020-07-08 09:26:39 +00:00
.. Flags ::default ( )
}
) ;
}
2021-08-09 14:53:21 +00:00
#[ test ]
2021-12-10 14:47:55 +00:00
fn repl_with_unsafely_ignore_certificate_errors ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" repl " ,
" --eval " ,
" console.log('hello'); " ,
" --unsafely-ignore-certificate-errors "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Repl ( ReplFlags {
2022-04-20 12:16:37 +00:00
eval_files : None ,
2021-12-10 14:47:55 +00:00
eval : Some ( " console.log('hello'); " . to_string ( ) ) ,
2022-12-07 19:21:18 +00:00
is_default_command : false ,
2021-12-10 14:47:55 +00:00
} ) ,
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2021-12-10 14:47:55 +00:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn run_with_unsafely_ignore_certificate_errors ( ) {
2021-08-09 14:53:21 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
2021-08-10 11:19:45 +00:00
" --unsafely-ignore-certificate-errors " ,
2021-08-09 14:53:21 +00:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2021-08-09 14:53:21 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2021-08-09 14:53:21 +00:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
2021-12-10 14:47:55 +00:00
fn run_with_unsafely_treat_insecure_origin_as_secure_with_ipv6_address ( ) {
2021-08-09 14:53:21 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
2021-08-10 11:19:45 +00:00
" --unsafely-ignore-certificate-errors=deno.land,localhost,::,127.0.0.1,[::1],1.2.3.4 " ,
2021-08-09 14:53:21 +00:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2021-08-09 14:53:21 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : Some ( svec! [
2021-08-09 14:53:21 +00:00
" deno.land " ,
" localhost " ,
" :: " ,
" 127.0.0.1 " ,
" [::1] " ,
" 1.2.3.4 "
] ) ,
.. Flags ::default ( )
}
) ;
}
2021-12-10 14:47:55 +00:00
#[ test ]
fn repl_with_unsafely_treat_insecure_origin_as_secure_with_ipv6_address ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" repl " ,
" --unsafely-ignore-certificate-errors=deno.land,localhost,::,127.0.0.1,[::1],1.2.3.4 " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2022-04-20 12:16:37 +00:00
subcommand : DenoSubcommand ::Repl ( ReplFlags {
eval_files : None ,
2022-12-07 19:21:18 +00:00
eval : None ,
is_default_command : false ,
2022-04-20 12:16:37 +00:00
} ) ,
2021-12-10 14:47:55 +00:00
unsafely_ignore_certificate_errors : Some ( svec! [
" deno.land " ,
" localhost " ,
" :: " ,
" 127.0.0.1 " ,
" [::1] " ,
" 1.2.3.4 "
] ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2021-12-10 14:47:55 +00:00
.. Flags ::default ( )
}
) ;
}
2019-07-20 13:19:06 +00:00
#[ test ]
2019-12-03 22:48:53 +00:00
fn no_remote ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-remote " , " script.ts " ] ) ;
2019-12-03 22:48:53 +00:00
assert_eq! (
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2019-12-03 22:48:53 +00:00
no_remote : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-12-03 22:48:53 +00:00
}
) ;
}
2022-09-07 13:33:51 +00:00
#[ test ]
fn no_npm ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-npm " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
no_npm : true ,
.. Flags ::default ( )
}
) ;
}
2022-09-22 15:17:02 +00:00
#[ test ]
fn local_npm ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --node-modules-dir " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
2023-02-20 18:14:06 +00:00
node_modules_dir : Some ( true ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --node-modules-dir=false " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
node_modules_dir : Some ( false ) ,
2022-09-22 15:17:02 +00:00
.. Flags ::default ( )
}
) ;
}
2019-12-03 22:48:53 +00:00
#[ test ]
fn cached_only ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --cached-only " , " script.ts " ] ) ;
2019-07-20 13:19:06 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2019-12-03 22:48:53 +00:00
cached_only : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-07-20 13:19:06 +00:00
}
) ;
}
2019-07-31 15:02:20 +00:00
2019-10-12 21:13:52 +00:00
#[ test ]
2020-06-13 17:09:39 +00:00
fn allow_net_allowlist_with_ports ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-10-12 21:13:52 +00:00
" deno " ,
2020-05-04 11:03:30 +00:00
" run " ,
2019-10-12 21:13:52 +00:00
" --allow-net=deno.land,:8000,:4545 " ,
" script.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( svec! [
2019-10-12 21:13:52 +00:00
" deno.land " ,
" 0.0.0.0:8000 " ,
" 127.0.0.1:8000 " ,
" localhost:8000 " ,
" 0.0.0.0:4545 " ,
" 127.0.0.1:4545 " ,
" localhost:4545 "
2020-12-29 18:34:35 +00:00
] ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-10-12 21:13:52 +00:00
}
) ;
}
2019-11-03 15:39:27 +00:00
2020-06-26 12:09:02 +00:00
#[ test ]
fn allow_net_allowlist_with_ipv6_address ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-06-26 12:09:02 +00:00
" deno " ,
" run " ,
" --allow-net=deno.land,deno.land:80,::,127.0.0.1,[::1],1.2.3.4:5678,:5678,[::1]:8080 " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-06-26 12:09:02 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( svec! [
2020-06-26 12:09:02 +00:00
" deno.land " ,
" deno.land:80 " ,
" :: " ,
" 127.0.0.1 " ,
" [::1] " ,
" 1.2.3.4:5678 " ,
" 0.0.0.0:5678 " ,
" 127.0.0.1:5678 " ,
" localhost:5678 " ,
" [::1]:8080 "
2020-12-29 18:34:35 +00:00
] ) ,
2020-06-26 12:09:02 +00:00
.. Flags ::default ( )
}
) ;
}
2019-11-03 15:39:27 +00:00
#[ test ]
2019-11-26 16:06:32 +00:00
fn lock_write ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2019-11-03 15:39:27 +00:00
" deno " ,
2020-05-04 11:03:30 +00:00
" run " ,
2019-11-03 15:39:27 +00:00
" --lock-write " ,
" --lock=lock.json " ,
" script.ts "
] ) ;
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-02-04 19:24:33 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2019-11-03 15:39:27 +00:00
lock_write : true ,
2020-10-19 19:19:20 +00:00
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-11-03 15:39:27 +00:00
}
) ;
2022-11-02 15:32:30 +00:00
2022-11-03 15:42:56 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-lock " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
no_lock : true ,
.. Flags ::default ( )
}
) ;
2022-11-02 15:32:30 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --lock " ,
" --lock-write " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
lock_write : true ,
lock : Some ( PathBuf ::from ( " ./deno.lock " ) ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --lock-write " ,
" --lock " ,
" lock.json " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
lock_write : true ,
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --lock-write " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
lock_write : true ,
.. Flags ::default ( )
}
) ;
2022-11-03 15:42:56 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --lock " , " --no-lock " , " script.ts " ] ) ;
assert! ( r . is_err ( ) , ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --lock-write " ,
" --no-lock " ,
" script.ts "
] ) ;
assert! ( r . is_err ( ) , ) ;
2019-11-03 15:39:27 +00:00
}
2019-11-13 16:21:17 +00:00
2023-01-09 12:29:43 +00:00
#[ test ]
fn test_no_colon_in_value_name ( ) {
let app =
runtime_args ( Command ::new ( " test_inspect_completion_value " ) , true , true ) ;
let inspect_args = app
. get_arguments ( )
. filter ( | arg | arg . get_id ( ) = = " inspect " )
. collect ::< Vec < _ > > ( ) ;
// The value_name cannot have a : otherwise it breaks shell completions for zsh.
let value_name = " HOST_AND_PORT " ;
let arg = inspect_args
. iter ( )
. any ( | v | v . get_value_names ( ) . unwrap ( ) = = [ value_name ] ) ;
assert_eq! ( arg , true ) ;
}
2019-11-26 16:06:32 +00:00
#[ test ]
2020-11-22 13:06:51 +00:00
fn test_with_flags ( ) {
#[ rustfmt::skip ]
2023-03-13 21:04:00 +00:00
let r = flags_from_vec ( svec! [ " deno " , " test " , " --unstable " , " --no-npm " , " --no-remote " , " --trace-ops " , " --no-run " , " --filter " , " - foo " , " --coverage=cov " , " --location " , " https:foo " , " --allow-net " , " --allow-none " , " dir1/ " , " dir2/ " , " -- " , " arg1 " , " arg2 " ] ) ;
2019-11-13 16:21:17 +00:00
assert_eq! (
2019-11-26 16:06:32 +00:00
r . unwrap ( ) ,
2020-02-26 10:52:15 +00:00
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2020-11-22 13:06:51 +00:00
no_run : true ,
2021-05-10 23:54:39 +00:00
doc : false ,
2021-07-12 10:55:42 +00:00
fail_fast : None ,
2020-11-22 13:06:51 +00:00
filter : Some ( " - foo " . to_string ( ) ) ,
2020-02-11 11:01:56 +00:00
allow_none : true ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " dir1/ " ) , PathBuf ::from ( " dir2/ " ) ] ,
ignore : vec ! [ ] ,
} ,
2021-07-06 01:20:33 +00:00
shuffle : None ,
2023-01-07 20:22:09 +00:00
concurrent_jobs : None ,
2022-02-25 15:14:46 +00:00
trace_ops : true ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-09-13 13:01:30 +00:00
unstable : true ,
2022-02-26 13:49:50 +00:00
no_prompt : true ,
2023-03-13 21:04:00 +00:00
no_npm : true ,
no_remote : true ,
2020-12-21 13:04:25 +00:00
coverage_dir : Some ( " cov " . to_string ( ) ) ,
2021-01-07 18:06:08 +00:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2020-12-29 18:34:35 +00:00
allow_net : Some ( vec! [ ] ) ,
2020-10-26 00:25:43 +00:00
argv : svec ! [ " arg1 " , " arg2 " ] ,
.. Flags ::default ( )
}
) ;
}
2020-04-02 13:26:40 +00:00
#[ test ]
fn run_with_cafile ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-04-02 13:26:40 +00:00
" deno " ,
" run " ,
" --cert " ,
" example.crt " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-04-02 13:26:40 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-04-02 13:26:40 +00:00
.. Flags ::default ( )
}
) ;
}
2020-02-17 16:59:51 +00:00
2021-07-23 14:31:16 +00:00
#[ test ]
fn run_with_enable_testing_features ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --enable-testing-features-do-not-use " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2021-07-23 14:31:16 +00:00
script : " script.ts " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-07-23 14:31:16 +00:00
enable_testing_features : true ,
.. Flags ::default ( )
}
) ;
}
2021-08-23 10:35:38 +00:00
#[ test ]
fn test_with_concurrent_jobs ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --jobs=4 " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-08-23 10:35:38 +00:00
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : Some ( NonZeroUsize ::new ( 4 ) . unwrap ( ) ) ,
2022-02-25 15:14:46 +00:00
trace_ops : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-02-26 13:49:50 +00:00
no_prompt : true ,
2021-08-23 10:35:38 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " test " , " --jobs=0 " ] ) ;
assert! ( r . is_err ( ) ) ;
}
2021-07-12 10:55:42 +00:00
#[ test ]
fn test_with_fail_fast ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --fail-fast=3 " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-07-12 10:55:42 +00:00
no_run : false ,
doc : false ,
2021-08-23 10:37:02 +00:00
fail_fast : Some ( NonZeroUsize ::new ( 3 ) . unwrap ( ) ) ,
2021-07-12 10:55:42 +00:00
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 15:14:46 +00:00
trace_ops : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-02-26 13:49:50 +00:00
no_prompt : true ,
2021-07-12 10:55:42 +00:00
.. Flags ::default ( )
}
) ;
2021-08-23 10:37:02 +00:00
let r = flags_from_vec ( svec! [ " deno " , " test " , " --fail-fast=0 " ] ) ;
assert! ( r . is_err ( ) ) ;
2021-07-12 10:55:42 +00:00
}
2021-07-23 14:31:16 +00:00
#[ test ]
fn test_with_enable_testing_features ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" test " ,
" --enable-testing-features-do-not-use "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-07-23 14:31:16 +00:00
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 15:14:46 +00:00
trace_ops : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-02-26 13:49:50 +00:00
no_prompt : true ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2021-07-23 14:31:16 +00:00
enable_testing_features : true ,
.. Flags ::default ( )
}
) ;
}
2021-07-27 18:18:16 +00:00
#[ test ]
fn test_shuffle ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --shuffle=1 " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-07-27 18:18:16 +00:00
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : Some ( 1 ) ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 15:14:46 +00:00
trace_ops : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-02-26 13:49:50 +00:00
no_prompt : true ,
2021-12-15 21:04:43 +00:00
watch : None ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2021-07-27 18:18:16 +00:00
.. Flags ::default ( )
}
) ;
}
2021-07-20 09:29:17 +00:00
#[ test ]
fn test_watch ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --watch " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Test ( TestFlags {
2021-07-20 09:29:17 +00:00
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
trace_ops : false ,
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
watch : Some ( vec! [ ] ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn test_watch_explicit_cwd ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --watch " , " ./ " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
files : FileFlags {
include : vec ! [ PathBuf ::from ( " ./ " ) ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 15:14:46 +00:00
trace_ops : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-02-26 13:49:50 +00:00
no_prompt : true ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2021-12-15 21:04:43 +00:00
watch : Some ( vec! [ ] ) ,
2021-07-20 09:29:17 +00:00
.. Flags ::default ( )
}
) ;
}
2022-01-31 16:39:39 +00:00
#[ test ]
fn test_watch_with_no_clear_screen ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " test " , " --watch " , " --no-clear-screen " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
no_run : false ,
doc : false ,
fail_fast : None ,
filter : None ,
allow_none : false ,
shuffle : None ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2022-02-25 15:14:46 +00:00
trace_ops : false ,
2022-01-31 16:39:39 +00:00
} ) ,
watch : Some ( vec! [ ] ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-01-31 16:39:39 +00:00
no_clear_screen : true ,
2022-02-26 13:49:50 +00:00
no_prompt : true ,
2022-01-31 16:39:39 +00:00
.. Flags ::default ( )
}
) ;
}
2020-04-02 13:26:40 +00:00
#[ test ]
fn bundle_with_cafile ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-04-02 13:26:40 +00:00
" deno " ,
" bundle " ,
" --cert " ,
" example.crt " ,
" source.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Bundle ( BundleFlags {
2020-04-02 13:26:40 +00:00
source_file : " source.ts " . to_string ( ) ,
out_file : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-04-02 13:26:40 +00:00
.. Flags ::default ( )
}
) ;
}
2020-02-17 16:59:51 +00:00
2020-07-06 03:58:23 +00:00
#[ test ]
fn upgrade_with_ca_file ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " upgrade " , " --cert " , " example.crt " ] ) ;
2020-07-06 03:58:23 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Upgrade ( UpgradeFlags {
2020-07-06 03:58:23 +00:00
force : false ,
dry_run : false ,
2020-11-29 19:00:35 +00:00
canary : false ,
2020-07-06 03:58:23 +00:00
version : None ,
2020-07-06 22:21:26 +00:00
output : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-07-06 03:58:23 +00:00
.. Flags ::default ( )
}
) ;
}
2020-04-02 13:26:40 +00:00
#[ test ]
2020-04-07 15:24:47 +00:00
fn cache_with_cafile ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-04-02 13:26:40 +00:00
" deno " ,
2020-04-07 15:24:47 +00:00
" cache " ,
2020-04-02 13:26:40 +00:00
" --cert " ,
" example.crt " ,
" script.ts " ,
" script_two.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Cache ( CacheFlags {
2020-04-02 13:26:40 +00:00
files : svec ! [ " script.ts " , " script_two.ts " ] ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-04-02 13:26:40 +00:00
.. Flags ::default ( )
}
) ;
}
2020-02-17 16:59:51 +00:00
2020-04-02 13:26:40 +00:00
#[ test ]
fn info_with_cafile ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-04-02 13:26:40 +00:00
" deno " ,
" info " ,
" --cert " ,
" example.crt " ,
" https://example.com "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Info ( InfoFlags {
2020-07-08 14:50:12 +00:00
json : false ,
2020-04-02 13:26:40 +00:00
file : Some ( " https://example.com " . to_string ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2020-04-02 13:26:40 +00:00
.. Flags ::default ( )
}
) ;
}
2020-02-17 16:59:51 +00:00
2020-04-02 13:26:40 +00:00
#[ test ]
fn doc ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " doc " , " --json " , " path/to/module.ts " ] ) ;
2020-04-02 13:26:40 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 12:16:33 +00:00
private : false ,
2020-04-02 13:26:40 +00:00
json : true ,
2023-01-14 17:39:56 +00:00
source_file : DocSourceFileFlag ::Path ( " path/to/module.ts " . to_string ( ) ) ,
2020-04-02 13:26:40 +00:00
filter : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-04-02 13:26:40 +00:00
.. Flags ::default ( )
}
) ;
2020-03-28 18:16:57 +00:00
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-04-02 13:26:40 +00:00
" deno " ,
" doc " ,
" path/to/module.ts " ,
" SomeClass.someField "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 12:16:33 +00:00
private : false ,
2020-04-02 13:26:40 +00:00
json : false ,
2023-01-14 17:39:56 +00:00
source_file : DocSourceFileFlag ::Path ( " path/to/module.ts " . to_string ( ) ) ,
2020-04-02 13:26:40 +00:00
filter : Some ( " SomeClass.someField " . to_string ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-04-02 13:26:40 +00:00
.. Flags ::default ( )
}
) ;
2020-04-09 12:34:24 +00:00
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " doc " ] ) ;
2020-04-09 12:34:24 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 12:16:33 +00:00
private : false ,
2020-04-09 12:34:24 +00:00
json : false ,
2023-01-14 17:39:56 +00:00
source_file : Default ::default ( ) ,
2020-04-09 12:34:24 +00:00
filter : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-04-09 12:34:24 +00:00
.. Flags ::default ( )
}
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " doc " , " --builtin " , " Deno.Listener " ] ) ;
2020-04-09 12:34:24 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 12:16:33 +00:00
private : false ,
2020-04-09 12:34:24 +00:00
json : false ,
2023-01-14 17:39:56 +00:00
source_file : DocSourceFileFlag ::Builtin ,
2020-04-09 12:34:24 +00:00
filter : Some ( " Deno.Listener " . to_string ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-04-09 12:34:24 +00:00
.. Flags ::default ( )
}
) ;
2020-07-12 12:16:33 +00:00
2023-03-13 21:04:00 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --no-npm " ,
" --no-remote " ,
" --private " ,
" path/to/module.js "
] ) ;
2020-07-12 12:16:33 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Doc ( DocFlags {
2020-07-12 12:16:33 +00:00
private : true ,
json : false ,
2023-01-14 17:39:56 +00:00
source_file : DocSourceFileFlag ::Path ( " path/to/module.js " . to_string ( ) ) ,
2020-07-12 12:16:33 +00:00
filter : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-03-13 21:04:00 +00:00
no_npm : true ,
no_remote : true ,
2020-07-12 12:16:33 +00:00
.. Flags ::default ( )
}
) ;
2020-04-02 13:26:40 +00:00
}
2020-03-27 20:09:51 +00:00
2020-04-02 13:26:40 +00:00
#[ test ]
fn inspect_default_host ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --inspect " , " foo.js " ] ) ;
2020-04-02 13:26:40 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags {
2020-04-02 13:26:40 +00:00
script : " foo.js " . to_string ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2020-04-03 17:40:11 +00:00
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2020-04-02 13:26:40 +00:00
.. Flags ::default ( )
}
) ;
}
2020-11-30 19:35:12 +00:00
2022-12-12 14:33:30 +00:00
#[ test ]
fn inspect_wait ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --inspect-wait " , " foo.js " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " foo.js " . to_string ( ) ,
} ) ,
inspect_wait : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --inspect-wait=127.0.0.1:3567 " ,
" foo.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " foo.js " . to_string ( ) ,
} ) ,
inspect_wait : Some ( " 127.0.0.1:3567 " . parse ( ) . unwrap ( ) ) ,
.. Flags ::default ( )
}
) ;
}
2020-11-30 19:35:12 +00:00
#[ test ]
fn compile ( ) {
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-11-30 19:35:12 +00:00
" deno " ,
" compile " ,
" https://deno.land/std/examples/colors.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Compile ( CompileFlags {
2020-11-30 19:35:12 +00:00
source_file : " https://deno.land/std/examples/colors.ts " . to_string ( ) ,
2021-01-04 23:15:52 +00:00
output : None ,
args : vec ! [ ] ,
2021-01-19 02:40:22 +00:00
target : None ,
2023-03-18 23:43:07 +00:00
include : vec ! [ ]
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2020-11-30 19:35:12 +00:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn compile_with_flags ( ) {
#[ rustfmt::skip ]
2021-08-10 11:19:45 +00:00
let r = flags_from_vec ( svec! [ " deno " , " compile " , " --import-map " , " import_map.json " , " --no-remote " , " --config " , " tsconfig.json " , " --no-check " , " --unsafely-ignore-certificate-errors " , " --reload " , " --lock " , " lock.json " , " --lock-write " , " --cert " , " example.crt " , " --cached-only " , " --location " , " https:foo " , " --allow-read " , " --allow-net " , " --v8-flags=--help " , " --seed " , " 1 " , " --output " , " colors " , " https://deno.land/std/examples/colors.ts " , " foo " , " bar " ] ) ;
2020-11-30 19:35:12 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Compile ( CompileFlags {
2020-11-30 19:35:12 +00:00
source_file : " https://deno.land/std/examples/colors.ts " . to_string ( ) ,
2021-01-04 23:15:52 +00:00
output : Some ( PathBuf ::from ( " colors " ) ) ,
args : svec ! [ " foo " , " bar " ] ,
2021-01-19 02:40:22 +00:00
target : None ,
2023-03-18 23:43:07 +00:00
include : vec ! [ ]
2021-09-03 23:33:35 +00:00
} ) ,
2020-11-30 19:35:12 +00:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
no_remote : true ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2020-11-30 19:35:12 +00:00
reload : true ,
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
lock_write : true ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_string ( ) ) ) ,
2021-01-04 23:15:52 +00:00
cached_only : true ,
2021-01-07 18:06:08 +00:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2021-01-04 23:15:52 +00:00
allow_read : Some ( vec! [ ] ) ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2021-01-04 23:15:52 +00:00
allow_net : Some ( vec! [ ] ) ,
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
seed : Some ( 1 ) ,
2020-11-30 19:35:12 +00:00
.. Flags ::default ( )
}
) ;
}
2021-01-24 01:18:19 +00:00
2021-02-24 14:27:51 +00:00
#[ test ]
fn coverage ( ) {
let r = flags_from_vec ( svec! [ " deno " , " coverage " , " foo.json " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2021-09-03 23:33:35 +00:00
subcommand : DenoSubcommand ::Coverage ( CoverageFlags {
2023-01-13 21:56:29 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " foo.json " ) ] ,
ignore : vec ! [ ] ,
} ,
2022-02-15 15:33:21 +00:00
output : None ,
2021-02-24 14:27:51 +00:00
include : vec ! [ r "^file:" . to_string ( ) ] ,
exclude : vec ! [ r "test\.(js|mjs|ts|jsx|tsx)$" . to_string ( ) ] ,
lcov : false ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-02-24 14:27:51 +00:00
.. Flags ::default ( )
}
) ;
}
2022-02-15 15:33:21 +00:00
#[ test ]
fn coverage_with_lcov_and_out_file ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" coverage " ,
" --lcov " ,
" --output=foo.lcov " ,
" foo.json "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Coverage ( CoverageFlags {
2023-01-13 21:56:29 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " foo.json " ) ] ,
ignore : vec ! [ ] ,
} ,
2022-02-15 15:33:21 +00:00
include : vec ! [ r "^file:" . to_string ( ) ] ,
exclude : vec ! [ r "test\.(js|mjs|ts|jsx|tsx)$" . to_string ( ) ] ,
lcov : true ,
output : Some ( PathBuf ::from ( " foo.lcov " ) ) ,
} ) ,
.. Flags ::default ( )
}
) ;
}
2021-01-24 01:18:19 +00:00
#[ test ]
fn location_with_bad_scheme ( ) {
#[ rustfmt::skip ]
let r = flags_from_vec ( svec! [ " deno " , " run " , " --location " , " foo: " , " mod.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
assert! ( r
. unwrap_err ( )
. to_string ( )
. contains ( " Expected protocol \" http \" or \" https \" " ) ) ;
}
2021-10-04 23:35:55 +00:00
2022-01-18 01:10:17 +00:00
#[ test ]
fn test_config_path_args ( ) {
let flags = flags_from_vec ( svec! [ " deno " , " run " , " foo.js " ] ) . unwrap ( ) ;
2023-03-14 01:12:09 +00:00
let cwd = std ::env ::current_dir ( ) . unwrap ( ) ;
assert_eq! ( flags . config_path_args ( & cwd ) , Some ( vec! [ cwd . join ( " foo.js " ) ] ) ) ;
2022-01-18 01:10:17 +00:00
2022-02-25 05:39:18 +00:00
let flags =
flags_from_vec ( svec! [ " deno " , " run " , " https://example.com/foo.js " ] )
. unwrap ( ) ;
2023-03-14 01:12:09 +00:00
assert_eq! ( flags . config_path_args ( & cwd ) , None ) ;
2022-02-25 05:39:18 +00:00
2022-01-18 01:10:17 +00:00
let flags =
flags_from_vec ( svec! [ " deno " , " lint " , " dir/a.js " , " dir/b.js " ] ) . unwrap ( ) ;
assert_eq! (
2023-03-14 01:12:09 +00:00
flags . config_path_args ( & cwd ) ,
2022-02-25 05:39:18 +00:00
Some ( vec! [ PathBuf ::from ( " dir/a.js " ) , PathBuf ::from ( " dir/b.js " ) ] )
2022-01-18 01:10:17 +00:00
) ;
let flags = flags_from_vec ( svec! [ " deno " , " lint " ] ) . unwrap ( ) ;
2023-03-14 01:12:09 +00:00
assert! ( flags . config_path_args ( & cwd ) . unwrap ( ) . is_empty ( ) ) ;
2022-01-18 01:10:17 +00:00
let flags =
flags_from_vec ( svec! [ " deno " , " fmt " , " dir/a.js " , " dir/b.js " ] ) . unwrap ( ) ;
assert_eq! (
2023-03-14 01:12:09 +00:00
flags . config_path_args ( & cwd ) ,
2022-02-25 05:39:18 +00:00
Some ( vec! [ PathBuf ::from ( " dir/a.js " ) , PathBuf ::from ( " dir/b.js " ) ] )
2022-01-18 01:10:17 +00:00
) ;
}
2022-01-31 16:39:39 +00:00
#[ test ]
fn test_no_clear_watch_flag_without_watch_flag ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-clear-screen " , " foo.js " ] ) ;
assert! ( r . is_err ( ) ) ;
let error_message = r . unwrap_err ( ) . to_string ( ) ;
assert! ( & error_message
. contains ( " error: The following required arguments were not provided: " ) ) ;
2022-03-28 01:57:56 +00:00
assert! ( & error_message . contains ( " --watch[=<FILES>...] " ) ) ;
2022-01-31 16:39:39 +00:00
}
2022-02-16 18:14:19 +00:00
#[ test ]
fn vendor_minimal ( ) {
let r = flags_from_vec ( svec! [ " deno " , " vendor " , " mod.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Vendor ( VendorFlags {
specifiers : svec ! [ " mod.ts " ] ,
force : false ,
output_path : None ,
} ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn vendor_all ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" vendor " ,
" --config " ,
" deno.json " ,
" --import-map " ,
" import_map.json " ,
" --lock " ,
" lock.json " ,
" --force " ,
" --output " ,
" out_dir " ,
" --reload " ,
" mod.ts " ,
" deps.test.ts " ,
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Vendor ( VendorFlags {
specifiers : svec ! [ " mod.ts " , " deps.test.ts " ] ,
force : true ,
output_path : Some ( PathBuf ::from ( " out_dir " ) ) ,
} ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " deno.json " . to_owned ( ) ) ,
2022-02-16 18:14:19 +00:00
import_map_path : Some ( " import_map.json " . to_string ( ) ) ,
lock : Some ( PathBuf ::from ( " lock.json " ) ) ,
reload : true ,
.. Flags ::default ( )
}
) ;
}
2022-03-11 01:56:14 +00:00
#[ test ]
fn task_subcommand ( ) {
2022-04-27 19:43:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " , " hello " , " world " , ] ) ;
2022-03-11 01:56:14 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-03-11 01:56:14 +00:00
} ) ,
argv : svec ! [ " hello " , " world " ] ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-06-08 21:30:16 +00:00
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " task " , " --cwd " , " foo " , " build " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
cwd : Some ( " foo " . to_string ( ) ) ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-03-11 01:56:14 +00:00
} ) ,
.. Flags ::default ( )
}
) ;
}
2022-04-27 19:43:36 +00:00
#[ test ]
fn task_subcommand_double_hyphen ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" task " ,
" -c " ,
" deno.json " ,
" build " ,
" -- " ,
" hello " ,
" world " ,
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-04-27 19:43:36 +00:00
} ) ,
argv : svec ! [ " -- " , " hello " , " world " ] ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " deno.json " . to_owned ( ) ) ,
2022-04-27 19:43:36 +00:00
.. Flags ::default ( )
2022-04-29 23:51:10 +00:00
}
) ;
2022-06-08 21:30:16 +00:00
let r = flags_from_vec ( svec! [
" deno " , " task " , " --cwd " , " foo " , " build " , " -- " , " hello " , " world "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
cwd : Some ( " foo " . to_string ( ) ) ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-06-08 21:30:16 +00:00
} ) ,
argv : svec ! [ " -- " , " hello " , " world " ] ,
.. Flags ::default ( )
}
) ;
2022-04-29 23:51:10 +00:00
}
#[ test ]
fn task_subcommand_double_hyphen_only ( ) {
// edge case, but it should forward
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " , " -- " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-04-29 23:51:10 +00:00
} ) ,
argv : svec ! [ " -- " ] ,
.. Flags ::default ( )
2022-04-27 19:43:36 +00:00
}
) ;
}
2022-04-29 14:29:14 +00:00
#[ test ]
fn task_following_arg ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " , " -1 " , " --test " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-04-29 14:29:14 +00:00
} ) ,
argv : svec ! [ " -1 " , " --test " ] ,
.. Flags ::default ( )
}
) ;
}
2022-05-11 16:58:35 +00:00
#[ test ]
fn task_following_double_hyphen_arg ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " build " , " --test " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-05-11 16:58:35 +00:00
} ) ,
argv : svec ! [ " --test " ] ,
.. Flags ::default ( )
}
) ;
}
2022-08-10 15:55:34 +00:00
#[ test ]
fn task_with_global_flags ( ) {
// can fail if the custom parser in task_parse() starts at the wrong index
let r =
flags_from_vec ( svec! [ " deno " , " --quiet " , " --unstable " , " task " , " build " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
cwd : None ,
2023-02-23 03:45:35 +00:00
task : Some ( " build " . to_string ( ) ) ,
2022-08-10 15:55:34 +00:00
} ) ,
unstable : true ,
log_level : Some ( log ::Level ::Error ) ,
.. Flags ::default ( )
}
) ;
}
2022-03-11 01:56:14 +00:00
#[ test ]
fn task_subcommand_empty ( ) {
2022-04-27 19:43:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " task " ] ) ;
2022-03-11 01:56:14 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : None ,
2022-03-11 01:56:14 +00:00
} ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn task_subcommand_config ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " --config " , " deno.jsonc " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : None ,
2022-03-11 01:56:14 +00:00
} ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2022-03-11 01:56:14 +00:00
.. Flags ::default ( )
}
2022-05-11 16:58:35 +00:00
) ;
}
#[ test ]
fn task_subcommand_config_short ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " -c " , " deno.jsonc " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Task ( TaskFlags {
2022-06-08 21:30:16 +00:00
cwd : None ,
2023-02-23 03:45:35 +00:00
task : None ,
2022-05-11 16:58:35 +00:00
} ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2022-05-11 16:58:35 +00:00
.. Flags ::default ( )
}
2022-03-11 01:56:14 +00:00
) ;
}
2022-03-11 22:07:02 +00:00
2022-06-28 19:47:51 +00:00
#[ test ]
fn task_subcommand_noconfig_invalid ( ) {
let r = flags_from_vec ( svec! [ " deno " , " task " , " --no-config " ] ) ;
assert_eq! ( r . unwrap_err ( ) . kind ( ) , clap ::ErrorKind ::UnknownArgument ) ;
}
2022-03-11 22:07:02 +00:00
#[ test ]
fn bench_with_flags ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" bench " ,
2023-02-12 17:40:45 +00:00
" --json " ,
2022-03-11 22:07:02 +00:00
" --unstable " ,
2023-03-13 21:04:00 +00:00
" --no-npm " ,
" --no-remote " ,
2022-03-11 22:07:02 +00:00
" --filter " ,
" - foo " ,
" --location " ,
" https:foo " ,
" --allow-net " ,
" dir1/ " ,
" dir2/ " ,
" -- " ,
" arg1 " ,
" arg2 "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Bench ( BenchFlags {
filter : Some ( " - foo " . to_string ( ) ) ,
2023-02-12 17:40:45 +00:00
json : true ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ PathBuf ::from ( " dir1/ " ) , PathBuf ::from ( " dir2/ " ) ] ,
ignore : vec ! [ ] ,
} ,
2022-03-11 22:07:02 +00:00
} ) ,
unstable : true ,
2023-03-13 21:04:00 +00:00
no_npm : true ,
no_remote : true ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-03-11 22:07:02 +00:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
allow_net : Some ( vec! [ ] ) ,
no_prompt : true ,
argv : svec ! [ " arg1 " , " arg2 " ] ,
.. Flags ::default ( )
}
) ;
}
2022-04-10 23:12:51 +00:00
2023-01-07 20:22:09 +00:00
#[ test ]
fn bench_watch ( ) {
let r = flags_from_vec ( svec! [ " deno " , " bench " , " --watch " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Bench ( BenchFlags {
filter : None ,
2023-02-12 17:40:45 +00:00
json : false ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
} ) ,
no_prompt : true ,
type_check_mode : TypeCheckMode ::Local ,
watch : Some ( vec! [ ] ) ,
.. Flags ::default ( )
}
) ;
}
2022-04-10 23:12:51 +00:00
#[ test ]
fn run_with_check ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --check " , " script.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-04-10 23:12:51 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --check=all " , " script.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::All ,
2022-04-10 23:12:51 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --check=foo " , " script.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::None ,
2022-04-10 23:12:51 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --no-check " ,
" --check " ,
" script.ts " ,
] ) ;
assert! ( r . is_err ( ) ) ;
}
2022-05-13 15:40:50 +00:00
#[ test ]
fn no_config ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --no-config " , " script.ts " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
} ) ,
config_flag : ConfigFlag ::Disabled ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --config " ,
" deno.json " ,
" --no-config " ,
" script.ts " ,
] ) ;
assert! ( r . is_err ( ) ) ;
}
2022-08-19 23:37:05 +00:00
#[ test ]
fn init ( ) {
let r = flags_from_vec ( svec! [ " deno " , " init " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Init ( InitFlags { dir : None } ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " init " , " foo " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Init ( InitFlags {
dir : Some ( String ::from ( " foo " ) ) ,
} ) ,
.. Flags ::default ( )
}
) ;
2022-09-02 15:59:36 +00:00
let r = flags_from_vec ( svec! [ " deno " , " init " , " --quiet " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Init ( InitFlags { dir : None } ) ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
2022-08-19 23:37:05 +00:00
}
2020-03-27 20:09:51 +00:00
}