2024-01-01 19:58:21 +00:00
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
2020-09-06 00:34:02 +00:00
2024-01-23 18:56:50 +00:00
use clap ::builder ::styling ::AnsiColor ;
2023-10-20 04:02:08 +00:00
use clap ::builder ::FalseyValueParser ;
2023-03-26 04:06:18 +00:00
use clap ::value_parser ;
2019-06-26 10:02:13 +00:00
use clap ::Arg ;
2023-03-26 04:06:18 +00:00
use clap ::ArgAction ;
2019-06-26 10:02:13 +00:00
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 ;
2024-03-27 22:47:46 +00:00
use deno_config ::glob ::PathOrPatternSet ;
2023-08-24 09:21:34 +00:00
use deno_config ::ConfigFlag ;
2024-05-06 23:21:58 +00:00
use deno_core ::anyhow ::bail ;
2024-03-27 22:47:46 +00:00
use deno_core ::anyhow ::Context ;
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 ;
2023-06-07 14:09:10 +00:00
use deno_graph ::GraphKind ;
2022-09-29 10:34:16 +00:00
use deno_runtime ::permissions ::parse_sys_kind ;
2024-05-06 23:21:58 +00:00
use deno_runtime ::permissions ::PermissionsOptions ;
2021-03-26 16:34:25 +00:00
use log ::debug ;
2019-06-22 16:02:51 +00:00
use log ::Level ;
2024-05-06 23:21:58 +00:00
use serde ::Deserialize ;
use serde ::Serialize ;
2022-04-18 19:08:30 +00:00
use std ::env ;
2024-03-22 21:03:56 +00:00
use std ::ffi ::OsString ;
2020-04-03 17:40:11 +00:00
use std ::net ::SocketAddr ;
2024-04-24 19:45:49 +00:00
use std ::num ::NonZeroU16 ;
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
2024-05-06 23:21:58 +00:00
use crate ::args ::resolve_no_prompt ;
2023-02-23 15:58:10 +00:00
use crate ::util ::fs ::canonicalize_path ;
2023-08-03 11:19:19 +00:00
use super ::flags_net ;
2024-05-08 19:34:46 +00:00
use super ::DENO_FUTURE ;
2022-06-27 20:54:09 +00:00
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
pub struct FileFlags {
2024-01-16 00:15:39 +00:00
pub ignore : Vec < String > ,
pub include : Vec < String > ,
2024-01-08 17:18:42 +00:00
}
2024-02-29 19:12:04 +00:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
pub struct AddFlags {
pub packages : Vec < String > ,
}
2023-01-07 20:22:09 +00:00
#[ 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 ,
2023-03-26 14:55:58 +00:00
pub no_run : bool ,
2023-06-15 17:09:37 +00:00
pub watch : Option < WatchFlags > ,
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 ,
2024-01-16 00:15:39 +00:00
pub out_file : Option < String > ,
2023-06-15 17:09:37 +00:00
pub watch : Option < WatchFlags > ,
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 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 ,
2024-03-14 23:53:46 +00:00
pub output : Option < String > ,
2021-09-03 23:33:35 +00:00
pub args : Vec < String > ,
pub target : Option < String > ,
2023-07-28 15:46:26 +00:00
pub no_terminal : bool ,
2023-03-18 23:43:07 +00:00
pub include : Vec < String > ,
2021-09-03 23:33:35 +00:00
}
2023-07-29 12:06:47 +00:00
impl CompileFlags {
pub fn resolve_target ( & self ) -> String {
self
. target
. clone ( )
. unwrap_or_else ( | | env! ( " TARGET " ) . to_string ( ) )
}
}
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-12-18 10:48:45 +00:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
2023-12-08 07:54:52 +00:00
pub enum CoverageType {
2023-12-18 10:48:45 +00:00
#[ default ]
2023-12-12 03:42:57 +00:00
Summary ,
2023-12-12 11:53:41 +00:00
Detailed ,
2023-12-08 07:54:52 +00:00
Lcov ,
Html ,
}
2023-12-18 10:48:45 +00:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
2021-09-03 23:33:35 +00:00
pub struct CoverageFlags {
2023-01-13 21:56:29 +00:00
pub files : FileFlags ,
2024-03-14 23:53:46 +00:00
pub output : Option < String > ,
2021-09-03 23:33:35 +00:00
pub include : Vec < String > ,
pub exclude : Vec < String > ,
2023-12-08 07:54:52 +00:00
pub r#type : CoverageType ,
2021-09-03 23:33:35 +00:00
}
2023-01-14 17:39:56 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub enum DocSourceFileFlag {
Builtin ,
2023-10-30 22:58:57 +00:00
Paths ( Vec < String > ) ,
2023-01-14 17:39:56 +00:00
}
impl Default for DocSourceFileFlag {
fn default ( ) -> Self {
Self ::Builtin
}
}
2023-11-01 15:25:05 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct DocHtmlFlag {
2024-04-24 20:34:21 +00:00
pub name : Option < String > ,
2024-03-14 23:53:46 +00:00
pub output : String ,
2023-11-01 15:25:05 +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 DocFlags {
pub private : bool ,
pub json : bool ,
2023-10-31 22:19:42 +00:00
pub lint : bool ,
2023-11-01 15:25:05 +00:00
pub html : Option < DocHtmlFlag > ,
2023-10-30 22:58:57 +00:00
pub source_files : 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 ,
}
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 ,
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 > ,
2023-06-15 17:09:37 +00:00
pub watch : Option < WatchFlags > ,
2021-09-03 23:33:35 +00:00
}
2023-06-14 22:29:19 +00:00
impl FmtFlags {
pub fn is_stdin ( & self ) -> bool {
let args = & self . files . include ;
2024-01-16 00:15:39 +00:00
args . len ( ) = = 1 & & args [ 0 ] = = " - "
2023-06-14 22:29:19 +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) ]
2024-04-04 14:40:54 +00:00
pub struct InstallFlagsGlobal {
2021-09-03 23:33:35 +00:00
pub module_url : String ,
pub args : Vec < String > ,
pub name : Option < String > ,
2023-11-13 14:44:01 +00:00
pub root : Option < String > ,
2021-09-03 23:33:35 +00:00
pub force : bool ,
2024-04-04 14:40:54 +00:00
}
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub enum InstallKind {
#[ allow(unused) ]
2024-05-08 19:34:46 +00:00
Local ( Option < AddFlags > ) ,
2024-04-04 14:40:54 +00:00
Global ( InstallFlagsGlobal ) ,
}
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct InstallFlags {
2024-03-27 22:45:57 +00:00
pub global : bool ,
2024-04-04 14:40:54 +00:00
pub kind : InstallKind ,
2021-09-03 23:33:35 +00:00
}
2023-09-16 00:42:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct JupyterFlags {
pub install : bool ,
pub kernel : bool ,
2024-03-14 23:53:46 +00:00
pub conn_file : Option < String > ,
2023-09-16 00:42:09 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2024-04-04 14:40:54 +00:00
pub struct UninstallFlagsGlobal {
2021-09-30 15:38:07 +00:00
pub name : String ,
2023-11-13 14:44:01 +00:00
pub root : Option < String > ,
2024-04-04 14:40:54 +00:00
}
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub enum UninstallKind {
#[ allow(unused) ]
Local ,
Global ( UninstallFlagsGlobal ) ,
}
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct UninstallFlags {
2024-03-27 22:45:57 +00:00
pub global : bool ,
2024-04-04 14:40:54 +00:00
pub kind : UninstallKind ,
2021-09-30 15:38:07 +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 LintFlags {
2023-01-07 20:22:09 +00:00
pub files : FileFlags ,
2021-09-03 23:33:35 +00:00
pub rules : bool ,
2024-03-21 21:18:59 +00:00
pub fix : 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 ,
2023-06-15 17:09:37 +00:00
pub watch : Option < WatchFlags > ,
2021-09-03 23:33:35 +00:00
}
2023-06-14 22:29:19 +00:00
impl LintFlags {
pub fn is_stdin ( & self ) -> bool {
let args = & self . files . include ;
2024-01-16 00:15:39 +00:00
args . len ( ) = = 1 & & args [ 0 ] = = " - "
2023-06-14 22:29:19 +00:00
}
}
2024-03-13 16:07:24 +00:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
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-11-14 21:06:00 +00:00
#[ derive(Clone, Debug, Eq, PartialEq, Default) ]
2021-09-03 23:33:35 +00:00
pub struct RunFlags {
pub script : String ,
2023-06-15 17:09:37 +00:00
pub watch : Option < WatchFlagsWithPaths > ,
2021-09-03 23:33:35 +00:00
}
2022-08-12 19:21:17 +00:00
impl RunFlags {
2023-12-06 21:36:06 +00:00
#[ cfg(test) ]
pub fn new_default ( script : String ) -> Self {
Self {
script ,
watch : None ,
}
}
2022-08-12 19:21:17 +00:00
pub fn is_stdin ( & self ) -> bool {
self . script = = " - "
}
}
2024-04-24 19:45:49 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct ServeFlags {
pub script : String ,
pub watch : Option < WatchFlagsWithPaths > ,
pub port : NonZeroU16 ,
pub host : String ,
}
impl ServeFlags {
#[ cfg(test) ]
pub fn new_default ( script : String , port : u16 , host : & str ) -> Self {
Self {
script ,
watch : None ,
port : NonZeroU16 ::new ( port ) . unwrap ( ) ,
host : host . to_owned ( ) ,
}
}
}
2023-06-15 17:09:37 +00:00
#[ derive(Clone, Default, Debug, Eq, PartialEq) ]
pub struct WatchFlags {
2023-10-31 00:25:58 +00:00
pub hmr : bool ,
2023-06-15 17:09:37 +00:00
pub no_clear_screen : bool ,
2024-03-27 22:47:46 +00:00
pub exclude : Vec < String > ,
2023-06-15 17:09:37 +00:00
}
#[ derive(Clone, Default, Debug, Eq, PartialEq) ]
pub struct WatchFlagsWithPaths {
2023-10-31 00:25:58 +00:00
pub hmr : bool ,
2024-03-14 23:53:46 +00:00
pub paths : Vec < String > ,
2023-06-15 17:09:37 +00:00
pub no_clear_screen : bool ,
2024-03-27 22:47:46 +00:00
pub exclude : Vec < String > ,
2023-06-15 17:09:37 +00:00
}
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-08-02 16:38:10 +00:00
#[ derive(Clone, Debug, Default, Eq, PartialEq) ]
pub enum TestReporterConfig {
#[ default ]
Pretty ,
Dot ,
2023-08-03 02:05:34 +00:00
Junit ,
2023-08-25 23:19:23 +00:00
Tap ,
2023-08-02 16:38:10 +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 ,
2023-06-15 17:09:37 +00:00
pub coverage_dir : Option < String > ,
2021-09-03 23:33:35 +00:00
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 > ,
2024-02-28 16:12:43 +00:00
pub trace_leaks : bool ,
2023-06-15 17:09:37 +00:00
pub watch : Option < WatchFlags > ,
2023-08-02 16:38:10 +00:00
pub reporter : TestReporterConfig ,
2023-08-03 02:05:34 +00:00
pub junit_path : Option < 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 UpgradeFlags {
pub dry_run : bool ,
pub force : bool ,
pub canary : bool ,
pub version : Option < String > ,
2024-03-14 23:53:46 +00:00
pub output : Option < String > ,
2021-09-03 23:33:35 +00:00
}
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 > ,
2024-03-14 23:53:46 +00:00
pub output_path : Option < String > ,
2022-02-16 18:14:19 +00:00
pub force : bool ,
}
2023-11-23 23:38:07 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
pub struct PublishFlags {
pub token : Option < String > ,
2024-01-11 21:17:03 +00:00
pub dry_run : bool ,
2024-02-19 15:28:41 +00:00
pub allow_slow_types : bool ,
2024-03-07 21:13:36 +00:00
pub allow_dirty : bool ,
2024-02-29 16:18:47 +00:00
pub no_provenance : bool ,
2023-11-23 23:38:07 +00:00
}
2023-01-07 20:22:09 +00:00
#[ derive(Clone, Debug, Eq, PartialEq) ]
2019-11-26 16:06:32 +00:00
pub enum DenoSubcommand {
2024-02-29 19:12:04 +00:00
Add ( AddFlags ) ,
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 ) ,
2023-09-16 00:42:09 +00:00
Jupyter ( JupyterFlags ) ,
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 ) ,
2024-04-24 19:45:49 +00:00
Serve ( ServeFlags ) ,
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 ) ,
2023-11-23 23:38:07 +00:00
Publish ( PublishFlags ) ,
2019-11-26 16:06:32 +00:00
}
2023-11-11 17:01:48 +00:00
impl DenoSubcommand {
pub fn is_run ( & self ) -> bool {
matches! ( self , Self ::Run ( _ ) )
}
2023-11-14 21:06:00 +00:00
2023-11-25 03:46:16 +00:00
// Returns `true` if the subcommand depends on testing infrastructure.
pub fn needs_test ( & self ) -> bool {
matches! (
self ,
Self ::Test ( _ )
| Self ::Jupyter ( _ )
| Self ::Repl ( _ )
| Self ::Bench ( _ )
| Self ::Lsp
)
2023-11-14 21:06:00 +00:00
}
2023-11-11 17:01:48 +00:00
}
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 ,
}
2023-06-07 14:09:10 +00:00
impl TypeCheckMode {
/// Gets if type checking will occur under this mode.
pub fn is_true ( & self ) -> bool {
match self {
Self ::None = > false ,
Self ::Local | Self ::All = > true ,
}
}
/// Gets the corresponding module `GraphKind` that should be created
/// for the current `TypeCheckMode`.
pub fn as_graph_kind ( & self ) -> GraphKind {
match self . is_true ( ) {
true = > GraphKind ::All ,
false = > GraphKind ::CodeOnly ,
}
}
}
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
}
}
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 > ) ,
}
2024-01-22 17:37:28 +00:00
#[ derive(
Clone , Default , Debug , Eq , PartialEq , serde ::Serialize , serde ::Deserialize ,
) ]
pub struct UnstableConfig {
pub legacy_flag_enabled : bool , // --unstable
pub bare_node_builtins : bool , // --unstable-bare-node-builts
pub byonm : bool ,
pub sloppy_imports : bool ,
pub features : Vec < String > , // --unstabe-kv --unstable-cron
}
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 ,
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 > ,
2023-08-07 01:56:56 +00:00
pub vendor : Option < bool > ,
2023-11-05 21:27:36 +00:00
pub enable_op_summary_metrics : bool ,
2021-07-23 14:31:16 +00:00
pub enable_testing_features : bool ,
2023-03-22 14:15:53 +00:00
pub ext : Option < String > ,
2024-03-14 23:53:46 +00:00
pub ignore : Vec < String > ,
2020-04-30 15:23:40 +00:00
pub import_map_path : Option < String > ,
2023-11-01 15:21:13 +00:00
pub env_file : 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 ,
2024-03-14 23:53:46 +00:00
pub lock : Option < String > ,
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 ,
2020-04-30 15:23:40 +00:00
pub reload : bool ,
pub seed : Option < u64 > ,
2023-11-10 17:41:24 +00:00
pub strace_ops : Option < Vec < String > > ,
2024-01-22 17:37:28 +00:00
pub unstable_config : UnstableConfig ,
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 > ,
2024-04-17 14:19:55 +00:00
pub code_cache_enabled : bool ,
2024-05-06 23:21:58 +00:00
pub permissions : PermissionFlags ,
}
#[ derive(Clone, Debug, Eq, PartialEq, Default, Serialize, Deserialize) ]
pub struct PermissionFlags {
pub allow_all : bool ,
pub allow_env : Option < Vec < String > > ,
pub deny_env : Option < Vec < String > > ,
pub allow_hrtime : bool ,
pub deny_hrtime : bool ,
pub allow_ffi : Option < Vec < String > > ,
pub deny_ffi : Option < Vec < String > > ,
pub allow_net : Option < Vec < String > > ,
pub deny_net : Option < Vec < String > > ,
pub allow_read : Option < Vec < String > > ,
pub deny_read : Option < Vec < String > > ,
pub allow_run : Option < Vec < String > > ,
pub deny_run : Option < Vec < String > > ,
pub allow_sys : Option < Vec < String > > ,
pub deny_sys : Option < Vec < String > > ,
pub allow_write : Option < Vec < String > > ,
pub deny_write : Option < Vec < String > > ,
pub no_prompt : bool ,
}
impl PermissionFlags {
pub fn has_permission ( & self ) -> bool {
self . allow_all
| | self . allow_env . is_some ( )
| | self . deny_env . is_some ( )
| | self . allow_hrtime
| | self . deny_hrtime
| | self . allow_ffi . is_some ( )
| | self . deny_ffi . is_some ( )
| | self . allow_net . is_some ( )
| | self . deny_net . is_some ( )
| | self . allow_read . is_some ( )
| | self . deny_read . is_some ( )
| | self . allow_run . is_some ( )
| | self . deny_run . is_some ( )
| | self . allow_sys . is_some ( )
| | self . deny_sys . is_some ( )
| | self . allow_write . is_some ( )
| | self . deny_write . is_some ( )
}
pub fn to_options (
& self ,
// will be None when `deno compile` can't resolve the cwd
initial_cwd : Option < & Path > ,
) -> Result < PermissionsOptions , AnyError > {
fn convert_option_str_to_path_buf (
flag : & Option < Vec < String > > ,
initial_cwd : Option < & Path > ,
) -> Result < Option < Vec < PathBuf > > , AnyError > {
let Some ( paths ) = & flag else {
return Ok ( None ) ;
} ;
let mut new_paths = Vec ::with_capacity ( paths . len ( ) ) ;
for path in paths {
if let Some ( initial_cwd ) = initial_cwd {
new_paths . push ( initial_cwd . join ( path ) )
} else {
let path = PathBuf ::from ( path ) ;
if path . is_absolute ( ) {
new_paths . push ( path ) ;
} else {
bail! ( " Could not resolve relative permission path '{}' when current working directory could not be resolved. " , path . display ( ) )
}
}
}
Ok ( Some ( new_paths ) )
}
Ok ( PermissionsOptions {
allow_all : self . allow_all ,
allow_env : self . allow_env . clone ( ) ,
deny_env : self . deny_env . clone ( ) ,
allow_hrtime : self . allow_hrtime ,
deny_hrtime : self . deny_hrtime ,
allow_net : self . allow_net . clone ( ) ,
deny_net : self . deny_net . clone ( ) ,
allow_ffi : convert_option_str_to_path_buf ( & self . allow_ffi , initial_cwd ) ? ,
deny_ffi : convert_option_str_to_path_buf ( & self . deny_ffi , initial_cwd ) ? ,
allow_read : convert_option_str_to_path_buf (
& self . allow_read ,
initial_cwd ,
) ? ,
deny_read : convert_option_str_to_path_buf ( & self . deny_read , initial_cwd ) ? ,
allow_run : self . allow_run . clone ( ) ,
deny_run : self . deny_run . clone ( ) ,
allow_sys : self . allow_sys . clone ( ) ,
deny_sys : self . deny_sys . clone ( ) ,
allow_write : convert_option_str_to_path_buf (
& self . allow_write ,
initial_cwd ,
) ? ,
deny_write : convert_option_str_to_path_buf (
& self . deny_write ,
initial_cwd ,
) ? ,
prompt : ! resolve_no_prompt ( self ) ,
} )
}
2018-11-15 17:56:17 +00:00
}
2024-03-14 23:53:46 +00:00
fn join_paths ( allowlist : & [ String ] , d : & str ) -> String {
2020-06-13 17:09:39 +00:00
allowlist
2020-02-11 09:29:36 +00:00
. iter ( )
2024-03-14 23:53:46 +00:00
. map ( | path | path . to_string ( ) )
2020-02-11 09:29:36 +00:00
. 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! [ ] ;
2024-05-06 23:21:58 +00:00
if self . permissions . allow_all {
2022-01-10 14:22:03 +00:00
args . push ( " --allow-all " . to_string ( ) ) ;
return args ;
}
2024-05-06 23:21:58 +00:00
match & self . permissions . allow_read {
2020-12-29 18:34:35 +00:00
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
}
2024-05-06 23:21:58 +00:00
match & self . permissions . deny_read {
2023-08-03 11:19:19 +00:00
Some ( read_denylist ) if read_denylist . is_empty ( ) = > {
args . push ( " --deny-read " . to_string ( ) ) ;
}
Some ( read_denylist ) = > {
let s = format! ( " --deny-read= {} " , join_paths ( read_denylist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2024-05-06 23:21:58 +00:00
match & self . permissions . allow_write {
2020-12-29 18:34:35 +00:00
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
}
2024-05-06 23:21:58 +00:00
match & self . permissions . deny_write {
2023-08-03 11:19:19 +00:00
Some ( write_denylist ) if write_denylist . is_empty ( ) = > {
args . push ( " --deny-write " . to_string ( ) ) ;
}
Some ( write_denylist ) = > {
let s = format! ( " --deny-write= {} " , join_paths ( write_denylist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2024-05-06 23:21:58 +00:00
match & self . permissions . allow_net {
2020-12-29 18:34:35 +00:00
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
}
2024-05-06 23:21:58 +00:00
match & self . permissions . deny_net {
2023-08-03 11:19:19 +00:00
Some ( net_denylist ) if net_denylist . is_empty ( ) = > {
args . push ( " --deny-net " . to_string ( ) ) ;
}
Some ( net_denylist ) = > {
let s = format! ( " --deny-net= {} " , net_denylist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
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 ) ;
}
_ = > { }
}
2024-05-06 23:21:58 +00:00
match & self . permissions . allow_env {
2021-04-13 11:25:21 +00:00
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
}
2024-05-06 23:21:58 +00:00
match & self . permissions . deny_env {
2023-08-03 11:19:19 +00:00
Some ( env_denylist ) if env_denylist . is_empty ( ) = > {
args . push ( " --deny-env " . to_string ( ) ) ;
}
Some ( env_denylist ) = > {
let s = format! ( " --deny-env= {} " , env_denylist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2024-05-06 23:21:58 +00:00
match & self . permissions . allow_run {
2021-04-09 22:12:00 +00:00
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
}
2024-05-06 23:21:58 +00:00
match & self . permissions . deny_run {
2023-08-03 11:19:19 +00:00
Some ( run_denylist ) if run_denylist . is_empty ( ) = > {
args . push ( " --deny-run " . to_string ( ) ) ;
}
Some ( run_denylist ) = > {
let s = format! ( " --deny-run= {} " , run_denylist . join ( " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2024-05-06 23:21:58 +00:00
match & self . permissions . allow_sys {
2022-09-28 12:46:50 +00:00
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 )
}
_ = > { }
}
2024-05-06 23:21:58 +00:00
match & self . permissions . deny_sys {
2023-08-03 11:19:19 +00:00
Some ( sys_denylist ) if sys_denylist . is_empty ( ) = > {
args . push ( " --deny-sys " . to_string ( ) ) ;
}
Some ( sys_denylist ) = > {
let s = format! ( " --deny-sys= {} " , sys_denylist . join ( " , " ) ) ;
args . push ( s )
}
_ = > { }
}
2024-05-06 23:21:58 +00:00
match & self . permissions . allow_ffi {
2021-08-06 21:28:10 +00:00
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
}
2024-05-06 23:21:58 +00:00
match & self . permissions . deny_ffi {
2023-08-03 11:19:19 +00:00
Some ( ffi_denylist ) if ffi_denylist . is_empty ( ) = > {
args . push ( " --deny-ffi " . to_string ( ) ) ;
}
Some ( ffi_denylist ) = > {
let s = format! ( " --deny-ffi= {} " , join_paths ( ffi_denylist , " , " ) ) ;
args . push ( s ) ;
}
_ = > { }
}
2024-05-06 23:21:58 +00:00
if self . permissions . allow_hrtime {
2020-01-30 23:42:39 +00:00
args . push ( " --allow-hrtime " . to_string ( ) ) ;
}
2024-05-06 23:21:58 +00:00
if self . permissions . deny_hrtime {
2023-08-03 11:19:19 +00:00
args . push ( " --deny-hrtime " . to_string ( ) ) ;
}
2020-01-30 23:42:39 +00:00
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 {
2024-01-16 00:15:39 +00:00
Fmt ( FmtFlags { files , .. } ) = > {
Some ( files . include . iter ( ) . map ( | p | current_dir . join ( p ) ) . collect ( ) )
}
Lint ( LintFlags { files , .. } ) = > {
Some ( files . include . iter ( ) . map ( | p | current_dir . join ( p ) ) . collect ( ) )
}
2023-06-15 17:09:37 +00:00
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 ) , ..
} ) = > {
2024-01-16 00:15:39 +00:00
// todo(dsherret): Why is this canonicalized? Document why.
2023-02-23 15:58:10 +00:00
// 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 {
2024-04-24 19:45:49 +00:00
Run ( RunFlags { script , .. } ) | Serve ( ServeFlags { 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 " {
2024-02-04 05:11:12 +00:00
Some ( current_dir . to_path_buf ( ) )
2023-02-23 03:45:35 +00:00
} 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 ( _ )
2024-02-23 14:56:49 +00:00
| Test ( _ ) | Bench ( _ ) | Repl ( _ ) | Compile ( _ ) | Publish ( _ ) = > {
2024-05-08 19:34:46 +00:00
Some ( current_dir . to_path_buf ( ) )
2023-05-11 00:06:59 +00:00
}
2024-02-29 19:12:04 +00:00
Add ( _ ) | Bundle ( _ ) | Completions ( _ ) | Doc ( _ ) | Fmt ( _ ) | Init ( _ )
2024-05-08 19:34:46 +00:00
| Uninstall ( _ ) | Jupyter ( _ ) | Lsp | Lint ( _ ) | Types | Upgrade ( _ )
| Vendor ( _ ) = > None ,
Install ( _ ) = > {
if * DENO_FUTURE {
Some ( current_dir . to_path_buf ( ) )
} else {
None
}
}
2023-02-20 18:14:06 +00:00
}
}
2022-11-24 03:00:31 +00:00
pub fn has_permission ( & self ) -> bool {
2024-05-06 23:21:58 +00:00
self . permissions . has_permission ( )
2022-11-24 03:00:31 +00:00
}
pub fn has_permission_in_argv ( & self ) -> bool {
self . argv . iter ( ) . any ( | arg | {
arg = = " --allow-all "
| | arg = = " --allow-hrtime "
2023-08-03 11:19:19 +00:00
| | arg = = " --deny-hrtime "
2022-11-24 03:00:31 +00:00
| | arg . starts_with ( " --allow-env " )
2023-08-03 11:19:19 +00:00
| | arg . starts_with ( " --deny-env " )
2022-11-24 03:00:31 +00:00
| | arg . starts_with ( " --allow-ffi " )
2023-08-03 11:19:19 +00:00
| | arg . starts_with ( " --deny-ffi " )
2022-11-24 03:00:31 +00:00
| | arg . starts_with ( " --allow-net " )
2023-08-03 11:19:19 +00:00
| | arg . starts_with ( " --deny-net " )
2022-11-24 03:00:31 +00:00
| | arg . starts_with ( " --allow-read " )
2023-08-03 11:19:19 +00:00
| | arg . starts_with ( " --deny-read " )
2022-11-24 03:00:31 +00:00
| | arg . starts_with ( " --allow-run " )
2023-08-03 11:19:19 +00:00
| | arg . starts_with ( " --deny-run " )
2022-11-24 03:00:31 +00:00
| | arg . starts_with ( " --allow-sys " )
2023-08-03 11:19:19 +00:00
| | arg . starts_with ( " --deny-sys " )
2022-11-24 03:00:31 +00:00
| | arg . starts_with ( " --allow-write " )
2023-08-03 11:19:19 +00:00
| | arg . starts_with ( " --deny-write " )
2022-11-24 03:00:31 +00:00
} )
}
2024-03-13 16:07:24 +00:00
#[ inline(always) ]
fn allow_all ( & mut self ) {
2024-05-06 23:21:58 +00:00
self . permissions . allow_all = true ;
self . permissions . allow_read = Some ( vec! [ ] ) ;
self . permissions . allow_env = Some ( vec! [ ] ) ;
self . permissions . allow_net = Some ( vec! [ ] ) ;
self . permissions . allow_run = Some ( vec! [ ] ) ;
self . permissions . allow_write = Some ( vec! [ ] ) ;
self . permissions . allow_sys = Some ( vec! [ ] ) ;
self . permissions . allow_ffi = Some ( vec! [ ] ) ;
self . permissions . allow_hrtime = true ;
2024-03-13 16:07:24 +00:00
}
2024-03-27 22:47:46 +00:00
pub fn resolve_watch_exclude_set (
& self ,
) -> Result < PathOrPatternSet , AnyError > {
if let DenoSubcommand ::Run ( RunFlags {
watch :
Some ( WatchFlagsWithPaths {
exclude : excluded_paths ,
..
} ) ,
..
} )
| DenoSubcommand ::Bundle ( BundleFlags {
watch :
Some ( WatchFlags {
exclude : excluded_paths ,
..
} ) ,
..
} )
| DenoSubcommand ::Bench ( BenchFlags {
watch :
Some ( WatchFlags {
exclude : excluded_paths ,
..
} ) ,
..
} )
| DenoSubcommand ::Test ( TestFlags {
watch :
Some ( WatchFlags {
exclude : excluded_paths ,
..
} ) ,
..
} )
| DenoSubcommand ::Lint ( LintFlags {
watch :
Some ( WatchFlags {
exclude : excluded_paths ,
..
} ) ,
..
} )
| DenoSubcommand ::Fmt ( FmtFlags {
watch :
Some ( WatchFlags {
exclude : excluded_paths ,
..
} ) ,
..
} ) = & self . subcommand
{
let cwd = std ::env ::current_dir ( ) ? ;
PathOrPatternSet ::from_exclude_relative_path_or_patterns (
& cwd ,
excluded_paths ,
)
. context ( " Failed resolving watch exclude patterns. " )
} else {
Ok ( PathOrPatternSet ::default ( ) )
}
}
2020-12-29 18:34:35 +00:00
}
2024-01-23 18:56:50 +00:00
static ENV_VARIABLES_HELP : & str = color_print ::cstr! (
r #" <y>Environment variables:</>
< g > DENO_AUTH_TOKENS < / > A semi - colon separated list of bearer tokens and
2021-02-16 02:50:27 +00:00
hostnames to use when fetching remote modules from
private repositories
( e . g . " abcde12345@deno.land;54321edcba@github.com " )
2024-01-23 18:56:50 +00:00
2024-04-16 16:58:48 +00:00
< g > DENO_FUTURE < / > Set to " 1 " to enable APIs that will take effect in
Deno 2
2024-01-23 18:56:50 +00:00
< g > DENO_CERT < / > Load certificate authority from PEM encoded file
< g > DENO_DIR < / > Set the cache directory
< g > DENO_INSTALL_ROOT < / > Set deno install ' s output directory
2020-04-16 22:15:42 +00:00
( defaults to $HOME / . deno / bin )
2024-01-23 18:56:50 +00:00
2024-04-16 16:58:48 +00:00
< g > DENO_JOBS < / > Number of parallel workers used for the - - parallel
flag with the test subcommand . Defaults to number
of available CPUs .
2024-01-23 18:56:50 +00:00
< g > DENO_REPL_HISTORY < / > Set REPL history file path
2023-03-16 16:22:24 +00:00
History file is disabled when the value is empty
( defaults to $DENO_DIR / deno_history . txt )
2024-01-23 18:56:50 +00:00
< g > DENO_NO_PACKAGE_JSON < / > Disables auto - resolution of package . json
< g > DENO_NO_PROMPT < / > Set to disable permission prompts on access
2022-04-18 19:08:30 +00:00
( alternative to passing - - no - prompt on invocation )
2024-01-23 18:56:50 +00:00
< g > DENO_NO_UPDATE_CHECK < / > Set to disable checking if a newer Deno version is
2022-10-20 14:15:21 +00:00
available
2024-01-23 18:56:50 +00:00
2024-04-16 16:58:48 +00:00
< g > DENO_TLS_CA_STORE < / > Comma - separated list of order dependent certificate
stores . Possible values : " system " , " mozilla " .
Defaults to " mozilla " .
2024-01-23 18:56:50 +00:00
< g > DENO_V8_FLAGS < / > Set V8 command line options
< g > DENO_WEBGPU_TRACE < / > Directory to use for wgpu traces
< g > HTTP_PROXY < / > Proxy address for HTTP requests
2020-04-16 22:15:42 +00:00
( module downloads , fetch )
2024-01-23 18:56:50 +00:00
< g > HTTPS_PROXY < / > Proxy address for HTTPS requests
2020-08-15 13:48:29 +00:00
( module downloads , fetch )
2024-01-23 18:56:50 +00:00
< g > NO_COLOR < / > Set to disable color
< g > NO_PROXY < / > Comma - separated list of hosts which do not use a proxy
2024-04-16 16:58:48 +00:00
( module downloads , fetch )
< g > NPM_CONFIG_REGISTRY < / > URL to use for the npm registry . " #
2024-01-23 18:56:50 +00:00
) ;
2019-06-05 17:44:46 +00:00
2023-03-27 16:28:41 +00:00
static DENO_HELP : & str = concat! (
2024-01-23 18:56:50 +00:00
color_print ::cstr! ( " <g>A modern JavaScript and TypeScript runtime</> " ) ,
"
2019-05-06 14:48:19 +00:00
2023-03-27 16:28:41 +00:00
Docs : https ://deno.land/manual@v",
env! ( " CARGO_PKG_VERSION " ) ,
2024-01-23 18:56:50 +00:00
color_print ::cstr! (
"
2024-04-10 21:26:35 +00:00
Standard Library : https ://jsr.io/@std
Modules : https ://jsr.io/ 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
2024-01-23 18:56:50 +00:00
< g > deno < / >
2019-05-23 18:57:44 +00:00
2019-11-26 16:06:32 +00:00
To execute a script :
2021-04-18 13:12:55 +00:00
2024-01-23 18:56:50 +00:00
< g > deno run https ://examples.deno.land/hello-world.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
2024-01-23 18:56:50 +00:00
< g > deno eval \ " console.log(30933 + 404) \" </>
2023-03-27 16:28:41 +00:00
"
2024-01-23 18:56:50 +00:00
)
2023-03-27 16:28:41 +00:00
) ;
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.
2024-03-22 21:03:56 +00:00
pub fn flags_from_vec ( args : Vec < OsString > ) -> clap ::error ::Result < Flags > {
2023-03-26 04:06:18 +00:00
let mut app = clap_root ( ) ;
let mut 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
2023-03-26 04:06:18 +00:00
if matches . get_flag ( " unstable " ) {
2024-01-22 17:37:28 +00:00
flags . unstable_config . legacy_flag_enabled = true ;
2020-09-20 11:45:00 +00:00
}
2023-11-25 16:41:21 +00:00
for ( name , _ , _ ) in crate ::UNSTABLE_GRANULAR_FLAGS {
if matches . get_flag ( & format! ( " unstable- {} " , name ) ) {
2024-01-22 17:37:28 +00:00
flags . unstable_config . features . push ( name . to_string ( ) ) ;
2023-11-25 16:41:21 +00:00
}
2023-11-01 22:15:08 +00:00
}
2023-01-15 04:06:46 +00:00
2024-01-22 17:37:28 +00:00
flags . unstable_config . bare_node_builtins =
2023-10-25 18:39:00 +00:00
matches . get_flag ( " unstable-bare-node-builtins " ) ;
2024-01-22 17:37:28 +00:00
flags . unstable_config . byonm = matches . get_flag ( " unstable-byonm " ) ;
flags . unstable_config . sloppy_imports =
matches . get_flag ( " unstable-sloppy-imports " ) ;
2023-10-20 04:02:08 +00:00
2023-03-26 04:06:18 +00:00
if matches . get_flag ( " quiet " ) {
2020-03-10 12:26:17 +00:00
flags . log_level = Some ( Level ::Error ) ;
2023-03-26 04:06:18 +00:00
} else if let Some ( log_level ) = matches . get_one ::< String > ( " log-level " ) {
flags . log_level = match log_level . as_str ( ) {
2023-09-09 18:03:19 +00:00
" trace " = > Some ( Level ::Trace ) ,
2023-03-26 04:06:18 +00:00
" debug " = > Some ( Level ::Debug ) ,
" info " = > Some ( Level ::Info ) ,
_ = > unreachable! ( ) ,
} ;
2020-03-10 12:26:17 +00:00
}
2019-11-26 16:06:32 +00:00
2023-03-26 04:06:18 +00:00
if let Some ( ( subcommand , mut m ) ) = matches . remove_subcommand ( ) {
match subcommand . as_str ( ) {
2024-02-29 19:12:04 +00:00
" add " = > add_parse ( & mut flags , & mut m ) ,
2023-03-26 04:06:18 +00:00
" bench " = > bench_parse ( & mut flags , & mut m ) ,
" bundle " = > bundle_parse ( & mut flags , & mut m ) ,
" cache " = > cache_parse ( & mut flags , & mut m ) ,
" check " = > check_parse ( & mut flags , & mut m ) ,
" compile " = > compile_parse ( & mut flags , & mut m ) ,
" completions " = > completions_parse ( & mut flags , & mut m , app ) ,
" coverage " = > coverage_parse ( & mut flags , & mut m ) ,
" doc " = > doc_parse ( & mut flags , & mut m ) ,
" eval " = > eval_parse ( & mut flags , & mut m ) ,
" fmt " = > fmt_parse ( & mut flags , & mut m ) ,
" init " = > init_parse ( & mut flags , & mut m ) ,
" info " = > info_parse ( & mut flags , & mut m ) ,
" install " = > install_parse ( & mut flags , & mut m ) ,
2023-09-16 00:42:09 +00:00
" jupyter " = > jupyter_parse ( & mut flags , & mut m ) ,
2023-03-26 04:06:18 +00:00
" lint " = > lint_parse ( & mut flags , & mut m ) ,
" lsp " = > lsp_parse ( & mut flags , & mut m ) ,
" repl " = > repl_parse ( & mut flags , & mut m ) ,
2023-08-13 02:04:17 +00:00
" run " = > run_parse ( & mut flags , & mut m , app ) ? ,
2024-04-24 19:45:49 +00:00
" serve " = > serve_parse ( & mut flags , & mut m , app ) ? ,
2023-03-26 04:06:18 +00:00
" task " = > task_parse ( & mut flags , & mut m ) ,
" test " = > test_parse ( & mut flags , & mut m ) ,
" types " = > types_parse ( & mut flags , & mut m ) ,
" uninstall " = > uninstall_parse ( & mut flags , & mut m ) ,
" upgrade " = > upgrade_parse ( & mut flags , & mut m ) ,
" vendor " = > vendor_parse ( & mut flags , & mut m ) ,
2024-01-08 20:07:36 +00:00
" publish " = > publish_parse ( & mut flags , & mut m ) ,
2023-03-26 04:06:18 +00:00
_ = > unreachable! ( ) ,
}
} else {
handle_repl_flags (
2022-04-20 12:16:37 +00:00
& 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
} ,
2023-03-26 04:06:18 +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 {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_net = Some ( vec! [ ] ) ;
flags . permissions . allow_env = Some ( vec! [ ] ) ;
flags . permissions . allow_run = Some ( vec! [ ] ) ;
flags . permissions . allow_read = Some ( vec! [ ] ) ;
flags . permissions . allow_sys = Some ( vec! [ ] ) ;
flags . permissions . allow_write = Some ( vec! [ ] ) ;
flags . permissions . allow_ffi = Some ( vec! [ ] ) ;
flags . permissions . allow_hrtime = true ;
2022-12-07 19:21:18 +00:00
}
2022-01-14 16:38:17 +00:00
flags . subcommand = DenoSubcommand ::Repl ( repl_flags ) ;
}
2023-03-26 04:06:18 +00:00
fn clap_root ( ) -> Command {
2023-03-27 16:28:41 +00:00
let long_version = format! (
" {} ({}, {}) \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
) ;
2023-11-01 22:15:08 +00:00
let mut cmd = Command ::new ( " deno " )
2019-11-26 16:06:32 +00:00
. bin_name ( " deno " )
2024-01-23 18:56:50 +00:00
. styles (
clap ::builder ::Styles ::styled ( )
. header ( AnsiColor ::Yellow . on_default ( ) )
. usage ( AnsiColor ::White . on_default ( ) )
. literal ( AnsiColor ::Green . on_default ( ) )
. placeholder ( AnsiColor ::Green . on_default ( ) )
)
. color ( ColorChoice ::Auto )
2022-04-11 05:01:02 +00:00
. max_term_width ( 80 )
2023-03-26 04:06:18 +00:00
. version ( crate ::version ::deno ( ) )
2023-03-27 16:28:41 +00:00
. long_version ( long_version )
2023-12-06 14:22:30 +00:00
// cause --unstable flags to display at the bottom of the help text
. next_display_order ( 1000 )
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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2020-09-20 11:45:00 +00:00
. global ( true ) ,
)
2023-10-20 04:02:08 +00:00
. arg (
Arg ::new ( " unstable-bare-node-builtins " )
. long ( " unstable-bare-node-builtins " )
. help ( " Enable unstable bare node builtins feature " )
. env ( " DENO_UNSTABLE_BARE_NODE_BUILTINS " )
. value_parser ( FalseyValueParser ::new ( ) )
. action ( ArgAction ::SetTrue )
. global ( true ) ,
)
2023-10-25 18:39:00 +00:00
. arg (
Arg ::new ( " unstable-byonm " )
. long ( " unstable-byonm " )
. help ( " Enable unstable 'bring your own node_modules' feature " )
. env ( " DENO_UNSTABLE_BYONM " )
. value_parser ( FalseyValueParser ::new ( ) )
. action ( ArgAction ::SetTrue )
. global ( true ) ,
2023-11-17 01:28:38 +00:00
)
2023-12-07 00:03:18 +00:00
. arg (
Arg ::new ( " unstable-sloppy-imports " )
. long ( " unstable-sloppy-imports " )
. help (
" Enable unstable resolving of specifiers by extension probing, .js to .ts, and directory probing. " ,
)
. env ( " DENO_UNSTABLE_SLOPPY_IMPORTS " )
. value_parser ( FalseyValueParser ::new ( ) )
. action ( ArgAction ::SetTrue )
. global ( true ) ,
2023-11-01 22:15:08 +00:00
) ;
for ( flag_name , help , _ ) in crate ::UNSTABLE_GRANULAR_FLAGS {
cmd = cmd . arg (
Arg ::new ( format! ( " unstable- {} " , flag_name ) )
. long ( format! ( " unstable- {} " , flag_name ) )
. help ( help )
. action ( ArgAction ::SetTrue )
. global ( true ) ,
) ;
}
cmd
2023-12-06 14:22:30 +00:00
// reset the display order after the unstable flags
. next_display_order ( 0 )
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 )
2023-09-09 18:03:19 +00:00
. value_parser ( [ " trace " , " 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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2020-03-10 12:26:17 +00:00
. global ( true ) ,
)
2019-11-26 16:06:32 +00:00
. subcommand ( run_subcommand ( ) )
2024-04-24 19:45:49 +00:00
. subcommand ( serve_subcommand ( ) )
2023-06-12 11:54:04 +00:00
. defer ( | cmd | {
cmd
2024-02-29 19:12:04 +00:00
. subcommand ( add_subcommand ( ) )
2023-06-12 11:54:04 +00:00
. subcommand ( bench_subcommand ( ) )
. subcommand ( bundle_subcommand ( ) )
. subcommand ( cache_subcommand ( ) )
. subcommand ( check_subcommand ( ) )
. subcommand ( compile_subcommand ( ) )
. subcommand ( completions_subcommand ( ) )
. subcommand ( coverage_subcommand ( ) )
. subcommand ( doc_subcommand ( ) )
. subcommand ( eval_subcommand ( ) )
. subcommand ( fmt_subcommand ( ) )
. subcommand ( init_subcommand ( ) )
. subcommand ( info_subcommand ( ) )
2024-05-08 19:34:46 +00:00
. subcommand ( if * DENO_FUTURE {
future_install_subcommand ( )
} else {
install_subcommand ( )
} )
2023-09-16 00:42:09 +00:00
. subcommand ( jupyter_subcommand ( ) )
2023-06-12 11:54:04 +00:00
. subcommand ( uninstall_subcommand ( ) )
. subcommand ( lsp_subcommand ( ) )
. subcommand ( lint_subcommand ( ) )
2023-11-23 23:38:07 +00:00
. subcommand ( publish_subcommand ( ) )
2023-06-12 11:54:04 +00:00
. subcommand ( repl_subcommand ( ) )
. subcommand ( task_subcommand ( ) )
. subcommand ( test_subcommand ( ) )
. subcommand ( types_subcommand ( ) )
. subcommand ( upgrade_subcommand ( ) )
. subcommand ( vendor_subcommand ( ) )
} )
2023-03-27 16:28:41 +00:00
. long_about ( DENO_HELP )
2019-11-26 16:06:32 +00:00
. after_help ( ENV_VARIABLES_HELP )
}
2019-11-13 15:35:56 +00:00
2024-02-29 19:12:04 +00:00
fn add_subcommand ( ) -> Command {
Command ::new ( " add " )
. about ( " Add dependencies " )
. long_about (
" Add dependencies to the configuration file.
deno add @ std / path
You can add multiple dependencies at once :
deno add @ std / path @ std / assert
" ,
)
. defer ( | cmd | {
cmd . arg (
Arg ::new ( " packages " )
. help ( " List of packages to add " )
. required ( true )
. num_args ( 1 .. )
. action ( ArgAction ::Append ) ,
)
} )
}
2023-03-26 04:06:18 +00:00
fn bench_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " bench " )
. about ( " Run benchmarks " )
. long_about (
" Run benchmarks using Deno's built-in bench tool.
2022-03-11 22:07:02 +00:00
2023-03-27 16:28:41 +00:00
Evaluate the given modules , run all benches declared with ' Deno . bench ( ) '
2022-04-11 05:01:02 +00:00
and report results to standard output :
2022-03-11 22:07:02 +00:00
deno bench src / fetch_bench . ts src / signal_bench . ts
2023-03-27 16:28:41 +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 / " ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
runtime_args ( cmd , true , false )
. arg ( check_arg ( true ) )
. arg (
Arg ::new ( " json " )
. long ( " json " )
. action ( ArgAction ::SetTrue )
. help ( " UNSTABLE: Output benchmark result in JSON format " ) ,
)
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
2024-01-16 00:15:39 +00:00
. help ( " Ignore files " ) ,
2023-06-28 00:57:20 +00:00
)
. arg (
Arg ::new ( " filter " )
. long ( " filter " )
. allow_hyphen_values ( true )
. help (
" Run benchmarks with this string or pattern in the bench name " ,
) ,
)
. arg (
Arg ::new ( " files " )
. help ( " List of file names to run " )
. num_args ( .. )
. action ( ArgAction ::Append ) ,
)
. arg (
Arg ::new ( " no-run " )
. long ( " no-run " )
. help ( " Cache bench modules, but don't run benchmarks " )
. action ( ArgAction ::SetTrue ) ,
)
. arg ( watch_arg ( false ) )
2024-03-27 22:47:46 +00:00
. arg ( watch_exclude_arg ( ) )
2023-06-28 00:57:20 +00:00
. arg ( no_clear_screen_arg ( ) )
. arg ( script_arg ( ) . last ( true ) )
2023-11-01 15:21:13 +00:00
. arg ( env_file_arg ( ) )
2023-06-28 00:57:20 +00:00
} )
2022-03-11 22:07:02 +00:00
}
2023-03-26 04:06:18 +00:00
fn bundle_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " bundle " )
. about ( " Bundle module and dependencies into single file " )
. long_about (
2024-01-24 01:36:51 +00:00
" ⚠️ Warning: `deno bundle` is deprecated and will be removed in Deno 2.0.
Use an alternative bundler like \ " deno_emit \" , \" esbuild \" or \" rollup \" instead.
Output a single JavaScript file with all dependencies .
2021-04-18 13:12:55 +00:00
2024-04-10 21:26:35 +00:00
deno bundle jsr :@ std / http / file - server file_server . bundle . js
2021-04-16 13:28:41 +00:00
If no output file is given , the output is written to standard output :
2021-04-18 13:12:55 +00:00
2024-04-10 21:26:35 +00:00
deno bundle jsr :@ std / http / file - server " ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
compile_args ( cmd )
. hide ( true )
. arg ( check_arg ( true ) )
. arg (
Arg ::new ( " source_file " )
. required ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2024-01-16 00:15:39 +00:00
. arg ( Arg ::new ( " out_file " ) . value_hint ( ValueHint ::FilePath ) )
2023-06-28 00:57:20 +00:00
. arg ( watch_arg ( false ) )
2024-03-27 22:47:46 +00:00
. arg ( watch_exclude_arg ( ) )
2023-06-28 00:57:20 +00:00
. arg ( no_clear_screen_arg ( ) )
. arg ( executable_ext_arg ( ) )
} )
2019-11-26 16:06:32 +00:00
}
2019-06-11 18:38:19 +00:00
2023-03-26 04:06:18 +00:00
fn cache_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " cache " )
. about ( " Cache the dependencies " )
. long_about (
" Cache and compile remote dependencies recursively.
2021-01-19 17:39:35 +00:00
2023-03-27 16:28:41 +00:00
Download and compile a module with all of its static dependencies and save
2022-04-11 05:01:02 +00:00
them in the local cache , without running any code :
2021-04-18 13:12:55 +00:00
2024-04-10 21:26:35 +00:00
deno cache jsr :@ std / http / file - server
2021-04-16 13:28:41 +00:00
2023-03-27 16:28:41 +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 . " ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
compile_args ( cmd ) . arg ( check_arg ( false ) ) . arg (
Arg ::new ( " file " )
. num_args ( 1 .. )
. required ( true )
. value_hint ( ValueHint ::FilePath ) ,
2023-06-12 11:54:04 +00:00
)
2023-06-28 00:57:20 +00:00
} )
2019-11-26 16:06:32 +00:00
}
2019-05-01 23:15:37 +00:00
2023-03-26 04:06:18 +00:00
fn check_subcommand ( ) -> Command {
2023-06-12 11:54:04 +00:00
Command ::new ( " check " )
2023-06-28 00:57:20 +00:00
. about ( " Type-check the dependencies " )
. long_about (
" Download and type-check without execution.
2024-04-10 21:26:35 +00:00
deno check jsr :@ std / http / file - server
2023-06-28 00:57:20 +00:00
Unless - - reload is specified , this command will not re - download already cached dependencies . " ,
)
2023-06-12 11:54:04 +00:00
. defer ( | cmd | compile_args_without_check_args ( cmd ) . arg (
2022-12-07 18:33:26 +00:00
Arg ::new ( " all " )
. long ( " all " )
. help ( " Type-check all code, including remote modules and npm packages " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2022-12-07 18:33:26 +00:00
. conflicts_with ( " no-remote " )
2022-04-10 23:12:51 +00:00
)
2023-06-12 11:54:04 +00:00
. arg (
// past alias for --all
Arg ::new ( " remote " )
. long ( " remote " )
. help ( " Type-check all modules, including remote " )
. action ( ArgAction ::SetTrue )
. conflicts_with ( " no-remote " )
. hide ( true )
2022-12-07 18:33:26 +00:00
)
2023-06-12 11:54:04 +00:00
. arg (
Arg ::new ( " file " )
. num_args ( 1 .. )
. required ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2023-06-28 00:57:20 +00:00
)
2022-04-10 23:12:51 +00:00
}
2023-03-26 04:06:18 +00:00
fn compile_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " compile " )
2023-10-28 01:54:52 +00:00
. about ( " Compile the script into a self contained executable " )
2023-06-28 00:57:20 +00:00
. long_about (
2023-10-28 01:54:52 +00:00
" Compiles the given script into a self contained executable.
2023-06-28 00:57:20 +00:00
2024-04-10 21:26:35 +00:00
deno compile - A jsr :@ std / http / file - server
deno compile - - output file_server jsr :@ std / http / file - server
2023-06-28 00:57:20 +00:00
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 .
" ,
)
. defer ( | cmd | {
runtime_args ( cmd , true , false )
2023-06-12 11:54:04 +00:00
. arg ( check_arg ( true ) )
. arg (
Arg ::new ( " include " )
. long ( " include " )
2023-10-28 01:54:52 +00:00
. help ( " Additional module to include in the module graph " )
2023-06-12 11:54:04 +00:00
. long_help (
" Includes an additional module in the compiled executable's module
2023-03-27 16:28:41 +00:00
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
2023-03-18 23:43:07 +00:00
times , to include multiple additional modules . " ,
2023-06-12 11:54:04 +00:00
)
. action ( ArgAction ::Append )
. value_hint ( ValueHint ::FilePath ) ,
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. short ( 'o' )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-06-12 11:54:04 +00:00
. help ( " Output file (defaults to $PWD/<inferred-name>) " )
. value_hint ( ValueHint ::FilePath ) ,
)
. arg (
Arg ::new ( " target " )
. long ( " target " )
. help ( " Target OS architecture " )
. value_parser ( [
" x86_64-unknown-linux-gnu " ,
2024-02-23 18:08:17 +00:00
" aarch64-unknown-linux-gnu " ,
2023-06-12 11:54:04 +00:00
" x86_64-pc-windows-msvc " ,
" x86_64-apple-darwin " ,
" aarch64-apple-darwin " ,
] ) ,
)
2023-07-28 15:46:26 +00:00
. arg (
Arg ::new ( " no-terminal " )
. long ( " no-terminal " )
. help ( " Hide terminal on Windows " )
. action ( ArgAction ::SetTrue ) ,
)
2023-06-12 11:54:04 +00:00
. arg ( executable_ext_arg ( ) )
2023-11-01 15:21:13 +00:00
. arg ( env_file_arg ( ) )
2023-09-08 17:14:59 +00:00
. arg ( script_arg ( ) . required ( true ) . trailing_var_arg ( true ) )
2023-06-28 00:57:20 +00:00
} )
2019-11-26 16:06:32 +00:00
}
2019-05-01 23:15:37 +00:00
2023-03-26 04:06:18 +00:00
fn completions_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " completions " )
. 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 " ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
cmd . disable_help_subcommand ( true ) . arg (
Arg ::new ( " shell " )
. value_parser ( [ " bash " , " fish " , " powershell " , " zsh " , " fig " ] )
. required ( true ) ,
2023-06-12 11:54:04 +00:00
)
2023-06-28 00:57:20 +00:00
} )
2020-11-30 19:35:12 +00:00
}
2023-03-26 04:06:18 +00:00
fn coverage_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " coverage " )
. 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
2023-03-27 16:28:41 +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
2022-04-11 05:01:02 +00:00
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
" ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
cmd
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Ignore coverage files " )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg (
Arg ::new ( " include " )
. long ( " include " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. value_name ( " regex " )
. require_equals ( true )
. default_value ( r "^file:" )
. help ( " Include source files in the report " ) ,
)
. arg (
Arg ::new ( " exclude " )
. long ( " exclude " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. value_name ( " regex " )
. require_equals ( true )
. default_value ( r "test\.(js|mjs|ts|jsx|tsx)$" )
. help ( " Exclude source files from the report " ) ,
)
. arg (
Arg ::new ( " lcov " )
. long ( " lcov " )
. help ( " Output coverage report in lcov format " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " output " )
. requires ( " lcov " )
. long ( " output " )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-06-28 00:57:20 +00:00
. help ( " Output file (defaults to stdout) for lcov " )
. long_help (
" Exports the coverage report in lcov format to the given file.
2023-03-27 16:28:41 +00:00
Filename should be passed along with '=' For example ' - - output = foo . lcov '
2022-04-11 05:01:02 +00:00
If no - - output arg is specified then the report is written to stdout . " ,
2023-06-28 00:57:20 +00:00
)
. require_equals ( true )
. value_hint ( ValueHint ::FilePath ) ,
)
2023-12-08 07:54:52 +00:00
. arg (
Arg ::new ( " html " )
. long ( " html " )
. help (
" Output coverage report in HTML format in the given directory " ,
)
. action ( ArgAction ::SetTrue ) ,
)
2023-12-12 03:42:57 +00:00
. arg (
2023-12-12 11:53:41 +00:00
Arg ::new ( " detailed " )
. long ( " detailed " )
. help ( " Output coverage report in detailed format in the terminal. " )
2023-12-12 03:42:57 +00:00
. action ( ArgAction ::SetTrue ) ,
)
2023-06-28 00:57:20 +00:00
. arg (
Arg ::new ( " files " )
2023-12-18 10:48:45 +00:00
. num_args ( 0 .. )
2023-06-28 00:57:20 +00:00
. action ( ArgAction ::Append )
. value_hint ( ValueHint ::AnyPath ) ,
)
} )
2019-11-26 16:06:32 +00:00
}
2019-08-12 00:43:01 +00:00
2023-03-26 04:06:18 +00:00
fn doc_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " doc " )
. 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
2023-11-01 15:25:05 +00:00
Output documentation in HTML format :
deno doc - - html - - name = \ " My library \" ./path/to/module.ts
deno doc - - html - - name = \ " My library \" ./main.ts ./dev.ts
deno doc - - html - - name = \ " My library \" --output=./documentation/ ./path/to/module.ts
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
2023-10-31 22:19:42 +00:00
Lint a module for documentation diagnostics :
deno doc - - lint . / path / to / module . ts
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
2024-04-04 22:03:29 +00:00
deno doc - - filter Deno . Listener " ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
cmd
. arg ( import_map_arg ( ) )
. arg ( reload_arg ( ) )
. arg ( lock_arg ( ) )
. arg ( no_lock_arg ( ) )
. arg ( no_npm_arg ( ) )
. arg ( no_remote_arg ( ) )
. arg (
Arg ::new ( " json " )
. long ( " json " )
. help ( " Output documentation in JSON format " )
. action ( ArgAction ::SetTrue ) ,
)
2023-11-01 15:25:05 +00:00
. arg (
Arg ::new ( " html " )
. long ( " html " )
. help ( " Output documentation in HTML format " )
. action ( ArgAction ::SetTrue )
. conflicts_with ( " json " )
)
. arg (
Arg ::new ( " name " )
. long ( " name " )
. help ( " The name that will be displayed in the docs " )
. action ( ArgAction ::Set )
. require_equals ( true )
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. help ( " Directory for HTML documentation output " )
. action ( ArgAction ::Set )
. require_equals ( true )
. value_hint ( ValueHint ::DirPath )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-11-01 15:25:05 +00:00
)
2023-06-28 00:57:20 +00:00
. arg (
Arg ::new ( " private " )
. long ( " private " )
. help ( " Output private documentation " )
. action ( ArgAction ::SetTrue ) ,
)
2023-10-30 22:58:57 +00:00
. arg (
Arg ::new ( " filter " )
. long ( " filter " )
. help ( " Dot separated path to symbol " )
. required ( false )
2023-10-31 22:19:42 +00:00
. conflicts_with ( " json " )
2023-11-01 15:25:05 +00:00
. conflicts_with ( " lint " )
. conflicts_with ( " html " ) ,
2023-10-31 22:19:42 +00:00
)
. arg (
Arg ::new ( " lint " )
. long ( " lint " )
. help ( " Output documentation diagnostics. " )
. action ( ArgAction ::SetTrue ) ,
2023-10-30 22:58:57 +00:00
)
2023-06-28 00:57:20 +00:00
// 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.
. allow_hyphen_values ( true )
. arg (
2023-10-30 22:58:57 +00:00
Arg ::new ( " source_file " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
2023-11-03 17:06:18 +00:00
. value_hint ( ValueHint ::FilePath )
. required_if_eq_any ( [ ( " html " , " true " ) , ( " lint " , " true " ) ] ) ,
2023-06-28 00:57:20 +00:00
)
} )
2020-09-18 17:09:11 +00:00
}
2023-03-26 04:06:18 +00:00
fn eval_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " eval " )
. 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 ) . " ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
runtime_args ( cmd , false , true )
. arg ( check_arg ( false ) )
. arg (
// TODO(@satyarohith): remove this argument in 2.0.
Arg ::new ( " ts " )
. conflicts_with ( " ext " )
. long ( " ts " )
. short ( 'T' )
2024-01-23 16:34:06 +00:00
. help ( " deprecated: Use `--ext=ts` instead. The `--ts` and `-T` flags are deprecated and will be removed in Deno 2.0. " )
2023-06-28 00:57:20 +00:00
. action ( ArgAction ::SetTrue )
. hide ( true ) ,
)
. arg ( executable_ext_arg ( ) )
. arg (
Arg ::new ( " print " )
. long ( " print " )
. short ( 'p' )
. help ( " print result to stdout " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " code_arg " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. help ( " Code arg " )
. value_name ( " CODE_ARG " )
. required ( true ) ,
)
2023-11-01 15:21:13 +00:00
. arg ( env_file_arg ( ) )
2023-06-28 00:57:20 +00:00
} )
2019-11-26 16:06:32 +00:00
}
2023-03-26 04:06:18 +00:00
fn fmt_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " fmt " )
. 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",
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
cmd
. arg ( config_arg ( ) )
. arg ( no_config_arg ( ) )
. arg (
Arg ::new ( " check " )
. long ( " check " )
. help ( " Check if the source files are formatted " )
. num_args ( 0 ) ,
)
. arg (
Arg ::new ( " ext " )
. long ( " ext " )
. help ( " Set content type of the supplied file " )
// prefer using ts for formatting instead of js because ts works in more scenarios
. default_value ( " ts " )
2023-11-27 15:32:12 +00:00
. value_parser ( [
" ts " , " tsx " , " js " , " jsx " , " md " , " json " , " jsonc " , " ipynb " ,
] ) ,
2023-06-28 00:57:20 +00:00
)
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Ignore formatting particular source files " )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg (
Arg ::new ( " files " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. required ( false )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg ( watch_arg ( false ) )
2024-03-27 22:47:46 +00:00
. arg ( watch_exclude_arg ( ) )
2023-06-28 00:57:20 +00:00
. arg ( no_clear_screen_arg ( ) )
. arg (
Arg ::new ( " use-tabs " )
. long ( " use-tabs " )
. alias ( " options-use-tabs " )
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
. require_equals ( true )
. help (
" Use tabs instead of spaces for indentation. Defaults to false. " ,
) ,
)
. arg (
Arg ::new ( " line-width " )
. long ( " line-width " )
. alias ( " options-line-width " )
. help ( " Define maximum line width. Defaults to 80. " )
. value_parser ( value_parser! ( NonZeroU32 ) ) ,
)
. arg (
Arg ::new ( " indent-width " )
. long ( " indent-width " )
. alias ( " options-indent-width " )
. help ( " Define indentation width. Defaults to 2. " )
. value_parser ( value_parser! ( NonZeroU8 ) ) ,
)
. arg (
Arg ::new ( " single-quote " )
. long ( " single-quote " )
. alias ( " options-single-quote " )
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
. require_equals ( true )
. help ( " Use single quotes. Defaults to false. " ) ,
)
. arg (
Arg ::new ( " prose-wrap " )
. long ( " prose-wrap " )
. alias ( " options-prose-wrap " )
. value_parser ( [ " always " , " never " , " preserve " ] )
. help ( " Define how prose should be wrapped. Defaults to always. " ) ,
)
. arg (
Arg ::new ( " no-semicolons " )
. long ( " no-semicolons " )
. alias ( " options-no-semicolons " )
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
. require_equals ( true )
2023-12-01 16:26:06 +00:00
. help (
" Don't use semicolons except where necessary. Defaults to false. " ,
) ,
2023-06-28 00:57:20 +00:00
)
} )
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2023-03-26 04:06:18 +00:00
fn init_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " init " )
. about ( " Initialize a new project " )
. defer ( | cmd | {
cmd . arg (
Arg ::new ( " dir " )
. required ( false )
. value_hint ( ValueHint ::DirPath ) ,
)
} )
2022-08-19 23:37:05 +00:00
}
2023-03-26 04:06:18 +00:00
fn info_subcommand ( ) -> Command {
2022-03-28 01:57:56 +00:00
Command ::new ( " info " )
2023-06-28 00:57:20 +00:00
. about ( " Show info about cache or info related to source file " )
2023-06-12 11:54:04 +00:00
. long_about (
" Information about a module or the cache directories.
2021-04-16 13:28:41 +00:00
Get information about a module :
2021-04-18 13:12:55 +00:00
2024-04-10 21:26:35 +00:00
deno info jsr :@ std / http / file - server
2021-04-16 13:28:41 +00:00
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 . " ,
2023-06-12 11:54:04 +00:00
)
2023-06-28 00:57:20 +00:00
. defer ( | cmd | cmd
2023-06-12 11:54:04 +00:00
. arg ( Arg ::new ( " file " ) . required ( false ) . value_hint ( ValueHint ::FilePath ) )
. arg ( reload_arg ( ) . requires ( " file " ) )
. arg ( ca_file_arg ( ) )
. 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>' " )
)
. arg ( no_check_arg ( ) . hide ( true ) ) // TODO(lucacasonato): remove for 2.0
. arg ( no_config_arg ( ) )
. arg ( no_remote_arg ( ) )
. arg ( no_npm_arg ( ) )
. arg ( lock_arg ( ) )
2024-02-19 12:02:40 +00:00
. arg ( lock_write_arg ( ) )
. arg ( no_lock_arg ( ) )
2023-06-12 11:54:04 +00:00
. arg ( config_arg ( ) )
. arg ( import_map_arg ( ) )
. arg ( node_modules_dir_arg ( ) )
2023-08-07 01:56:56 +00:00
. arg ( vendor_arg ( ) )
2023-06-12 11:54:04 +00:00
. arg (
Arg ::new ( " json " )
. long ( " json " )
. help ( " UNSTABLE: Outputs the information in JSON format " )
. action ( ArgAction ::SetTrue ) ,
) )
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2024-05-08 19:34:46 +00:00
fn install_args ( cmd : Command , deno_future : bool ) -> Command {
let cmd = if deno_future {
cmd . arg (
Arg ::new ( " cmd " )
. required_if_eq ( " global " , " true " )
. num_args ( 1 .. )
. value_hint ( ValueHint ::FilePath ) ,
)
} else {
cmd . arg (
Arg ::new ( " cmd " )
. required ( true )
. num_args ( 1 .. )
. value_hint ( ValueHint ::FilePath ) ,
)
} ;
cmd
. arg (
Arg ::new ( " name " )
. long ( " name " )
. short ( 'n' )
. help ( " Executable file name " )
. required ( false ) ,
)
. arg (
Arg ::new ( " root " )
. long ( " root " )
. help ( " Installation root " )
. value_hint ( ValueHint ::DirPath ) ,
)
. arg (
Arg ::new ( " force " )
. long ( " force " )
. short ( 'f' )
. help ( " Forcefully overwrite existing installation " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " global " )
. long ( " global " )
. short ( 'g' )
. help ( " Install a package or script as a globally available executable " )
. action ( ArgAction ::SetTrue ) ,
)
. arg ( env_file_arg ( ) )
}
fn future_install_subcommand ( ) -> Command {
Command ::new ( " install " )
. visible_alias ( " i " )
. about ( " Install dependencies " )
. long_about (
" Installs dependencies either in the local project or globally to a bin directory.
Local installation
- - - - - - - - - - - - - - - - - - -
If the - - global flag is not set , adds dependencies to the local project ' s configuration
( package . json / deno . json ) and installs them in the package cache . If no dependency
is specified , installs all dependencies listed in package . json .
deno install
deno install @ std / bytes
deno install npm :chalk
Global installation
- - - - - - - - - - - - - - - - - - -
If the - - global flag is set , installs a script as an executable in the installation root ' s bin directory .
deno install - - global - - allow - net - - allow - read jsr :@ std / http / file - server
deno install - g https ://examples.deno.land/color-logging.ts
To change the executable name , use - n / - - name :
deno install - g - - allow - net - - allow - read - n serve jsr :@ std / http / file - server
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 .
To change the installation root , use - - root :
deno install - g - - allow - net - - allow - read - - root / usr / local jsr :@ std / http / file - server
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 . " )
. defer ( | cmd | {
let cmd = runtime_args ( cmd , true , true ) . arg ( check_arg ( true ) ) ;
install_args ( cmd , true )
} )
}
2023-03-26 04:06:18 +00:00
fn install_subcommand ( ) -> Command {
2023-06-12 11:54:04 +00:00
Command ::new ( " install " )
2023-06-28 00:57:20 +00:00
. about ( " Install script as an executable " )
. long_about (
2024-05-08 19:34:46 +00:00
" Installs a script as an executable in the installation root's bin directory.
2021-04-18 13:12:55 +00:00
2024-04-10 21:26:35 +00:00
deno install - - global - - allow - net - - allow - read jsr :@ std / http / file - server
2024-03-27 22:45:57 +00:00
deno install - g https ://examples.deno.land/color-logging.ts
2020-05-01 19:33:11 +00:00
To change the executable name , use - n / - - name :
2021-04-18 13:12:55 +00:00
2024-04-10 21:26:35 +00:00
deno install - g - - allow - net - - allow - read - n serve jsr :@ std / http / file - server
2020-05-01 19:33:11 +00:00
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
2024-04-10 21:26:35 +00:00
deno install - g - - allow - net - - allow - read - - root / usr / local jsr :@ std / http / file - server
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
2023-06-28 00:57:20 +00:00
These must be added to the path manually if required . " )
2024-05-08 19:34:46 +00:00
. defer ( | cmd | {
let cmd = runtime_args ( cmd , true , true ) . arg ( check_arg ( true ) ) ;
install_args ( cmd , false )
} )
2023-06-28 00:57:20 +00:00
}
2023-09-16 00:42:09 +00:00
fn jupyter_subcommand ( ) -> Command {
Command ::new ( " jupyter " )
. arg (
Arg ::new ( " install " )
. long ( " install " )
. help ( " Installs kernelspec, requires 'jupyter' command to be available. " )
. conflicts_with ( " kernel " )
. action ( ArgAction ::SetTrue )
)
. arg (
Arg ::new ( " kernel " )
. long ( " kernel " )
. help ( " Start the kernel " )
. conflicts_with ( " install " )
. requires ( " conn " )
. action ( ArgAction ::SetTrue )
)
. arg (
Arg ::new ( " conn " )
. long ( " conn " )
. help ( " Path to JSON file describing connection parameters, provided by Jupyter " )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-09-16 00:42:09 +00:00
. value_hint ( ValueHint ::FilePath )
. conflicts_with ( " install " ) )
. about ( " Deno kernel for Jupyter notebooks " )
}
2023-06-28 00:57:20 +00:00
fn uninstall_subcommand ( ) -> Command {
Command ::new ( " uninstall " )
2023-06-12 11:54:04 +00:00
. about ( " Uninstall a script previously installed with deno install " )
. long_about (
" Uninstalls an executable script in the installation root's bin directory.
2021-09-30 15:38:07 +00:00
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
2023-06-28 00:57:20 +00:00
- $HOME / . deno " )
. defer ( | cmd | cmd . arg ( Arg ::new ( " name " ) . required ( true ) )
. arg (
Arg ::new ( " root " )
. long ( " root " )
. help ( " Installation root " )
2024-03-27 22:45:57 +00:00
. value_hint ( ValueHint ::DirPath )
)
. arg (
Arg ::new ( " global " )
. long ( " global " )
. short ( 'g' )
. help ( " Remove globally installed package or module " )
. action ( ArgAction ::SetTrue )
)
2023-06-28 00:57:20 +00:00
)
2021-09-30 15:38:07 +00:00
}
2023-03-27 16:28:41 +00:00
static LSP_HELP : & str = concat! (
" 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 ' :
2023-03-27 16:28:41 +00:00
https ://deno.land/manual@v",
env! ( " CARGO_PKG_VERSION " ) ,
" /getting_started/setup_your_environment#editors-and-ides " ,
) ;
2022-05-09 18:16:34 +00:00
2023-03-26 04:06:18 +00:00
fn lsp_subcommand ( ) -> Command {
2022-05-09 18:16:34 +00:00
Command ::new ( " lsp " )
2023-06-28 00:57:20 +00:00
. about ( " Start the language server " )
. long_about ( LSP_HELP )
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn lint_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " lint " )
. about ( " Lint source files " )
. long_about (
" 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
" ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
cmd
2024-03-21 21:18:59 +00:00
. arg (
Arg ::new ( " fix " )
. long ( " fix " )
. help ( " Fix any linting errors for rules that support it " )
. action ( ArgAction ::SetTrue ) ,
)
2023-06-28 00:57:20 +00:00
. arg (
Arg ::new ( " rules " )
. long ( " rules " )
. help ( " List available rules " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " rules-tags " )
. long ( " rules-tags " )
. require_equals ( true )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. use_value_delimiter ( true )
. help ( " Use set of rules with a tag " ) ,
)
. arg (
Arg ::new ( " rules-include " )
. long ( " rules-include " )
. require_equals ( true )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. conflicts_with ( " rules " )
. help ( " Include lint rules " ) ,
)
. arg (
Arg ::new ( " rules-exclude " )
. long ( " rules-exclude " )
. require_equals ( true )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. conflicts_with ( " rules " )
. help ( " Exclude lint rules " ) ,
)
. arg ( no_config_arg ( ) )
. arg ( config_arg ( ) )
. arg (
Arg ::new ( " ignore " )
. long ( " ignore " )
. num_args ( 1 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. help ( " Ignore linting particular source files " )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg (
Arg ::new ( " json " )
. long ( " json " )
. help ( " Output lint result in JSON format " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " compact " )
. long ( " compact " )
. help ( " Output lint result in compact format " )
. action ( ArgAction ::SetTrue )
. conflicts_with ( " json " ) ,
)
. arg (
Arg ::new ( " files " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. required ( false )
. value_hint ( ValueHint ::AnyPath ) ,
)
. arg ( watch_arg ( false ) )
2024-03-27 22:47:46 +00:00
. arg ( watch_exclude_arg ( ) )
2023-06-28 00:57:20 +00:00
. arg ( no_clear_screen_arg ( ) )
} )
2021-04-16 13:28:41 +00:00
}
2019-05-16 14:39:19 +00:00
2023-03-26 04:06:18 +00:00
fn repl_subcommand ( ) -> Command {
2023-06-12 11:54:04 +00:00
Command ::new ( " repl " )
2023-06-28 00:57:20 +00:00
. about ( " Read Eval Print Loop " )
. defer ( | cmd | runtime_args ( cmd , true , true )
2023-06-12 11:54:04 +00:00
. arg ( check_arg ( false ) )
. arg (
Arg ::new ( " eval-file " )
. long ( " eval-file " )
. num_args ( 1 .. )
. 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 ) ,
)
. arg (
Arg ::new ( " eval " )
. long ( " eval " )
. help ( " Evaluates the provided code when the REPL starts. " )
. value_name ( " code " ) ,
) )
2023-11-01 15:21:13 +00:00
. arg ( env_file_arg ( ) )
2019-11-26 16:06:32 +00:00
}
2023-03-26 04:06:18 +00:00
fn run_subcommand ( ) -> Command {
2022-03-28 01:57:56 +00:00
runtime_args ( Command ::new ( " run " ) , true , true )
2023-04-13 01:42:28 +00:00
. arg ( check_arg ( false ) )
2023-10-06 21:33:14 +00:00
. arg ( watch_arg ( true ) )
2024-03-27 22:47:46 +00:00
. arg ( watch_exclude_arg ( ) )
2023-10-31 00:25:58 +00:00
. arg ( hmr_arg ( true ) )
2022-01-31 16:39:39 +00:00
. arg ( no_clear_screen_arg ( ) )
2023-03-22 14:15:53 +00:00
. arg ( executable_ext_arg ( ) )
2023-03-26 04:06:18 +00:00
. arg (
script_arg ( )
. required_unless_present ( " v8-flags " )
. trailing_var_arg ( true ) ,
)
2023-11-01 15:21:13 +00:00
. arg ( env_file_arg ( ) )
2024-04-17 14:19:55 +00:00
. arg ( no_code_cache_arg ( ) )
2021-04-18 13:12:55 +00:00
. 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
2023-11-20 22:59:13 +00:00
deno run https ://examples.deno.land/hello-world.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
2024-04-10 21:26:35 +00:00
deno run - A jsr :@ std / http / file - server
2021-04-16 13:28:41 +00:00
Grant permission to read from disk and listen to network :
2021-04-18 13:12:55 +00:00
2024-04-10 21:26:35 +00:00
deno run - - allow - read - - allow - net jsr :@ std / http / file - server
2021-04-16 13:28:41 +00:00
Grant permission to read allow - listed files from disk :
2021-04-18 13:12:55 +00:00
2024-04-10 21:26:35 +00:00
deno run - - allow - read = / etc jsr :@ std / http / file - server
2021-04-16 13:28:41 +00:00
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
2023-11-20 22:59:13 +00:00
curl https ://examples.deno.land/hello-world.ts | deno run -",
2020-02-28 14:17:56 +00:00
)
2021-04-16 13:28:41 +00:00
}
2024-04-24 19:45:49 +00:00
fn serve_host_validator ( host : & str ) -> Result < String , String > {
if Url ::parse ( & format! ( " internal:// {host} :9999 " ) ) . is_ok ( ) {
Ok ( host . to_owned ( ) )
} else {
Err ( format! ( " Bad serve host: {host} " ) )
}
}
fn serve_subcommand ( ) -> Command {
runtime_args ( Command ::new ( " serve " ) , true , true )
. arg (
Arg ::new ( " port " )
. long ( " port " )
. help ( " The TCP port to serve on, defaulting to 8000. " )
. value_parser ( value_parser! ( NonZeroU16 ) ) ,
)
. arg (
Arg ::new ( " host " )
. long ( " host " )
. help ( " The TCP address to serve on, defaulting to 0.0.0.0 (all interfaces). " )
. value_parser ( serve_host_validator ) ,
)
. arg ( check_arg ( false ) )
. arg ( watch_arg ( true ) )
. arg ( watch_exclude_arg ( ) )
. arg ( hmr_arg ( true ) )
. arg ( no_clear_screen_arg ( ) )
. arg ( executable_ext_arg ( ) )
. arg (
script_arg ( )
. required_unless_present ( " v8-flags " )
. trailing_var_arg ( true ) ,
)
. arg ( env_file_arg ( ) )
. arg ( no_code_cache_arg ( ) )
. about ( " Run a server " )
. long_about ( " Run a server defined in a main module
The serve command uses the default exports of the main module to determine which
servers to start .
See https ://docs.deno.com/runtime/manual/tools/serve for
more detailed information .
Start a server defined in server . ts :
deno serve server . ts
Start a server defined in server . ts , watching for changes and running on port 5050 :
deno serve - - watch - - port 5050 server . ts " )
}
2023-03-26 04:06:18 +00:00
fn task_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " task " )
. about ( " Run a task defined in the configuration file " )
. long_about (
" Run a task defined in the configuration file
2022-03-11 01:56:14 +00:00
deno task build " ,
2023-06-28 00:57:20 +00:00
)
. defer ( | cmd | {
cmd
. allow_external_subcommands ( true )
. subcommand_value_name ( " TASK " )
. arg ( config_arg ( ) )
. arg (
Arg ::new ( " cwd " )
. long ( " cwd " )
. value_name ( " DIR " )
. help ( " Specify the directory to run the task in " )
. value_hint ( ValueHint ::DirPath ) ,
)
} )
2022-03-11 01:56:14 +00:00
}
2023-03-26 04:06:18 +00:00
fn test_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " test " )
. about ( " Run tests " )
. long_about (
" Run tests using Deno's built-in test runner.
Evaluate the given modules , run all tests declared with ' Deno . test ( ) ' and
report results to standard output :
deno test src / fetch_test . ts src / signal_test . ts
Directory arguments are expanded to all contained files matching the glob
{ * _ , * . , } test . { js , mjs , ts , mts , jsx , tsx } :
deno test src / " ,
)
. defer ( | cmd | runtime_args ( cmd , true , true )
2023-04-13 01:42:28 +00:00
. arg ( check_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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 1 .. )
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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue ) ,
2021-02-21 16:58:32 +00:00
)
2022-02-25 15:14:46 +00:00
. arg (
Arg ::new ( " trace-ops " )
. long ( " trace-ops " )
2024-02-28 16:12:43 +00:00
. help ( " Deprecated alias for --trace-leaks. " )
. hide ( true )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " trace-leaks " )
. long ( " trace-leaks " )
. help ( " Enable tracing of leaks. Useful when debugging leaking ops in test, but impacts test execution time. " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue ) ,
2022-02-25 15:14:46 +00:00
)
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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue ) ,
2021-05-10 23:54:39 +00:00
)
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. " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
2021-07-12 10:55:42 +00:00
. require_equals ( true )
. value_name ( " N " )
2023-03-26 04:06:18 +00:00
. value_parser ( value_parser! ( NonZeroUsize ) ) ,
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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue ) ,
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 " )
. 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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
2021-07-06 01:20:33 +00:00
. require_equals ( true )
2023-03-26 04:06:18 +00:00
. value_parser ( value_parser! ( u64 ) ) ,
2021-07-06 01:20:33 +00:00
)
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 " )
2021-08-12 08:21:38 +00:00
. value_name ( " DIR " )
2023-12-08 08:35:42 +00:00
. num_args ( 0 ..= 1 )
. require_equals ( true )
. default_missing_value ( " coverage " )
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-12-08 08:35:42 +00:00
. help ( " Collect coverage profile data into DIR. If DIR is not specified, it uses 'coverage/'. " ) ,
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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2022-07-20 21:36:54 +00:00
)
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 " )
2024-01-23 01:19:12 +00:00
. help ( " deprecated: The `--jobs` flag is deprecated and will be removed in Deno 2.0. Use the `--parallel` flag with possibly the `DENO_JOBS` environment variable instead. " )
2022-07-20 21:36:54 +00:00
. hide ( true )
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( NonZeroUsize ) ) ,
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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
. action ( ArgAction ::Append )
2022-03-14 18:41:35 +00:00
. 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 " ) ,
)
2024-03-27 22:47:46 +00:00
. arg ( watch_exclude_arg ( ) )
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 ) )
2023-07-26 22:12:35 +00:00
. arg (
2023-08-03 02:05:34 +00:00
Arg ::new ( " junit-path " )
. long ( " junit-path " )
2023-07-26 22:12:35 +00:00
. value_name ( " PATH " )
. value_hint ( ValueHint ::FilePath )
. help ( " Write a JUnit XML test report to PATH. Use '-' to write to stdout which is the default when PATH is not provided. " )
)
2023-08-02 16:38:10 +00:00
. arg (
2023-08-03 02:05:34 +00:00
Arg ::new ( " reporter " )
. long ( " reporter " )
. help ( " Select reporter to use. Default to 'pretty'. " )
2023-08-25 23:19:23 +00:00
. value_parser ( [ " pretty " , " dot " , " junit " , " tap " ] )
2023-08-02 16:38:10 +00:00
)
2023-11-01 15:21:13 +00:00
. arg ( env_file_arg ( ) )
2023-06-28 00:57:20 +00:00
)
2019-06-05 17:44:46 +00:00
}
2023-03-26 04:06:18 +00:00
fn types_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " types " )
. about ( " Print runtime TypeScript declarations " )
. long_about (
" 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 . " ,
2023-06-28 00:57:20 +00:00
)
2021-04-16 13:28:41 +00:00
}
2021-02-24 14:27:51 +00:00
2023-03-26 04:06:18 +00:00
fn upgrade_subcommand ( ) -> Command {
2023-06-28 00:57:20 +00:00
Command ::new ( " upgrade " )
. about ( " Upgrade deno executable to given version " )
. long_about (
" Upgrade deno executable to the given version.
2021-04-16 13:28:41 +00:00
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 " ,
2023-06-28 00:57:20 +00:00
)
2023-11-29 18:52:25 +00:00
. hide ( cfg! ( not ( feature = " upgrade " ) ) )
2023-06-28 00:57:20 +00:00
. defer ( | cmd | {
cmd
. arg (
Arg ::new ( " version " )
. long ( " version " )
. help ( " The version to upgrade to " ) ,
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. help ( " The path to output the updated version to " )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-06-28 00:57:20 +00:00
. value_hint ( ValueHint ::FilePath ) ,
)
. arg (
Arg ::new ( " dry-run " )
. long ( " dry-run " )
. help ( " Perform all checks without replacing old exe " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " force " )
. long ( " force " )
. short ( 'f' )
. help ( " Replace current exe even if not out-of-date " )
. action ( ArgAction ::SetTrue ) ,
)
. arg (
Arg ::new ( " canary " )
. long ( " canary " )
. help ( " Upgrade to canary builds " )
. action ( ArgAction ::SetTrue ) ,
)
. arg ( ca_file_arg ( ) )
} )
2020-03-23 15:37:24 +00:00
}
2023-03-26 04:06:18 +00:00
fn vendor_subcommand ( ) -> Command {
2022-03-28 01:57:56 +00:00
Command ::new ( " vendor " )
2023-06-28 00:57:20 +00:00
. about ( " Vendor remote modules into a local directory " )
2023-06-12 11:54:04 +00:00
. long_about (
" Vendor remote modules into a local directory.
2022-02-16 18:14:19 +00:00
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 :
2024-04-10 21:26:35 +00:00
deno vendor main . ts test . deps . ts jsr :@ std / path " ,
2023-06-12 11:54:04 +00:00
)
2023-06-28 00:57:20 +00:00
. defer ( | cmd | cmd
2023-06-12 11:54:04 +00:00
. arg (
Arg ::new ( " specifiers " )
. num_args ( 1 .. )
. action ( ArgAction ::Append )
. required ( true ) ,
)
. arg (
Arg ::new ( " output " )
. long ( " output " )
. help ( " The directory to output the vendored modules to " )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-06-12 11:54:04 +00:00
. value_hint ( ValueHint ::DirPath ) ,
)
. arg (
Arg ::new ( " force " )
. long ( " force " )
. short ( 'f' )
. help (
" Forcefully overwrite conflicting files in existing output directory " ,
)
. action ( ArgAction ::SetTrue ) ,
)
. arg ( no_config_arg ( ) )
. arg ( config_arg ( ) )
. arg ( import_map_arg ( ) )
. arg ( lock_arg ( ) )
. arg ( node_modules_dir_arg ( ) )
2023-08-07 01:56:56 +00:00
. arg ( vendor_arg ( ) )
2023-06-12 11:54:04 +00:00
. arg ( reload_arg ( ) )
. arg ( ca_file_arg ( ) ) )
2022-02-16 18:14:19 +00:00
}
2023-11-23 23:38:07 +00:00
fn publish_subcommand ( ) -> Command {
2024-01-08 20:07:36 +00:00
Command ::new ( " publish " )
2023-11-23 23:38:07 +00:00
. hide ( true )
2024-01-10 22:40:30 +00:00
. about ( " Unstable preview feature: Publish the current working directory's package or workspace " )
2023-11-23 23:38:07 +00:00
// TODO: .long_about()
. defer ( | cmd | {
cmd . arg (
Arg ::new ( " token " )
2023-11-24 13:05:47 +00:00
. long ( " token " )
. help ( " The API token to use when publishing. If unset, interactive authentication is be used " )
2023-11-23 23:38:07 +00:00
)
2024-02-14 17:13:07 +00:00
. arg ( config_arg ( ) )
. arg ( no_config_arg ( ) )
2024-01-11 21:17:03 +00:00
. arg (
Arg ::new ( " dry-run " )
. long ( " dry-run " )
. help ( " Prepare the package for publishing performing all checks and validations without uploading " )
. action ( ArgAction ::SetTrue ) ,
)
2024-01-31 15:10:31 +00:00
. arg (
2024-02-19 15:28:41 +00:00
Arg ::new ( " allow-slow-types " )
. long ( " allow-slow-types " )
. help ( " Allow publishing with slow types " )
2024-01-31 15:10:31 +00:00
. action ( ArgAction ::SetTrue ) ,
)
2024-02-28 02:28:02 +00:00
. arg (
2024-03-07 21:13:36 +00:00
Arg ::new ( " allow-dirty " )
. long ( " allow-dirty " )
2024-03-08 18:03:32 +00:00
. help ( " Allow publishing if the repository has uncommitted changed " )
2024-03-07 21:13:36 +00:00
. action ( ArgAction ::SetTrue ) ,
) . arg (
2024-02-29 16:18:47 +00:00
Arg ::new ( " no-provenance " )
. long ( " no-provenance " )
. help ( " Disable provenance attestation. Enabled by default on Github actions, publicly links the package to where it was built and published from. " )
2024-02-28 02:28:02 +00:00
. action ( ArgAction ::SetTrue )
)
2024-02-21 13:35:25 +00:00
. arg ( check_arg ( /* type checks by default */ true ) )
. arg ( no_check_arg ( ) )
2023-11-23 23:38:07 +00:00
} )
}
2022-03-28 01:57:56 +00:00
fn compile_args ( app : Command ) -> Command {
2023-04-13 01:42:28 +00:00
compile_args_without_check_args ( app . arg ( no_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 ( ) )
2023-05-19 22:39:27 +00:00
. arg ( node_modules_dir_arg ( ) )
2023-08-07 01:56:56 +00:00
. arg ( vendor_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 ( ) )
}
2023-04-27 00:49:59 +00:00
static ALLOW_READ_HELP : & str = concat! (
" Allow file system read access. Optionally specify allowed paths. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-read \n " ,
" --allow-read= \" /etc,/var/log.txt \" "
) ;
2023-08-03 11:19:19 +00:00
static DENY_READ_HELP : & str = concat! (
" Deny file system read access. Optionally specify denied paths. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-read \n " ,
" --deny-read= \" /etc,/var/log.txt \" "
) ;
2023-04-27 00:49:59 +00:00
static ALLOW_WRITE_HELP : & str = concat! (
" Allow file system write access. Optionally specify allowed paths. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-write \n " ,
" --allow-write= \" /etc,/var/log.txt \" "
) ;
2023-08-03 11:19:19 +00:00
static DENY_WRITE_HELP : & str = concat! (
" Deny file system write access. Optionally specify denied paths. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-write \n " ,
" --deny-write= \" /etc,/var/log.txt \" "
) ;
2023-04-27 00:49:59 +00:00
static ALLOW_NET_HELP : & str = concat! (
" Allow network access. Optionally specify allowed IP addresses and host names, with ports as necessary. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-net \n " ,
" --allow-net= \" localhost:8080,deno.land \" "
) ;
2023-08-03 11:19:19 +00:00
static DENY_NET_HELP : & str = concat! (
" Deny network access. Optionally specify denied IP addresses and host names, with ports as necessary. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-net \n " ,
" --deny-net= \" localhost:8080,deno.land \" "
) ;
2023-04-27 00:49:59 +00:00
static ALLOW_ENV_HELP : & str = concat! (
" Allow access to system environment information. Optionally specify accessible environment variables. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-env \n " ,
" --allow-env= \" PORT,HOME,PATH \" "
) ;
2023-08-03 11:19:19 +00:00
static DENY_ENV_HELP : & str = concat! (
" Deny access to system environment information. Optionally specify accessible environment variables. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-env \n " ,
" --deny-env= \" PORT,HOME,PATH \" "
) ;
2023-04-27 00:49:59 +00:00
static ALLOW_SYS_HELP : & str = concat! (
" Allow access to OS information. Optionally allow specific APIs by function name. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-sys \n " ,
" --allow-sys= \" systemMemoryInfo,osRelease \" "
) ;
2023-08-03 11:19:19 +00:00
static DENY_SYS_HELP : & str = concat! (
" Deny access to OS information. Optionally deny specific APIs by function name. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-sys \n " ,
" --deny-sys= \" systemMemoryInfo,osRelease \" "
) ;
2023-04-27 00:49:59 +00:00
static ALLOW_RUN_HELP : & str = concat! (
" Allow running subprocesses. Optionally specify allowed runnable program names. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-run \n " ,
" --allow-run= \" whoami,ps \" "
) ;
2023-08-03 11:19:19 +00:00
static DENY_RUN_HELP : & str = concat! (
" Deny running subprocesses. Optionally specify denied runnable program names. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-run \n " ,
" --deny-run= \" whoami,ps \" "
) ;
2023-04-27 00:49:59 +00:00
static ALLOW_FFI_HELP : & str = concat! (
" (Unstable) Allow loading dynamic libraries. Optionally specify allowed directories or files. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --allow-ffi \n " ,
" --allow-ffi= \" ./libfoo.so \" "
) ;
2023-08-03 11:19:19 +00:00
static DENY_FFI_HELP : & str = concat! (
" (Unstable) Deny loading dynamic libraries. Optionally specify denied directories or files. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n " ,
" Examples: \n " ,
" --deny-ffi \n " ,
" --deny-ffi= \" ./libfoo.so \" "
) ;
2023-04-27 00:49:59 +00:00
static ALLOW_HRTIME_HELP : & str = concat! (
" Allow high-resolution time measurement. Note: this can enable timing attacks and fingerprinting. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n "
) ;
2023-08-03 11:19:19 +00:00
static DENY_HRTIME_HELP : & str = concat! (
" Deny high-resolution time measurement. Note: this can prevent timing attacks and fingerprinting. \n " ,
" Docs: https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n "
) ;
2023-04-27 00:49:59 +00:00
static ALLOW_ALL_HELP : & str = concat! (
" Allow all permissions. Learn more about permissions in Deno: \n " ,
" https://deno.land/manual@v " ,
env! ( " CARGO_PKG_VERSION " ) ,
" /basics/permissions \n "
) ;
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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2019-11-26 16:06:32 +00:00
. require_equals ( true )
2023-04-27 00:49:59 +00:00
. value_name ( " PATH " )
. help ( ALLOW_READ_HELP )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::AnyPath ) ,
2019-11-26 16:06:32 +00:00
)
2023-08-03 11:19:19 +00:00
. arg (
Arg ::new ( " deny-read " )
. long ( " deny-read " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " PATH " )
. help ( DENY_READ_HELP )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-08-03 11:19:19 +00:00
. 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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2019-11-26 16:06:32 +00:00
. require_equals ( true )
2023-04-27 00:49:59 +00:00
. value_name ( " PATH " )
. help ( ALLOW_WRITE_HELP )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::AnyPath ) ,
2019-11-26 16:06:32 +00:00
)
2023-08-03 11:19:19 +00:00
. arg (
Arg ::new ( " deny-write " )
. long ( " deny-write " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " PATH " )
. help ( DENY_WRITE_HELP )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-08-03 11:19:19 +00:00
. 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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2019-11-26 16:06:32 +00:00
. require_equals ( true )
2023-04-27 00:49:59 +00:00
. value_name ( " IP_OR_HOSTNAME " )
. help ( ALLOW_NET_HELP )
2023-08-03 11:19:19 +00:00
. value_parser ( flags_net ::validator ) ,
)
. arg (
Arg ::new ( " deny-net " )
. long ( " deny-net " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " IP_OR_HOSTNAME " )
. help ( DENY_NET_HELP )
. value_parser ( flags_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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-04-13 11:25:21 +00:00
. require_equals ( true )
2023-04-27 00:49:59 +00:00
. value_name ( " VARIABLE_NAME " )
. help ( ALLOW_ENV_HELP )
2023-03-26 04:06:18 +00:00
. value_parser ( | key : & str | {
if key . is_empty ( ) | | key . contains ( & [ '=' , '\0' ] as & [ char ] ) {
return Err ( format! ( " invalid key \" {key} \" " ) ) ;
2021-04-13 11:25:21 +00:00
}
2023-03-26 04:06:18 +00:00
Ok ( if cfg! ( windows ) {
key . to_uppercase ( )
} else {
key . to_string ( )
} )
2021-04-13 11:25:21 +00:00
} ) ,
2019-11-26 16:06:32 +00:00
)
2023-08-03 11:19:19 +00:00
. arg (
Arg ::new ( " deny-env " )
. long ( " deny-env " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " VARIABLE_NAME " )
. help ( DENY_ENV_HELP )
. value_parser ( | key : & str | {
if key . is_empty ( ) | | key . contains ( & [ '=' , '\0' ] as & [ char ] ) {
return Err ( format! ( " invalid key \" {key} \" " ) ) ;
}
Ok ( if cfg! ( windows ) {
key . to_uppercase ( )
} else {
key . to_string ( )
} )
} ) ,
)
2022-09-28 12:46:50 +00:00
. arg (
Arg ::new ( " allow-sys " )
. long ( " allow-sys " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
2022-09-28 12:46:50 +00:00
. use_value_delimiter ( true )
. require_equals ( true )
2023-04-27 00:49:59 +00:00
. value_name ( " API_NAME " )
. help ( ALLOW_SYS_HELP )
2023-03-26 04:06:18 +00:00
. value_parser ( | key : & str | parse_sys_kind ( key ) . map ( ToString ::to_string ) ) ,
2022-09-28 12:46:50 +00:00
)
2023-08-03 11:19:19 +00:00
. arg (
Arg ::new ( " deny-sys " )
. long ( " deny-sys " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " API_NAME " )
. help ( DENY_SYS_HELP )
. value_parser ( | key : & str | parse_sys_kind ( key ) . map ( ToString ::to_string ) ) ,
)
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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-04-09 22:12:00 +00:00
. require_equals ( true )
2023-04-27 00:49:59 +00:00
. value_name ( " PROGRAM_NAME " )
. help ( ALLOW_RUN_HELP ) ,
2019-11-26 16:06:32 +00:00
)
2023-08-03 11:19:19 +00:00
. arg (
Arg ::new ( " deny-run " )
. long ( " deny-run " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " PROGRAM_NAME " )
. help ( DENY_RUN_HELP ) ,
)
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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
2022-03-28 01:57:56 +00:00
. use_value_delimiter ( true )
2021-08-06 21:28:10 +00:00
. require_equals ( true )
2023-04-27 00:49:59 +00:00
. value_name ( " PATH " )
. help ( ALLOW_FFI_HELP )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::AnyPath ) ,
2019-12-05 20:30:20 +00:00
)
2023-08-03 11:19:19 +00:00
. arg (
Arg ::new ( " deny-ffi " )
. long ( " deny-ffi " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " PATH " )
. help ( DENY_FFI_HELP )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-08-03 11:19:19 +00:00
. value_hint ( ValueHint ::AnyPath ) ,
)
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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2023-04-27 00:49:59 +00:00
. help ( ALLOW_HRTIME_HELP ) ,
2019-11-26 16:06:32 +00:00
)
2023-08-03 11:19:19 +00:00
. arg (
Arg ::new ( " deny-hrtime " )
. long ( " deny-hrtime " )
. action ( ArgAction ::SetTrue )
. help ( DENY_HRTIME_HELP ) ,
)
2019-11-26 16:06:32 +00:00
. 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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2023-04-27 00:49:59 +00:00
. help ( ALLOW_ALL_HELP ) ,
2019-11-26 16:06:32 +00:00
)
2021-04-12 02:15:43 +00:00
. arg (
2022-02-13 03:13:21 +00:00
Arg ::new ( " no-prompt " )
. long ( " no-prompt " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2022-02-13 03:13:21 +00:00
. 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 ( ) )
2023-11-10 17:41:24 +00:00
. arg ( strace_ops_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) " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
2021-04-16 13:28:41 +00:00
. require_equals ( true )
2023-03-26 04:06:18 +00:00
. value_parser ( value_parser! ( SocketAddr ) ) ,
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 " ,
)
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
2022-12-12 14:33:30 +00:00
. require_equals ( true )
2023-03-26 04:06:18 +00:00
. value_parser ( value_parser! ( SocketAddr ) ) ,
2022-12-12 14:33:30 +00:00
)
. 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
)
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
2021-04-16 13:28:41 +00:00
. require_equals ( true )
2023-03-26 04:06:18 +00:00
. value_parser ( value_parser! ( SocketAddr ) ) ,
2019-11-26 16:06:32 +00:00
)
2019-04-29 23:43:06 +00:00
}
2023-03-27 16:28:41 +00:00
static IMPORT_MAP_HELP : & str = concat! (
" Load import map file from local file or remote URL.
2024-01-06 10:55:28 +00:00
Docs : https ://docs.deno.com/runtime/manual/basics/import_maps
2023-03-27 16:28:41 +00:00
Specification : https ://wicg.github.io/import-maps/
Examples : https ://github.com/WICG/import-maps#the-import-map",
) ;
2022-05-09 18:16:34 +00:00
2023-03-26 04:06:18 +00:00
fn import_map_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
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 " )
2023-03-27 16:28:41 +00:00
. long_help ( IMPORT_MAP_HELP )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 13:28:41 +00:00
}
2023-11-01 15:21:13 +00:00
fn env_file_arg ( ) -> Arg {
Arg ::new ( " env " )
. long ( " env " )
. value_name ( " FILE " )
. help ( " Load .env file " )
. long_help ( " UNSTABLE: Load environment variables from local file. Only the first environment variable with a given key is used. Existing process environment variables are not overwritten. " )
. value_hint ( ValueHint ::FilePath )
. default_missing_value ( " .env " )
. require_equals ( true )
. num_args ( 0 ..= 1 )
}
2023-03-26 04:06:18 +00:00
fn reload_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " reload " )
. short ( 'r' )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
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
2024-04-10 21:26:35 +00:00
- - reload = jsr :@ std / http / file - server
2021-04-16 13:28:41 +00:00
Reload only standard modules
2024-04-10 21:26:35 +00:00
- - reload = jsr :@ std / http / file - server , jsr :@ std / assert / assert - equals
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 )
2023-03-26 04:06:18 +00:00
. value_parser ( reload_arg_validate )
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn ca_file_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " cert " )
2021-04-16 13:28:41 +00:00
. long ( " cert " )
. value_name ( " FILE " )
. help ( " Load certificate authority from PEM encoded file " )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn cached_only_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " cached-only " )
2021-04-16 13:28:41 +00:00
. long ( " cached-only " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2021-04-16 13:28:41 +00:00
. help ( " Require that remote dependencies are already cached " )
}
2023-03-22 14:15:53 +00:00
/// Used for subcommands that operate on executable scripts only.
/// `deno fmt` has its own `--ext` arg because its possible values differ.
/// If --ext is not provided and the script doesn't have a file extension,
/// deno_graph::parse_module() defaults to js.
2023-03-26 04:06:18 +00:00
fn executable_ext_arg ( ) -> Arg {
2023-03-22 14:15:53 +00:00
Arg ::new ( " ext " )
. long ( " ext " )
. help ( " Set content type of the supplied file " )
2023-03-26 04:06:18 +00:00
. value_parser ( [ " ts " , " tsx " , " js " , " jsx " ] )
2023-03-22 14:15:53 +00:00
}
2023-03-26 04:06:18 +00:00
fn location_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " location " )
2021-04-16 13:28:41 +00:00
. long ( " location " )
. value_name ( " HREF " )
2023-03-26 04:06:18 +00:00
. value_parser ( | href : & str | -> Result < Url , String > {
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 ( ) ;
2023-03-26 04:06:18 +00:00
Ok ( url )
2021-04-16 13:28:41 +00:00
} )
. 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
}
2023-03-26 04:06:18 +00:00
fn enable_testing_features_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
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 " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2022-01-14 16:38:17 +00:00
. hide ( true )
2021-07-23 14:31:16 +00:00
}
2023-11-10 17:41:24 +00:00
fn strace_ops_arg ( ) -> Arg {
Arg ::new ( " strace-ops " )
. long ( " strace-ops " )
. num_args ( 0 .. )
. use_value_delimiter ( true )
. require_equals ( true )
. value_name ( " OPS " )
. help ( " Trace low-level op calls " )
. hide ( true )
}
2023-03-26 04:06:18 +00:00
fn v8_flags_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " v8-flags " )
2021-04-16 13:28:41 +00:00
. long ( " v8-flags " )
2023-03-26 04:06:18 +00:00
. num_args ( .. )
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-27 16:28:41 +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
}
2023-03-26 04:06:18 +00:00
fn seed_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
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 " )
2023-03-26 04:06:18 +00:00
. value_parser ( value_parser! ( u64 ) )
2021-04-16 13:28:41 +00:00
}
2023-10-31 00:25:58 +00:00
fn hmr_arg ( takes_files : bool ) -> Arg {
let arg = Arg ::new ( " hmr " )
. long ( " unstable-hmr " )
. help ( " UNSTABLE: Watch for file changes and hot replace modules " )
. conflicts_with ( " watch " ) ;
if takes_files {
arg
. value_name ( " FILES " )
. num_args ( 0 .. )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2023-10-31 00:25:58 +00:00
. use_value_delimiter ( true )
. require_equals ( true )
. long_help (
" Watch for file changes and restart process automatically.
Local files from entry point module graph are watched by default .
Additional paths might be watched by passing them as arguments to this flag . " ,
)
. value_hint ( ValueHint ::AnyPath )
} else {
arg . action ( ArgAction ::SetTrue ) . long_help (
" Watch for file changes and restart process automatically.
Only local files from entry point module graph are watched . " ,
)
}
}
2023-03-26 04:06:18 +00:00
fn watch_arg ( takes_files : bool ) -> Arg {
2022-01-14 16:38:17 +00:00
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 " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
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 {
2023-03-26 04:06:18 +00:00
arg . action ( ArgAction ::SetTrue ) . long_help (
2023-03-27 16:28:41 +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
}
2023-03-26 04:06:18 +00:00
fn no_clear_screen_arg ( ) -> Arg {
2022-01-31 16:39:39 +00:00
Arg ::new ( " no-clear-screen " )
. requires ( " watch " )
. long ( " no-clear-screen " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2022-01-31 16:39:39 +00:00
. help ( " Do not clear terminal screen when under watch mode " )
}
2024-04-17 14:19:55 +00:00
fn no_code_cache_arg ( ) -> Arg {
Arg ::new ( " no-code-cache " )
. long ( " no-code-cache " )
. help ( " Disable V8 code cache feature " )
. action ( ArgAction ::SetTrue )
}
2024-03-27 22:47:46 +00:00
fn watch_exclude_arg ( ) -> Arg {
Arg ::new ( " watch-exclude " )
. long ( " watch-exclude " )
. help ( " Exclude provided files/patterns from watch mode " )
. value_name ( " FILES " )
. num_args ( 0 .. )
. value_parser ( value_parser! ( String ) )
. use_value_delimiter ( true )
. require_equals ( true )
. value_hint ( ValueHint ::AnyPath )
}
2023-03-26 04:06:18 +00:00
fn no_check_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " no-check " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
2021-11-29 22:23:30 +00:00
. require_equals ( true )
. 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 (
2023-03-27 16:28:41 +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
}
2023-04-13 01:42:28 +00:00
fn check_arg ( checks_local_by_default : bool ) -> Arg {
let arg = Arg ::new ( " check " )
2022-04-10 23:12:51 +00:00
. conflicts_with ( " no-check " )
. long ( " check " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
2022-04-10 23:12:51 +00:00
. require_equals ( true )
. value_name ( " CHECK_TYPE " )
2023-04-13 01:42:28 +00:00
. help ( " Type-check modules " ) ;
2022-04-10 23:12:51 +00:00
2023-04-13 01:42:28 +00:00
if checks_local_by_default {
arg . long_help (
" Set type-checking behavior. This subcommand type-checks local modules by
default , so adding - - check is redundant .
2022-04-10 23:12:51 +00:00
If the value of ' - - check = all ' is supplied , diagnostic errors from remote modules
2023-04-13 01:42:28 +00:00
will be included .
2023-04-26 17:07:15 +00:00
2023-04-13 01:42:28 +00:00
Alternatively , the ' deno check ' subcommand can be used . " ,
2022-04-10 23:12:51 +00:00
)
2023-04-13 01:42:28 +00:00
} else {
arg . long_help (
" Enable type-checking. This subcommand does not type-check by default.
If the value of ' - - check = all ' is supplied , diagnostic errors from remote modules
will be included .
Alternatively , the ' deno check ' subcommand can be used . " ,
)
}
2022-04-10 23:12:51 +00:00
}
2023-03-26 04:06:18 +00:00
fn script_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " script_arg " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
. action ( ArgAction ::Append )
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.
2023-03-26 04:06:18 +00:00
. default_value_ifs ( [
( " v8-flags " , " --help " , Some ( " _ " ) ) ,
( " v8-flags " , " -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
}
2023-03-26 04:06:18 +00:00
fn lock_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " lock " )
2021-04-16 13:28:41 +00:00
. long ( " lock " )
. value_name ( " FILE " )
2023-03-30 14:43:16 +00:00
. help ( " Check the specified lock file.
2023-03-27 16:28:41 +00:00
If value is not provided , defaults to \ " deno.lock \" in the current working directory. " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
2024-03-14 23:53:46 +00:00
. value_parser ( value_parser! ( String ) )
2022-03-14 18:41:35 +00:00
. value_hint ( ValueHint ::FilePath )
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn lock_write_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " lock-write " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
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
}
2023-03-26 04:06:18 +00:00
fn no_lock_arg ( ) -> Arg {
2022-11-03 15:42:56 +00:00
Arg ::new ( " no-lock " )
. long ( " no-lock " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2022-11-03 15:42:56 +00:00
. help ( " Disable auto discovery of the lock file. " )
. conflicts_with ( " lock " )
}
2023-03-27 16:28:41 +00:00
static CONFIG_HELP : & str = concat! (
" 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",
env! ( " CARGO_PKG_VERSION " ) ,
" /getting_started/configuration_file "
) ;
2022-05-09 18:16:34 +00:00
2023-03-26 04:06:18 +00:00
fn config_arg ( ) -> Arg {
2022-06-28 19:47:51 +00:00
Arg ::new ( " config " )
. short ( 'c' )
. long ( " config " )
. value_name ( " FILE " )
. help ( " Specify the configuration file " )
2023-03-27 16:28:41 +00:00
. long_help ( CONFIG_HELP )
2022-06-28 19:47:51 +00:00
. value_hint ( ValueHint ::FilePath )
}
2023-03-26 04:06:18 +00:00
fn no_config_arg ( ) -> Arg {
2022-06-28 19:47:51 +00:00
Arg ::new ( " no-config " )
. long ( " no-config " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2022-06-28 19:47:51 +00:00
. help ( " Disable automatic loading of the configuration file. " )
. conflicts_with ( " config " )
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn no_remote_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " no-remote " )
2021-04-16 13:28:41 +00:00
. long ( " no-remote " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2021-04-16 13:28:41 +00:00
. help ( " Do not resolve remote modules " )
}
2023-03-26 04:06:18 +00:00
fn no_npm_arg ( ) -> Arg {
2022-09-07 13:33:51 +00:00
Arg ::new ( " no-npm " )
. long ( " no-npm " )
2023-03-26 04:06:18 +00:00
. action ( ArgAction ::SetTrue )
2022-09-07 13:33:51 +00:00
. help ( " Do not resolve npm modules " )
}
2023-05-19 22:39:27 +00:00
fn node_modules_dir_arg ( ) -> Arg {
2022-09-22 15:17:02 +00:00
Arg ::new ( " node-modules-dir " )
. long ( " node-modules-dir " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
2023-02-20 18:14:06 +00:00
. require_equals ( true )
2023-05-18 22:10:44 +00:00
. help ( " Enables or disables the use of a local node_modules folder for npm packages " )
2022-09-22 15:17:02 +00:00
}
2023-08-07 01:56:56 +00:00
fn vendor_arg ( ) -> Arg {
Arg ::new ( " vendor " )
. long ( " vendor " )
2023-08-02 00:49:09 +00:00
. num_args ( 0 ..= 1 )
. value_parser ( value_parser! ( bool ) )
. default_missing_value ( " true " )
. require_equals ( true )
2023-08-07 01:56:56 +00:00
. help ( " UNSTABLE: Enables or disables the use of a local vendor folder for remote modules and node_modules folder for npm packages " )
2023-08-02 00:49:09 +00:00
}
2023-03-26 04:06:18 +00:00
fn unsafely_ignore_certificate_errors_arg ( ) -> Arg {
2022-01-14 16:38:17 +00:00
Arg ::new ( " unsafely-ignore-certificate-errors " )
2021-12-10 14:47:55 +00:00
. long ( " unsafely-ignore-certificate-errors " )
2023-03-26 04:06:18 +00:00
. num_args ( 0 .. )
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 " )
2023-08-03 11:19:19 +00:00
. value_parser ( flags_net ::validator )
2021-12-10 14:47:55 +00:00
}
2024-02-29 19:12:04 +00:00
fn add_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2024-05-08 19:34:46 +00:00
flags . subcommand = DenoSubcommand ::Add ( add_parse_inner ( matches , None ) ) ;
}
fn add_parse_inner (
matches : & mut ArgMatches ,
packages : Option < clap ::parser ::Values < String > > ,
) -> AddFlags {
let packages = packages
. unwrap_or_else ( | | matches . remove_many ::< String > ( " packages " ) . unwrap ( ) )
. collect ( ) ;
AddFlags { packages }
2024-02-29 19:12:04 +00:00
}
2023-03-26 04:06:18 +00:00
fn bench_parse ( flags : & mut Flags , matches : & mut 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
2024-05-06 23:21:58 +00:00
flags . permissions . no_prompt = true ;
2022-03-11 22:07:02 +00:00
2023-03-26 04:06:18 +00:00
let json = matches . get_flag ( " json " ) ;
2023-02-12 17:40:45 +00:00
2024-01-16 00:15:39 +00:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 04:06:18 +00:00
Some ( f ) = > f . collect ( ) ,
2022-03-11 22:07:02 +00:00
None = > vec! [ ] ,
} ;
2023-03-26 04:06:18 +00:00
let filter = matches . remove_one ::< String > ( " filter " ) ;
2022-03-11 22:07:02 +00:00
2023-03-26 04:06:18 +00:00
if matches . contains_id ( " script_arg " ) {
flags
. argv
. extend ( matches . remove_many ::< String > ( " script_arg " ) . unwrap ( ) ) ;
2022-03-11 22:07:02 +00:00
}
2024-01-16 00:15:39 +00:00
let include = if let Some ( files ) = matches . remove_many ::< String > ( " files " ) {
2023-03-26 04:06:18 +00:00
files . collect ( )
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
} ;
2023-03-26 14:55:58 +00:00
let no_run = matches . get_flag ( " no-run " ) ;
2022-03-11 22:07:02 +00:00
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 ,
2023-03-26 14:55:58 +00:00
no_run ,
2023-06-15 17:09:37 +00:00
watch : watch_arg_parse ( matches ) ,
2022-03-11 22:07:02 +00:00
} ) ;
}
2023-03-26 04:06:18 +00:00
fn bundle_parse ( flags : & mut Flags , matches : & mut 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 ) ;
2023-03-26 04:06:18 +00:00
let source_file = matches . remove_one ::< String > ( " source_file " ) . unwrap ( ) ;
2021-04-16 13:28:41 +00:00
2023-03-26 04:06:18 +00:00
let out_file =
2024-01-16 00:15:39 +00:00
if let Some ( out_file ) = matches . remove_one ::< String > ( " out_file " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_write = Some ( vec! [ ] ) ;
2023-03-26 04:06:18 +00:00
Some ( out_file )
} else {
None
} ;
2021-04-16 13:28:41 +00:00
2023-03-22 14:15:53 +00:00
ext_arg_parse ( flags , matches ) ;
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 ,
2023-06-15 17:09:37 +00:00
watch : watch_arg_parse ( matches ) ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn cache_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 13:28:41 +00:00
compile_args_parse ( flags , matches ) ;
2023-03-26 04:06:18 +00:00
let files = matches . remove_many ::< String > ( " file " ) . unwrap ( ) . collect ( ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Cache ( CacheFlags { files } ) ;
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn check_parse ( flags : & mut Flags , matches : & mut 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 ) ;
2023-03-26 04:06:18 +00:00
let files = matches . remove_many ::< String > ( " file " ) . unwrap ( ) . collect ( ) ;
if matches . get_flag ( " all " ) | | matches . get_flag ( " 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
}
2023-03-26 04:06:18 +00:00
fn compile_parse ( flags : & mut Flags , matches : & mut 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 ) ;
2023-03-26 04:06:18 +00:00
let mut script = matches . remove_many ::< String > ( " script_arg " ) . unwrap ( ) ;
let source_file = script . next ( ) . unwrap ( ) ;
let args = script . collect ( ) ;
2024-03-14 23:53:46 +00:00
let output = matches . remove_one ::< String > ( " output " ) ;
2023-03-26 04:06:18 +00:00
let target = matches . remove_one ::< String > ( " target " ) ;
2023-07-28 15:46:26 +00:00
let no_terminal = matches . get_flag ( " no-terminal " ) ;
2023-03-26 04:06:18 +00:00
let include = match matches . remove_many ::< String > ( " include " ) {
Some ( f ) = > f . collect ( ) ,
2023-03-18 23:43:07 +00:00
None = > vec! [ ] ,
} ;
2023-03-22 14:15:53 +00:00
ext_arg_parse ( flags , matches ) ;
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-07-28 15:46:26 +00:00
no_terminal ,
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 ,
2023-03-26 04:06:18 +00:00
matches : & mut ArgMatches ,
mut app : 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 " ;
2023-03-26 04:06:18 +00:00
match matches . get_one ::< String > ( " shell " ) . unwrap ( ) . as_str ( ) {
2022-01-14 16:38:17 +00:00
" 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
}
2023-03-26 04:06:18 +00:00
fn coverage_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2024-01-16 00:15:39 +00:00
let files = match matches . remove_many ::< String > ( " files " ) {
2023-03-26 04:06:18 +00:00
Some ( f ) = > f . collect ( ) ,
2024-01-16 00:15:39 +00:00
None = > vec! [ " coverage " . to_string ( ) ] , // default
2021-04-16 13:28:41 +00:00
} ;
2024-01-16 00:15:39 +00:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 04:06:18 +00:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 13:28:41 +00:00
None = > vec! [ ] ,
} ;
2023-03-26 04:06:18 +00:00
let include = match matches . remove_many ::< String > ( " include " ) {
Some ( f ) = > f . collect ( ) ,
2021-04-16 13:28:41 +00:00
None = > vec! [ ] ,
} ;
2023-03-26 04:06:18 +00:00
let exclude = match matches . remove_many ::< String > ( " exclude " ) {
Some ( f ) = > f . collect ( ) ,
2021-04-16 13:28:41 +00:00
None = > vec! [ ] ,
} ;
2023-12-08 07:54:52 +00:00
let r#type = if matches . get_flag ( " lcov " ) {
CoverageType ::Lcov
} else if matches . get_flag ( " html " ) {
CoverageType ::Html
2023-12-12 11:53:41 +00:00
} else if matches . get_flag ( " detailed " ) {
CoverageType ::Detailed
2023-12-12 03:42:57 +00:00
} else {
CoverageType ::Summary
2023-12-08 07:54:52 +00:00
} ;
2024-03-14 23:53:46 +00:00
let output = matches . remove_one ::< String > ( " output " ) ;
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 ,
2023-12-08 07:54:52 +00:00
r#type ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn doc_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 13:28:41 +00:00
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-10-30 22:58:57 +00:00
let source_files_val = matches . remove_many ::< String > ( " source_file " ) ;
let source_files = if let Some ( val ) = source_files_val {
let vals : Vec < String > = val . collect ( ) ;
if vals . len ( ) = = 1 {
if vals [ 0 ] = = " --builtin " {
2023-01-14 17:39:56 +00:00
DocSourceFileFlag ::Builtin
} else {
2023-10-30 22:58:57 +00:00
DocSourceFileFlag ::Paths ( vec! [ vals [ 0 ] . to_string ( ) ] )
2023-01-14 17:39:56 +00:00
}
2023-10-30 22:58:57 +00:00
} else {
DocSourceFileFlag ::Paths (
vals . into_iter ( ) . filter ( | v | v ! = " --builtin " ) . collect ( ) ,
)
}
} else {
DocSourceFileFlag ::Builtin
} ;
2023-03-26 04:06:18 +00:00
let private = matches . get_flag ( " private " ) ;
2023-10-31 22:19:42 +00:00
let lint = matches . get_flag ( " lint " ) ;
2023-03-26 04:06:18 +00:00
let json = matches . get_flag ( " json " ) ;
let filter = matches . remove_one ::< String > ( " filter " ) ;
2023-11-01 15:25:05 +00:00
let html = if matches . get_flag ( " html " ) {
2024-04-24 20:34:21 +00:00
let name = matches . remove_one ::< String > ( " name " ) ;
2023-11-01 15:25:05 +00:00
let output = matches
2024-03-14 23:53:46 +00:00
. remove_one ::< String > ( " output " )
. unwrap_or ( String ::from ( " ./docs/ " ) ) ;
2023-11-01 15:25:05 +00:00
Some ( DocHtmlFlag { name , output } )
} else {
None
} ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Doc ( DocFlags {
2023-10-30 22:58:57 +00:00
source_files ,
2021-04-16 13:28:41 +00:00
json ,
2023-10-31 22:19:42 +00:00
lint ,
2023-11-01 15:25:05 +00:00
html ,
2021-04-16 13:28:41 +00:00
filter ,
private ,
2021-09-03 23:33:35 +00:00
} ) ;
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn eval_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 13:28:41 +00:00
runtime_args_parse ( flags , matches , false , true ) ;
2024-03-13 16:07:24 +00:00
flags . allow_all ( ) ;
2023-03-22 14:15:53 +00:00
ext_arg_parse ( flags , matches ) ;
2021-04-16 13:28:41 +00:00
// TODO(@satyarohith): remove this flag in 2.0.
2023-03-26 04:06:18 +00:00
let as_typescript = matches . get_flag ( " ts " ) ;
2023-03-22 14:15:53 +00:00
2024-05-09 02:45:06 +00:00
#[ allow(clippy::print_stderr) ]
2023-03-22 14:15:53 +00:00
if as_typescript {
eprintln! (
2024-01-23 16:34:06 +00:00
" ⚠️ {} " ,
2023-03-22 14:15:53 +00:00
crate ::colors ::yellow (
2024-01-23 16:34:06 +00:00
" Use `--ext=ts` instead. The `--ts` and `-T` flags are deprecated and will be removed in Deno 2.0. "
2023-03-22 14:15:53 +00:00
) ,
) ;
flags . ext = Some ( " ts " . to_string ( ) ) ;
}
2021-04-16 13:28:41 +00:00
2023-03-26 04:06:18 +00:00
let print = matches . get_flag ( " print " ) ;
let mut code_args = matches . remove_many ::< String > ( " code_arg " ) . unwrap ( ) ;
let code = code_args . next ( ) . unwrap ( ) ;
flags . argv . extend ( code_args ) ;
2023-03-22 14:15:53 +00:00
flags . subcommand = DenoSubcommand ::Eval ( EvalFlags { print , code } ) ;
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
fn fmt_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-05-13 15:40:50 +00:00
config_args_parse ( flags , matches ) ;
2023-03-22 14:15:53 +00:00
ext_arg_parse ( flags , matches ) ;
2022-01-31 16:39:39 +00:00
2024-01-16 00:15:39 +00:00
let include = match matches . remove_many ::< String > ( " files " ) {
2023-03-26 04:06:18 +00:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 13:28:41 +00:00
None = > vec! [ ] ,
} ;
2024-01-16 00:15:39 +00:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 04:06:18 +00:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 13:28:41 +00:00
None = > vec! [ ] ,
} ;
2019-04-29 23:43:06 +00:00
2023-03-26 04:06:18 +00:00
let use_tabs = matches . remove_one ::< bool > ( " use-tabs " ) ;
let line_width = matches . remove_one ::< NonZeroU32 > ( " line-width " ) ;
let indent_width = matches . remove_one ::< NonZeroU8 > ( " indent-width " ) ;
let single_quote = matches . remove_one ::< bool > ( " single-quote " ) ;
let prose_wrap = matches . remove_one ::< String > ( " prose-wrap " ) ;
let no_semicolons = matches . remove_one ::< bool > ( " no-semicolons " ) ;
2021-09-13 20:06:45 +00:00
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Fmt ( FmtFlags {
2023-03-26 04:06:18 +00:00
check : matches . get_flag ( " check " ) ,
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 ,
2023-06-15 17:09:37 +00:00
watch : watch_arg_parse ( matches ) ,
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-03-26 04:06:18 +00:00
fn init_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-08-19 23:37:05 +00:00
flags . subcommand = DenoSubcommand ::Init ( InitFlags {
2023-03-26 04:06:18 +00:00
dir : matches . remove_one ::< String > ( " dir " ) ,
2022-08-19 23:37:05 +00:00
} ) ;
}
2023-03-26 04:06:18 +00:00
fn info_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 13:28:41 +00:00
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 ) ;
2023-08-07 01:56:56 +00:00
node_modules_and_vendor_dir_arg_parse ( flags , matches ) ;
2024-02-19 12:02:40 +00:00
lock_args_parse ( flags , matches ) ;
2023-03-13 21:04:00 +00:00
no_remote_arg_parse ( flags , matches ) ;
no_npm_arg_parse ( flags , matches ) ;
2023-03-26 04:06:18 +00:00
let json = matches . get_flag ( " json " ) ;
2021-09-03 23:33:35 +00:00
flags . subcommand = DenoSubcommand ::Info ( InfoFlags {
2023-03-26 04:06:18 +00:00
file : matches . remove_one ::< String > ( " file " ) ,
2021-04-16 13:28:41 +00:00
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
2023-03-26 04:06:18 +00:00
fn install_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 13:28:41 +00:00
runtime_args_parse ( flags , matches , true , true ) ;
2024-03-27 22:45:57 +00:00
let global = matches . get_flag ( " global " ) ;
2024-05-08 19:34:46 +00:00
if global | | ! * DENO_FUTURE {
let root = matches . remove_one ::< String > ( " root " ) ;
let force = matches . get_flag ( " force " ) ;
let name = matches . remove_one ::< String > ( " name " ) ;
let mut cmd_values =
matches . remove_many ::< String > ( " cmd " ) . unwrap_or_default ( ) ;
let module_url = cmd_values . next ( ) . unwrap ( ) ;
let args = cmd_values . collect ( ) ;
flags . subcommand = DenoSubcommand ::Install ( InstallFlags {
// TODO(bartlomieju): remove for 2.0
global ,
kind : InstallKind ::Global ( InstallFlagsGlobal {
name ,
module_url ,
args ,
root ,
force ,
} ) ,
} ) ;
} else {
let local_flags = matches
. remove_many ( " cmd " )
. map ( | packages | add_parse_inner ( matches , Some ( packages ) ) ) ;
flags . subcommand = DenoSubcommand ::Install ( InstallFlags {
global ,
kind : InstallKind ::Local ( local_flags ) ,
} )
}
2020-01-08 19:59:53 +00:00
}
2023-09-16 00:42:09 +00:00
fn jupyter_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2024-03-14 23:53:46 +00:00
let conn_file = matches . remove_one ::< String > ( " conn " ) ;
2023-09-16 00:42:09 +00:00
let kernel = matches . get_flag ( " kernel " ) ;
let install = matches . get_flag ( " install " ) ;
flags . subcommand = DenoSubcommand ::Jupyter ( JupyterFlags {
install ,
kernel ,
conn_file ,
} ) ;
}
2023-03-26 04:06:18 +00:00
fn uninstall_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2023-11-13 14:44:01 +00:00
let root = matches . remove_one ::< String > ( " root " ) ;
2024-03-27 22:45:57 +00:00
let global = matches . get_flag ( " global " ) ;
2023-03-26 04:06:18 +00:00
let name = matches . remove_one ::< String > ( " name " ) . unwrap ( ) ;
2024-04-04 14:40:54 +00:00
flags . subcommand = DenoSubcommand ::Uninstall ( UninstallFlags {
// TODO(bartlomieju): remove once `deno uninstall` supports both local and
// global installs
global ,
kind : UninstallKind ::Global ( UninstallFlagsGlobal { name , root } ) ,
} ) ;
2021-09-30 15:38:07 +00:00
}
2023-03-26 04:06:18 +00:00
fn lsp_parse ( flags : & mut Flags , _matches : & mut ArgMatches ) {
2021-06-23 01:48:01 +00:00
flags . subcommand = DenoSubcommand ::Lsp ;
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2023-03-26 04:06:18 +00:00
fn lint_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-05-13 15:40:50 +00:00
config_args_parse ( flags , matches ) ;
2024-01-16 00:15:39 +00:00
let files = match matches . remove_many ::< String > ( " files " ) {
2023-03-26 04:06:18 +00:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 13:28:41 +00:00
None = > vec! [ ] ,
} ;
2024-01-16 00:15:39 +00:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 04:06:18 +00:00
Some ( f ) = > f . collect ( ) ,
2021-04-16 13:28:41 +00:00
None = > vec! [ ] ,
} ;
2024-03-21 21:18:59 +00:00
let fix = matches . get_flag ( " fix " ) ;
2023-03-26 04:06:18 +00:00
let rules = matches . get_flag ( " rules " ) ;
2021-11-04 15:12:12 +00:00
let maybe_rules_tags = matches
2023-03-26 04:06:18 +00:00
. remove_many ::< String > ( " rules-tags " )
. map ( | f | f . collect ( ) ) ;
2021-11-04 15:12:12 +00:00
let maybe_rules_include = matches
2023-03-26 04:06:18 +00:00
. remove_many ::< String > ( " rules-include " )
. map ( | f | f . collect ( ) ) ;
2021-11-04 15:12:12 +00:00
let maybe_rules_exclude = matches
2023-03-26 04:06:18 +00:00
. remove_many ::< String > ( " rules-exclude " )
. map ( | f | f . collect ( ) ) ;
2021-11-04 15:12:12 +00:00
2023-03-26 04:06:18 +00:00
let json = matches . get_flag ( " json " ) ;
let compact = matches . get_flag ( " 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 ,
} ,
2024-03-21 21:18:59 +00:00
fix ,
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 ,
2021-04-16 13:28:41 +00:00
json ,
2022-09-28 16:47:48 +00:00
compact ,
2023-06-15 17:09:37 +00:00
watch : watch_arg_parse ( matches ) ,
2021-09-03 23:33:35 +00:00
} ) ;
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2023-03-26 04:06:18 +00:00
fn repl_parse ( flags : & mut Flags , matches : & mut 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
2023-03-26 04:06:18 +00:00
let eval_files = matches
. remove_many ::< String > ( " eval-file " )
. map ( | values | values . collect ( ) ) ;
2022-04-20 12:16:37 +00:00
2022-01-14 16:38:17 +00:00
handle_repl_flags (
flags ,
ReplFlags {
2022-04-20 12:16:37 +00:00
eval_files ,
2023-03-26 04:06:18 +00:00
eval : matches . remove_one ::< String > ( " eval " ) ,
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
2023-08-13 02:04:17 +00:00
fn run_parse (
flags : & mut Flags ,
matches : & mut ArgMatches ,
app : Command ,
) -> clap ::error ::Result < ( ) > {
2021-04-16 13:28:41 +00:00
runtime_args_parse ( flags , matches , true , true ) ;
2024-04-17 14:19:55 +00:00
flags . code_cache_enabled = ! matches . get_flag ( " no-code-cache " ) ;
2023-08-13 02:04:17 +00:00
let mut script_arg =
matches . remove_many ::< String > ( " script_arg " ) . ok_or_else ( | | {
let mut app = app ;
let subcommand = & mut app . find_subcommand_mut ( " run " ) . unwrap ( ) ;
subcommand . error (
clap ::error ::ErrorKind ::MissingRequiredArgument ,
" [SCRIPT_ARG] may only be omitted with --v8-flags=--help " ,
)
} ) ? ;
2023-03-26 04:06:18 +00:00
let script = script_arg . next ( ) . unwrap ( ) ;
flags . argv . extend ( script_arg ) ;
2021-04-16 13:28:41 +00:00
2023-03-22 14:15:53 +00:00
ext_arg_parse ( flags , matches ) ;
2023-06-15 17:09:37 +00:00
flags . subcommand = DenoSubcommand ::Run ( RunFlags {
script ,
watch : watch_arg_parse_with_paths ( matches ) ,
} ) ;
2023-08-13 02:04:17 +00:00
Ok ( ( ) )
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2024-04-24 19:45:49 +00:00
fn serve_parse (
flags : & mut Flags ,
matches : & mut ArgMatches ,
app : Command ,
) -> clap ::error ::Result < ( ) > {
// deno serve implies --allow-net=host:port
let port = matches
. remove_one ::< NonZeroU16 > ( " port " )
. unwrap_or ( NonZeroU16 ::new ( 8000 ) . unwrap ( ) ) ;
let host = matches
. remove_one ::< String > ( " host " )
. unwrap_or_else ( | | " 0.0.0.0 " . to_owned ( ) ) ;
runtime_args_parse ( flags , matches , true , true ) ;
// If the user didn't pass --allow-net, add this port to the network
// allowlist. If the host is 0.0.0.0, we add :{port} and allow the same network perms
// as if it was passed to --allow-net directly.
let allowed = flags_net ::parse ( vec! [ if host = = " 0.0.0.0 " {
format! ( " : {port} " )
} else {
format! ( " {host} : {port} " )
} ] ) ? ;
2024-05-06 23:21:58 +00:00
match & mut flags . permissions . allow_net {
None = > flags . permissions . allow_net = Some ( allowed ) ,
2024-04-24 19:45:49 +00:00
Some ( v ) = > {
if ! v . is_empty ( ) {
v . extend ( allowed ) ;
}
}
}
flags . code_cache_enabled = ! matches . get_flag ( " no-code-cache " ) ;
let mut script_arg =
matches . remove_many ::< String > ( " script_arg " ) . ok_or_else ( | | {
let mut app = app ;
let subcommand = & mut app . find_subcommand_mut ( " serve " ) . unwrap ( ) ;
subcommand . error (
clap ::error ::ErrorKind ::MissingRequiredArgument ,
" [SCRIPT_ARG] may only be omitted with --v8-flags=--help " ,
)
} ) ? ;
let script = script_arg . next ( ) . unwrap ( ) ;
flags . argv . extend ( script_arg ) ;
ext_arg_parse ( flags , matches ) ;
flags . subcommand = DenoSubcommand ::Serve ( ServeFlags {
script ,
watch : watch_arg_parse_with_paths ( matches ) ,
port ,
host ,
} ) ;
Ok ( ( ) )
}
2023-03-26 04:06:18 +00:00
fn task_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . config_flag = matches
. remove_one ::< String > ( " config " )
2023-04-26 17:07:15 +00:00
. map ( ConfigFlag ::Path )
. unwrap_or ( ConfigFlag ::Discover ) ;
2022-03-11 01:56:14 +00:00
2022-06-08 21:30:16 +00:00
let mut task_flags = TaskFlags {
2023-03-26 04:06:18 +00:00
cwd : matches . remove_one ::< String > ( " cwd " ) ,
2023-02-23 03:45:35 +00:00
task : None ,
2022-06-08 21:30:16 +00:00
} ;
2023-03-26 04:06:18 +00:00
if let Some ( ( task , mut matches ) ) = matches . remove_subcommand ( ) {
task_flags . task = Some ( task ) ;
2022-03-11 01:56:14 +00:00
2023-03-26 04:06:18 +00:00
flags . argv . extend (
matches
. remove_many ::< std ::ffi ::OsString > ( " " )
. into_iter ( )
. flatten ( )
. filter_map ( | arg | arg . into_string ( ) . ok ( ) ) ,
) ;
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
}
2023-03-26 04:06:18 +00:00
fn test_parse ( flags : & mut Flags , matches : & mut 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
2024-05-06 23:21:58 +00:00
flags . permissions . no_prompt = true ;
2021-04-16 13:28:41 +00:00
2024-01-16 00:15:39 +00:00
let ignore = match matches . remove_many ::< String > ( " ignore " ) {
2023-03-26 04:06:18 +00:00
Some ( f ) = > f . collect ( ) ,
2021-08-24 15:23:29 +00:00
None = > vec! [ ] ,
} ;
2023-03-26 04:06:18 +00:00
let no_run = matches . get_flag ( " no-run " ) ;
2024-02-28 16:12:43 +00:00
let trace_leaks =
matches . get_flag ( " trace-ops " ) | | matches . get_flag ( " trace-leaks " ) ;
2024-05-09 02:45:06 +00:00
#[ allow(clippy::print_stderr) ]
2024-02-28 16:12:43 +00:00
if trace_leaks & & matches . get_flag ( " trace-ops " ) {
// 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! (
" ⚠️ {} " ,
crate ::colors ::yellow ( " The `--trace-ops` flag is deprecated and will be removed in Deno 2.0. \n Use the `--trace-leaks` flag instead. " ) ,
) ;
}
2023-03-26 04:06:18 +00:00
let doc = matches . get_flag ( " doc " ) ;
let allow_none = matches . get_flag ( " allow-none " ) ;
let filter = matches . remove_one ::< String > ( " filter " ) ;
2021-04-16 13:28:41 +00:00
2023-03-26 04:06:18 +00:00
let fail_fast = if matches . contains_id ( " fail-fast " ) {
Some (
matches
. remove_one ::< NonZeroUsize > ( " fail-fast " )
. unwrap_or_else ( | | NonZeroUsize ::new ( 1 ) . unwrap ( ) ) ,
)
2021-07-12 10:55:42 +00:00
} else {
None
} ;
2023-03-26 04:06:18 +00:00
let shuffle = if matches . contains_id ( " shuffle " ) {
Some (
matches
. remove_one ::< u64 > ( " shuffle " )
. unwrap_or_else ( rand ::random ) ,
)
2021-07-06 01:20:33 +00:00
} else {
None
} ;
2021-05-10 06:06:13 +00:00
2023-03-26 04:06:18 +00:00
if let Some ( script_arg ) = matches . remove_many ::< String > ( " script_arg " ) {
flags . argv . extend ( script_arg ) ;
2021-04-16 13:28:41 +00:00
}
2023-03-26 04:06:18 +00:00
let concurrent_jobs = if matches . get_flag ( " parallel " ) {
2022-07-20 21:36:54 +00:00
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
}
2023-03-26 04:06:18 +00:00
} else if matches . contains_id ( " 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.
2024-05-09 02:45:06 +00:00
#[ allow(clippy::print_stderr) ]
{
eprintln! (
" ⚠️ {} " ,
crate ::colors ::yellow ( concat! (
" The `--jobs` flag is deprecated and will be removed in Deno 2.0. \n " ,
" Use the `--parallel` flag with possibly the `DENO_JOBS` environment variable instead. \n " ,
" Learn more at: https://docs.deno.com/runtime/manual/basics/env_variables "
) ) ,
) ;
}
2023-03-26 04:06:18 +00:00
if let Some ( value ) = matches . remove_one ::< NonZeroUsize > ( " jobs " ) {
Some ( value )
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
} ;
2024-01-16 00:15:39 +00:00
let include = if let Some ( files ) = matches . remove_many ::< String > ( " files " ) {
2023-03-26 04:06:18 +00:00
files . collect ( )
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
} ;
2023-08-03 02:05:34 +00:00
let junit_path = matches . remove_one ::< String > ( " junit-path " ) ;
let reporter =
if let Some ( reporter ) = matches . remove_one ::< String > ( " reporter " ) {
match reporter . as_str ( ) {
" pretty " = > TestReporterConfig ::Pretty ,
" junit " = > TestReporterConfig ::Junit ,
" dot " = > TestReporterConfig ::Dot ,
2023-08-25 23:19:23 +00:00
" tap " = > TestReporterConfig ::Tap ,
2023-08-03 02:05:34 +00:00
_ = > unreachable! ( ) ,
}
} else {
TestReporterConfig ::Pretty
} ;
2023-08-25 23:19:23 +00:00
if matches! ( reporter , TestReporterConfig ::Dot | TestReporterConfig ::Tap ) {
2023-08-02 16:38:10 +00:00
flags . log_level = Some ( Level ::Error ) ;
}
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 ,
2023-06-15 17:09:37 +00:00
coverage_dir : matches . remove_one ::< String > ( " coverage " ) ,
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 ,
2024-02-28 16:12:43 +00:00
trace_leaks ,
2023-06-15 17:09:37 +00:00
watch : watch_arg_parse ( matches ) ,
2023-08-02 16:38:10 +00:00
reporter ,
2023-08-03 02:05:34 +00:00
junit_path ,
2021-09-03 23:33:35 +00:00
} ) ;
2020-02-17 16:59:51 +00:00
}
2020-04-03 17:40:11 +00:00
2023-03-26 04:06:18 +00:00
fn types_parse ( flags : & mut Flags , _matches : & mut ArgMatches ) {
2021-04-16 13:28:41 +00:00
flags . subcommand = DenoSubcommand ::Types ;
2020-02-17 16:59:51 +00:00
}
2023-03-26 04:06:18 +00:00
fn upgrade_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2021-04-16 13:28:41 +00:00
ca_file_arg_parse ( flags , matches ) ;
2023-03-26 04:06:18 +00:00
let dry_run = matches . get_flag ( " dry-run " ) ;
let force = matches . get_flag ( " force " ) ;
let canary = matches . get_flag ( " canary " ) ;
let version = matches . remove_one ::< String > ( " version " ) ;
2024-03-14 23:53:46 +00:00
let output = matches . remove_one ::< String > ( " output " ) ;
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
}
2023-03-26 04:06:18 +00:00
fn vendor_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-02-16 18:14:19 +00:00
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 ) ;
2023-08-07 01:56:56 +00:00
node_modules_and_vendor_dir_arg_parse ( flags , matches ) ;
2022-02-16 18:14:19 +00:00
reload_arg_parse ( flags , matches ) ;
flags . subcommand = DenoSubcommand ::Vendor ( VendorFlags {
specifiers : matches
2023-03-26 04:06:18 +00:00
. remove_many ::< String > ( " specifiers " )
. map ( | p | p . collect ( ) )
2022-02-16 18:14:19 +00:00
. unwrap_or_default ( ) ,
2024-03-14 23:53:46 +00:00
output_path : matches . remove_one ::< String > ( " output " ) ,
2023-03-26 04:06:18 +00:00
force : matches . get_flag ( " force " ) ,
2022-02-16 18:14:19 +00:00
} ) ;
}
2023-11-23 23:38:07 +00:00
fn publish_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2024-02-21 13:35:25 +00:00
flags . type_check_mode = TypeCheckMode ::Local ; // local by default
no_check_arg_parse ( flags , matches ) ;
check_arg_parse ( flags , matches ) ;
2024-02-14 17:13:07 +00:00
config_args_parse ( flags , matches ) ;
2023-11-23 23:38:07 +00:00
flags . subcommand = DenoSubcommand ::Publish ( PublishFlags {
token : matches . remove_one ( " token " ) ,
2024-01-11 21:17:03 +00:00
dry_run : matches . get_flag ( " dry-run " ) ,
2024-02-19 15:28:41 +00:00
allow_slow_types : matches . get_flag ( " allow-slow-types " ) ,
2024-03-07 21:13:36 +00:00
allow_dirty : matches . get_flag ( " allow-dirty " ) ,
2024-02-29 16:18:47 +00:00
no_provenance : matches . get_flag ( " no-provenance " ) ,
2023-11-23 23:38:07 +00:00
} ) ;
}
2023-03-26 04:06:18 +00:00
fn compile_args_parse ( flags : & mut Flags , matches : & mut 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 ,
2023-03-26 04:06:18 +00:00
matches : & mut ArgMatches ,
2022-04-10 23:12:51 +00:00
) {
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 ) ;
2023-08-07 01:56:56 +00:00
node_modules_and_vendor_dir_arg_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 ) ;
}
2023-03-26 04:06:18 +00:00
fn permission_args_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2022-01-14 16:38:17 +00:00
unsafely_ignore_certificate_errors_parse ( flags , matches ) ;
2024-03-14 23:53:46 +00:00
if let Some ( read_wl ) = matches . remove_many ::< String > ( " allow-read " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_read = Some ( read_wl . collect ( ) ) ;
2021-04-16 13:28:41 +00:00
}
2024-03-14 23:53:46 +00:00
if let Some ( read_wl ) = matches . remove_many ::< String > ( " deny-read " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . deny_read = Some ( read_wl . collect ( ) ) ;
2023-08-03 11:19:19 +00:00
}
2024-03-14 23:53:46 +00:00
if let Some ( write_wl ) = matches . remove_many ::< String > ( " allow-write " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_write = Some ( write_wl . collect ( ) ) ;
2021-04-16 13:28:41 +00:00
}
2024-03-14 23:53:46 +00:00
if let Some ( write_wl ) = matches . remove_many ::< String > ( " deny-write " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . deny_write = Some ( write_wl . collect ( ) ) ;
2023-08-03 11:19:19 +00:00
}
2023-03-26 04:06:18 +00:00
if let Some ( net_wl ) = matches . remove_many ::< String > ( " allow-net " ) {
2023-08-03 11:19:19 +00:00
let net_allowlist = flags_net ::parse ( net_wl . collect ( ) ) . unwrap ( ) ;
2024-05-06 23:21:58 +00:00
flags . permissions . allow_net = Some ( net_allowlist ) ;
2021-08-09 14:53:21 +00:00
}
2023-08-03 11:19:19 +00:00
if let Some ( net_wl ) = matches . remove_many ::< String > ( " deny-net " ) {
let net_denylist = flags_net ::parse ( net_wl . collect ( ) ) . unwrap ( ) ;
2024-05-06 23:21:58 +00:00
flags . permissions . deny_net = Some ( net_denylist ) ;
2023-08-03 11:19:19 +00:00
}
2023-03-26 04:06:18 +00:00
if let Some ( env_wl ) = matches . remove_many ::< String > ( " allow-env " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_env = Some ( env_wl . collect ( ) ) ;
debug! ( " env allowlist: {:#?} " , & flags . permissions . allow_env ) ;
2021-04-16 13:28:41 +00:00
}
2023-08-03 11:19:19 +00:00
if let Some ( env_wl ) = matches . remove_many ::< String > ( " deny-env " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . deny_env = Some ( env_wl . collect ( ) ) ;
debug! ( " env denylist: {:#?} " , & flags . permissions . deny_env ) ;
2023-08-03 11:19:19 +00:00
}
2023-03-26 04:06:18 +00:00
if let Some ( run_wl ) = matches . remove_many ::< String > ( " allow-run " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_run = Some ( run_wl . collect ( ) ) ;
debug! ( " run allowlist: {:#?} " , & flags . permissions . allow_run ) ;
2021-04-16 13:28:41 +00:00
}
2023-08-03 11:19:19 +00:00
if let Some ( run_wl ) = matches . remove_many ::< String > ( " deny-run " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . deny_run = Some ( run_wl . collect ( ) ) ;
debug! ( " run denylist: {:#?} " , & flags . permissions . deny_run ) ;
2023-08-03 11:19:19 +00:00
}
2023-03-26 04:06:18 +00:00
if let Some ( sys_wl ) = matches . remove_many ::< String > ( " allow-sys " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_sys = Some ( sys_wl . collect ( ) ) ;
debug! ( " sys info allowlist: {:#?} " , & flags . permissions . allow_sys ) ;
2022-09-28 12:46:50 +00:00
}
2023-08-03 11:19:19 +00:00
if let Some ( sys_wl ) = matches . remove_many ::< String > ( " deny-sys " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . deny_sys = Some ( sys_wl . collect ( ) ) ;
debug! ( " sys info denylist: {:#?} " , & flags . permissions . deny_sys ) ;
2023-08-03 11:19:19 +00:00
}
2024-03-14 23:53:46 +00:00
if let Some ( ffi_wl ) = matches . remove_many ::< String > ( " allow-ffi " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_ffi = Some ( ffi_wl . collect ( ) ) ;
debug! ( " ffi allowlist: {:#?} " , & flags . permissions . allow_ffi ) ;
2021-04-16 13:28:41 +00:00
}
2021-08-06 21:28:10 +00:00
2024-03-14 23:53:46 +00:00
if let Some ( ffi_wl ) = matches . remove_many ::< String > ( " deny-ffi " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . deny_ffi = Some ( ffi_wl . collect ( ) ) ;
debug! ( " ffi denylist: {:#?} " , & flags . permissions . deny_ffi ) ;
2023-08-03 11:19:19 +00:00
}
2023-03-26 04:06:18 +00:00
if matches . get_flag ( " allow-hrtime " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . allow_hrtime = true ;
2021-04-16 13:28:41 +00:00
}
2023-08-03 11:19:19 +00:00
if matches . get_flag ( " deny-hrtime " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . deny_hrtime = true ;
2023-08-03 11:19:19 +00:00
}
2023-03-26 04:06:18 +00:00
if matches . get_flag ( " allow-all " ) {
2024-03-13 16:07:24 +00:00
flags . allow_all ( ) ;
2021-04-16 13:28:41 +00:00
}
2023-08-03 11:19:19 +00:00
2023-03-26 04:06:18 +00:00
if matches . get_flag ( " no-prompt " ) {
2024-05-06 23:21:58 +00:00
flags . permissions . no_prompt = true ;
2021-04-16 13:28:41 +00:00
}
2020-03-27 20:09:51 +00:00
}
2023-11-10 17:41:24 +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 ,
2023-03-26 04:06:18 +00:00
matches : & mut ArgMatches ,
2021-12-10 14:47:55 +00:00
) {
2023-03-26 04:06:18 +00:00
if let Some ( ic_wl ) =
matches . remove_many ::< String > ( " unsafely-ignore-certificate-errors " )
{
2023-08-03 11:19:19 +00:00
let ic_allowlist = flags_net ::parse ( ic_wl . 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 ,
2023-03-26 04:06:18 +00:00
matches : & mut ArgMatches ,
2021-04-16 13:28:41 +00:00
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 ) ;
2023-11-01 15:21:13 +00:00
env_file_arg_parse ( flags , matches ) ;
2023-11-10 17:41:24 +00:00
strace_ops_parse ( flags , matches ) ;
2020-04-03 17:40:11 +00:00
}
2023-03-26 04:06:18 +00:00
fn inspect_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
2020-04-03 17:40:11 +00:00
let default = | | " 127.0.0.1:9229 " . parse ::< SocketAddr > ( ) . unwrap ( ) ;
2023-03-26 04:06:18 +00:00
flags . inspect = if matches . contains_id ( " inspect " ) {
Some (
matches
. remove_one ::< SocketAddr > ( " inspect " )
. unwrap_or_else ( default ) ,
)
2020-03-27 20:09:51 +00:00
} else {
None
} ;
2023-03-26 04:06:18 +00:00
flags . inspect_brk = if matches . contains_id ( " inspect-brk " ) {
Some (
matches
. remove_one ::< SocketAddr > ( " inspect-brk " )
. unwrap_or_else ( default ) ,
)
2020-03-27 20:09:51 +00:00
} else {
None
} ;
2023-03-26 04:06:18 +00:00
flags . inspect_wait = if matches . contains_id ( " inspect-wait " ) {
Some (
matches
. remove_one ::< SocketAddr > ( " inspect-wait " )
. unwrap_or_else ( default ) ,
)
2022-12-12 14:33:30 +00:00
} else {
None
} ;
2020-03-27 20:09:51 +00:00
}
2023-03-26 04:06:18 +00:00
fn import_map_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . import_map_path = matches . remove_one ::< String > ( " import-map " ) ;
2019-11-26 16:06:32 +00:00
}
2019-08-15 14:11:52 +00:00
2023-11-01 15:21:13 +00:00
fn env_file_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . env_file = matches . remove_one ::< String > ( " env " ) ;
}
2023-03-26 04:06:18 +00:00
fn reload_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( cache_bl ) = matches . remove_many ::< String > ( " reload " ) {
let raw_cache_blocklist : Vec < String > = cache_bl . 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
2023-03-26 04:06:18 +00:00
fn ca_file_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . ca_data = matches . remove_one ::< String > ( " cert " ) . 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 ,
2023-03-26 04:06:18 +00:00
matches : & mut ArgMatches ,
2021-07-23 14:31:16 +00:00
) {
2023-03-26 04:06:18 +00:00
if matches . get_flag ( " enable-testing-features-do-not-use " ) {
2021-07-23 14:31:16 +00:00
flags . enable_testing_features = true
}
}
2023-11-10 17:41:24 +00:00
fn strace_ops_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( patterns ) = matches . remove_many ::< String > ( " strace-ops " ) {
flags . strace_ops = Some ( patterns . collect ( ) ) ;
}
}
2023-03-26 04:06:18 +00:00
fn cached_only_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if matches . get_flag ( " cached-only " ) {
2021-04-16 13:28:41 +00:00
flags . cached_only = true ;
}
2019-11-26 16:06:32 +00:00
}
2019-10-04 13:02:36 +00:00
2023-03-26 04:06:18 +00:00
fn ext_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . ext = matches . remove_one ::< String > ( " ext " ) ;
2023-03-22 14:15:53 +00:00
}
2023-03-26 04:06:18 +00:00
fn location_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . location = matches . remove_one ::< Url > ( " location " ) ;
2019-11-27 04:25:14 +00:00
}
2023-03-26 04:06:18 +00:00
fn v8_flags_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( v8_flags ) = matches . remove_many ::< String > ( " v8-flags " ) {
flags . v8_flags = v8_flags . collect ( ) ;
2019-11-27 04:25:14 +00:00
}
}
2023-03-26 04:06:18 +00:00
fn seed_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( seed ) = matches . remove_one ::< u64 > ( " seed " ) {
2020-09-18 17:09:11 +00:00
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
}
}
2023-03-26 04:06:18 +00:00
fn no_check_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( cache_type ) = matches . get_one ::< String > ( " no-check " ) {
match cache_type . as_str ( ) {
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
) ,
}
2023-03-26 04:06:18 +00:00
} else if matches . contains_id ( " no-check " ) {
2022-04-10 23:12:51 +00:00
flags . type_check_mode = TypeCheckMode ::None ;
}
}
2023-03-26 04:06:18 +00:00
fn check_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if let Some ( cache_type ) = matches . get_one ::< String > ( " check " ) {
match cache_type . as_str ( ) {
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
) ,
}
2023-03-26 04:06:18 +00:00
} else if matches . contains_id ( " check " ) {
2022-06-13 21:13:16 +00:00
flags . type_check_mode = TypeCheckMode ::Local ;
2020-07-08 09:26:39 +00:00
}
}
2023-03-26 04:06:18 +00:00
fn lock_args_parse ( flags : & mut Flags , matches : & mut 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 ) ;
2023-03-26 04:06:18 +00:00
if matches . get_flag ( " lock-write " ) {
2022-02-16 18:14:19 +00:00
flags . lock_write = true ;
}
}
2023-03-26 04:06:18 +00:00
fn lock_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if matches . contains_id ( " lock " ) {
let lockfile = matches
2024-03-14 23:53:46 +00:00
. remove_one ::< String > ( " lock " )
. unwrap_or_else ( | | String ::from ( " ./deno.lock " ) ) ;
2023-03-26 04:06:18 +00:00
flags . lock = Some ( lockfile ) ;
2021-04-16 13:28:41 +00:00
}
}
2023-03-26 04:06:18 +00:00
fn no_lock_arg_parse ( flags : & mut Flags , matches : & ArgMatches ) {
if matches . get_flag ( " no-lock " ) {
2023-03-13 21:04:00 +00:00
flags . no_lock = true ;
}
}
2023-03-26 04:06:18 +00:00
fn config_args_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
flags . config_flag = if matches . get_flag ( " no-config " ) {
2022-05-13 15:40:50 +00:00
ConfigFlag ::Disabled
2023-03-26 04:06:18 +00:00
} else if let Some ( config ) = matches . remove_one ::< String > ( " config " ) {
ConfigFlag ::Path ( config )
2022-05-13 15:40:50 +00:00
} else {
ConfigFlag ::Discover
} ;
2019-12-03 22:48:53 +00:00
}
2023-03-26 04:06:18 +00:00
fn no_remote_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if matches . get_flag ( " no-remote " ) {
2019-12-03 22:48:53 +00:00
flags . no_remote = true ;
}
}
2023-03-26 04:06:18 +00:00
fn no_npm_arg_parse ( flags : & mut Flags , matches : & mut ArgMatches ) {
if matches . get_flag ( " no-npm " ) {
2022-09-07 13:33:51 +00:00
flags . no_npm = true ;
}
}
2023-08-07 01:56:56 +00:00
fn node_modules_and_vendor_dir_arg_parse (
2023-08-02 00:49:09 +00:00
flags : & mut Flags ,
matches : & mut ArgMatches ,
) {
2023-03-26 04:06:18 +00:00
flags . node_modules_dir = matches . remove_one ::< bool > ( " node-modules-dir " ) ;
2023-08-07 01:56:56 +00:00
flags . vendor = matches . remove_one ::< bool > ( " vendor " ) ;
2020-01-30 23:42:39 +00:00
}
2023-03-26 04:06:18 +00:00
fn reload_arg_validate ( urlstr : & str ) -> Result < String , String > {
2022-09-06 16:30:42 +00:00
if urlstr . is_empty ( ) {
return Err ( String ::from ( " Missing url. Check for extra commas. " ) ) ;
}
match Url ::from_str ( urlstr ) {
2023-03-26 04:06:18 +00:00
Ok ( _ ) = > Ok ( urlstr . to_string ( ) ) ,
2022-09-06 16:30:42 +00:00
Err ( e ) = > Err ( e . to_string ( ) ) ,
}
}
2023-06-15 17:09:37 +00:00
fn watch_arg_parse ( matches : & mut ArgMatches ) -> Option < WatchFlags > {
if matches . get_flag ( " watch " ) {
Some ( WatchFlags {
2023-10-31 00:25:58 +00:00
hmr : false ,
2023-06-15 17:09:37 +00:00
no_clear_screen : matches . get_flag ( " no-clear-screen " ) ,
2024-03-27 22:47:46 +00:00
exclude : matches
. remove_many ::< String > ( " watch-exclude " )
. map ( | f | f . collect ::< Vec < String > > ( ) )
. unwrap_or_default ( ) ,
2023-06-15 17:09:37 +00:00
} )
} else {
None
2021-12-15 21:04:43 +00:00
}
2023-06-15 17:09:37 +00:00
}
2022-01-31 16:39:39 +00:00
2023-06-15 17:09:37 +00:00
fn watch_arg_parse_with_paths (
matches : & mut ArgMatches ,
) -> Option < WatchFlagsWithPaths > {
2024-03-14 23:53:46 +00:00
if let Some ( paths ) = matches . remove_many ::< String > ( " watch " ) {
2023-10-31 00:25:58 +00:00
return Some ( WatchFlagsWithPaths {
paths : paths . collect ( ) ,
hmr : false ,
no_clear_screen : matches . get_flag ( " no-clear-screen " ) ,
2024-03-27 22:47:46 +00:00
exclude : matches
. remove_many ::< String > ( " watch-exclude " )
. map ( | f | f . collect ::< Vec < String > > ( ) )
. unwrap_or_default ( ) ,
2023-10-31 00:25:58 +00:00
} ) ;
}
2023-06-15 17:09:37 +00:00
matches
2024-03-14 23:53:46 +00:00
. remove_many ::< String > ( " hmr " )
2023-10-31 00:25:58 +00:00
. map ( | paths | WatchFlagsWithPaths {
paths : paths . collect ( ) ,
hmr : true ,
2023-06-15 17:09:37 +00:00
no_clear_screen : matches . get_flag ( " no-clear-screen " ) ,
2024-03-27 22:47:46 +00:00
exclude : matches
. remove_many ::< String > ( " watch-exclude " )
. map ( | f | f . collect ::< Vec < String > > ( ) )
. unwrap_or_default ( ) ,
2023-06-15 17:09:37 +00:00
} )
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 {
2024-03-22 21:03:56 +00:00
( $( $x :expr ) , * $(, ) ? ) = > ( vec! [ $( $x . to_string ( ) . into ( ) ) , * ] ) ;
2022-02-16 18:14:19 +00:00
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( )
) ) ,
2024-01-22 17:37:28 +00:00
unstable_config : UnstableConfig {
legacy_flag_enabled : true ,
.. Default ::default ( )
} ,
2020-09-20 11:45:00 +00:00
log_level : Some ( Level ::Error ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2020-09-20 11:45:00 +00:00
.. 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 ( )
}
) ;
}
2024-03-14 23:53:46 +00:00
#[ test ]
fn upgrade_with_output_flag ( ) {
let r = flags_from_vec ( svec! [ " deno " , " upgrade " , " --output " , " example.txt " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Upgrade ( UpgradeFlags {
force : false ,
dry_run : false ,
canary : false ,
version : None ,
output : Some ( String ::from ( " example.txt " ) ) ,
} ) ,
.. Flags ::default ( )
}
) ;
}
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 " ] ) ;
2023-03-26 04:06:18 +00:00
assert_eq! (
r . unwrap_err ( ) . kind ( ) ,
clap ::error ::ErrorKind ::DisplayVersion
) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [ " deno " , " -V " ] ) ;
2023-03-26 04:06:18 +00:00
assert_eq! (
r . unwrap_err ( ) . kind ( ) ,
clap ::error ::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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( )
) ) ,
2019-04-21 15:34:18 +00:00
reload : true ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : 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 ( ) ,
2023-06-15 17:09:37 +00:00
watch : Some ( WatchFlagsWithPaths {
2023-10-31 00:25:58 +00:00
hmr : false ,
2023-06-15 17:09:37 +00:00
paths : vec ! [ ] ,
no_clear_screen : false ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-06-15 17:09:37 +00:00
} ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2021-12-15 21:04:43 +00:00
.. Flags ::default ( )
}
) ;
2023-10-31 00:25:58 +00:00
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 ( WatchFlagsWithPaths {
hmr : false ,
paths : vec ! [ ] ,
no_clear_screen : true ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-10-31 00:25:58 +00:00
} ) ,
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-10-31 00:25:58 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --unstable-hmr " ,
" --no-clear-screen " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : true ,
paths : vec ! [ ] ,
no_clear_screen : true ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-10-31 00:25:58 +00:00
} ) ,
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-10-31 00:25:58 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --unstable-hmr=foo.txt " ,
" --no-clear-screen " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : true ,
2024-03-14 23:53:46 +00:00
paths : vec ! [ String ::from ( " foo.txt " ) ] ,
2023-10-31 00:25:58 +00:00
no_clear_screen : true ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-10-31 00:25:58 +00:00
} ) ,
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-10-31 00:25:58 +00:00
.. Flags ::default ( )
}
) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --hmr " , " --watch " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
2021-12-15 21:04:43 +00:00
}
#[ 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 ( ) ,
2023-06-15 17:09:37 +00:00
watch : Some ( WatchFlagsWithPaths {
2023-10-31 00:25:58 +00:00
hmr : false ,
2024-03-14 23:53:46 +00:00
paths : vec ! [ String ::from ( " file1 " ) , String ::from ( " file2 " ) ] ,
2023-06-15 17:09:37 +00:00
no_clear_screen : false ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-06-15 17:09:37 +00:00
} ) ,
2021-12-15 21:04:43 +00:00
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 ( ) ,
2023-06-15 17:09:37 +00:00
watch : Some ( WatchFlagsWithPaths {
2023-10-31 00:25:58 +00:00
hmr : false ,
2023-06-15 17:09:37 +00:00
paths : vec ! [ ] ,
no_clear_screen : true ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
} ) ,
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2024-03-27 22:47:46 +00:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn run_watch_with_excluded_paths ( ) {
let r = flags_from_vec ( svec! (
" deno " ,
" run " ,
" --watch " ,
" --watch-exclude=foo " ,
" script.ts "
) ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : false ,
paths : vec ! [ ] ,
no_clear_screen : false ,
exclude : vec ! [ String ::from ( " foo " ) ] ,
} ) ,
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2024-03-27 22:47:46 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! (
" deno " ,
" run " ,
" --watch=foo " ,
" --watch-exclude=bar " ,
" script.ts "
) ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : false ,
paths : vec ! [ String ::from ( " foo " ) ] ,
no_clear_screen : false ,
exclude : vec ! [ String ::from ( " bar " ) ] ,
} ) ,
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2024-03-27 22:47:46 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --watch " ,
" --watch-exclude=foo,bar " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : false ,
paths : vec ! [ ] ,
no_clear_screen : false ,
exclude : vec ! [ String ::from ( " foo " ) , String ::from ( " bar " ) ] ,
} ) ,
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2024-03-27 22:47:46 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --watch=foo,bar " ,
" --watch-exclude=baz,qux " ,
" script.ts "
] ) ;
let flags = r . unwrap ( ) ;
assert_eq! (
flags ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags {
script : " script.ts " . to_string ( ) ,
watch : Some ( WatchFlagsWithPaths {
hmr : false ,
paths : vec ! [ String ::from ( " foo " ) , String ::from ( " bar " ) ] ,
no_clear_screen : false ,
exclude : vec ! [ String ::from ( " baz " ) , String ::from ( " qux " ) , ] ,
2023-12-06 21:36:06 +00:00
} ) ,
2022-01-31 16:39:39 +00:00
} ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-01-31 16:39:39 +00:00
.. 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 ,
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( )
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_write : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default ( " _ " . to_string ( ) ) ) ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --help " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
2024-04-24 19:45:49 +00:00
" script.ts " . to_string ( ) ,
2023-12-06 21:36:06 +00:00
) ) ,
2020-12-06 17:19:21 +00:00
v8_flags : svec ! [ " --expose-gc " , " --gc-stats=1 " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-04-21 15:34:18 +00:00
}
) ;
2023-08-13 02:04:17 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --v8-flags=--expose-gc " ] ) ;
assert! ( r
. unwrap_err ( )
. to_string ( )
. contains ( " [SCRIPT_ARG] may only be omitted with --v8-flags=--help " ) ) ;
2019-04-21 15:34:18 +00:00
}
2024-04-24 19:45:49 +00:00
#[ test ]
fn serve_flags ( ) {
let r = flags_from_vec ( svec! [ " deno " , " serve " , " main.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Serve ( ServeFlags ::new_default (
" main.ts " . to_string ( ) ,
8000 ,
" 0.0.0.0 "
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [
" 0.0.0.0:8000 " . to_string ( ) ,
" 127.0.0.1:8000 " . to_string ( ) ,
" localhost:8000 " . to_string ( )
] ) ,
.. Default ::default ( )
} ,
2024-04-24 19:45:49 +00:00
code_cache_enabled : true ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " serve " , " --port " , " 5000 " , " main.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Serve ( ServeFlags ::new_default (
" main.ts " . to_string ( ) ,
5000 ,
" 0.0.0.0 "
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [
" 0.0.0.0:5000 " . to_string ( ) ,
" 127.0.0.1:5000 " . to_string ( ) ,
" localhost:5000 " . to_string ( )
] ) ,
.. Default ::default ( )
} ,
2024-04-24 19:45:49 +00:00
code_cache_enabled : true ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" serve " ,
" --port " ,
" 5000 " ,
" --allow-net=example.com " ,
" main.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Serve ( ServeFlags ::new_default (
" main.ts " . to_string ( ) ,
5000 ,
" 0.0.0.0 "
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [
" example.com " . to_string ( ) ,
" 0.0.0.0:5000 " . to_string ( ) ,
" 127.0.0.1:5000 " . to_string ( ) ,
" localhost:5000 " . to_string ( )
] ) ,
.. Default ::default ( )
} ,
2024-04-24 19:45:49 +00:00
code_cache_enabled : true ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" serve " ,
" --port " ,
" 5000 " ,
" --allow-net " ,
" main.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Serve ( ServeFlags ::new_default (
" main.ts " . to_string ( ) ,
5000 ,
" 0.0.0.0 "
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2024-04-24 19:45:49 +00:00
code_cache_enabled : true ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" serve " ,
" --port " ,
" 5000 " ,
" --host " ,
" example.com " ,
" main.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Serve ( ServeFlags ::new_default (
" main.ts " . to_string ( ) ,
5000 ,
" example.com "
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [ " example.com:5000 " . to_owned ( ) ] ) ,
.. Default ::default ( )
} ,
2024-04-24 19:45:49 +00:00
code_cache_enabled : true ,
.. Flags ::default ( )
}
) ;
}
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 ) ;
2023-08-03 11:19:19 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-read " , " x.ts " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission ( ) , true ) ;
2022-11-24 03:00:31 +00:00
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 ) ;
2023-08-03 11:19:19 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " x.ts " , " --deny-read " ] ) ;
assert_eq! ( r . unwrap ( ) . has_permission_in_argv ( ) , true ) ;
2022-11-24 03:00:31 +00:00
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( )
) ) ,
2020-02-04 19:24:33 +00:00
argv : svec ! [ " --title " , " X " ] ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : 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_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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( )
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_all : true ,
allow_net : Some ( vec! [ ] ) ,
allow_env : Some ( vec! [ ] ) ,
allow_run : Some ( vec! [ ] ) ,
allow_read : Some ( vec! [ ] ) ,
allow_sys : Some ( vec! [ ] ) ,
allow_write : Some ( vec! [ ] ) ,
allow_ffi : Some ( vec! [ ] ) ,
allow_hrtime : true ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( )
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_read : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : 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
}
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_read ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-read " , " gist.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( )
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_read : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_hrtime : true ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : 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
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_hrtime ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-hrtime " , " gist.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" gist.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_hrtime : true ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-02-04 19:24:33 +00:00
argv : svec ! [ " -- " , " -D " , " --allow-net " ] ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_write : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : 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
) ;
}
#[ 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 ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
2024-01-16 00:15:39 +00:00
include : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 ,
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 ,
2023-10-31 00:25:58 +00:00
watch : Some ( Default ::default ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Some ( WatchFlags {
2023-10-31 00:25:58 +00:00
hmr : false ,
2023-06-15 17:09:37 +00:00
no_clear_screen : true ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-06-15 17:09:37 +00:00
} )
2022-01-31 16:39:39 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
2022-01-31 16:39:39 +00:00
.. 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 ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
2024-01-16 00:15:39 +00:00
include : vec ! [ " foo.ts " . to_string ( ) ] ,
ignore : vec ! [ " bar.js " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
} ,
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 ,
2023-10-31 00:25:58 +00:00
watch : Some ( Default ::default ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2021-09-13 18:19:10 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
2024-01-16 00:15:39 +00:00
include : vec ! [ " foo.ts " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
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 ,
2023-10-31 00:25:58 +00:00
watch : Some ( Default ::default ( ) ) ,
2021-09-13 18:19:10 +00:00
} ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " deno.jsonc " . to_string ( ) ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 ,
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 ) ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2023-01-25 20:06:00 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
2023-01-25 20:06:00 +00:00
.. 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 ,
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 ) ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2021-09-13 20:06:45 +00:00
} ) ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) , ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
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 ,
2023-10-31 00:25:58 +00:00
watch : Some ( Default ::default ( ) ) ,
2022-01-31 16:39:39 +00:00
} ) ,
.. 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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Some ( WatchFlags {
2023-10-31 00:25:58 +00:00
hmr : false ,
2023-06-15 17:09:37 +00:00
no_clear_screen : true ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-06-15 17:09:37 +00:00
} )
2022-01-31 16:39:39 +00:00
} ) ,
.. Flags ::default ( )
}
) ;
2024-03-21 21:18:59 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --fix " ,
" --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 ! [ ] ,
2024-01-16 00:15:39 +00:00
ignore : vec ! [ " script_1.ts " . to_string ( ) , " script_2.ts " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
} ,
2024-03-21 21:18:59 +00:00
fix : true ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2021-09-03 15:01:58 +00:00
.. Flags ::default ( )
}
) ;
2023-07-25 21:24:06 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" lint " ,
" --rules " ,
" --rules-tags=recommended "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Lint ( LintFlags {
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
2023-07-25 21:24:06 +00:00
rules : true ,
maybe_rules_tags : Some ( svec! [ " recommended " ] ) ,
maybe_rules_include : None ,
maybe_rules_exclude : None ,
json : false ,
compact : false ,
watch : Default ::default ( ) ,
} ) ,
.. Flags ::default ( )
}
) ;
2021-09-03 15:01:58 +00:00
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 ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " script_1.ts " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " script_1.ts " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2022-09-28 16:47:48 +00:00
} ) ,
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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " script_1.ts " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
2024-03-21 21:18:59 +00:00
fix : false ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 "
] ) ;
2023-03-26 04:06:18 +00:00
assert_eq! (
r . unwrap_err ( ) . kind ( ) ,
clap ::error ::ErrorKind ::ArgumentConflict
) ;
2022-12-07 18:33:26 +00:00
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Path ( " tsconfig.json " . to_owned ( ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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-09-03 23:33:35 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_all : true ,
allow_net : Some ( vec! [ ] ) ,
allow_env : Some ( vec! [ ] ) ,
allow_run : Some ( vec! [ ] ) ,
allow_read : Some ( vec! [ ] ) ,
allow_sys : Some ( vec! [ ] ) ,
allow_write : Some ( vec! [ ] ) ,
allow_ffi : Some ( vec! [ ] ) ,
allow_hrtime : true ,
.. Default ::default ( )
} ,
2020-02-28 14:17:56 +00:00
.. 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-09-03 23:33:35 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_all : true ,
allow_net : Some ( vec! [ ] ) ,
allow_env : Some ( vec! [ ] ) ,
allow_run : Some ( vec! [ ] ) ,
allow_read : Some ( vec! [ ] ) ,
allow_sys : Some ( vec! [ ] ) ,
allow_write : Some ( vec! [ ] ) ,
allow_ffi : Some ( vec! [ ] ) ,
allow_hrtime : true ,
.. Default ::default ( )
} ,
2020-05-21 14:35:36 +00:00
.. 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-09-03 23:33:35 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_all : true ,
allow_net : Some ( vec! [ ] ) ,
allow_env : Some ( vec! [ ] ) ,
allow_run : Some ( vec! [ ] ) ,
allow_read : Some ( vec! [ ] ) ,
allow_sys : Some ( vec! [ ] ) ,
allow_write : Some ( vec! [ ] ) ,
allow_ffi : Some ( vec! [ ] ) ,
allow_hrtime : true ,
.. Default ::default ( )
} ,
2023-03-22 14:15:53 +00:00
ext : Some ( " ts " . to_string ( ) ) ,
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 ]
2023-11-01 15:21:13 +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 " , " --env=.example.env " , " 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-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 ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::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 ( ) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_all : true ,
allow_net : Some ( vec! [ ] ) ,
allow_env : Some ( vec! [ ] ) ,
allow_run : Some ( vec! [ ] ) ,
allow_read : Some ( vec! [ ] ) ,
allow_sys : Some ( vec! [ ] ) ,
allow_write : Some ( vec! [ ] ) ,
allow_ffi : Some ( vec! [ ] ) ,
allow_hrtime : true ,
.. Default ::default ( )
} ,
2023-11-01 15:21:13 +00:00
env_file : Some ( " .example.env " . to_owned ( ) ) ,
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-09-03 23:33:35 +00:00
} ) ,
2020-11-30 02:10:21 +00:00
argv : svec ! [ " arg1 " , " arg2 " ] ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_all : true ,
allow_net : Some ( vec! [ ] ) ,
allow_env : Some ( vec! [ ] ) ,
allow_run : Some ( vec! [ ] ) ,
allow_read : Some ( vec! [ ] ) ,
allow_sys : Some ( vec! [ ] ) ,
allow_write : Some ( vec! [ ] ) ,
allow_ffi : Some ( vec! [ ] ) ,
allow_hrtime : true ,
.. Default ::default ( )
} ,
2020-11-30 02:10:21 +00:00
.. 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
} ) ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : None ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [ ] ) ,
allow_env : Some ( vec! [ ] ) ,
deny_env : None ,
allow_run : Some ( vec! [ ] ) ,
deny_run : None ,
allow_read : Some ( vec! [ ] ) ,
deny_read : None ,
allow_sys : Some ( vec! [ ] ) ,
deny_sys : None ,
allow_write : Some ( vec! [ ] ) ,
deny_write : None ,
allow_ffi : Some ( vec! [ ] ) ,
deny_ffi : None ,
allow_hrtime : true ,
.. Default ::default ( )
} ,
2020-02-26 10:52:15 +00:00
.. Flags ::default ( )
2019-05-03 21:15:16 +00:00
}
) ;
}
2023-11-10 17:41:24 +00:00
#[ test ]
fn repl_strace_ops ( ) {
// Lightly test this undocumented flag
let r = flags_from_vec ( svec! [ " deno " , " repl " , " --strace-ops " ] ) ;
assert_eq! ( r . unwrap ( ) . strace_ops , Some ( vec! [ ] ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " repl " , " --strace-ops=http,websocket " ] ) ;
assert_eq! (
r . unwrap ( ) . strace_ops ,
Some ( vec! [ " http " . to_string ( ) , " websocket " . to_string ( ) ] )
) ;
}
2020-04-30 15:23:40 +00:00
#[ test ]
2020-09-18 17:09:11 +00:00
fn repl_with_flags ( ) {
#[ rustfmt::skip ]
2023-11-01 15:21:13 +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 " , " --env=.example.env " ] ) ;
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 ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::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 ( ) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_all : true ,
allow_net : Some ( vec! [ ] ) ,
allow_env : Some ( vec! [ ] ) ,
allow_run : Some ( vec! [ ] ) ,
allow_read : Some ( vec! [ ] ) ,
allow_sys : Some ( vec! [ ] ) ,
allow_write : Some ( vec! [ ] ) ,
allow_ffi : Some ( vec! [ ] ) ,
allow_hrtime : true ,
.. Default ::default ( )
} ,
2023-11-01 15:21:13 +00:00
env_file : Some ( " .example.env " . to_owned ( ) ) ,
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
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_write : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
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 ( ) ;
2024-03-14 23:53:46 +00:00
let temp_dir = temp_dir_guard . path ( ) . to_string ( ) ;
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 " ,
2024-03-14 23:53:46 +00:00
format! ( " --allow-read=., {} " , temp_dir ) ,
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 {
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_read : Some ( vec! [ String ::from ( " . " ) , temp_dir ] ) ,
.. Default ::default ( )
} ,
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_read_denylist ( ) {
use test_util ::TempDir ;
let temp_dir_guard = TempDir ::new ( ) ;
2024-03-14 23:53:46 +00:00
let temp_dir = temp_dir_guard . path ( ) . to_string ( ) ;
2023-08-03 11:19:19 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
2024-03-14 23:53:46 +00:00
format! ( " --deny-read=., {} " , temp_dir ) ,
2023-08-03 11:19:19 +00:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_read : Some ( vec! [ String ::from ( " . " ) , temp_dir ] ) ,
.. Default ::default ( )
} ,
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
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 ( ) ;
2024-03-14 23:53:46 +00:00
let temp_dir = temp_dir_guard . path ( ) . to_string ( ) ;
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 " ,
2024-03-14 23:53:46 +00:00
format! ( " --allow-write=., {} " , temp_dir ) ,
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 {
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_write : Some ( vec! [ String ::from ( " . " ) , temp_dir ] ) ,
.. Default ::default ( )
} ,
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_write_denylist ( ) {
use test_util ::TempDir ;
let temp_dir_guard = TempDir ::new ( ) ;
2024-03-14 23:53:46 +00:00
let temp_dir = temp_dir_guard . path ( ) . to_string ( ) ;
2023-08-03 11:19:19 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
2024-03-14 23:53:46 +00:00
format! ( " --deny-write=., {} " , temp_dir ) ,
2023-08-03 11:19:19 +00:00
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_write : Some ( vec! [ String ::from ( " . " ) , temp_dir ] ) ,
.. Default ::default ( )
} ,
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( svec! [ " 127.0.0.1 " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_net_denylist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-net=127.0.0.1 " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_net : Some ( svec! [ " 127.0.0.1 " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_env : Some ( svec! [ " HOME " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2021-04-13 11:25:21 +00:00
.. Flags ::default ( )
}
) ;
}
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_env_denylist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=HOME " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_env : Some ( svec! [ " HOME " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
2021-04-13 11:25:21 +00:00
#[ 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_env : Some ( svec! [ " HOME " , " PATH " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2021-04-13 11:25:21 +00:00
.. Flags ::default ( )
}
) ;
}
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_env_denylist_multiple ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=HOME,PATH " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_env : Some ( svec! [ " HOME " , " PATH " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
2021-04-13 11:25:21 +00:00
#[ 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 ( ) ) ;
}
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_env_denylist_validator ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=HOME " , " script.ts " ] ) ;
assert! ( r . is_ok ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-env=H=ME " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_sys : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-09-28 12:46:50 +00:00
.. Flags ::default ( )
}
) ;
}
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_sys ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-sys " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_sys : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
2022-09-28 12:46:50 +00:00
#[ test ]
fn allow_sys_allowlist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --allow-sys=hostname " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_sys : Some ( svec! [ " hostname " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-09-28 12:46:50 +00:00
.. Flags ::default ( )
}
) ;
}
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_sys_denylist ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-sys=hostname " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_sys : Some ( svec! [ " hostname " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
2022-09-28 12:46:50 +00:00
#[ 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_sys : Some ( svec! [ " hostname " , " osRelease " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-09-28 12:46:50 +00:00
.. Flags ::default ( )
}
) ;
}
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_sys_denylist_multiple ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-sys=hostname,osRelease " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_sys : Some ( svec! [ " hostname " , " osRelease " ] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
2022-09-28 12:46:50 +00:00
#[ 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 ( ) ) ;
}
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_sys_denylist_validator ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --deny-sys=hostname " , " script.ts " ] ) ;
assert! ( r . is_ok ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-sys=hostname,osRelease " ,
" script.ts "
] ) ;
assert! ( r . is_ok ( ) ) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --deny-sys=foo " , " script.ts " ] ) ;
assert! ( r . is_err ( ) ) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 ( ) ,
2024-01-16 00:15:39 +00:00
out_file : Some ( " bundle.js " . to_string ( ) ) ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_write : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
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 ( ) ,
2024-01-16 00:15:39 +00:00
out_file : Some ( " bundle.js " . to_string ( ) ) ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_write : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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 ,
2023-10-31 00:25:58 +00:00
watch : Some ( Default ::default ( ) ) ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
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 ,
2023-06-15 17:09:37 +00:00
watch : Some ( WatchFlags {
2023-10-31 00:25:58 +00:00
hmr : false ,
2023-06-15 17:09:37 +00:00
no_clear_screen : true ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-06-15 17:09:37 +00:00
} ) ,
2022-01-31 16:39:39 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2022-01-31 16:39:39 +00:00
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-10-20 12:30:59 +00:00
import_map_path : Some ( " import_map.json " . to_owned ( ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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-10-30 22:58:57 +00:00
source_files : DocSourceFileFlag ::Paths ( vec! [ " script.ts " . to_owned ( ) ] ) ,
2020-10-11 23:05:46 +00:00
private : false ,
json : false ,
2023-11-01 15:25:05 +00:00
html : None ,
2023-10-31 22:19:42 +00:00
lint : false ,
2020-10-11 23:05:46 +00:00
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
2023-11-01 15:21:13 +00:00
#[ test ]
fn run_env_file_default ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --env " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-11-01 15:21:13 +00:00
env_file : Some ( " .env " . to_owned ( ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn run_no_code_cache ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --no-code-cache " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-11-01 15:21:13 +00:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn run_env_file_defined ( ) {
let r =
flags_from_vec ( svec! [ " deno " , " run " , " --env=.another_env " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-11-01 15:21:13 +00:00
env_file : Some ( " .another_env " . to_owned ( ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-11-01 15:21:13 +00:00
.. Flags ::default ( )
}
) ;
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
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 " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
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 " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 ( ) {
2024-04-10 21:26:35 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " install " , " jsr:@std/http/file-server " ] ) ;
2019-06-15 14:08:11 +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 {
2024-04-04 14:40:54 +00:00
kind : InstallKind ::Global ( InstallFlagsGlobal {
name : None ,
2024-04-10 21:26:35 +00:00
module_url : " jsr:@std/http/file-server " . to_string ( ) ,
2024-04-04 14:40:54 +00:00
args : vec ! [ ] ,
root : None ,
force : false ,
} ) ,
2024-03-27 22:45:57 +00:00
global : false ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" install " ,
" -g " ,
2024-04-10 21:26:35 +00:00
" jsr:@std/http/file-server "
2024-03-27 22:45:57 +00:00
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Install ( InstallFlags {
2024-04-04 14:40:54 +00:00
kind : InstallKind ::Global ( InstallFlagsGlobal {
name : None ,
2024-04-10 21:26:35 +00:00
module_url : " jsr:@std/http/file-server " . to_string ( ) ,
2024-04-04 14:40:54 +00:00
args : vec ! [ ] ,
root : None ,
force : false ,
} ) ,
2024-03-27 22:45:57 +00:00
global : true ,
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 ]
2024-04-10 21:26:35 +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 " , " --env=.example.env " , " jsr:@std/http/file-server " , " 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 {
2024-04-04 14:40:54 +00:00
kind : InstallKind ::Global ( InstallFlagsGlobal {
name : Some ( " file_server " . to_string ( ) ) ,
2024-04-10 21:26:35 +00:00
module_url : " jsr:@std/http/file-server " . to_string ( ) ,
2024-04-04 14:40:54 +00:00
args : svec ! [ " foo " , " bar " ] ,
root : Some ( " /foo " . to_string ( ) ) ,
force : true ,
} ) ,
2024-03-27 22:45:57 +00:00
global : false ,
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 ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::from ( " lock.json " ) ) ,
2020-10-19 19:19:20 +00:00
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 ( ) ) ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [ ] ) ,
allow_read : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2023-11-01 15:21:13 +00:00
env_file : Some ( " .example.env " . to_owned ( ) ) ,
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 {
2024-04-04 14:40:54 +00:00
kind : UninstallKind ::Global ( UninstallFlagsGlobal {
name : " file_server " . to_string ( ) ,
root : None ,
} ) ,
2024-03-27 22:45:57 +00:00
global : false ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " uninstall " , " -g " , " file_server " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Uninstall ( UninstallFlags {
2024-04-04 14:40:54 +00:00
kind : UninstallKind ::Global ( UninstallFlagsGlobal {
name : " file_server " . to_string ( ) ,
root : None ,
} ) ,
2024-03-27 22:45:57 +00:00
global : true ,
2023-01-06 02:09:39 +00:00
} ) ,
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn uninstall_with_help_flag ( ) {
let r = flags_from_vec ( svec! [ " deno " , " uninstall " , " --help " ] ) ;
2023-03-26 04:06:18 +00:00
assert_eq! ( r . err ( ) . unwrap ( ) . kind ( ) , clap ::error ::ErrorKind ::DisplayHelp ) ;
2023-01-06 02:09:39 +00:00
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2019-06-22 16:02:51 +00:00
log_level : Some ( Level ::Debug ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-03-10 12:26:17 +00:00
log_level : Some ( Level ::Error ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2020-03-10 12:26:17 +00:00
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " --allow-read " , " --allow-net " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-01-07 18:06:08 +00:00
location : Some ( Url ::parse ( " https://foo/ " ) . unwrap ( ) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_read : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " --allow-net " , " -r " , " --help " , " --foo " , " bar " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " foo " , " bar " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2020-08-28 23:20:57 +00:00
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " - " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2020-08-28 23:20:57 +00:00
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2020-08-28 23:20:57 +00:00
argv : svec ! [ " - " , " foo " , " bar " ] ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2020-08-28 23:20:57 +00:00
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::None ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-04-10 23:12:51 +00:00
type_check_mode : TypeCheckMode ::Local ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
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 "
] ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2021-08-09 14:53:21 +00:00
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2019-12-03 22:48:53 +00:00
no_remote : true ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-09-07 13:33:51 +00:00
no_npm : true ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-09-07 13:33:51 +00:00
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-02-20 18:14:06 +00:00
node_modules_dir : Some ( true ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-02-20 18:14:06 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --node-modules-dir=false " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-02-20 18:14:06 +00:00
node_modules_dir : Some ( false ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-09-22 15:17:02 +00:00
.. Flags ::default ( )
}
) ;
}
2023-08-02 00:49:09 +00:00
#[ test ]
2023-08-07 01:56:56 +00:00
fn vendor_flag ( ) {
let r = flags_from_vec ( svec! [ " deno " , " run " , " --vendor " , " script.ts " ] ) ;
2023-08-02 00:49:09 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-07 01:56:56 +00:00
vendor : Some ( true ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-02 00:49:09 +00:00
.. Flags ::default ( )
}
) ;
2023-08-07 01:56:56 +00:00
let r = flags_from_vec ( svec! [ " deno " , " run " , " --vendor=false " , " script.ts " ] ) ;
2023-08-02 00:49:09 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-08-07 01:56:56 +00:00
vendor : Some ( false ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-02 00:49:09 +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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2019-12-03 22:48:53 +00:00
cached_only : true ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( svec! [
" 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 "
] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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
2023-08-03 11:19:19 +00:00
#[ test ]
fn deny_net_denylist_with_ports ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-net=deno.land,:8000,:4545 " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_net : Some ( svec! [
" 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 "
] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( svec! [
" 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 "
] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2023-08-03 11:19:19 +00:00
.. Flags ::default ( )
}
) ;
}
#[ test ]
fn deny_net_denylist_with_ipv6_address ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --deny-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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
deny_net : Some ( svec! [
" 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 "
] ) ,
.. Default ::default ( )
} ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2019-11-03 15:39:27 +00:00
lock_write : true ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::from ( " lock.json " ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-11-03 15:42:56 +00:00
no_lock : true ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-11-03 15:42:56 +00:00
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-11-02 15:32:30 +00:00
lock_write : true ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::from ( " ./deno.lock " ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-11-02 15:32:30 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --lock-write " ,
" --lock " ,
" lock.json " ,
" script.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-11-02 15:32:30 +00:00
lock_write : true ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::from ( " lock.json " ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-11-02 15:32:30 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " run " , " --lock-write " , " script.ts " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-11-02 15:32:30 +00:00
lock_write : true ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-11-02 15:32:30 +00:00
.. 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 ]
2024-02-28 16:12:43 +00:00
let r = flags_from_vec ( svec! [ " deno " , " test " , " --unstable " , " --no-npm " , " --no-remote " , " --trace-leaks " , " --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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " dir1/ " . to_string ( ) , " dir2/ " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
2021-07-06 01:20:33 +00:00
shuffle : None ,
2023-01-07 20:22:09 +00:00
concurrent_jobs : None ,
2024-02-28 16:12:43 +00:00
trace_leaks : true ,
2023-06-15 17:09:37 +00:00
coverage_dir : Some ( " cov " . to_string ( ) ) ,
watch : Default ::default ( ) ,
2023-08-02 16:38:10 +00:00
reporter : Default ::default ( ) ,
2023-08-03 02:05:34 +00:00
junit_path : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2024-01-22 17:37:28 +00:00
unstable_config : UnstableConfig {
legacy_flag_enabled : true ,
.. Default ::default ( )
} ,
2023-03-13 21:04:00 +00:00
no_npm : true ,
no_remote : true ,
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 ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
allow_net : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2023-01-18 00:18:24 +00:00
ca_data : Some ( CaData ::File ( " example.crt " . to_owned ( ) ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2021-07-23 14:31:16 +00:00
enable_testing_features : true ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2021-07-23 14:31:16 +00:00
.. 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 ,
2023-08-02 16:38:10 +00:00
reporter : Default ::default ( ) ,
2021-08-23 10:35:38 +00:00
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 ( ) ) ,
2024-02-28 16:12:43 +00:00
trace_leaks : false ,
2023-06-15 17:09:37 +00:00
coverage_dir : None ,
watch : Default ::default ( ) ,
2023-08-03 02:05:34 +00:00
junit_path : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
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 ,
2024-02-28 16:12:43 +00:00
trace_leaks : false ,
2023-06-15 17:09:37 +00:00
coverage_dir : None ,
watch : Default ::default ( ) ,
2023-08-02 16:38:10 +00:00
reporter : Default ::default ( ) ,
2023-08-03 02:05:34 +00:00
junit_path : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
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 ,
2024-02-28 16:12:43 +00:00
trace_leaks : false ,
2023-06-15 17:09:37 +00:00
coverage_dir : None ,
watch : Default ::default ( ) ,
2023-08-02 16:38:10 +00:00
reporter : Default ::default ( ) ,
2023-08-03 02:05:34 +00:00
junit_path : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
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
2023-08-02 16:38:10 +00:00
#[ test ]
2023-08-03 02:05:34 +00:00
fn test_reporter ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --reporter=pretty " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Pretty ,
.. Default ::default ( )
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2023-08-03 02:05:34 +00:00
type_check_mode : TypeCheckMode ::Local ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " test " , " --reporter=dot " ] ) ;
2023-08-02 16:38:10 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Dot ,
2023-08-03 02:05:34 +00:00
.. Default ::default ( )
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2023-08-03 02:05:34 +00:00
type_check_mode : TypeCheckMode ::Local ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " test " , " --reporter=junit " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Junit ,
.. Default ::default ( )
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2023-08-03 02:05:34 +00:00
type_check_mode : TypeCheckMode ::Local ,
.. Flags ::default ( )
2023-08-25 23:19:23 +00:00
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " test " , " --reporter=tap " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Tap ,
.. Default ::default ( )
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2023-08-25 23:19:23 +00:00
type_check_mode : TypeCheckMode ::Local ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
2023-08-03 02:05:34 +00:00
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" test " ,
" --reporter=dot " ,
" --junit-path=report.xml "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
reporter : TestReporterConfig ::Dot ,
junit_path : Some ( " report.xml " . to_string ( ) ) ,
.. Default ::default ( )
2023-08-02 16:38:10 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2023-08-02 16:38:10 +00:00
type_check_mode : TypeCheckMode ::Local ,
log_level : Some ( Level ::Error ) ,
.. Flags ::default ( )
}
) ;
2023-08-03 02:05:34 +00:00
let r = flags_from_vec ( svec! [ " deno " , " test " , " --junit-path " ] ) ;
2023-08-02 16:38:10 +00:00
assert! ( r . is_err ( ) ) ;
}
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 ,
2024-02-28 16:12:43 +00:00
trace_leaks : false ,
2023-06-15 17:09:37 +00:00
coverage_dir : None ,
watch : Default ::default ( ) ,
2023-08-02 16:38:10 +00:00
reporter : Default ::default ( ) ,
2023-08-03 02:05:34 +00:00
junit_path : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
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 ,
2024-02-28 16:12:43 +00:00
trace_leaks : false ,
2023-06-15 17:09:37 +00:00
coverage_dir : None ,
2023-10-31 00:25:58 +00:00
watch : Some ( Default ::default ( ) ) ,
2023-08-02 16:38:10 +00:00
reporter : Default ::default ( ) ,
2023-08-03 02:05:34 +00:00
junit_path : None ,
2023-01-07 20:22:09 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2023-01-07 20:22:09 +00:00
type_check_mode : TypeCheckMode ::Local ,
.. 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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " ./ " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
concurrent_jobs : None ,
2024-02-28 16:12:43 +00:00
trace_leaks : false ,
2023-06-15 17:09:37 +00:00
coverage_dir : None ,
2023-10-31 00:25:58 +00:00
watch : Some ( Default ::default ( ) ) ,
2023-08-02 16:38:10 +00:00
reporter : Default ::default ( ) ,
2023-08-03 02:05:34 +00:00
junit_path : None ,
2021-09-03 23:33:35 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
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 ,
2024-02-28 16:12:43 +00:00
trace_leaks : false ,
2023-06-15 17:09:37 +00:00
coverage_dir : None ,
watch : Some ( WatchFlags {
2023-10-31 00:25:58 +00:00
hmr : false ,
2023-06-15 17:09:37 +00:00
no_clear_screen : true ,
2024-03-27 22:47:46 +00:00
exclude : vec ! [ ] ,
2023-06-15 17:09:37 +00:00
} ) ,
2023-08-02 16:38:10 +00:00
reporter : Default ::default ( ) ,
2023-08-03 02:05:34 +00:00
junit_path : None ,
2022-01-31 16:39:39 +00:00
} ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2022-01-31 16:39:39 +00:00
.. Flags ::default ( )
2023-12-08 08:35:42 +00:00
}
) ;
}
#[ test ]
fn test_coverage_default_dir ( ) {
let r = flags_from_vec ( svec! [ " deno " , " test " , " --coverage " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Test ( TestFlags {
coverage_dir : Some ( " coverage " . to_string ( ) ) ,
.. TestFlags ::default ( )
} ) ,
type_check_mode : TypeCheckMode ::Local ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2023-12-08 08:35:42 +00:00
.. Flags ::default ( )
2022-01-31 16:39:39 +00:00
}
) ;
}
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 ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
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-11-01 15:25:05 +00:00
html : None ,
2023-10-31 22:19:42 +00:00
lint : false ,
2023-11-01 15:25:05 +00:00
source_files : DocSourceFileFlag ::Paths ( svec! [ " path/to/module.ts " ] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " doc " , " --html " , " path/to/module.ts " ] ) ;
2024-04-24 20:34:21 +00:00
assert! ( r . is_ok ( ) ) ;
2023-11-01 15:25:05 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --html " ,
" --name=My library " ,
" path/to/module.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
json : false ,
lint : false ,
html : Some ( DocHtmlFlag {
2024-04-24 20:34:21 +00:00
name : Some ( " My library " . to_string ( ) ) ,
2024-03-14 23:53:46 +00:00
output : String ::from ( " ./docs/ " ) ,
2023-11-01 15:25:05 +00:00
} ) ,
source_files : DocSourceFileFlag ::Paths ( svec! [ " path/to/module.ts " ] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --html " ,
" --name=My library " ,
" --lint " ,
" --output=./foo " ,
" path/to/module.ts "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
json : false ,
html : Some ( DocHtmlFlag {
2024-04-24 20:34:21 +00:00
name : Some ( " My library " . to_string ( ) ) ,
2024-03-14 23:53:46 +00:00
output : String ::from ( " ./foo " ) ,
2023-11-01 15:25:05 +00:00
} ) ,
lint : true ,
source_files : DocSourceFileFlag ::Paths ( svec! [ " path/to/module.ts " ] ) ,
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
2023-11-03 17:06:18 +00:00
let r =
flags_from_vec ( svec! [ " deno " , " doc " , " --html " , " --name=My library " , ] ) ;
assert! ( r . is_err ( ) ) ;
2021-01-07 18:06:08 +00:00
let r = flags_from_vec ( svec! [
2020-04-02 13:26:40 +00:00
" deno " ,
" doc " ,
2023-10-30 22:58:57 +00:00
" --filter " ,
" SomeClass.someField " ,
2020-04-02 13:26:40 +00:00
" path/to/module.ts " ,
] ) ;
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-11-01 15:25:05 +00:00
html : None ,
2023-10-31 22:19:42 +00:00
lint : false ,
2023-10-30 22:58:57 +00:00
source_files : DocSourceFileFlag ::Paths ( vec! [
" 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-11-01 15:25:05 +00:00
html : None ,
2023-10-31 22:19:42 +00:00
lint : false ,
2023-10-30 22:58:57 +00:00
source_files : 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 ( )
}
) ;
2023-10-30 22:58:57 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --filter " ,
" Deno.Listener " ,
" --builtin "
] ) ;
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 ,
2023-10-31 22:19:42 +00:00
lint : false ,
2020-04-09 12:34:24 +00:00
json : false ,
2023-11-01 15:25:05 +00:00
html : None ,
2023-10-30 22:58:57 +00:00
source_files : 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 ,
2023-10-31 22:19:42 +00:00
lint : false ,
2020-07-12 12:16:33 +00:00
json : false ,
2023-11-01 15:25:05 +00:00
html : None ,
source_files : DocSourceFileFlag ::Paths ( svec! [ " path/to/module.js " ] ) ,
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 ( )
}
) ;
2023-10-30 22:58:57 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" path/to/module.js " ,
" path/to/module2.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
2023-10-31 22:19:42 +00:00
lint : false ,
2023-10-30 22:58:57 +00:00
json : false ,
2023-11-01 15:25:05 +00:00
html : None ,
2023-10-30 22:58:57 +00:00
source_files : DocSourceFileFlag ::Paths ( vec! [
" path/to/module.js " . to_string ( ) ,
" path/to/module2.js " . to_string ( )
] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" path/to/module.js " ,
" --builtin " ,
" path/to/module2.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
json : false ,
2023-11-01 15:25:05 +00:00
html : None ,
2023-10-31 22:19:42 +00:00
lint : false ,
source_files : DocSourceFileFlag ::Paths ( vec! [
" path/to/module.js " . to_string ( ) ,
" path/to/module2.js " . to_string ( )
] ) ,
filter : None ,
} ) ,
.. Flags ::default ( )
}
) ;
2023-11-03 17:06:18 +00:00
let r = flags_from_vec ( svec! [ " deno " , " doc " , " --lint " , ] ) ;
assert! ( r . is_err ( ) ) ;
2023-10-31 22:19:42 +00:00
let r = flags_from_vec ( svec! [
" deno " ,
" doc " ,
" --lint " ,
" path/to/module.js " ,
" path/to/module2.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Doc ( DocFlags {
private : false ,
lint : true ,
json : false ,
2023-11-01 15:25:05 +00:00
html : None ,
2023-10-30 22:58:57 +00:00
source_files : DocSourceFileFlag ::Paths ( vec! [
" path/to/module.js " . to_string ( ) ,
" path/to/module2.js " . to_string ( )
] ) ,
filter : None ,
} ) ,
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" foo.js " . to_string ( ) ,
) ) ,
2020-04-03 17:40:11 +00:00
inspect : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" foo.js " . to_string ( ) ,
) ) ,
2022-12-12 14:33:30 +00:00
inspect_wait : Some ( " 127.0.0.1:9229 " . parse ( ) . unwrap ( ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-12-12 14:33:30 +00:00
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" run " ,
" --inspect-wait=127.0.0.1:3567 " ,
" foo.js "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" foo.js " . to_string ( ) ,
) ) ,
2022-12-12 14:33:30 +00:00
inspect_wait : Some ( " 127.0.0.1:3567 " . parse ( ) . unwrap ( ) ) ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-12-12 14:33:30 +00:00
.. 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 " ,
2023-12-02 02:20:06 +00:00
" https://examples.deno.land/color-logging.ts "
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 {
2023-12-02 02:20:06 +00:00
source_file : " https://examples.deno.land/color-logging.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-07-28 15:46:26 +00:00
no_terminal : false ,
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 ]
2023-12-02 02:20:06 +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 " , " --no-terminal " , " --output " , " colors " , " --env=.example.env " , " https://examples.deno.land/color-logging.ts " , " foo " , " bar " , " -p " , " 8080 " ] ) ;
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 {
2023-12-02 02:20:06 +00:00
source_file : " https://examples.deno.land/color-logging.ts "
. to_string ( ) ,
2024-03-14 23:53:46 +00:00
output : Some ( String ::from ( " colors " ) ) ,
2023-09-08 17:14:59 +00:00
args : svec ! [ " foo " , " bar " , " -p " , " 8080 " ] ,
2021-01-19 02:40:22 +00:00
target : None ,
2023-07-28 15:46:26 +00:00
no_terminal : true ,
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 ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::from ( " lock.json " ) ) ,
2020-11-30 19:35:12 +00:00
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 ( ) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_read : Some ( vec! [ ] ) ,
allow_net : Some ( vec! [ ] ) ,
.. Default ::default ( )
} ,
2021-08-10 11:19:45 +00:00
unsafely_ignore_certificate_errors : Some ( vec! [ ] ) ,
2021-01-04 23:15:52 +00:00
v8_flags : svec ! [ " --help " , " --random-seed=1 " ] ,
seed : Some ( 1 ) ,
2023-11-01 15:21:13 +00:00
env_file : Some ( " .example.env " . to_owned ( ) ) ,
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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " foo.json " . to_string ( ) ] ,
2023-01-13 21:56:29 +00:00
ignore : vec ! [ ] ,
} ,
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 ( ) ] ,
2023-12-18 10:48:45 +00:00
.. CoverageFlags ::default ( )
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 {
2024-01-16 00:15:39 +00:00
include : vec ! [ " foo.json " . to_string ( ) ] ,
2023-01-13 21:56:29 +00:00
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 ( ) ] ,
2023-12-08 07:54:52 +00:00
r#type : CoverageType ::Lcov ,
2024-03-14 23:53:46 +00:00
output : Some ( String ::from ( " foo.lcov " ) ) ,
2022-02-15 15:33:21 +00:00
} ) ,
.. Flags ::default ( )
}
) ;
}
2023-12-18 10:48:45 +00:00
#[ test ]
fn coverage_with_default_files ( ) {
let r = flags_from_vec ( svec! [ " deno " , " coverage " , ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Coverage ( CoverageFlags {
files : FileFlags {
2024-01-16 00:15:39 +00:00
include : vec ! [ " coverage " . to_string ( ) ] ,
2023-12-18 10:48:45 +00:00
ignore : vec ! [ ] ,
} ,
include : vec ! [ r "^file:" . to_string ( ) ] ,
exclude : vec ! [ r "test\.(js|mjs|ts|jsx|tsx)$" . to_string ( ) ] ,
.. CoverageFlags ::default ( )
} ) ,
.. 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 ) ,
2024-01-16 00:15:39 +00:00
Some ( vec! [ cwd . join ( " dir/a.js " ) , cwd . join ( " 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 ) ,
2024-01-16 00:15:39 +00:00
Some ( vec! [ cwd . join ( " dir/a.js " ) , cwd . join ( " 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
2023-03-26 04:06:18 +00:00
. 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 ,
2024-03-14 23:53:46 +00:00
output_path : Some ( String ::from ( " out_dir " ) ) ,
2022-02-16 18:14:19 +00:00
} ) ,
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 ( ) ) ,
2024-03-14 23:53:46 +00:00
lock : Some ( String ::from ( " lock.json " ) ) ,
2022-02-16 18:14:19 +00:00
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
} ) ,
2024-01-22 17:37:28 +00:00
unstable_config : UnstableConfig {
legacy_flag_enabled : true ,
.. Default ::default ( )
} ,
2022-08-10 15:55:34 +00:00
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 " ] ) ;
2023-03-26 04:06:18 +00:00
assert_eq! (
r . unwrap_err ( ) . kind ( ) ,
clap ::error ::ErrorKind ::UnknownArgument
) ;
2022-06-28 19:47:51 +00:00
}
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 " ,
2023-03-26 14:55:58 +00:00
" --no-run " ,
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-03-26 14:55:58 +00:00
no_run : true ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
2024-01-16 00:15:39 +00:00
include : vec ! [ " dir1/ " . to_string ( ) , " dir2/ " . to_string ( ) ] ,
2023-01-07 20:22:09 +00:00
ignore : vec ! [ ] ,
} ,
2023-06-15 17:09:37 +00:00
watch : Default ::default ( ) ,
2022-03-11 22:07:02 +00:00
} ) ,
2024-01-22 17:37:28 +00:00
unstable_config : UnstableConfig {
legacy_flag_enabled : true ,
.. Default ::default ( )
} ,
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 ( ) ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
allow_net : Some ( vec! [ ] ) ,
no_prompt : true ,
.. Default ::default ( )
} ,
2022-03-11 22:07:02 +00:00
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-03-26 14:55:58 +00:00
no_run : false ,
2023-01-07 20:22:09 +00:00
files : FileFlags {
include : vec ! [ ] ,
ignore : vec ! [ ] ,
} ,
2023-10-31 00:25:58 +00:00
watch : Some ( Default ::default ( ) ) ,
2023-01-07 20:22:09 +00:00
} ) ,
2024-05-06 23:21:58 +00:00
permissions : PermissionFlags {
no_prompt : true ,
.. Default ::default ( )
} ,
2023-01-07 20:22:09 +00:00
type_check_mode : TypeCheckMode ::Local ,
.. 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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::Local ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::All ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-06-13 21:13:16 +00:00
type_check_mode : TypeCheckMode ::None ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
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 {
2023-12-06 21:36:06 +00:00
subcommand : DenoSubcommand ::Run ( RunFlags ::new_default (
" script.ts " . to_string ( ) ,
) ) ,
2022-05-13 15:40:50 +00:00
config_flag : ConfigFlag ::Disabled ,
2024-04-17 14:19:55 +00:00
code_cache_enabled : true ,
2022-05-13 15:40:50 +00:00
.. 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
}
2023-09-16 00:42:09 +00:00
#[ test ]
fn jupyter ( ) {
2024-01-22 17:37:28 +00:00
let r = flags_from_vec ( svec! [ " deno " , " jupyter " ] ) ;
2023-09-16 00:42:09 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Jupyter ( JupyterFlags {
install : false ,
kernel : false ,
conn_file : None ,
} ) ,
.. Flags ::default ( )
}
) ;
2024-01-22 17:37:28 +00:00
let r = flags_from_vec ( svec! [ " deno " , " jupyter " , " --install " ] ) ;
2023-09-16 00:42:09 +00:00
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Jupyter ( JupyterFlags {
install : true ,
kernel : false ,
conn_file : None ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" jupyter " ,
" --kernel " ,
" --conn " ,
" path/to/conn/file "
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Jupyter ( JupyterFlags {
install : false ,
kernel : true ,
2024-03-14 23:53:46 +00:00
conn_file : Some ( String ::from ( " path/to/conn/file " ) ) ,
2023-09-16 00:42:09 +00:00
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [
" deno " ,
" jupyter " ,
" --install " ,
" --conn " ,
" path/to/conn/file "
] ) ;
r . unwrap_err ( ) ;
let r = flags_from_vec ( svec! [ " deno " , " jupyter " , " --kernel " , ] ) ;
r . unwrap_err ( ) ;
let r = flags_from_vec ( svec! [ " deno " , " jupyter " , " --install " , " --kernel " , ] ) ;
r . unwrap_err ( ) ;
}
2024-02-21 13:35:25 +00:00
#[ test ]
fn publish_args ( ) {
let r = flags_from_vec ( svec! [
" deno " ,
" publish " ,
2024-02-29 16:18:47 +00:00
" --no-provenance " ,
2024-02-21 13:35:25 +00:00
" --dry-run " ,
" --allow-slow-types " ,
2024-03-07 21:13:36 +00:00
" --allow-dirty " ,
2024-02-21 13:35:25 +00:00
" --token=asdf " ,
] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Publish ( PublishFlags {
token : Some ( " asdf " . to_string ( ) ) ,
dry_run : true ,
allow_slow_types : true ,
2024-03-07 21:13:36 +00:00
allow_dirty : true ,
2024-02-29 16:18:47 +00:00
no_provenance : true ,
2024-02-21 13:35:25 +00:00
} ) ,
type_check_mode : TypeCheckMode ::Local ,
.. Flags ::default ( )
}
) ;
}
2024-02-29 19:12:04 +00:00
#[ test ]
fn add_subcommand ( ) {
let r = flags_from_vec ( svec! [ " deno " , " add " ] ) ;
r . unwrap_err ( ) ;
let r = flags_from_vec ( svec! [ " deno " , " add " , " @david/which " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Add ( AddFlags {
packages : svec ! [ " @david/which " ] ,
} ) ,
.. Flags ::default ( )
}
) ;
let r = flags_from_vec ( svec! [ " deno " , " add " , " @david/which " , " @luca/hello " ] ) ;
assert_eq! (
r . unwrap ( ) ,
Flags {
subcommand : DenoSubcommand ::Add ( AddFlags {
packages : svec ! [ " @david/which " , " @luca/hello " ] ,
} ) ,
.. Flags ::default ( )
}
) ;
}
2020-03-27 20:09:51 +00:00
}